/** * PGPLUG-001..020 — 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, every statement runs alone, * the pool client a call used goes back without anything the call set, and * erasing a plugin drops its schema and nothing else. * * The lane connects as a superuser, which is exactly the role plugin SQL is * refused for (PGPLUG-013). So the stores here run as a role of the test's * own that may only create schemas in the database, the role TREK is meant * to run as, and the layers behind the role check are also shown to hold on * the superuser connection with that check switched off (PGPLUG-014 to 020). */ import type { DbSettings } from '../../src/app-config'; import { buildApp } from '../../src/bootstrap'; import { PRIVILEGED_ROLE_PLUGIN_REFUSAL, type PluginRoleGate } from '../../src/db/engine/postgres/plugin-data-checks'; import { type ConnectPluginClient, PluginDataSlots, type PluginSqlClient, poolClients, PostgresPluginDataStore, } from '../../src/db/engine/postgres/plugin-data-store'; import { TrekPostgreSqlDriver } from '../../src/db/engine/postgres/postgres-driver'; import { putTempSchemaLast } from '../../src/db/engine/postgres/session-search-path'; import { DATABASE_SETTINGS } from '../../src/nest/database/database-engine.module'; import { withRequestContext } from '../../src/nest/database/request-context'; import { PLUGIN_DATA, PostgresPluginDataBackend, 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 { withAdmin } from './databases'; import { MikroORM } from '@mikro-orm/core'; import type { INestApplication } from '@nestjs/common'; import type { DatabaseConnection } from 'kysely'; import fs from 'node:fs'; import os from 'node:os'; import path from 'node:path'; import Cursor from 'pg-cursor'; import { afterAll, beforeAll, describe, expect, it } from 'vitest'; /** The roles this file creates: cluster-wide, so named after the worker and the process. */ const ROLE = `trek_plugin_lane_${process.env.VITEST_POOL_ID ?? '0'}_${process.pid}`; const FILE_ROLE = `${ROLE}_files`; const PASSWORD = 'lane-plugin-role'; let app: INestApplication; let orm: MikroORM; /** The app's own backend, on the lane's superuser connection. */ let superData: PluginDataBackend; /** A backend like the app's, on a pool connected as {@link ROLE}. */ let data: PostgresPluginDataBackend; let roleOrm: MikroORM; let fileRoleOrm: MikroORM; let dataDir: string; /** The lane's URL for this file's database, as the superuser. */ function superUrl(): string { return process.env.TREK_DB_URL as string; } /** An ORM on this file's database as `role`, built as the app builds its own (TREK's driver, `pg_temp` last). */ async function ormAs(role: string): Promise { const url = new URL(superUrl()); url.username = role; url.password = PASSWORD; return MikroORM.init({ driver: TrekPostgreSqlDriver, clientUrl: url.toString(), entities: [], discovery: { warnWhenNoEntities: false }, pool: { min: 0, max: 4 }, onCreateConnection: (connection: unknown) => putTempSchemaLast(connection as DatabaseConnection), }); } 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); superData = app.get(PLUGIN_DATA, { strict: false }); const database = new URL(superUrl()).pathname.slice(1); await withAdmin(superUrl(), (run) => inSequence( [ ...[ROLE, FILE_ROLE].flatMap((role) => [ `create role "${role}" login password '${PASSWORD}'`, `grant create on database "${database}" to "${role}"`, ]), // Reading server files is one of the privileges the role check counts. `grant pg_read_server_files to "${FILE_ROLE}"`, ], (sql) => run(sql), ), ); roleOrm = await ormAs(ROLE); fileRoleOrm = await ormAs(FILE_ROLE); data = new PostgresPluginDataBackend(roleOrm, app.get(DATABASE_SETTINGS, { strict: false })); }, 60_000); afterAll(async () => { await roleOrm?.close(true); await fileRoleOrm?.close(true); await app?.close(); await withAdmin(superUrl(), (run) => inSequence( [ROLE, FILE_ROLE].flatMap((role) => [`drop owned by "${role}" cascade`, `drop role "${role}"`]), (sql) => run(sql), ), ); delete process.env.TREK_PLUGINS_DATA_DIR; fs.rmSync(dataDir, { recursive: true, force: true }); }, 60_000); /** `work` for each item, one after the other. */ async function inSequence(items: readonly T[], work: (item: T) => Promise): Promise { await items.reduce>((previous, item) => previous.then(() => work(item)), Promise.resolve()); } /** Runs `sql` as the superuser, outside any plugin store. */ async function asSuper(sql: string): Promise { return withRequestContext(orm, () => orm.em.getConnection().execute(sql, [], 'all')); } /** The plugin schemas the database holds now. */ async function pluginSchemas(): Promise { const rows = await asSuper<{ nspname: string }>( "select nspname from pg_namespace where starts_with(nspname, 'trek_plugin_') order by nspname", ); return rows.map((row) => row.nspname); } /** Clients of the pool connected as {@link ROLE}, as the backend hands them to a store. */ function appClients(): ConnectPluginClient { return poolClients(roleOrm.em.getConnection()); } /** A store as {@link ROLE} with limits small enough to reach in a test. */ function cappedStore( id: string, limits: { maxRows?: number; timeBudgetMs?: number; quotaBytes?: number; maxObjects?: number }, ) { return new PostgresPluginDataStore(id, appClients(), new PluginDataSlots(1), limits); } /** No role check: what the layers behind it hold on their own. */ const NO_ROLE_CHECK: PluginRoleGate = { refuseIfPrivileged: async () => undefined }; /** A store on the lane's superuser connection with the role check switched off. */ function superuserStore(id: string, limits: { quotaBytes?: number; maxObjects?: number } = {}) { return new PostgresPluginDataStore( id, poolClients(orm.em.getConnection()), new PluginDataSlots(1), limits, NO_ROLE_CHECK, ); } /** `client` for every call of a store, kept checked out by the test: a release only records whether it would close it. */ function keep(client: PluginSqlClient, released: boolean[] = []): ConnectPluginClient { return async () => ({ query: (arg: never) => client.query(arg), release: (destroy?: boolean) => released.push(destroy === true), }) as unknown as PluginSqlClient; } /** * Pool clients that hand Postgres `swap[text]` in place of a plugin statement * whose text is `text`, as a store would if the guard let a second statement * through: as an extended query or as a cursor, whichever the store sends. */ function smuggling(swap: Record): ConnectPluginClient { const connect = appClients(); return async () => { const client = await connect(); const query = (arg: unknown): unknown => { if (arg instanceof Cursor) { const cursor = arg as unknown as { text: string }; cursor.text = swap[cursor.text] ?? cursor.text; return client.query(arg); } const config = arg as { text?: unknown; values: unknown[] }; if (typeof config.text === 'string' && swap[config.text]) { return client.query({ ...config, text: swap[config.text] }); } return client.query(arg as never); }; return { query, release: (destroy?: boolean) => client.release(destroy) } as unknown as PluginSqlClient; }; } /** Whether the catalog type `name` still exists under that name. */ async function catalogType(name: string): Promise { const rows = await asSuper<{ n: number }>( `select count(*) as n from pg_type t join pg_namespace n on n.oid = t.typnamespace ` + `where n.nspname = 'pg_catalog' and t.typname = '${name}'`, ); return Number(rows[0].n) === 1; } 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/); await Promise.all( [ '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'", ].map((sql) => expect(store.query(sql), sql).rejects.toThrow(/not allowed for plugin databases/)), ); await Promise.all( [ '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', ].map((sql) => expect(store.exec(sql), sql).rejects.toThrow(/not allowed/)), ); // Nothing of TREK's was touched along the way. const [{ n }] = await asSuper<{ n: number }>('select count(*) as n from users'); 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' }]); await Promise.all( [ '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', ].map((sql) => 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.engine says postgres and db.* answers the role refusal on a superuser', 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' } }); const answers = await Promise.all([ call('db.migrate', { id: '001', sql: 'CREATE TABLE t (v text)' }), call('db.exec', { sql: 'INSERT INTO t VALUES ($1)', args: ['x'] }), call('db.query', { sql: 'SELECT 1' }), ]); const refused = { ok: false, error: { code: 'HOST_ERROR', message: PRIVILEGED_ROLE_PLUGIN_REFUSAL } }; expect(answers).toMatchObject([refused, refused, refused]); expect(await pluginSchemas()).not.toContain('trek_plugin_pg_rpc'); closePluginDataDb('pg-rpc'); }); it("PGPLUG-009: the review's bypasses are refused before they run: SQL hidden behind a CR, and SELECT ... INTO TEMP", async () => { const store = data.open('pg-bypass'); await store.migrate('001', 'CREATE TABLE notes (id bigserial PRIMARY KEY, body text NOT NULL)'); const reads = [ 'select 1 --\rfrom public.users', 'select 1 --x\rfrom public.users', 'select 1 --\r, email, password_hash from public.users', "(select 1 as id, 'admin' as role into temp users)", "(select 99 as id, 'forged'::text as name into temp users)", '((select 1 into t))', '(select 1) into t', 'select * from (select 1 into t) s', 'select 1 from public.users', ]; await Promise.all(reads.map((sql) => expect(store.query(sql), sql).rejects.toThrow(/not allowed for plugin/))); const scripts = [ "select 1 --\r; reset search_path; update users set role = 'admin' where id = 1", "insert into notes (body) values ('x') --x\r; update public.users set role = 1", "select 1 --x\r; create function f() returns int language sql as 'select 1'", "select 1 --\r; copy notes to program 'id'", '(select 1 into temp t)', 'select 1 into temporary t', ]; await Promise.all(scripts.map((sql) => expect(store.exec(sql), sql).rejects.toThrow(/not allowed for plugin/))); // Nothing hidden ran: no temporary table anywhere in the database, no function. The insert in front of the // CR is a statement of its own, which a script commits before the next one is refused, as on SQLite. const [{ temps, functions }] = await asSuper<{ temps: number; functions: number }>( "select (select count(*) from pg_class where relpersistence = 't') as temps, " + "(select count(*) from pg_proc where proname = 'f') as functions", ); expect({ temps, functions }).toEqual({ temps: 0, functions: 0 }); expect(await store.query('SELECT body FROM notes')).toEqual([{ body: 'x' }]); }); it('PGPLUG-010: every plugin statement runs alone: a second one smuggled into its text is refused by Postgres, not run', async () => { const store = data.open('pg-proto'); await store.migrate('001', 'CREATE TABLE t (x int)'); const two = 'insert into trek_plugin_pg_proto.t values (1); insert into trek_plugin_pg_proto.t values (2)'; // What the store would hand Postgres if the guard let a second statement through, as a write and as a read. const fooled = new PostgresPluginDataStore( 'pg-proto', smuggling({ 'INSERT INTO t VALUES (7)': two, 'SELECT x FROM t': `select x from t; ${two}` }), new PluginDataSlots(1), ); await expect(fooled.exec('INSERT INTO t VALUES (7)')).rejects.toThrow( /cannot insert multiple commands into a prepared statement/, ); await expect(fooled.exec('INSERT INTO t VALUES (7)', [])).rejects.toThrow(/cannot insert multiple commands/); await expect(fooled.tx([{ sql: 'INSERT INTO t VALUES (7)' }])).rejects.toThrow(/cannot insert multiple commands/); await expect(fooled.query('SELECT x FROM t')).rejects.toThrow(/cannot insert multiple commands/); expect(await store.query('SELECT count(*) AS n FROM t')).toEqual([{ n: 0 }]); // The same text over the simple protocol runs both, which is what sending each statement extended prevents. const client = await appClients()(); try { await client.query(two); } finally { client.release(); } expect(await store.query('SELECT count(*) AS n FROM t')).toEqual([{ n: 2 }]); // A single statement runs and reports its rows, with or without args. expect(await store.exec('DELETE FROM t WHERE x = $1', [1])).toEqual({ changes: 1 }); expect(await store.exec('DELETE FROM t')).toEqual({ changes: 0 }); expect(await store.exec('INSERT INTO t VALUES (5)', [])).toEqual({ changes: 0 }); expect(await store.tx([{ sql: 'INSERT INTO t VALUES (6)' }, { sql: 'DELETE FROM t' }])).toEqual({ results: [{ changes: 1 }, { changes: 2 }], }); }); it("PGPLUG-011: pg_temp is searched last, so a temporary table never stands in for TREK's tables or a plugin's", async () => { const [{ path: searchPath, schema }] = await asSuper<{ path: string; schema: string }>( "select current_setting('search_path') as path, current_schema() as schema", ); expect(searchPath).toMatch(/, pg_temp$/); expect(schema).toBe('public'); const store = data.open('pg-shadow'); await store.migrate('001', 'CREATE TABLE notes (body text)'); await store.exec('INSERT INTO notes VALUES ($1)', ['real']); // A pool client holding temporary tables named like TREK's and the plugin's, as one left behind would. const client = await appClients()(); try { await client.query("create temp table users as select 'forged'::text as email"); await client.query("create temp table notes as select 'forged'::text as body"); const released: boolean[] = []; const onClient = new PostgresPluginDataStore('pg-shadow', keep(client, released), new PluginDataSlots(1)); expect(await onClient.query('SELECT body FROM notes')).toEqual([{ body: 'real' }]); // Nor can the plugin reach them, or change them, by naming the temporary schema. await expect(onClient.query('SELECT body FROM pg_temp.notes')).rejects.toThrow(/"pg_temp" may not be named/); // The call dropped them with the rest of the session's state before it gave the client back. const temps = await client.query( "select count(*)::int as n from pg_class where relpersistence = 't' and relnamespace = pg_my_temp_schema()", ); expect(temps.rows).toEqual([{ n: 0 }]); expect(released).toEqual([false]); } finally { await client.query('drop table if exists pg_temp.users, pg_temp.notes'); client.release(); } }); it('PGPLUG-012: a call leaves nothing it set on the pool client it used, a cancelled one neither', async () => { const store = data.open('pg-session'); await store.migrate('001', 'CREATE TABLE notes (body text)'); const settings = "select current_setting('search_path') as path, current_setting('statement_timeout') as timeout, " + "current_setting('standard_conforming_strings') as strings, now() = statement_timestamp() as outside"; const client = await appClients()(); try { const before = await client.query(settings); const released: boolean[] = []; const onClient = new PostgresPluginDataStore('pg-session', keep(client, released), new PluginDataSlots(1), { timeBudgetMs: 300, }); await onClient.tx([{ sql: "INSERT INTO notes VALUES ('a')" }, { sql: 'SELECT body FROM notes' }]); await expect(onClient.query('SELECT count(*) FROM generate_series(1, 2000000000)')).rejects.toThrow( 'query exceeded its 300 ms time budget', ); await onClient.migrate('002', 'CREATE INDEX notes_body ON notes (body)'); // Same search_path and settings as before, and no transaction left open (now() moves with each statement). expect((await client.query(settings)).rows).toEqual(before.rows); expect(released).toEqual([false, false, false]); } finally { client.release(); } }); it('PGPLUG-013: on a privileged role every db:own call is refused with the reason, before anything is created', async () => { // The lane's own connection is a superuser: the app's backend refuses it. const store = superData.open('pg-privileged'); await Promise.all( [ store.migrate('001', 'CREATE TABLE t (x int)'), store.exec('CREATE TABLE t (x int)'), store.query('SELECT 1'), store.tx([{ sql: 'SELECT 1' }]), ].map((call) => expect(call).rejects.toThrow(PRIVILEGED_ROLE_PLUGIN_REFUSAL)), ); // A role that may read the server's files is refused as well. const settings = app.get(DATABASE_SETTINGS, { strict: false }); const files = new PostgresPluginDataBackend(fileRoleOrm, settings).open('pg-files'); await expect(files.query('SELECT 1')).rejects.toThrow(/db:own\) are refused on Postgres while TREK_DB_URL/); const schemas = await pluginSchemas(); expect(schemas).not.toContain('trek_plugin_pg_privileged'); expect(schemas).not.toContain('trek_plugin_pg_files'); }); // The re-review's escape: an unqualified ALTER TYPE renamed pg_catalog's types for the whole database. const CATALOG_TARGETS = [ 'alter type int4 rename to int4x', 'alter type text rename to evil', 'alter type cstring rename to foo', 'alter type box rename to boxx', 'ALTER TYPE "int4" RENAME TO x', 'alter type timestamptz owner to current_user', 'drop type if exists box cascade', 'drop type int4, text', ]; it('PGPLUG-014: ALTER and DROP of a catalog type are refused by where Postgres resolves it, on a superuser too', async () => { const refused = /schema "pg_catalog"; a plugin changes its own objects only|may not change the owner/; await Promise.all( [data.open('pg-types'), superuserStore('pg-types-su')].map(async (store) => { await Promise.all(CATALOG_TARGETS.map((sql) => expect(store.exec(sql), sql).rejects.toThrow(refused))); // TREK's own tables are not on the plugin's path, so a name of theirs resolves to nothing there. await expect(store.exec('drop table users')).rejects.toThrow(/does not exist/); await expect(store.exec('drop table if exists users, trips cascade')).resolves.toEqual({ changes: 0 }); await expect(store.exec('truncate users')).rejects.toThrow(/does not exist/); await expect(store.exec('create index evil on users (email)')).rejects.toThrow(/does not exist/); await expect(store.exec('create table kid (x int) inherits (users)')).rejects.toThrow(/does not exist/); }), ); const names = ['int4', 'text', 'cstring', 'box', 'timestamptz']; expect(await Promise.all(names.map(catalogType))).toEqual(names.map(() => true)); expect(await asSuper('select 1::int4 as one, 1::text as two')).toEqual([{ one: 1, two: '1' }]); expect((await asSuper<{ n: number }>("select count(*) as n from pg_class where relname = 'users'"))[0].n).toBe(1); }); it('PGPLUG-015: a plugin still changes its own objects of every kind', async () => { const own = async (store: PostgresPluginDataStore | ReturnType) => { await store.exec( "CREATE TYPE mood AS ENUM ('ok'); ALTER TYPE mood ADD VALUE 'sad'; ALTER TYPE mood RENAME TO feeling; " + 'CREATE TABLE t (id bigserial PRIMARY KEY, f feeling, temp real); CREATE TABLE kid (y int) INHERITS (t); ' + 'CREATE TABLE r (t_id bigint REFERENCES t (id)); CREATE INDEX t_f ON t (f); ALTER INDEX t_f RENAME TO t_g; ' + 'CREATE MATERIALIZED VIEW mv AS SELECT count(*) AS n FROM t; REFRESH MATERIALIZED VIEW mv; ' + 'ALTER TABLE t ADD COLUMN z int; CREATE SEQUENCE s; ALTER SEQUENCE s RESTART WITH 5; ' + 'TRUNCATE r, kid; DROP TABLE r; DROP MATERIALIZED VIEW mv; DROP SEQUENCE s', ); await store.exec("INSERT INTO t (f, temp) VALUES ('sad', 21.5)"); expect(await store.query('SELECT f, temp FROM t ORDER BY temp')).toEqual([{ f: 'sad', temp: 21.5 }]); await store.exec('DROP TABLE kid; DROP TABLE t; DROP TYPE feeling'); }; await Promise.all([own(data.open('pg-own')), own(superuserStore('pg-own-su'))]); }); it('PGPLUG-016: the quota counts every relation, sequences and TOAST included, and the object cap catalog-only objects', async () => { const sequences = cappedStore('pg-seq', { quotaBytes: 64 * 1024 }); const script = Array.from({ length: 20 }, (_, i) => `CREATE SEQUENCE s${i}`).join('; '); await expect(sequences.exec(script)).rejects.toThrow(/past its 0\.0625 MB quota/); const [{ made }] = await asSuper<{ made: number }>( 'select count(*) as made from pg_class c join pg_namespace n on n.oid = c.relnamespace ' + "where n.nspname = 'trek_plugin_pg_seq' and c.relkind = 'S'", ); expect(made).toBeGreaterThan(0); expect(made).toBeLessThan(20); const toast = cappedStore('pg-toast', { quotaBytes: 64 * 1024 }); await toast.migrate('001', 'CREATE TABLE big (body text)'); await expect( toast.exec("INSERT INTO big SELECT string_agg(md5(random()::text), '') FROM generate_series(1, 8000)"), ).rejects.toThrow(/past its 0\.0625 MB quota/); const views = Array.from({ length: 30 }, (_, i) => `CREATE VIEW v${i} AS SELECT ${i} AS n`).join('; '); const capped = async (store: PostgresPluginDataStore) => { await expect(store.exec(views)).rejects.toThrow(/holds more than 40 catalog objects/); await expect(store.exec("CREATE TYPE e AS ENUM ('a')")).rejects.toThrow(/holds more than 40 catalog objects/); // At the cap, dropping still works. await expect(store.exec('DROP VIEW v0')).resolves.toEqual({ changes: 0 }); }; await Promise.all([ capped(cappedStore('pg-objects', { maxObjects: 40 })), capped(superuserStore('pg-objects-su', { maxObjects: 40 })), ]); }); it('PGPLUG-017: the reg* types and the functions that look objects up by name are refused in every spelling', async () => { const payloads = [ "select 'public.users'::regtype::oid", "select cast('public.users' as regtype)", "select regtype 'public.users'", `select 'public.users'::"regtype"`, "select 'english'::regconfig", "select 'simple'::regdictionary", "select '{public.users}'::_regclass", "select has_table_privilege('public.users', 'select')", "select currtid2('public.users', '(0,1)')", "select to_regtype('public.users')", ]; const stores = [data.open('pg-reg'), superuserStore('pg-reg-su')]; await Promise.all( stores.flatMap((store) => payloads.map((sql) => expect(store.query(sql), sql).rejects.toThrow(/may not be named/)), ), ); }); it('PGPLUG-018: INTO makes no table unless INSERT or MERGE is the verb, whatever a column alias is called', async () => { const aliases = ['select 1 insert into t1', 'select 1 merge into t9', 'select 1 insert into unlogged t10']; const into = async (store: PostgresPluginDataStore | ReturnType, schema: string) => { await store.migrate('001', 'CREATE TABLE notes (id bigserial PRIMARY KEY, body text)'); await Promise.all( aliases.map((sql) => expect(store.exec(sql), sql).rejects.toThrow(/SELECT \.\.\. INTO is not allowed/)), ); const [{ made }] = await asSuper<{ made: number }>( `select count(*) as made from pg_class c join pg_namespace n on n.oid = c.relnamespace ` + `where n.nspname = '${schema}' and c.relname in ('t1', 't9', 't10')`, ); expect(made).toBe(0); // INSERT INTO as the verb, after a WITH clause and inside one, still writes. await store.exec("WITH x AS (SELECT 'a' AS b) INSERT INTO notes (body) SELECT b FROM x"); expect( await store.query("WITH n AS (INSERT INTO notes (body) VALUES ('b') RETURNING id) SELECT count(*) AS n FROM n"), ).toEqual([{ n: 1 }]); expect(await store.query('SELECT body FROM notes ORDER BY id')).toEqual([{ body: 'a' }, { body: 'b' }]); }; await Promise.all([ into(data.open('pg-into'), 'trek_plugin_pg_into'), into(superuserStore('pg-into-su'), 'trek_plugin_pg_into_su'), ]); }); it('PGPLUG-019: TEMP is refused where it makes a temporary object, and a column named temp works again', async () => { const store = data.open('pg-temp'); await Promise.all( [ 'CREATE TEMP TABLE t (x int)', 'CREATE LOCAL TEMPORARY TABLE t (x int)', 'CREATE OR REPLACE TEMP VIEW v AS SELECT 1', 'CREATE TEMPORARY SEQUENCE s', 'select 1 into temp t', '(select 1 as id into temporary users)', ].map((sql) => expect(store.exec(sql), sql).rejects.toThrow(/not allowed/)), ); await store.migrate('001', 'CREATE TABLE readings (day text, temp real)'); await store.exec('INSERT INTO readings (day, temp) VALUES ($1, $2), ($3, $4)', ['mon', 21.5, 'tue', 18]); expect(await store.query('SELECT day, temp FROM readings WHERE temp > 1 ORDER BY temp')).toEqual([ { day: 'tue', temp: 18 }, { day: 'mon', temp: 21.5 }, ]); const [{ temps }] = await asSuper<{ temps: number }>( "select count(*) as temps from pg_class where relpersistence = 't'", ); expect(temps).toBe(0); }); it('PGPLUG-020: a NUL in an argument or in the SQL is refused with the reason, and nothing is stored', async () => { const store = data.open('pg-nul'); await store.migrate('001', 'CREATE TABLE kv (k text PRIMARY KEY)'); const reason = /U\+0000 \(NUL\), which Postgres text cannot store/; await expect(store.exec('INSERT INTO kv VALUES ($1)', ['a\u0000b'])).rejects.toThrow(reason); await expect(store.query('SELECT k FROM kv WHERE k = $1', ['ab\u0000'])).rejects.toThrow(reason); await expect(store.tx([{ sql: 'INSERT INTO kv VALUES ($1)', args: [['x', '\u0000']] }])).rejects.toThrow(reason); await expect(store.migrate('002\u0000', 'CREATE TABLE more (x int)')).rejects.toThrow(reason); await expect(store.exec("INSERT INTO kv VALUES ('a\u0000b')")).rejects.toThrow(/U\+0000 \(NUL\)/); expect(await store.query('SELECT count(*) AS n FROM kv')).toEqual([{ n: 0 }]); // Binary data with a zero byte goes to bytea. await store.migrate('003', 'CREATE TABLE raw (b bytea)'); await store.exec('INSERT INTO raw VALUES ($1)', [Buffer.from([1, 0, 2])]); expect(await store.query('SELECT length(b) AS n FROM raw')).toEqual([{ n: 3 }]); }); });