fix(db): hold plugin SQL on Postgres in layers the database enforces

The token guard kept leaking: on a superuser connection an unqualified
`alter type int4 rename to int4x` renamed pg_catalog's type for the whole
server, sequences and catalog-only objects grew the database past the quota,
regtype/regconfig/regdictionary looked TREK's objects up by name, and a
column alias named insert or merge in front of INTO made a table. Instead
of a longer word list, the store now asks the database:

- No plugin SQL while TREK's role is privileged in the sense of the restore
  check (PRIVILEGED_ROLE_SQL, imported from server-checks.ts): every db:own
  call fails with PRIVILEGED_ROLE_PLUGIN_REFUSAL, read once per pool
  connection, and the boot log says why.
- The objects an ALTER, DROP, REFRESH, TRUNCATE or CREATE INDEX ... ON
  changes, and the tables a CREATE or ALTER TABLE ties to its own, are
  resolved with to_regclass/to_regtype in the transaction right before the
  statement, and it is refused unless each one found lies in the plugin's
  schema. An unqualified int4, text or box is pg_catalog's and refused even
  with the role check off.
- The quota counts every relation of the schema with its TOAST table, and a
  schema holds at most PLUGIN_SCHEMA_MAX_OBJECTS catalog objects (relations,
  types, constraints, enum labels).
- The guard refuses every reg* type and its array in every spelling, the
  has_*_privilege functions, currtid2 and the BRIN/GIN maintenance
  functions; INTO only after the INSERT or MERGE that is the statement's
  verb or a WITH body's; TEMP only where it makes a temporary object
  (CREATE TEMP/TEMPORARY, SELECT ... INTO TEMP), so a column named temp
  works again; a base type; and a NUL anywhere in the SQL text.
- A bound value or a migration id holding NUL is refused with the reason
  instead of being stripped, so the plugin's keys never change meaning.

Every bypass from the re-review is a test on the real database, on the
role the plugin data is meant to run as and on a superuser connection with
the role check off.
This commit is contained in:
Maurice
2026-11-17 22:28:38 +01:00
parent da1a02e7a8
commit f1ea716305
10 changed files with 1097 additions and 151 deletions
+322 -51
View File
@@ -1,5 +1,5 @@
/**
* PGPLUG-001..012 — a plugin's own data (`db:own`) on Postgres, against the
* 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,
@@ -7,8 +7,16 @@
* 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,
@@ -16,62 +24,147 @@ import {
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, type PluginDataBackend } from '../../src/nest/plugins/host/plugin-data.backend';
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;
let data: PluginDataBackend;
/** 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<MikroORM> {
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);
data = app.get<PluginDataBackend>(PLUGIN_DATA, { strict: false });
superData = app.get<PluginDataBackend>(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<DbSettings>(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<T>(items: readonly T[], work: (item: T) => Promise<unknown>): Promise<void> {
await items.reduce<Promise<unknown>>((previous, item) => previous.then(() => work(item)), Promise.resolve());
}
/** Runs `sql` as the superuser, outside any plugin store. */
async function asSuper<T>(sql: string): Promise<T[]> {
return withRequestContext(orm, () => orm.em.getConnection().execute<T[]>(sql, [], 'all'));
}
/** The plugin schemas the database holds now. */
async function pluginSchemas(): Promise<string[]> {
const rows = await withRequestContext(orm, () =>
orm.em
.getConnection()
.execute<Array<{ nspname: string }>>(
"select nspname from pg_namespace where starts_with(nspname, 'trek_plugin_') order by nspname",
[],
'all',
),
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 app's pool, as the backend hands them to a store. */
/** Clients of the pool connected as {@link ROLE}, as the backend hands them to a store. */
function appClients(): ConnectPluginClient {
return poolClients(orm.em.getConnection());
return poolClients(roleOrm.em.getConnection());
}
/** 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 }) {
/** 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 () =>
@@ -106,6 +199,15 @@ function smuggling(swap: Record<string, string>): ConnectPluginClient {
};
}
/** Whether the catalog type `name` still exists under that name. */
async function catalogType(name: string): Promise<boolean> {
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');
@@ -191,9 +293,7 @@ describe('plugin data on Postgres', () => {
].map((sql) => 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<Array<{ n: number }>>('select count(*) as n from users', [], 'all'),
);
const [{ n }] = await asSuper<{ n: number }>('select count(*) as n from users');
expect(n).toBeGreaterThanOrEqual(0);
});
@@ -256,24 +356,21 @@ describe('plugin data on Postgres', () => {
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 () => {
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<string, unknown>) =>
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');
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');
});
@@ -289,7 +386,7 @@ describe('plugin data on Postgres', () => {
'((select 1 into t))',
'(select 1) into t',
'select * from (select 1 into t) s',
'select 1 from public.users',
'select 1 from public.users',
];
await Promise.all(reads.map((sql) => expect(store.query(sql), sql).rejects.toThrow(/not allowed for plugin/)));
const scripts = [
@@ -304,15 +401,9 @@ describe('plugin data on Postgres', () => {
// 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 withRequestContext(orm, () =>
orm.em
.getConnection()
.execute<Array<{ 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",
[],
'all',
),
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' }]);
@@ -356,16 +447,10 @@ describe('plugin data on Postgres', () => {
});
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, schema }] = await withRequestContext(orm, () =>
orm.em
.getConnection()
.execute<Array<{ path: string; schema: string }>>(
"select current_setting('search_path') as path, current_schema() as schema",
[],
'all',
),
const [{ path: searchPath, schema }] = await asSuper<{ path: string; schema: string }>(
"select current_setting('search_path') as path, current_schema() as schema",
);
expect(path).toMatch(/, pg_temp$/);
expect(searchPath).toMatch(/, pg_temp$/);
expect(schema).toBe('public');
const store = data.open('pg-shadow');
@@ -379,6 +464,8 @@ describe('plugin data on Postgres', () => {
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()",
@@ -416,4 +503,188 @@ describe('plugin data on Postgres', () => {
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<DbSettings>(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<PluginDataBackend['open']>) => {
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<PluginDataBackend['open']>, 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 }]);
});
});
+8 -1
View File
@@ -269,7 +269,14 @@ describe('moving a SQLite install to Postgres', () => {
const highest = Math.max(...(await findRows(sqliteOrm, Users)).map((row) => row.id));
expect(user.id).toBeGreaterThan(highest);
const store = new PostgresPluginDataStore(PLUGIN_ID, poolClients(pgOrm.em.getConnection()), new PluginDataSlots(1));
// The lane connects as a superuser, for which plugin SQL is refused (PGPLUG-013); the move is what is read here.
const store = new PostgresPluginDataStore(
PLUGIN_ID,
poolClients(pgOrm.em.getConnection()),
new PluginDataSlots(1),
{},
{ refuseIfPrivileged: async () => undefined },
);
expect(await store.query('select id, body, score from notes order by id')).toEqual([
{ id: 1, body: 'first', score: 1.5 },
{ id: 2, body: 'second', score: null },
@@ -10,6 +10,7 @@
* store on a real database is the Postgres lane's
* tests/postgres/plugin-data.test.ts.
*/
import { PRIVILEGED_ROLE_PLUGIN_REFUSAL } from '../../../../../src/db/engine/postgres/plugin-data-checks';
import {
dropPluginSchema,
END_SESSION,
@@ -18,6 +19,7 @@ import {
PostgresPluginDataStore,
type PluginSqlClient,
} from '../../../../../src/db/engine/postgres/plugin-data-store';
import { PRIVILEGED_ROLE_SQL } from '../../../../../src/db/engine/postgres/server-checks';
import type { Kysely } from 'kysely';
import Cursor from 'pg-cursor';
@@ -28,6 +30,12 @@ interface FakeOptions {
schemas?: string[];
/** The sizes the quota reads answer, in order. */
sizes?: number[];
/** The catalog object counts the quota reads answer, in order. */
objects?: number[];
/** Whether the role check answers that TREK's role is privileged. */
privileged?: boolean;
/** The objects the target check finds outside the plugin's schema. */
foreign?: Array<{ name: string; nspname: string }>;
/** Rows a cursor yields, by its statement's text; read two at a time. */
rows?: Record<string, unknown[]>;
/** What a write reports as changed. */
@@ -62,6 +70,7 @@ function fakePool(options: FakeOptions = {}) {
const cursors: Array<{ text: string; values: unknown[] | null; closed: boolean }> = [];
const releases: boolean[] = [];
let size = 0;
let objects = 0;
const run = (sql: string) => {
log.push(sql);
const err = options.fail?.(sql);
@@ -69,7 +78,14 @@ function fakePool(options: FakeOptions = {}) {
};
const answer = (sql: string) => {
if (sql.startsWith('select nspname')) return { rows: (options.schemas ?? []).map((nspname) => ({ nspname })) };
if (sql.startsWith('select coalesce(sum(')) return { rows: [{ bytes: options.sizes?.[size++] ?? 0 }], rowCount: 1 };
if (sql.startsWith('select (exists')) return { rows: [{ privileged: options.privileged === true }], rowCount: 1 };
if (sql.startsWith('select t.name')) return { rows: options.foreign ?? [], rowCount: 0 };
if (sql.startsWith('select coalesce((select sum(')) {
return {
rows: [{ bytes: options.sizes?.[size++] ?? 0, objects: options.objects?.[objects++] ?? 0 }],
rowCount: 1,
};
}
if (sql.startsWith('select 1 from')) return { rows: options.migrated ? [{ '?column?': 1 }] : [], rowCount: 0 };
return { rows: [], rowCount: options.changes ?? 0 };
};
@@ -119,6 +135,9 @@ function store(options: FakeOptions = {}, limits = {}) {
return { ...pool, store: new PostgresPluginDataStore('notes', pool.connect, new PluginDataSlots(4), limits) };
}
/** The role check every first call on a client runs before its transaction. */
const ROLE_CHECK = `select (${PRIVILEGED_ROLE_SQL}) as privileged`;
/** A pg error with its SQLSTATE. */
function pgError(code: string, message: string): Error {
return Object.assign(new Error(message), { code });
@@ -132,6 +151,7 @@ describe('Postgres plugin data store', () => {
expect(s.engine).toBe('postgres');
expect(await s.query('SELECT body FROM notes')).toEqual([{ body: 'a' }, { body: 'b' }, { body: 'c' }]);
expect(log).toEqual([
ROLE_CHECK,
'begin',
[
'create schema if not exists "trek_plugin_notes"',
@@ -199,7 +219,7 @@ describe('Postgres plugin data store', () => {
const reads = store({}, { quotaBytes: 1 });
await reads.store.query('SELECT 1');
expect(reads.log.some((sql) => sql.startsWith('select coalesce(sum('))).toBe(false);
expect(reads.log.some((sql) => sql.startsWith('select coalesce((select sum('))).toBe(false);
});
it('PGSTORE-006: a script commits statement by statement and stops at the first that fails', async () => {
@@ -304,7 +324,7 @@ describe('Postgres plugin data store', () => {
expect(configs.filter((q) => q.queryMode === 'extended')).toHaveLength(plugin.length);
});
it('PGSTORE-013: every read goes through a cursor on the same client, closed however the read ends, args without NUL', async () => {
it('PGSTORE-013: every read goes through a cursor on the same client, closed however the read ends', async () => {
// EXTQ-002 before the store checked out its own clients: what is not a plugin write reaches pg as it was.
const rows = Array.from({ length: 7 }, (_, i) => ({ i }));
const {
@@ -312,9 +332,9 @@ describe('Postgres plugin data store', () => {
cursors,
configs,
} = store({ rows: { 'SELECT i FROM t WHERE x = $1': rows, 'SELECT 1 FROM t': [{}] } }, { maxRows: 5 });
await expect(s.query('SELECT i FROM t WHERE x = $1', ['a\u0000b'])).rejects.toThrow('more than 5 rows');
await expect(s.query('SELECT i FROM t WHERE x = $1', ['ab'])).rejects.toThrow('more than 5 rows');
await s.exec('SELECT 1 FROM t', ['x']);
await s.exec('INSERT INTO t VALUES ($1)', ['c\u0000d']);
await s.exec('INSERT INTO t VALUES ($1)', ['cd']);
expect(cursors).toEqual([
{ text: 'SELECT i FROM t WHERE x = $1', values: ['ab'], closed: true },
{ text: 'SELECT 1 FROM t', values: ['x'], closed: true },
@@ -322,6 +342,77 @@ describe('Postgres plugin data store', () => {
expect(configs.find((q) => q.text.startsWith('INSERT'))?.values).toEqual(['cd']);
});
it('PGSTORE-016: an argument or a migration id holding NUL is refused before a client is taken, never altered', async () => {
const { store: s, log, releases } = store();
const nul = /U\+0000 \(NUL\), which Postgres text cannot store/;
await expect(s.query('SELECT 1 FROM t WHERE k = $1', ['a\u0000b'])).rejects.toThrow(nul);
await expect(s.exec('INSERT INTO t VALUES ($1)', [['x', 'c\u0000d']])).rejects.toThrow(nul);
await expect(s.tx([{ sql: 'SELECT 1' }, { sql: 'DELETE FROM t WHERE k = $1', args: ['\u0000'] }])).rejects.toThrow(
nul,
);
await expect(s.migrate('001\u0000', 'CREATE TABLE t (k text)')).rejects.toThrow(nul);
expect({ log, releases }).toEqual({ log: [], releases: [] });
// A Buffer goes to bytea, which holds any byte.
await expect(s.exec('INSERT INTO t VALUES ($1)', [Buffer.from([0, 1])])).resolves.toEqual({ changes: 0 });
});
it('PGSTORE-017: a privileged role is refused before the transaction opens, and the answer is kept per connection', async () => {
const privileged = store({ privileged: true });
await expect(privileged.store.query('SELECT 1')).rejects.toThrow(PRIVILEGED_ROLE_PLUGIN_REFUSAL);
await expect(privileged.store.exec('CREATE TABLE t (x int)')).rejects.toThrow(/db:own\) are refused on Postgres/);
// One read for the connection, no transaction, and the client goes back clean.
expect(privileged.log).toEqual([ROLE_CHECK, END_SESSION, END_SESSION]);
expect(privileged.releases).toEqual([false, false]);
const plain = store();
await plain.store.query('SELECT 1');
await plain.store.query('SELECT 2');
expect(plain.log.filter((sql) => sql === ROLE_CHECK)).toHaveLength(1);
// A read that failed is asked again on the next call.
let fails = 1;
const flaky = store({ fail: (sql) => (sql === ROLE_CHECK && fails-- > 0 ? new Error('reset') : undefined) });
await expect(flaky.store.query('SELECT 1')).rejects.toThrow('reset');
await expect(flaky.store.query('SELECT 1')).resolves.toEqual([]);
expect(flaky.log.filter((sql) => sql === ROLE_CHECK)).toHaveLength(2);
});
it('PGSTORE-018: the objects a statement changes are resolved right before it runs, and one outside the schema refuses it', async () => {
const own = store();
await own.store.migrate('001', 'CREATE TABLE a (x int); ALTER TYPE mood RENAME TO feeling; DROP TABLE "B", c');
const checks = own.configs.filter((q) => q.text.startsWith('select t.name'));
expect(checks.map((q) => q.values)).toEqual([
[['"mood"'], ['type'], 'trek_plugin_notes'],
[['"B"', '"c"'], ['relation', 'relation'], 'trek_plugin_notes'],
]);
// Each check comes right before its statement, after the ones before it ran.
const order = own.log
.filter((sql) => /^(select t\.name|CREATE|ALTER|DROP)/.test(sql))
.map((sql) => sql.slice(0, 13));
expect(order).toEqual(['CREATE TABLE ', 'select t.name', 'ALTER TYPE mo', 'select t.name', 'DROP TABLE "B']);
const foreign = store({ foreign: [{ name: '"int4"', nspname: 'pg_catalog' }] });
await expect(foreign.store.exec('ALTER TYPE int4 RENAME TO int4x')).rejects.toThrow(
/"int4" is an object of the schema "pg_catalog"; a plugin changes its own objects only/,
);
expect(foreign.log).not.toContain('ALTER TYPE int4 RENAME TO int4x');
expect(foreign.log.slice(-2)).toEqual(['rollback', END_SESSION]);
// A statement that changes no existing object asks nothing.
const plain = store();
await plain.store.exec('INSERT INTO a VALUES (1)');
expect(plain.log.some((sql) => sql.startsWith('select t.name'))).toBe(false);
});
it('PGSTORE-019: a write that takes the schema past its object cap and adds objects rolls back; a drop still runs', async () => {
const grows = store({ sizes: [0, 0], objects: [10, 11] }, { maxObjects: 10 });
await expect(grows.store.exec('CREATE TABLE t (x int)')).rejects.toThrow(
'the plugin database holds more than 10 catalog objects',
);
expect(grows.log.slice(-2)).toEqual(['rollback', END_SESSION]);
const drops = store({ sizes: [0, 0], objects: [12, 11] }, { maxObjects: 10 });
await expect(drops.store.exec('DROP TABLE t')).resolves.toEqual({ changes: 0 });
});
it('PGSTORE-014: each transaction checks out a client of its own and gives it back clean, or closes it', async () => {
const ok = store({ changes: 1 });
await ok.store.exec('INSERT INTO a VALUES (1); INSERT INTO b VALUES (2)');
@@ -11,6 +11,7 @@ import {
parsePluginSql,
PluginSqlRefused,
tokenize,
type PluginTarget,
} from '../../../../../src/db/engine/postgres/plugin-sql-guard';
import { describe, expect, it } from 'vitest';
@@ -63,6 +64,20 @@ describe('plugin SQL guard', () => {
'WITH gone AS (DELETE FROM notes RETURNING id) INSERT INTO trash SELECT id FROM gone',
'MERGE INTO notes n USING incoming i ON n.id = i.id WHEN NOT MATCHED THEN INSERT (body) VALUES (i.body)',
'SELECT body AS "into", "temporary" FROM notes',
// TEMP is refused only where it makes a temporary object; a column of that name is fine.
'CREATE TABLE readings (day text, temp real, temporary bool)',
'SELECT day, temp FROM readings WHERE temp > 1 ORDER BY temp',
'select 1 from notes as temporary',
'INSERT INTO temp (x) VALUES (1)',
// INSERT INTO in a WITH query's body or after a WITH clause is the statement's own verb.
'WITH n AS (INSERT INTO notes (body) VALUES ($1) RETURNING id) SELECT id FROM n',
'WITH n AS NOT MATERIALIZED (SELECT 1) INSERT INTO notes (body) SELECT * FROM n',
'WITH n AS MATERIALIZED (INSERT INTO notes (body) VALUES (1) RETURNING id) SELECT 1',
// Names that only start like a refused one.
'SELECT region, regexp_replace(body, $1, $2), regr_slope(1, 2) FROM notes',
'CREATE TYPE span AS RANGE (subtype = float8)',
'CREATE TABLE index (x int)',
'CREATE INDEX ON notes (body)',
])('lets through %s', (sql) => {
expect(() => check(sql)).not.toThrow();
});
@@ -126,7 +141,6 @@ describe('plugin SQL guard', () => {
['SELECT `x`', /unexpected character/],
['SELECT 1; SELECT * FROM public.users', /another schema/],
['SELECT 1 FROM notes INTO TEMP copy', /SELECT \.\.\. INTO/],
['SELECT * FROM notes WHERE temp > 1', /TEMP/],
['SELECT 0x1F', /hexadecimal/],
['SELECT 0o17, 0b1', /hexadecimal/],
['SELECT 1_000', /digit separators/],
@@ -165,8 +179,33 @@ describe('plugin SQL guard', () => {
['CREATE TEMP VIEW v AS SELECT 1', /CREATE TEMP is not allowed/],
['CREATE OR REPLACE TEMP VIEW v AS SELECT 1', /CREATE TEMP is not allowed/],
['CREATE TEMPORARY SEQUENCE s', /CREATE TEMPORARY is not allowed/],
['select temp from notes', /TEMP/],
['select 1 from notes as temporary', /TEMPORARY/],
// The re-review's bypasses. A column alias named insert or merge in front of INTO made a table.
['select 1 insert into t1', /SELECT \.\.\. INTO/],
['select 1 merge into t9', /SELECT \.\.\. INTO/],
['select 1 insert into unlogged t10', /SELECT \.\.\. INTO/],
['select x as insert into t from notes', /SELECT \.\.\. INTO/],
['WITH x AS (SELECT 1) SELECT 1 insert INTO t', /SELECT \.\.\. INTO/],
['insert into notes select 1 insert into t', /SELECT \.\.\. INTO/],
['select 1 insert into temp t', /SELECT \.\.\. INTO TEMP/],
// The reg* types and functions that look an object up by a name in a string, in every spelling.
["select 'public.users'::regtype::oid", /"regtype" may not be named/],
["select cast('int4' as regtype)", /"regtype" may not be named/],
["select regtype 'text'", /"regtype" may not be named/],
[`select 'x'::"regtype"`, /"regtype" may not be named/],
["select 'english'::regconfig", /"regconfig" may not be named/],
["select 'simple'::regdictionary", /"regdictionary" may not be named/],
["select '{public.users}'::_regclass", /"_regclass" may not be named/],
["select 'x'::pg_catalog.regtype", /"pg_catalog" may not be named/],
["select has_table_privilege('public.users', 'select')", /"has_table_privilege" may not be named/],
["select currtid2('public.users', '(0,1)')", /"currtid2" may not be named/],
["select gin_clean_pending_list('public.users_idx')", /"gin_clean_pending_list" may not be named/],
["select to_regtype('int4')", /"to_regtype" may not be named/],
// A base type is built from C functions, which only a superuser may do.
['CREATE TYPE fake (INPUT = int4in, OUTPUT = int4out, INTERNALLENGTH = 1000)', /composite, enum or range/],
// The protocol ends a statement's text at a NUL, in a string as anywhere else.
["select 'a\u0000' -- then\nfrom public.users", /U\+0000/],
['CREATE INDEX i (x)', /must name its table with ON/],
['ALTER TABLE', /could not be read/],
])('refuses the bypass %j', (sql, reason) => {
expect(() => check(sql)).toThrow(PluginSqlRefused);
expect(() => check(sql)).toThrow(reason);
@@ -234,6 +273,54 @@ describe('plugin SQL guard', () => {
expect(qualified.qualifies).toBe(true);
});
it('refuses TEMP where it makes a temporary object, and says so', () => {
for (const sql of [
'CREATE TEMP TABLE t (x int)',
'CREATE TEMPORARY VIEW v AS SELECT 1',
'CREATE OR REPLACE TEMP VIEW v AS SELECT 1',
'CREATE LOCAL TEMP TABLE t (x int)',
'CREATE GLOBAL TEMPORARY TABLE t (x int)',
]) {
expect(() => check(sql), sql).toThrow(/is not allowed: a temporary object outlives the call/);
}
expect(() => check('select 1 into temp t')).toThrow(/SELECT \.\.\. INTO TEMP is not allowed: no temporary tables/);
expect(() => check('CREATE LOCAL TABLE t (x int)')).toThrow(/CREATE LOCAL is not allowed$/);
});
it('names the existing objects a statement changes, for the store to resolve in its transaction', () => {
const targets = (sql: string) => parsePluginSql(sql)[0].targets;
const rel = (...name: string[]): PluginTarget => ({ kind: 'relation', name });
expect(targets('ALTER TYPE int4 RENAME TO int4x')).toEqual([{ kind: 'type', name: ['int4'] }]);
expect(targets('DROP TYPE IF EXISTS mood, "Text" CASCADE')).toEqual([
{ kind: 'type', name: ['mood'] },
{ kind: 'type', name: ['Text'] },
]);
expect(targets('DROP TABLE IF EXISTS a, "B", trek_plugin_notes.c CASCADE')).toEqual([
rel('a'),
rel('B'),
rel('trek_plugin_notes', 'c'),
]);
expect(targets('DROP INDEX CONCURRENTLY IF EXISTS i')).toEqual([rel('i')]);
expect(targets('DROP MATERIALIZED VIEW mv')).toEqual([rel('mv')]);
expect(targets('REFRESH MATERIALIZED VIEW CONCURRENTLY mv WITH DATA')).toEqual([rel('mv')]);
expect(targets('TRUNCATE TABLE ONLY a, b * RESTART IDENTITY')).toEqual([rel('a'), rel('b')]);
expect(targets('TRUNCATE a')).toEqual([rel('a')]);
expect(targets('CREATE UNIQUE INDEX CONCURRENTLY IF NOT EXISTS i ON ONLY t USING btree (x)')).toEqual([rel('t')]);
expect(targets('CREATE INDEX ON t (x)')).toEqual([rel('t')]);
expect(targets('ALTER MATERIALIZED VIEW IF EXISTS mv RENAME TO mv2')).toEqual([rel('mv')]);
expect(targets('ALTER TABLE IF EXISTS ONLY t ADD CONSTRAINT f FOREIGN KEY (x) REFERENCES p (id)')).toEqual([
rel('t'),
rel('p'),
]);
expect(targets('CREATE TABLE c (x int REFERENCES p) INHERITS (q, r)')).toEqual([rel('p'), rel('q'), rel('r')]);
expect(targets('CREATE TABLE c PARTITION OF p FOR VALUES IN (1)')).toEqual([rel('p')]);
expect(targets('ALTER TABLE p ATTACH PARTITION c FOR VALUES IN (1)')).toEqual([rel('p'), rel('c')]);
expect(targets('ALTER TABLE c NO INHERIT p')).toEqual([rel('c'), rel('p')]);
expect(targets('CREATE TABLE t (x int)')).toEqual([]);
expect(targets('SELECT 1')).toEqual([]);
expect(() => parsePluginSql('DROP TABLE a.b.c.d')).toThrow(/at most three parts/);
});
it('turns a SQLite ? placeholder into a message about $1 when args are bound', () => {
const [sqliteStyle] = parsePluginSql('SELECT * FROM notes WHERE id = ?');
expect(() => checkPlaceholders(sqliteStyle, [1])).toThrow(/\$1, \$2/);
@@ -7,7 +7,9 @@
*/
import type { DbSettings } from '../../../src/app-config';
import type { DatabaseEngine } from '../../../src/db/engine';
import { PRIVILEGED_ROLE_PLUGIN_REFUSAL } from '../../../src/db/engine/postgres/plugin-data-checks';
import { PostgresPluginDataStore } from '../../../src/db/engine/postgres/plugin-data-store';
import { PRIVILEGED_ROLE_DESCRIPTION } from '../../../src/db/engine/postgres/server-checks';
import {
PLUGIN_DATA,
PLUGIN_DATA_PROVIDERS,
@@ -21,7 +23,13 @@ import type { FactoryProvider } 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';
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
const { logWarn } = vi.hoisted(() => ({ logWarn: vi.fn() }));
vi.mock('../../../src/nest/audit/audit-log.logger', async (importOriginal) => ({
...(await importOriginal<typeof import('../../../src/nest/audit/audit-log.logger')>()),
logWarn,
}));
let tmp: string;
beforeAll(() => {
@@ -33,15 +41,30 @@ afterAll(() => {
fs.rmSync(tmp, { recursive: true, force: true });
});
/** An ORM whose Kysely client records the SQL it is handed. */
function fakeOrm(executed: string[]): MikroORM {
/**
* An ORM whose Kysely client records the SQL it is handed, and whose pool
* hands out a client answering the role check with `privileged` (or failing
* with it, when it is an Error).
*/
function fakeOrm(executed: string[], privileged: boolean | Error = false, released: boolean[] = []): MikroORM {
const client = {
executeQuery: async (query: { sql: string }) => {
executed.push(query.sql);
return { rows: [] };
},
};
return { em: { getConnection: () => ({ getClient: () => client }) } } as unknown as MikroORM;
const pgClient = {
query: async (sql: string) => {
executed.push(sql);
if (privileged instanceof Error) throw privileged;
return { rows: [{ privileged }], rowCount: 1 };
},
release: (destroy?: boolean) => released.push(destroy === true),
};
const pool = { connect: async () => pgClient };
return {
em: { getConnection: () => ({ getClient: () => client, getNativeClient: async () => pool }) },
} as unknown as MikroORM;
}
const POSTGRES = { engine: 'postgres', url: 'postgres://trek@db/trek', poolMax: 4 } as unknown as DbSettings;
@@ -101,4 +124,30 @@ describe('plugin data port', () => {
await expect(store.query('SELECT 1')).rejects.toThrow('The database connection is not open');
await expect(store.query('SELECT * FROM public.users')).rejects.toThrow('The database connection is not open');
});
it("PLUGDATA-006: on Postgres the boot log says when TREK's role keeps plugin databases refused, and why", async () => {
logWarn.mockClear();
const released: boolean[] = [];
await new PostgresPluginDataBackend(fakeOrm([], true, released), POSTGRES).onApplicationBootstrap();
expect(logWarn).toHaveBeenCalledWith(PRIVILEGED_ROLE_PLUGIN_REFUSAL);
expect(PRIVILEGED_ROLE_PLUGIN_REFUSAL).toContain(PRIVILEGED_ROLE_DESCRIPTION);
expect(released).toEqual([false]);
logWarn.mockClear();
await new PostgresPluginDataBackend(fakeOrm([], false), POSTGRES).onApplicationBootstrap();
await new PostgresPluginDataBackend(fakeOrm([], true), SQLITE).onApplicationBootstrap();
expect(logWarn).not.toHaveBeenCalled();
await new PostgresPluginDataBackend(fakeOrm([], new Error('down')), POSTGRES).onApplicationBootstrap();
expect(logWarn).toHaveBeenCalledWith("Could not check whether TREK's role may run plugin SQL: down");
});
it('PLUGDATA-007: the stores of one backend share its role check, so a connection is asked once', async () => {
const executed: string[] = [];
const backend = new PostgresPluginDataBackend(fakeOrm(executed, true), POSTGRES);
await backend.onApplicationBootstrap();
await expect(backend.open('pg-four').query('SELECT 1')).rejects.toThrow(PRIVILEGED_ROLE_PLUGIN_REFUSAL);
await expect(backend.open('pg-five').query('SELECT 1')).rejects.toThrow(PRIVILEGED_ROLE_PLUGIN_REFUSAL);
expect(executed.filter((sql) => sql.includes('as privileged'))).toHaveLength(1);
});
});