/** * PGPLUG-001..008 — a plugin's own data (`db:own`) on Postgres, against the * real app on the lane's database: each plugin gets a schema of its own and no * SQLite file, its SQL keeps the SQLite store's semantics (migrate once per * id, a script's statements committed one by one, an atomic tx, the row cap, * the time budget, the quota), it cannot reach TREK's tables or another * plugin's schema however it spells the name, and erasing a plugin drops its * schema and nothing else. */ import { buildApp } from '../../src/bootstrap'; import { PluginDataSlots, PostgresPluginDataStore } from '../../src/db/engine/postgres/plugin-data-store'; import { withRequestContext } from '../../src/nest/database/request-context'; import { PLUGIN_DATA, type PluginDataBackend } from '../../src/nest/plugins/host/plugin-data.backend'; import { closePluginDataDb } from '../../src/nest/plugins/host/plugin-host-state'; import { PluginRpcHostFactory } from '../../src/nest/plugins/host/plugin-rpc-host.factory'; import { MikroORM } from '@mikro-orm/core'; import type { AbstractSqlConnection } from '@mikro-orm/sql'; import type { INestApplication } from '@nestjs/common'; import fs from 'node:fs'; import os from 'node:os'; import path from 'node:path'; import { afterAll, beforeAll, describe, expect, it } from 'vitest'; let app: INestApplication; let orm: MikroORM; let data: PluginDataBackend; let dataDir: string; beforeAll(async () => { dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'trek-pg-plugin-data-')); process.env.TREK_PLUGINS_DATA_DIR = dataDir; app = await buildApp(); orm = app.get(MikroORM); data = app.get(PLUGIN_DATA, { strict: false }); }, 60_000); afterAll(async () => { await app?.close(); delete process.env.TREK_PLUGINS_DATA_DIR; fs.rmSync(dataDir, { recursive: true, force: true }); }); /** The plugin schemas the database holds now. */ async function pluginSchemas(): Promise { const rows = await withRequestContext(orm, () => orm.em .getConnection() .execute>( "select nspname from pg_namespace where starts_with(nspname, 'trek_plugin_') order by nspname", [], 'all', ), ); return rows.map((row) => row.nspname); } /** A store on the app's pool with limits small enough to reach in a test. */ function cappedStore(id: string, limits: { maxRows?: number; timeBudgetMs?: number; quotaBytes?: number }) { const client = (orm.em.getConnection() as AbstractSqlConnection).getClient(); return new PostgresPluginDataStore(id, client, new PluginDataSlots(1), limits); } describe('plugin data on Postgres', () => { it('PGPLUG-001: a plugin gets a schema of its own, migrates once per id, reads and writes there, and no SQLite file', async () => { const store = data.open('pg-alpha'); expect(store.engine).toBe('postgres'); expect(await store.migrate('001', 'CREATE TABLE notes (id bigserial PRIMARY KEY, body text NOT NULL)')).toEqual({ applied: true, }); expect(await store.migrate('001', 'CREATE TABLE never (x int)')).toEqual({ applied: false }); expect(await store.exec('INSERT INTO notes (body) VALUES ($1), ($2)', ['a', 'b'])).toEqual({ changes: 2 }); expect(await store.query('SELECT body FROM notes WHERE body <> $1 ORDER BY id', ['x'])).toEqual([ { body: 'a' }, { body: 'b' }, ]); expect(await pluginSchemas()).toContain('trek_plugin_pg_alpha'); expect(fs.readdirSync(path.join(dataDir, 'pg-alpha'))).toEqual([]); }); it('PGPLUG-002: a script commits statement by statement, a tx all or nothing', async () => { const store = data.open('pg-script'); await store.migrate('001', 'CREATE TABLE kv (k text PRIMARY KEY, n int NOT NULL)'); await expect(store.exec("INSERT INTO kv VALUES ('one', 1); INSERT INTO kv VALUES ('one', 2)")).rejects.toThrow( /duplicate key/, ); expect(await store.query('SELECT k, n FROM kv')).toEqual([{ k: 'one', n: 1 }]); await expect( store.tx([ { sql: 'UPDATE kv SET n = n + 1 WHERE k = $1', args: ['one'] }, { sql: "INSERT INTO kv VALUES ('one', 9)" }, ]), ).rejects.toThrow(/duplicate key/); expect(await store.query('SELECT n FROM kv')).toEqual([{ n: 1 }]); const batch = await store.tx([ { sql: "INSERT INTO kv VALUES ('two', 2)" }, { sql: 'SELECT k FROM kv ORDER BY k' }, { sql: "UPDATE kv SET n = 3 WHERE k = 'two' RETURNING n" }, ]); expect(batch.results).toEqual([{ changes: 1 }, { rows: [{ k: 'one' }, { k: 'two' }] }, { rows: [{ n: 3 }] }]); await expect(store.tx([{ sql: 'COMMIT' }])).rejects.toThrow(/transaction-control/); await expect(store.query('SELECT n FROM kv WHERE k = ?', ['one'])).rejects.toThrow(/\$1, \$2/); }); it("PGPLUG-003: a plugin cannot read TREK's tables, however it spells their name", async () => { const store = data.open('pg-alpha'); // Unqualified, the name finds nothing: only the plugin's schema is on the search_path. await expect(store.query('SELECT email FROM users')).rejects.toThrow(/does not exist/); for (const sql of [ 'SELECT email FROM public.users', 'SELECT email FROM "public"."users"', 'SELECT email FROM PUBLIC . users', 'SELECT email FROM public/* x */.users', "SELECT query_to_xml('select email from public.users', true, true, '')", "SELECT ts_stat('select to_tsvector(email) from public.users')", 'SELECT * FROM pg_catalog.pg_tables', 'SELECT * FROM pg_stats', 'SELECT * FROM information_schema.tables', "SELECT set_config('search_path', 'public', true)", "SELECT setval('public.users_id_seq', 1)", "SELECT 'public.users'::regclass", 'SELECT database_to_xml(true, true, $$x$$)', "SELECT E'\\'' || 'x'", ]) { await expect(store.query(sql), sql).rejects.toThrow(/not allowed for plugin databases/); } for (const sql of [ 'CREATE TEMP TABLE t (x int)', 'SELECT 1 AS x INTO t2', 'CREATE FUNCTION f() RETURNS int LANGUAGE sql AS $$ SELECT 1 $$', 'ALTER TABLE notes SET SCHEMA public', 'ALTER TABLE notes OWNER TO postgres', 'CREATE SCHEMA mine', 'DROP SCHEMA trek_plugin_pg_alpha CASCADE', 'SET search_path TO public', "COPY notes TO '/tmp/x'", 'CREATE TABLE copy AS SELECT * FROM public.users', 'CREATE VIEW v AS SELECT email FROM public.users', 'GRANT SELECT ON notes TO PUBLIC', 'DROP OWNED BY CURRENT_USER', ]) { await expect(store.exec(sql), sql).rejects.toThrow(/not allowed/); } // Nothing of TREK's was touched along the way. const [{ n }] = await withRequestContext(orm, () => orm.em.getConnection().execute>('select count(*) as n from users', [], 'all'), ); expect(n).toBeGreaterThanOrEqual(0); }); it("PGPLUG-004: two plugins never see each other's schema, even with tables of one name", async () => { const alpha = data.open('pg-alpha'); const beta = data.open('pg-beta'); await beta.migrate('001', 'CREATE TABLE notes (id bigserial PRIMARY KEY, body text NOT NULL)'); await beta.exec('INSERT INTO notes (body) VALUES ($1)', ['beta secret']); expect(await alpha.query('SELECT body FROM notes ORDER BY id')).toEqual([{ body: 'a' }, { body: 'b' }]); expect(await beta.query('SELECT body FROM notes')).toEqual([{ body: 'beta secret' }]); for (const sql of [ 'SELECT body FROM trek_plugin_pg_beta.notes', 'SELECT body FROM "trek_plugin_pg_beta".notes', 'SELECT body FROM trek_plugin_not_yet_installed.notes', ]) { await expect(alpha.query(sql), sql).rejects.toThrow(/another schema/); } // Its own schema, qualified, is fine. expect(await alpha.query('SELECT count(*) AS n FROM trek_plugin_pg_alpha.notes')).toEqual([{ n: 2 }]); }); it('PGPLUG-005: the row cap and the time budget hold, the budget even inside one statement', async () => { const store = cappedStore('pg-capped', { maxRows: 5, timeBudgetMs: 300 }); await expect(store.query('SELECT x FROM generate_series(1, 10) AS g(x)')).rejects.toThrow( 'query returned more than 5 rows', ); expect(await store.query('SELECT x FROM generate_series(1, 5) AS g(x)')).toHaveLength(5); await expect( store.tx([{ sql: 'SELECT 1 FROM generate_series(1, 3)' }, { sql: 'SELECT 1 FROM generate_series(1, 3)' }]), ).rejects.toThrow('tx returned more than 5 rows in total'); await expect(store.query('SELECT count(*) FROM generate_series(1, 2000000000)')).rejects.toThrow( 'query exceeded its 300 ms time budget', ); }); it('PGPLUG-006: a write that takes the schema past its quota is rolled back, a delete still runs', async () => { const store = cappedStore('pg-quota', { quotaBytes: 64 * 1024 }); await store.migrate('001', 'CREATE TABLE blobs (body text)'); await store.exec("INSERT INTO blobs SELECT repeat('x', 100) FROM generate_series(1, 10)"); await expect( store.exec('INSERT INTO blobs SELECT md5(x::text) FROM generate_series(1, 20000) AS g(x)'), ).rejects.toThrow(/past its 0\.0625 MB quota/); expect(await store.query('SELECT count(*) AS n FROM blobs')).toEqual([{ n: 10 }]); expect(await store.exec('DELETE FROM blobs WHERE length(body) > $1', [0])).toEqual({ changes: 10 }); }); it('PGPLUG-007: erasing a plugin drops its schema and its data directory, and only its own', async () => { data.open('pg-gone'); await data.open('pg-gone').migrate('001', 'CREATE TABLE t (x int)'); expect(fs.existsSync(path.join(dataDir, 'pg-gone'))).toBe(true); await data.erase('pg-gone'); const schemas = await pluginSchemas(); expect(schemas).not.toContain('trek_plugin_pg_gone'); expect(schemas).toEqual(expect.arrayContaining(['trek_plugin_pg_alpha', 'trek_plugin_pg_beta'])); expect(fs.existsSync(path.join(dataDir, 'pg-gone'))).toBe(false); // An id no schema can be made from has nothing to drop. await expect(data.erase('Not_An_Id')).resolves.toBeUndefined(); }); it('PGPLUG-008: through the RPC host, db.* reaches the plugin schema and db.engine says postgres', async () => { const router = { callPlugin: async () => undefined, emitPluginEvent: async () => {} }; const host = app.get(PluginRpcHostFactory).create('pg-rpc', new Set(['db:own']), router); const call = (method: string, params: Record) => host.dispatch({ k: 'req', id: method, method, params }); expect(await call('db.engine', {})).toMatchObject({ ok: true, result: { engine: 'postgres' } }); expect(await call('db.migrate', { id: '001', sql: 'CREATE TABLE t (v text)' })).toMatchObject({ ok: true }); expect(await call('db.exec', { sql: 'INSERT INTO t VALUES ($1)', args: ['x'] })).toMatchObject({ ok: true, result: { changes: 1 }, }); expect(await call('db.query', { sql: 'SELECT v FROM t' })).toMatchObject({ ok: true, result: [{ v: 'x' }] }); expect(await call('db.query', { sql: 'SELECT email FROM public.users' })).toMatchObject({ ok: false, error: { code: 'HOST_ERROR' }, }); expect(await pluginSchemas()).toContain('trek_plugin_pg_rpc'); closePluginDataDb('pg-rpc'); }); });