mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-21 19:40:34 +00:00
3f38621024
A trip can now turn a trip addon (lists, costs, documents, collab, road trip, tours) on or off for itself, whatever the instance switch says. No row in the new trip_addon_overrides table means the trip follows the instance; a row is the owner's choice. Going back to the instance setting deletes the row, and no addon data is touched either way. - GET/PUT /api/trips/:tripId/addons[/:addonId] (every member reads, the owner writes) and the MCP tools get_trip_addons and set_trip_addon, on the shared tripAddons contract; tripAddons:changed tells the members. - Every trip-scoped addon surface asks the trip: REST through TripAddonGuard, MCP through a per-call gate on the named or pinned trip, plugin RPC and events, the share link, the offline bundle, reminders, doc sync, the assistant (tools, keep_attached_file), booking costs, the trip summary prompt, and the cross-trip tour reads (library, Atlas stats, collection save). - Routes without a trip open while the addon is on in any of the user's trips. Switching an addon on that the instance has off ends the members' MCP sessions so they reconnect with its tools. - A copied trip takes its owner's choices along. Behaviour changes: an anonymous call to an addon route that is off now gets 401 instead of 404, and with an instance switch off the packing, todo and files plugin RPC methods, the files MCP tools, todo reminder mails, core plugin events, plugin view contributions, the share link's lists, costs and chat sections and the offline bundle's lists follow it.
233 lines
8.4 KiB
TypeScript
233 lines
8.4 KiB
TypeScript
import { openDatabase } from '../../../src/db/connection';
|
|
import { SqliteEngine } from '../../../src/db/engine/sqlite/sqlite-engine';
|
|
import { Places } from '../../../src/db/entities/Places.entity';
|
|
import { Trips } from '../../../src/db/entities/Trips.entity';
|
|
import { UnitOfWork } from '../../../src/nest/database/unit-of-work';
|
|
import { TripsService } from '../../../src/nest/trips/trips.service';
|
|
import { createSnapshotTestDb } from '../../helpers/db-mock';
|
|
import {
|
|
createDayAssignment,
|
|
createDayNote,
|
|
createPackingItem,
|
|
createPlace,
|
|
createTrip,
|
|
createUser,
|
|
} from '../../helpers/factories';
|
|
import { countRows } from '../../helpers/factories/rows';
|
|
import { readTripDays } from '../../helpers/factories/trips';
|
|
import { createTestOrm } from '../../helpers/test-orm';
|
|
|
|
import Database from 'better-sqlite3';
|
|
import fs from 'fs';
|
|
import os from 'os';
|
|
import path from 'path';
|
|
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
|
|
|
// #2518: a container with a read-only root filesystem and no tmpfs on /tmp
|
|
// gives SQLite nowhere to put a temp file, so deleting a trip failed with
|
|
// SQLITE_IOERR_GETTEMPPATH. Every connection TREK opens keeps its temp storage
|
|
// in memory now, and these tests pin that down.
|
|
|
|
const SERVER_ROOT = path.resolve(__dirname, '../../..');
|
|
const MEMORY = 2; // PRAGMA temp_store: 0 default, 1 file, 2 memory
|
|
|
|
let tmpDir: string;
|
|
let schemaFile: string;
|
|
|
|
beforeAll(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'trek-connection-'));
|
|
// Real schema, built once and copied per test: the delete below has to
|
|
// cascade through the same tables and foreign keys a live install has.
|
|
// The schema is the migrated snapshot the vitest global setup built, written
|
|
// out as a file so every copy is a real on-disk database.
|
|
schemaFile = path.join(tmpDir, 'schema.db');
|
|
const snapshot = createSnapshotTestDb();
|
|
fs.writeFileSync(schemaFile, snapshot.serialize());
|
|
snapshot.close();
|
|
const db = openDatabase(schemaFile);
|
|
db.exec('PRAGMA journal_mode = WAL');
|
|
db.exec('PRAGMA foreign_keys = ON');
|
|
db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
|
|
db.close();
|
|
});
|
|
|
|
afterAll(() => {
|
|
fs.rmSync(tmpDir, { recursive: true, force: true });
|
|
});
|
|
|
|
function freshCopy(name: string): string {
|
|
const file = path.join(tmpDir, `${name}.db`);
|
|
fs.copyFileSync(schemaFile, file);
|
|
return file;
|
|
}
|
|
|
|
describe('openDatabase', () => {
|
|
it('keeps temp storage in memory on a read-write handle', () => {
|
|
const db = openDatabase(freshCopy('rw'));
|
|
try {
|
|
expect(db.pragma('temp_store', { simple: true })).toBe(MEMORY);
|
|
} finally {
|
|
db.close();
|
|
}
|
|
});
|
|
|
|
it('keeps temp storage in memory on a read-only handle', () => {
|
|
const db = openDatabase(freshCopy('ro'), { readonly: true });
|
|
try {
|
|
expect(db.readonly).toBe(true);
|
|
expect(db.pragma('temp_store', { simple: true })).toBe(MEMORY);
|
|
} finally {
|
|
db.close();
|
|
}
|
|
});
|
|
|
|
it('is what the server opens its main database with', async () => {
|
|
const { db } = await import('../../../src/db/database');
|
|
expect(db.pragma('temp_store', { simple: true })).toBe(MEMORY);
|
|
});
|
|
});
|
|
|
|
// SQLite names every temp file etilqs_<random>. Linux unlinks the file the
|
|
// moment it is opened, so it only shows among the process's open descriptors;
|
|
// Windows keeps it in the temp directory until it is closed. macOS offers
|
|
// neither view, which is why the test below does not run there.
|
|
const canSeeTempFiles = process.platform === 'linux' || process.platform === 'win32';
|
|
|
|
function sqliteTempFiles(): string[] {
|
|
if (process.platform === 'linux') {
|
|
return fs
|
|
.readdirSync('/proc/self/fd')
|
|
.flatMap((fd) => {
|
|
try {
|
|
return [fs.readlinkSync(`/proc/self/fd/${fd}`)];
|
|
} catch {
|
|
return [];
|
|
}
|
|
})
|
|
.filter((target) => target.includes('etilqs_'));
|
|
}
|
|
return fs.readdirSync(os.tmpdir()).filter((name) => name.startsWith('etilqs_'));
|
|
}
|
|
|
|
/**
|
|
* Builds a trip the size of a real one on `db`, deletes it through
|
|
* TripsService.remove and reports which SQLite temp files were open while the
|
|
* delete ran. A trigger calls back into the test after the cascade, still
|
|
* inside the statement, which is when a spilled statement journal is open.
|
|
*/
|
|
async function deleteTripAndWatchTempFiles(db: Database.Database): Promise<{
|
|
tempFiles: string[];
|
|
tripLeft: number;
|
|
placesLeft: number;
|
|
}> {
|
|
db.exec('PRAGMA journal_mode = WAL');
|
|
db.exec('PRAGMA foreign_keys = ON');
|
|
|
|
const { user } = createUser(db);
|
|
const trip = createTrip(db, user.id, {
|
|
title: 'Niederlande Hoofddorp',
|
|
start_date: '2026-06-01',
|
|
end_date: '2026-06-14',
|
|
});
|
|
const t = await createTestOrm(db);
|
|
const days = await readTripDays(t, trip.id);
|
|
for (let i = 0; i < 25; i++) {
|
|
const place = createPlace(db, trip.id, { name: `Ort ${i}`, description: 'Grachten und Tulpen. '.repeat(10) });
|
|
createDayAssignment(db, days[i % days.length].id, place.id);
|
|
}
|
|
days.forEach((day) => createDayNote(db, day.id, trip.id));
|
|
for (let i = 0; i < 20; i++) createPackingItem(db, trip.id, { name: `Teil ${i}` });
|
|
|
|
const before = new Set(sqliteTempFiles());
|
|
const seen = new Set<string>();
|
|
db.function('trek_watch_temp_files', () => {
|
|
for (const file of sqliteTempFiles()) if (!before.has(file)) seen.add(file);
|
|
return null;
|
|
});
|
|
db.exec('CREATE TRIGGER trek_watch_trip_delete AFTER DELETE ON trips BEGIN SELECT trek_watch_temp_files(); END');
|
|
|
|
const none = undefined as never;
|
|
try {
|
|
const trips = new TripsService(
|
|
none,
|
|
none,
|
|
none,
|
|
none,
|
|
none,
|
|
none,
|
|
none,
|
|
none,
|
|
new UnitOfWork(t.em, new SqliteEngine()),
|
|
t.em,
|
|
none,
|
|
none,
|
|
);
|
|
await trips.remove(trip.id, user.id, 'user');
|
|
return {
|
|
tempFiles: [...seen],
|
|
tripLeft: await countRows(t, Trips, { id: trip.id }),
|
|
placesLeft: await countRows(t, Places, { trip: trip.id }),
|
|
};
|
|
} finally {
|
|
await t.close();
|
|
}
|
|
}
|
|
|
|
describe.runIf(canSeeTempFiles)('deleting a trip with content (#2518)', () => {
|
|
it('needs a temp file on a connection left at the SQLite default', async () => {
|
|
// The control: proves the watcher sees temp files, and that this delete is
|
|
// one SQLite cannot finish without one where no temp directory is writable.
|
|
const db = new Database(freshCopy('default'));
|
|
try {
|
|
const result = await deleteTripAndWatchTempFiles(db);
|
|
expect(result.tempFiles.length).toBeGreaterThan(0);
|
|
expect(result.tripLeft).toBe(0);
|
|
} finally {
|
|
db.close();
|
|
}
|
|
});
|
|
|
|
it('never touches a temp file on a connection TREK opens', async () => {
|
|
const db = openDatabase(freshCopy('trek'));
|
|
try {
|
|
const result = await deleteTripAndWatchTempFiles(db);
|
|
expect(result.tempFiles).toEqual([]);
|
|
expect(result.tripLeft).toBe(0);
|
|
expect(result.placesLeft).toBe(0);
|
|
} finally {
|
|
db.close();
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('every SQLite connection goes through openDatabase', () => {
|
|
function sourceFiles(dir: string): string[] {
|
|
return fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
|
|
const full = path.join(dir, entry.name);
|
|
if (entry.isDirectory()) return sourceFiles(full);
|
|
return entry.name.endsWith('.ts') ? [full] : [];
|
|
});
|
|
}
|
|
|
|
it('leaves no other place in src/ constructing a better-sqlite3 handle', () => {
|
|
const offenders = sourceFiles(path.join(SERVER_ROOT, 'src')).filter((file) => {
|
|
if (file === path.join(SERVER_ROOT, 'src', 'db', 'connection.ts')) return false;
|
|
const source = fs.readFileSync(file, 'utf8');
|
|
// A value import (not `import type`) under whatever local name, then `new` on it.
|
|
const imported = /import\s+(?!type\b)(\w+)[^;]*?from\s+['"]better-sqlite3['"]/.exec(source)?.[1];
|
|
const required = /(\w+)\s*=\s*require\(\s*['"]better-sqlite3['"]\s*\)/.exec(source)?.[1];
|
|
return [imported, required].some((name) => name && new RegExp(`new\\s+${name}\\s*\\(`).test(source));
|
|
});
|
|
expect(offenders.map((file) => path.relative(SERVER_ROOT, file))).toEqual([]);
|
|
});
|
|
|
|
it('is mirrored by the standalone scripts that cannot import it', () => {
|
|
// reset-admin.js and the key rotation run in the container without src/,
|
|
// so they set the pragma themselves.
|
|
for (const script of ['reset-admin.js', 'scripts/migrate-encryption.ts']) {
|
|
const source = fs.readFileSync(path.join(SERVER_ROOT, script), 'utf8');
|
|
expect(source, script).toMatch(/PRAGMA temp_store = MEMORY|pragma\('temp_store = MEMORY'\)/);
|
|
}
|
|
});
|
|
});
|