fix(plugins): hold plugin data on Postgres to its own schema and to one contract on both engines

The plugin SQL guard now refuses what still reached outside a plugin's
schema or depended on the server:
- reads of the system columns (xmin, xmax, cmin, cmax, ctid, tableoid),
  which show transaction ids and storage layout and do not exist on
  SQLite; a value of the plugin's own may still be named xmin with AS
- the xid and xid8 types wherever the word stands for the type, since
  age() of an xid is the cluster's transaction counter
- the text search functions that coerce a text argument to regconfig, a
  catalog lookup by name, which leave the allowlist
- collations and access methods outside the set every server has, which
  could tell whether a locale or an extension exists

Every plugin transaction pins, with SET LOCAL, the settings that decide
how values print and parse (TimeZone UTC, DateStyle, the C locales, float,
bytea and xml output, the text search configuration), so a plugin's output
neither depends on nor reveals the server's configuration.

Both stores now keep one contract. Its texts and caps live once, in
plugin-data-contract.ts, and both stores throw only those: NUL in SQL,
an argument or a migration id is refused on SQLite as on Postgres,
transaction control is refused in every call on both engines (tx() is
how a batch becomes atomic), a closed store refuses every call, and the
Postgres store answers the cases better-sqlite3 names with its words.
The SQLite store moves beside the Postgres one as SqlitePluginDataStore
in db/engine/sqlite, takes its file from the backend so src/db never
imports src/nest, and no longer needs the driver exemption. A contract
test runs every violation on both stores and fails when they answer
differently. The Postgres lane holds the allowlist, the pinned settings
and the SQL plugins commonly write against a real database.
This commit is contained in:
Maurice
2026-11-18 13:20:07 +01:00
parent cc0fe6ce2b
commit c970245e0d
26 changed files with 1932 additions and 513 deletions
@@ -7,10 +7,11 @@
* - disable() tears the child down.
* The child runs its own process — its crash/throw can never reach this test.
*/
import { SqlitePluginDataStore } from '../../../src/db/engine/sqlite/plugin-data-store';
import { createTestPluginRegistry } from '../../../src/nest-rpc/rpc-kit/testing';
import { PluginDataDb } from '../../../src/nest/plugins/host/plugin-data.service';
import { PluginRpcHost, type HostDeps } from '../../../src/nest/plugins/host/rpc-host';
import { DbRpc } from '../../../src/nest/plugins/host/rpc/db.rpc';
import { pluginDbFile } from '../../../src/nest/plugins/paths';
import type { PluginUserSettingsService } from '../../../src/nest/plugins/plugin-user-settings.service';
import {
PluginSupervisor,
@@ -51,7 +52,7 @@ function makeSupervisor(
): PluginSupervisor {
const createRpcHost = (id: string, granted: ReadonlySet<string>): PluginRpcHost => {
const deps: HostDeps = {
data: new PluginDataDb(id),
data: new SqlitePluginDataStore(id, pluginDbFile(id)),
callPlugin: async () => undefined,
emitPluginEvent: async (event, payload) => {
broadcasts.push({ id, event, payload });
@@ -74,7 +75,7 @@ function makeSupervisor(
// through PluginSupervisor.onMessage's 'req' branch over real child-process
// IPC, which now THROWS without a resolveOrm thunk rather than dispatching
// unwrapped — so this double needs a real (if otherwise unused) ORM, even
// though PluginDataDb/DbRpc here are raw better-sqlite3, not MikroORM.
// though the plugin store and DbRpc here are raw better-sqlite3, not MikroORM.
return new PluginSupervisor(createRpcHost, hooks, tuning, () => ormHandle.orm);
}
+272 -6
View File
@@ -1,5 +1,5 @@
/**
* PGPLUG-001..021 — a plugin's own data (`db:own`) on Postgres, against the
* PGPLUG-001..024: 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,
@@ -16,6 +16,7 @@
*/
import type { DbSettings } from '../../src/app-config';
import { buildApp } from '../../src/bootstrap';
import { PLUGIN_SQL_NUL_REFUSAL, PLUGIN_VALUE_NUL_REFUSAL } from '../../src/db/engine/plugin-data-contract';
import { PRIVILEGED_ROLE_PLUGIN_REFUSAL, type PluginRoleGate } from '../../src/db/engine/postgres/plugin-data-checks';
import {
type ConnectPluginClient,
@@ -24,7 +25,12 @@ import {
poolClients,
PostgresPluginDataStore,
} from '../../src/db/engine/postgres/plugin-data-store';
import { catalogFunctionNames, COLUMN_NAMES } from '../../src/db/engine/postgres/plugin-sql-functions';
import { PLUGIN_SESSION_SETTINGS } from '../../src/db/engine/postgres/plugin-session';
import {
catalogFunctionNames,
COLUMN_NAMES,
pluginFunctionNames,
} from '../../src/db/engine/postgres/plugin-sql-functions';
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';
@@ -375,7 +381,7 @@ describe('plugin data on Postgres', () => {
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 () => {
it('PGPLUG-009: bypasses an earlier guard let through 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 = [
@@ -525,7 +531,7 @@ describe('plugin data on Postgres', () => {
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.
// An unqualified ALTER TYPE could rename pg_catalog's types for the whole database.
const CATALOG_TARGETS = [
'alter type int4 rename to int4x',
'alter type text rename to evil',
@@ -679,12 +685,12 @@ describe('plugin data on Postgres', () => {
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/;
const reason = PLUGIN_VALUE_NUL_REFUSAL;
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\)/);
await expect(store.exec("INSERT INTO kv VALUES ('a\u0000b')")).rejects.toThrow(PLUGIN_SQL_NUL_REFUSAL);
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)');
@@ -758,4 +764,264 @@ describe('plugin data on Postgres', () => {
]);
await asSuper('comment on table users is null');
});
it('PGPLUG-022: no allowed function looks an object up by a name, and system columns and transaction ids stay out', async () => {
const names = [...pluginFunctionNames()].map((name) => `'${name}'`).join(', ');
const lookups = await asSuper<{ f: string }>(
'with lookup as (select t.oid from pg_type t where t.typnamespace = ' +
"'pg_catalog'::regnamespace and (t.typname ~ '^_?reg' or t.typname in ('aclitem', '_aclitem'))) " +
'select p.oid::regprocedure::text as f from pg_proc p ' +
`where p.pronamespace = 'pg_catalog'::regnamespace and p.proname in (${names}) ` +
'and (p.prorettype in (select oid from lookup) or exists (select 1 from ' +
'unnest(coalesce(p.proallargtypes, p.proargtypes::oid[])) a(t) where a.t in (select oid from lookup))) ' +
'order by 1',
);
expect(
lookups.map((row) => row.f),
'These functions of server/assets/postgres/plugin-functions.txt take or return a type that looks an ' +
'object up by a name (a reg* type or aclitem): Postgres turns a text argument into a catalog lookup, so ' +
'the call tells a plugin which schemas and objects exist. Remove each name from the allowlist.',
).toEqual([]);
// min(xid8) and max(xid8) return what they are given; a function that makes a transaction id
// out of anything else is the leak.
const xids = await asSuper<{ f: string }>(
"with xid as (select t.oid from pg_type t where t.typname in ('xid', 'xid8', '_xid', '_xid8')) " +
'select p.oid::regprocedure::text as f from pg_proc p ' +
`where p.pronamespace = 'pg_catalog'::regnamespace and p.proname in (${names}) ` +
'and p.prorettype in (select oid from xid) and not exists (select 1 from ' +
'unnest(coalesce(p.proallargtypes, p.proargtypes::oid[])) a(t) where a.t in (select oid from xid)) ' +
'order by 1',
);
expect(
xids.map((row) => row.f),
'These functions of server/assets/postgres/plugin-functions.txt make a transaction id out of other ' +
'values: age() of one is how many transactions the server ran, and the guard keeps xid values out only by ' +
"refusing the type's name and the system columns. Remove each name from the allowlist.",
).toEqual([]);
const stores = [data.open('pg-lookup'), superuserStore('pg-lookup-su')];
await Promise.all(
stores.map(async (store) => {
await store.migrate('001', 'CREATE TABLE t (id bigserial PRIMARY KEY, tags text[])');
await store.exec("INSERT INTO t (tags) VALUES (array['a', 'b'])");
await Promise.all(
[
"select to_tsvector('trek_plugin_other.cfg', 'a')",
"select to_tsvector('public.x', 'a')",
"select plainto_tsquery('english', 'a')",
"select ts_headline('a', 'a'::tsquery)",
].map((sql) => expect(store.query(sql), sql).rejects.toThrow(/a plugin may not call/)),
);
await expect(store.query('select websearch_to_tsquery($1, $2)', ['english', 'a'])).rejects.toThrow(
/a plugin may not call/,
);
await Promise.all(
[
'select xmin from t',
'select t.xmax, t.cmin, t.cmax from t',
'select ctid from t',
'select "tableoid" from t',
"update t set tags = '{}' where xmin = '1'",
].map((sql) => expect(store.query(sql), sql).rejects.toThrow(/reads a Postgres system column/)),
);
await Promise.all(
[
"select age('3'::xid)",
"select cast('3' as xid8)",
"select age(xid('3'))",
"select age(u.xid) from unnest(array['3']) u",
'select age(x.a) from json_to_record(\'{"a": "3"}\') as x(a xid)',
].map((sql) => expect(store.query(sql), sql).rejects.toThrow(/stands for a transaction id type/)),
);
await expect(store.query('select age($1.xid)', ['3'])).rejects.toThrow(/stands for a transaction id type/);
await Promise.all(
[
`select 'a' collate "de_DE.utf8"`,
`select 'a' collate "und-x-icu"`,
'create index i on t using bloom (id)',
'create table c (x int) using columnar',
].map((sql) => expect(store.query(sql), sql).rejects.toThrow(/a collation other than|built-in access/)),
);
// A value of the plugin's own may carry a system column's name, and a column of its own be called xid.
expect(
await store.query(
'SELECT min(id) AS xmin, max(id) AS xmax FROM t UNION ALL ' +
'SELECT * FROM (WITH b(xmin, xmax) AS (SELECT 5, 6) SELECT * FROM b) AS b(cmin, ctid)',
),
).toEqual([
{ xmin: 1, xmax: 1 },
{ xmin: 5, xmax: 6 },
]);
await store.migrate(
'002',
'CREATE TABLE pay (id bigserial PRIMARY KEY, xid text NOT NULL UNIQUE); ' +
'CREATE INDEX pay_xid ON pay USING btree (xid COLLATE "C")',
);
await store.exec('INSERT INTO pay (xid) VALUES ($1) ON CONFLICT (xid) DO NOTHING', ['b']);
await store.exec("INSERT INTO pay (xid) VALUES ('a'), ('B')");
expect(await store.query('SELECT xid FROM pay WHERE xid <> $1 ORDER BY xid COLLATE "C"', ['zzz'])).toEqual([
{ xid: 'B' },
{ xid: 'a' },
{ xid: 'b' },
]);
// Text search on vectors a plugin builds itself needs no configuration and still works.
expect(
await store.query(
"SELECT ts_rank(array_to_tsvector(tags), 'a & b'::tsquery) > 0 AS hit, " +
"array_to_tsvector(tags) @@ 'b'::tsquery AS b FROM t",
),
).toEqual([{ hit: true, b: true }]);
}),
);
});
/**
* The settings a client may change in the categories that decide how values
* print and parse and how statements behave, that a plugin transaction
* leaves as the server has them, with the reason each cannot change what a
* plugin reads. Every other one must be pinned in PLUGIN_SESSION_SETTINGS.
*/
const UNPINNED: Record<string, string> = {
client_encoding: 'pg sets UTF8 when it connects, and a plugin cannot SET it',
search_path: "set by the store per call to the plugin's schema",
statement_timeout: "set by the store per call to the call's time budget",
check_function_bodies: 'a plugin cannot create functions',
client_min_messages: 'notices never reach the plugin',
createrole_self_grant: 'a plugin cannot create roles',
icu_validation_level: 'a plugin cannot create collations',
row_security: 'a plugin cannot create policies',
local_preload_libraries: 'read when a connection starts',
default_table_access_method: 'where rows are stored, not what a query answers',
default_tablespace: 'where rows are stored, not what a query answers',
temp_tablespaces: 'where rows are stored, not what a query answers',
default_toast_compression: 'how rows are stored, not what a query answers',
gin_pending_list_limit: 'when an index is maintained, not what it finds',
restrict_nonsystem_relation_kind: 'TREK sets no restriction a plugin could see',
synchronize_seqscans: 'rows without ORDER BY have no order on Postgres in any case',
escape_string_warning: 'a warning, never an answer',
default_transaction_deferrable: "the transaction is TREK's",
default_transaction_isolation: "the transaction is TREK's",
default_transaction_read_only: "the transaction is TREK's",
transaction_deferrable: "the transaction is TREK's",
transaction_isolation: "the transaction is TREK's",
transaction_read_only: "the transaction is TREK's",
transaction_timeout: "the transaction is TREK's",
idle_in_transaction_session_timeout: "the connection is TREK's",
idle_session_timeout: "the connection is TREK's",
lock_timeout: "the connection is TREK's",
vacuum_failsafe_age: 'maintenance, not an answer',
vacuum_freeze_min_age: 'maintenance, not an answer',
vacuum_freeze_table_age: 'maintenance, not an answer',
vacuum_multixact_failsafe_age: 'maintenance, not an answer',
vacuum_multixact_freeze_min_age: 'maintenance, not an answer',
vacuum_multixact_freeze_table_age: 'maintenance, not an answer',
};
it('PGPLUG-023: a plugin reads values formatted the same on every server, and its settings end with its call', async () => {
const settings = await asSuper<{ name: string }>(
"select name from pg_settings where context = 'user' and (category like 'Client Connection Defaults%' " +
"or category like 'Version and Platform Compatibility%') order by name",
);
const known = new Set(settings.map((row) => row.name));
expect(
settings.map((row) => row.name).filter((name) => !(name in PLUGIN_SESSION_SETTINGS) && !(name in UNPINNED)),
'These settings of this Postgres may change how a value prints or a statement behaves. Pin each in ' +
'PLUGIN_SESSION_SETTINGS (server/src/db/engine/postgres/plugin-session.ts) to its built-in default, or add ' +
'it to UNPINNED in this test with the reason it cannot change what a plugin reads.',
).toEqual([]);
expect(Object.keys(PLUGIN_SESSION_SETTINGS).filter((name) => !known.has(name))).toEqual([]);
const store = data.open('pg-settings');
await store.migrate('001', 'CREATE TABLE notes (id bigserial PRIMARY KEY)');
// A server set up far from the defaults: the session of the very client the plugin call uses.
const odd = [
"set timezone to 'Pacific/Chatham'",
"set datestyle to 'German, DMY'",
"set intervalstyle to 'iso_8601'",
"set lc_monetary to 'en_US.utf8'",
"set lc_numeric to 'en_US.utf8'",
"set lc_time to 'en_US.utf8'",
'set extra_float_digits to 0',
"set bytea_output to 'escape'",
"set default_text_search_config to 'pg_catalog.english'",
'set quote_all_identifiers to on',
'set transform_null_equals to on',
'set array_nulls to off',
];
const read =
"SELECT '2024-01-02 03:04:05+00'::timestamptz::text AS ts, '2024-01-02'::date::text AS d, " +
"'1 day 02:00'::interval::text AS i, 12.5::money::text AS m, to_char(1234.5, 'FM9G999D9') AS n, " +
"to_char('2024-03-01'::date, 'TMMonth') AS month, 0.1::float8::text AS f, '\\x01'::bytea::text AS b, " +
"quote_ident('a') AS q, 'The Cats' @@ 'cat' AS fts, (null = null) IS NULL AS nulls, " +
"('{NULL}'::text[])[1] IS NULL AS arr, date_trunc('day', '2024-01-01 23:00:00+00'::timestamptz)::text AS day";
const pinned = {
ts: '2024-01-02 03:04:05+00',
d: '2024-01-02',
i: '1 day 02:00:00',
m: '$12.50',
n: '1,234.5',
month: 'March',
f: '0.1',
b: '\\x01',
q: 'a',
fts: false,
nulls: true,
arr: true,
day: '2024-01-01 00:00:00+00',
};
const client = await appClients()();
try {
await inSequence(odd, (sql) => client.query(sql));
const show = 'select current_setting($1) as v';
const current = () =>
Promise.all(
['TimeZone', 'DateStyle', 'default_text_search_config'].map(
async (name) => (await client.query({ text: show, values: [name] })).rows,
),
);
const before = await current();
const onClient = new PostgresPluginDataStore('pg-settings', keep(client), new PluginDataSlots(1));
expect(await onClient.query(read)).toEqual([pinned]);
expect(await onClient.tx([{ sql: read }])).toEqual({ results: [{ rows: [pinned] }] });
// The session still answers as it was set: the plugin's settings were local to its transaction.
const session = (await client.query(read)).rows[0] as Record<string, unknown>;
expect(session.ts).not.toBe(pinned.ts);
expect(session.fts).toBe(true);
expect(await current()).toEqual(before);
} finally {
// The test changed this client's session, so it is closed rather than handed back.
client.release(true);
}
});
it('PGPLUG-024: the SQL plugins commonly write runs unchanged', async () => {
const store = data.open('pg-common');
await store.migrate(
'001',
'CREATE TABLE t (id bigserial PRIMARY KEY, name text UNIQUE NOT NULL, n int NOT NULL DEFAULT 0, ' +
'at timestamptz NOT NULL DEFAULT now(), uid uuid NOT NULL DEFAULT gen_random_uuid())',
);
await store.exec('INSERT INTO t (name, n) VALUES ($1, $2), ($3, $4)', ['a', 1, 'b', 2]);
await store.exec('INSERT INTO t (name, n) VALUES ($1, $2) ON CONFLICT (name) DO UPDATE SET n = t.n + excluded.n', [
'a',
10,
]);
await store.exec('INSERT INTO t (name) VALUES ($1) ON CONFLICT DO NOTHING', ['b']);
expect(
await store.query(
'WITH ranked AS (SELECT t.name, t.n, row_number() OVER (ORDER BY t.n DESC) AS r FROM t) ' +
"SELECT name, n, r, coalesce(nullif(name, 'a'), 'first') AS c FROM ranked ORDER BY r",
),
).toEqual([
{ name: 'a', n: 11, r: 1, c: 'first' },
{ name: 'b', n: 2, r: 2, c: 'b' },
]);
expect(
await store.query(
"SELECT count(*) AS total, string_agg(name, ',' ORDER BY name) AS names, " +
"bool_and(at <= now()) AS past, bool_and(date_trunc('day', at) <= at) AS trunc, " +
'min(extract(year FROM at)) >= 2024 AS year, count(DISTINCT uid) AS uids FROM t',
),
).toEqual([{ total: 2, names: 'a,b', past: true, trunc: true, year: true, uids: 2 }]);
});
});
@@ -0,0 +1,326 @@
/**
* The contract a plugin's own database (`db:own`) answers alike on both
* engines: every call that breaks it, run on the SQLite store
* (src/db/engine/sqlite/plugin-data-store.ts) and on the Postgres store
* (src/db/engine/postgres/plugin-data-store.ts), must be refused with the
* same words, and those words are the ones `plugin-data-contract.ts`
* holds. A store that answers one case differently, or a
* text spelled by hand in one store, fails here.
*
* The SQLite store runs on a file of its own. The Postgres store runs on a
* stand-in `pg` client that answers every statement with no rows and every
* cursor with the rows of the seeded table, which is all these cases reach;
* the same store on a real database is the Postgres lane's
* tests/postgres/plugin-data.test.ts.
*/
import type { PluginDataStore } from '../../../../src/db/engine/plugin-data';
import {
PLUGIN_DATA_CAPS,
PLUGIN_DATA_ERRORS,
PLUGIN_SQL_NUL_REFUSAL,
PLUGIN_VALUE_NUL_REFUSAL,
refuseTransactionControl,
} from '../../../../src/db/engine/plugin-data-contract';
import {
PluginDataSlots,
PostgresPluginDataStore,
type PluginSqlClient,
} from '../../../../src/db/engine/postgres/plugin-data-store';
import { SqlitePluginDataStore } from '../../../../src/db/engine/sqlite/plugin-data-store';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import Cursor from 'pg-cursor';
import { afterAll, describe, expect, it } from 'vitest';
/** The rows of `seq` on both engines: five of them, more than the row cap below. */
const SEQ_ROWS = [1, 2, 3, 4, 5].map((n) => ({ n }));
interface Limits {
maxRows?: number;
timeBudgetMs?: number;
now?: () => number;
}
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'trek-plugin-contract-'));
let stores = 0;
afterAll(() => {
fs.rmSync(dir, { recursive: true, force: true });
});
/** A SQLite store on a file of its own, holding the table `seq`. */
function sqliteStore(limits: Limits): SqlitePluginDataStore {
const id = `contract-${++stores}`;
const store = new SqlitePluginDataStore(id, path.join(dir, id, 'plugin.db'), limits);
store.migrate('seq', 'CREATE TABLE seq (n INTEGER)');
store.exec(`INSERT INTO seq (n) VALUES ${SEQ_ROWS.map((row) => `(${row.n})`).join(', ')}`);
return store;
}
/** A Postgres store whose client reads {@link SEQ_ROWS} from every cursor, one row per read. */
function postgresStore(limits: Limits): PostgresPluginDataStore {
const client = {
query(arg: unknown): unknown {
if (arg instanceof Cursor) {
let next = 0;
return {
read: async () => (next < SEQ_ROWS.length ? [SEQ_ROWS[next++]] : []),
close: async () => undefined,
};
}
return Promise.resolve({ rows: [], rowCount: 0 });
},
release: () => undefined,
};
return new PostgresPluginDataStore(
'contract',
async () => client as unknown as PluginSqlClient,
new PluginDataSlots(1),
limits,
{ refuseIfPrivileged: async () => undefined },
);
}
/** A clock that moves `step` ms each time it is read, so a budget runs out on cue. */
function steppingClock(step: number): () => number {
let t = 0;
return () => (t += step);
}
/** What a call answered: its result, or the message it was refused with. */
async function outcome(call: () => unknown): Promise<string> {
try {
return `answered ${JSON.stringify(await call())}`;
} catch (err) {
return `refused: ${err instanceof Error ? err.message : String(err)}`;
}
}
type Case = [name: string, call: (store: PluginDataStore) => unknown, expected: string];
const refused = (message: string) => `refused: ${message}`;
const tooManyOps = Array.from({ length: PLUGIN_DATA_CAPS.maxTxOps + 1 }, () => ({ sql: 'SELECT 1' }));
/**
* Transaction control in any call and any statement position, in every spelling
* either engine knows, refused with one sentence; and the words where they are no
* statement's verb, which run.
*/
const TX_CONTROL_CASES: Case[] = [
...[
'BEGIN',
'begin transaction',
'START TRANSACTION',
'COMMIT',
'End',
'ROLLBACK',
'ABORT',
'SAVEPOINT a',
'RELEASE a',
'-- a comment first\nCOMMIT',
'/* x */ROLLBACK',
'/* a; b */ /* c */ end',
].map((sql): Case => [
`a query of ${JSON.stringify(sql)}`,
(s) => s.query(sql),
refused(PLUGIN_DATA_ERRORS.txControl),
]),
[
'a script that opens a transaction',
(s) => s.exec('BEGIN; INSERT INTO seq (n) VALUES (6); COMMIT;'),
refused(PLUGIN_DATA_ERRORS.txControl),
],
[
'a script that ends with COMMIT',
(s) => s.exec('INSERT INTO seq (n) VALUES (6);\n-- done\ncommit'),
refused(PLUGIN_DATA_ERRORS.txControl),
],
['an exec with args of COMMIT', (s) => s.exec('COMMIT', [1]), refused(PLUGIN_DATA_ERRORS.txControl)],
[
'a tx op of transaction control',
(s) => s.tx([{ sql: 'UPDATE seq SET n = n' }, { sql: ' /* x */ SAVEPOINT a' }]),
refused(PLUGIN_DATA_ERRORS.txControl),
],
[
'a migration that commits',
(s) => s.migrate('m', 'CREATE TABLE t (x INTEGER); COMMIT; CREATE TABLE u (x INTEGER)'),
refused(PLUGIN_DATA_ERRORS.txControl),
],
['a CASE ... END expression', (s) => s.exec("SELECT CASE WHEN 1 = 1 THEN 'y' END AS s"), 'answered {"changes":0}'],
['the words in a string', (s) => s.exec("SELECT 'BEGIN; COMMIT' AS s"), 'answered {"changes":0}'],
['the words in a comment', (s) => s.exec('SELECT 1; -- COMMIT\n/* END; */'), 'answered {"changes":0}'],
];
/** Calls that break the contract, or sit at its edge, on a store that is open. */
const OPEN_CASES: Case[] = [
['query with SQL that is no string', (s) => s.query(42 as never), refused(PLUGIN_DATA_ERRORS.sqlNotString)],
['exec with SQL that is no string', (s) => s.exec(null as never), refused(PLUGIN_DATA_ERRORS.sqlNotString)],
['migrate with SQL that is no string', (s) => s.migrate('m', {} as never), refused(PLUGIN_DATA_ERRORS.sqlNotString)],
['a tx op with SQL that is no string', (s) => s.tx([{ sql: 7 as never }]), refused(PLUGIN_DATA_ERRORS.sqlNotString)],
['a tx op that is no object', (s) => s.tx([null as never]), refused(PLUGIN_DATA_ERRORS.sqlNotString)],
[
'SQL past the length cap',
(s) => s.query('x'.repeat(PLUGIN_DATA_CAPS.maxSqlLength + 1)),
refused(PLUGIN_DATA_ERRORS.sqlTooLong),
],
['SQL holding NUL', (s) => s.query("SELECT 'a\u0000'"), refused(PLUGIN_SQL_NUL_REFUSAL)],
['a script holding NUL', (s) => s.exec("SELECT 'a\u0000'"), refused(PLUGIN_SQL_NUL_REFUSAL)],
['an argument holding NUL', (s) => s.query('SELECT 1', ['a\u0000']), refused(PLUGIN_VALUE_NUL_REFUSAL)],
['a migration id holding NUL', (s) => s.migrate('m\u0000', 'SELECT 1'), refused(PLUGIN_VALUE_NUL_REFUSAL)],
['a query without a statement', (s) => s.query(''), refused(PLUGIN_DATA_ERRORS.noStatement)],
['a query of a comment only', (s) => s.query('-- nothing'), refused(PLUGIN_DATA_ERRORS.noStatement)],
['a query of two statements', (s) => s.query('SELECT 1; SELECT 2'), refused(PLUGIN_DATA_ERRORS.moreThanOneStatement)],
[
'an exec with args of two statements',
(s) => s.exec('SELECT 1; SELECT 2', [1]),
refused(PLUGIN_DATA_ERRORS.moreThanOneStatement),
],
['an empty script', (s) => s.exec(''), 'answered {"changes":0}'],
['a script of a comment only', (s) => s.exec('-- nothing'), 'answered {"changes":0}'],
['a tx that is no array', (s) => s.tx('nope' as never), refused(PLUGIN_DATA_ERRORS.txNotArray)],
['an empty tx', (s) => s.tx([]), 'answered {"results":[]}'],
[
'a tx past the statement cap',
(s) => s.tx(tooManyOps),
refused(PLUGIN_DATA_ERRORS.txTooManyOps(PLUGIN_DATA_CAPS.maxTxOps)),
],
['a query past the row cap', (s) => s.query('SELECT n FROM seq'), refused(PLUGIN_DATA_ERRORS.queryTooManyRows(3))],
['a tx past the row cap', (s) => s.tx([{ sql: 'SELECT n FROM seq' }]), refused(PLUGIN_DATA_ERRORS.txTooManyRows(3))],
...TX_CONTROL_CASES,
];
/** Calls on a store whose clock runs out of its time budget while it reads. */
const BUDGET_CASES: Case[] = [
[
'a query past its time budget',
(s) => s.query('SELECT n FROM seq'),
refused(PLUGIN_DATA_ERRORS.overBudget('query', 100)),
],
[
'a tx past its time budget',
(s) => s.tx([{ sql: 'SELECT n FROM seq' }]),
refused(PLUGIN_DATA_ERRORS.overBudget('tx', 100)),
],
];
/** Calls on a store that was closed. */
const CLOSED_CASES: Case[] = [
['a query', (s) => s.query('SELECT 1'), refused(PLUGIN_DATA_ERRORS.closed)],
['an exec with args', (s) => s.exec('SELECT ?', [1]), refused(PLUGIN_DATA_ERRORS.closed)],
['a script', (s) => s.exec('SELECT 1'), refused(PLUGIN_DATA_ERRORS.closed)],
['an empty script', (s) => s.exec(''), refused(PLUGIN_DATA_ERRORS.closed)],
['a script of a comment only', (s) => s.exec('-- nothing'), refused(PLUGIN_DATA_ERRORS.closed)],
['an empty tx', (s) => s.tx([]), refused(PLUGIN_DATA_ERRORS.closed)],
['a tx', (s) => s.tx([{ sql: 'SELECT 1' }]), refused(PLUGIN_DATA_ERRORS.closed)],
['a migration', (s) => s.migrate('m', 'SELECT 1'), refused(PLUGIN_DATA_ERRORS.closed)],
];
/** What each engine's store answers `call` with, on a store made by `limits` and `prepare`. */
async function bothAnswer(
call: Case[1],
limits: () => Limits,
prepare: (store: PluginDataStore) => void = () => undefined,
): Promise<{ sqlite: string; postgres: string }> {
const sqlite = sqliteStore(limits());
const postgres = postgresStore(limits());
prepare(sqlite);
prepare(postgres);
try {
return { sqlite: await outcome(() => call(sqlite)), postgres: await outcome(() => call(postgres)) };
} finally {
sqlite.close();
}
}
describe('plugin data contract on both engines', () => {
it.each(OPEN_CASES)('PLUGCONTRACT-001: %s is answered alike', async (_name, call, expected) => {
const answers = await bothAnswer(call, () => ({ maxRows: 3 }));
expect(answers).toEqual({ sqlite: expected, postgres: expected });
});
it.each(BUDGET_CASES)('PLUGCONTRACT-002: %s is answered alike', async (_name, call, expected) => {
const answers = await bothAnswer(call, () => ({ timeBudgetMs: 100, now: steppingClock(30) }));
expect(answers).toEqual({ sqlite: expected, postgres: expected });
});
it.each(CLOSED_CASES)('PLUGCONTRACT-003: %s on a closed store is answered alike', async (_name, call, expected) => {
const answers = await bothAnswer(
call,
() => ({}),
(store) => store.close(),
);
expect(answers).toEqual({ sqlite: expected, postgres: expected });
});
});
/**
* The scan behind refuseTransactionControl, which the SQLite store and the SDK
* run (the Postgres guard reads plugin SQL with its own lexer). A SQLite built
* with Tcl variables (node:sqlite under trek-plugin dev) reads `$a(...)` up to
* the closing parenthesis as one parameter, quotes and semicolons included.
*/
describe('refuseTransactionControl', () => {
const hiddenCommit = "INSERT INTO seq (n) VALUES ($a(')); COMMIT; --')";
it.each([
hiddenCommit,
"SELECT @a(')",
"SELECT :a(')",
"SELECT #a(')",
"SELECT $a::b(')",
"SELECT $::a(')",
'SELECT $1(1)',
"SELECT 1; SELECT $a('x')",
])('PLUGCONTRACT-004: refuses a parameter name directly followed by "(" in %j', (sql) => {
expect(() => refuseTransactionControl(sql)).toThrow(new Error(PLUGIN_DATA_ERRORS.parameterBeforeParenthesis));
});
it.each([
'SELECT $a, :b, @c, #d, ?1',
'SELECT $a (1)',
'SELECT 1 WHERE $a::b = 1',
"SELECT '$a(' AS s",
'SELECT "$a(" FROM seq',
'SELECT [$a(] FROM seq',
'SELECT 1 -- $a(\n',
'SELECT x::numeric(10, 2), y #> $1, z @> $2, w := 1 FROM seq',
'SELECT $ (1), @(1), :(1)',
])('PLUGCONTRACT-005: lets %j through', (sql) => {
expect(() => refuseTransactionControl(sql)).not.toThrow();
});
it.each([
'EXPLAIN CREATE TRIGGER t AFTER INSERT ON seq BEGIN SELECT 1; END',
'explain query plan create temp trigger t after insert on seq begin select 1; end;',
'EXPLAIN CREATE TEMPORARY TRIGGER t AFTER INSERT ON seq BEGIN SELECT 1; SELECT 2; END; SELECT 3',
])('PLUGCONTRACT-006: reads the body of %j as a trigger body', (sql) => {
expect(() => refuseTransactionControl(sql)).not.toThrow();
});
it.each([
'EXPLAIN CREATE TRIGGER t AFTER INSERT ON seq BEGIN SELECT 1; END; COMMIT',
'EXPLAIN QUERY PLAN CREATE TRIGGER t AFTER INSERT ON seq BEGIN SELECT 1; END; ROLLBACK',
'EXPLAIN SELECT 1; END',
'EXPLAIN QUERY SELECT 1; END',
])('PLUGCONTRACT-007: refuses the transaction control in %j', (sql) => {
expect(() => refuseTransactionControl(sql)).toThrow(new Error(PLUGIN_DATA_ERRORS.txControl));
});
it('PLUGCONTRACT-008: the SQLite store refuses the hidden COMMIT and runs EXPLAIN CREATE TRIGGER', () => {
const store = sqliteStore({});
try {
expect(() => store.exec(hiddenCommit)).toThrow(new Error(PLUGIN_DATA_ERRORS.parameterBeforeParenthesis));
expect(store.query('SELECT count(*) AS c FROM seq')).toEqual([{ c: SEQ_ROWS.length }]);
expect(store.query('EXPLAIN CREATE TRIGGER t AFTER INSERT ON seq BEGIN SELECT 1; END').length).toBeGreaterThan(0);
expect(
store.query('EXPLAIN QUERY PLAN CREATE TEMP TRIGGER t AFTER INSERT ON seq BEGIN SELECT 1; END'),
).toBeInstanceOf(Array);
// EXPLAIN only describes the statement: no trigger was made.
expect(store.query("SELECT count(*) AS c FROM sqlite_master WHERE type = 'trigger'")).toEqual([{ c: 0 }]);
} finally {
store.close();
}
});
});
@@ -10,6 +10,11 @@
* store on a real database is the Postgres lane's
* tests/postgres/plugin-data.test.ts.
*/
import {
PLUGIN_DATA_ERRORS,
PLUGIN_SQL_NUL_REFUSAL,
PLUGIN_VALUE_NUL_REFUSAL,
} from '../../../../../src/db/engine/plugin-data-contract';
import { PRIVILEGED_ROLE_PLUGIN_REFUSAL } from '../../../../../src/db/engine/postgres/plugin-data-checks';
import {
dropPluginSchema,
@@ -19,6 +24,7 @@ import {
PostgresPluginDataStore,
type PluginSqlClient,
} from '../../../../../src/db/engine/postgres/plugin-data-store';
import { PLUGIN_SESSION_SETTINGS } from '../../../../../src/db/engine/postgres/plugin-session';
import { PRIVILEGED_ROLE_SQL } from '../../../../../src/db/engine/postgres/server-checks';
import type { Kysely } from 'kysely';
@@ -144,7 +150,7 @@ function pgError(code: string, message: string): Error {
}
describe('Postgres plugin data store', () => {
it('PGSTORE-001: a query runs in a transaction that makes the schema, scopes the search_path and sets the budget', async () => {
it('PGSTORE-001: a query runs in a transaction that makes the schema, scopes the search_path, pins the settings and sets the budget', async () => {
const { store: s, log } = store({
rows: { 'SELECT body FROM notes': [{ body: 'a' }, { body: 'b' }, { body: 'c' }] },
});
@@ -157,7 +163,24 @@ describe('Postgres plugin data store', () => {
'create schema if not exists "trek_plugin_notes"',
'create table if not exists "trek_plugin_notes"._plugin_migrations (id text primary key, applied_at bigint)',
'set local search_path to "trek_plugin_notes", pg_temp',
'set local standard_conforming_strings to on',
"set local TimeZone to 'UTC'",
"set local DateStyle to 'ISO, MDY'",
"set local IntervalStyle to 'postgres'",
"set local timezone_abbreviations to 'Default'",
"set local lc_monetary to 'C'",
"set local lc_numeric to 'C'",
"set local lc_time to 'C'",
"set local extra_float_digits to '1'",
"set local bytea_output to 'hex'",
"set local xmlbinary to 'base64'",
"set local xmloption to 'content'",
"set local default_text_search_config to 'pg_catalog.simple'",
"set local standard_conforming_strings to 'on'",
"set local backslash_quote to 'safe_encoding'",
"set local array_nulls to 'on'",
"set local transform_null_equals to 'off'",
"set local quote_all_identifiers to 'off'",
"set local gin_fuzzy_search_limit to '0'",
'set local statement_timeout to 2000',
].join(';\n'),
'SELECT body FROM notes',
@@ -166,6 +189,13 @@ describe('Postgres plugin data store', () => {
]);
});
it('PGSTORE-020: every pinned setting is a plain name and value, set with SET LOCAL', () => {
for (const [name, value] of Object.entries(PLUGIN_SESSION_SETTINGS)) {
expect(name).toMatch(/^[A-Za-z_]+$/);
expect(value).not.toMatch(/['\\]/);
}
});
it("PGSTORE-002: a qualified name is checked against the database's schemas before the statement runs", async () => {
const { store: s, log } = store({ schemas: ['public', 'auth', 'trek_plugin_notes'] });
await expect(s.query('SELECT x FROM auth.secret')).rejects.toThrow(/"auth" is another schema/);
@@ -252,7 +282,7 @@ describe('Postgres plugin data store', () => {
await expect(s.tx([])).resolves.toEqual({ results: [] });
await expect(s.tx(Array.from({ length: 101 }, () => ({ sql: 'SELECT 1' })))).rejects.toThrow(/at most 100/);
await expect(s.tx([{ sql: '/* x */ COMMIT' }])).rejects.toThrow(/transaction-control/);
await expect(s.tx([{ sql: '/* x */ COMMIT' }])).rejects.toThrow(PLUGIN_DATA_ERRORS.txControl);
await expect(s.tx('nope' as never)).rejects.toThrow(/requires an array/);
});
@@ -281,7 +311,7 @@ describe('Postgres plugin data store', () => {
await expect(s.query(42 as never)).rejects.toThrow('sql must be a string');
await expect(s.query('x'.repeat(100_001))).rejects.toThrow('sql too long');
await expect(s.query('-- only a comment')).rejects.toThrow('contains no statements');
await expect(s.query('SELECT 1; SELECT 2')).rejects.toThrow(/exactly one statement/);
await expect(s.query('SELECT 1; SELECT 2')).rejects.toThrow(PLUGIN_DATA_ERRORS.moreThanOneStatement);
await expect(s.exec('DO $$ BEGIN END $$')).rejects.toThrow(/dollar-quoted/);
expect(log).toEqual([]);
expect(releases).toEqual([]);
@@ -342,9 +372,12 @@ 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 () => {
it('PGSTORE-016: SQL, 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/;
const nul = PLUGIN_VALUE_NUL_REFUSAL;
// The same refusal as on SQLite, before the guard reads the SQL.
await expect(s.exec("INSERT INTO t VALUES ('a\u0000')")).rejects.toThrow(PLUGIN_SQL_NUL_REFUSAL);
await expect(s.query('SELECT 1 FROM t WHERE k = $1', [{ nested: ['\u0000'] }])).rejects.toThrow(nul);
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(
@@ -416,7 +449,7 @@ describe('Postgres plugin data store', () => {
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)');
await expect(ok.store.query('SELECT 1; SELECT 2')).rejects.toThrow(/exactly one statement/);
await expect(ok.store.query('SELECT 1; SELECT 2')).rejects.toThrow(PLUGIN_DATA_ERRORS.moreThanOneStatement);
// One client per statement of the script, each after its session state was dropped; the refused read took none.
expect(ok.releases).toEqual([false, false]);
expect(ok.log.filter((sql) => sql === END_SESSION)).toHaveLength(2);
@@ -60,6 +60,12 @@ describe('functions a plugin may call on Postgres', () => {
"select has_largeobject_privilege(1, 'select')",
'select acldefault(1, 10)',
'select setseed(0.5)',
// A text search configuration is a regconfig, looked up by a name in a string.
"select to_tsvector('trek_plugin_other.cfg', 'a')",
"select to_tsvector('english', body) @@ plainto_tsquery('english', $1) from notes",
"select to_tsquery('a'), phraseto_tsquery('a'), websearch_to_tsquery('a')",
"select ts_headline('a', 'a'::tsquery)",
"select jsonb_to_tsvector('{}'::jsonb, '[\"all\"]')",
// Every spelling of the call.
'SELECT OBJ_DESCRIPTION(16386)',
'select "obj_description"(16386)',
@@ -92,6 +98,15 @@ describe('functions a plugin may call on Postgres', () => {
expect(() => parsePluginSql(sql)).toThrow(/a plugin may not (call|read)/);
});
it.each([
// xid is the transaction id type age() reads the server's counter with; after a dot it is a cast.
"select age('3'::xid)",
'select n.xid from notes n',
'select $1.xid',
])('refuses %s as a transaction id', (sql) => {
expect(() => parsePluginSql(sql)).toThrow(/stands for a transaction id type/);
});
it.each([
"select lower(body), substring(body from 2 for 3), regexp_replace(body, 'a', 'b') from notes",
"select now(), date_trunc('day', now()), extract(epoch from now()), to_char(now(), 'YYYY')",
@@ -100,7 +115,9 @@ describe('functions a plugin may call on Postgres', () => {
'select gen_random_uuid(), md5(body), sha256(body::bytea) from notes',
'select x from generate_series(1, 5) as g(x)',
'select unnest(array[1, 2]), cardinality(array[1])',
"select to_tsvector('english', body) @@ plainto_tsquery('english', $1) from notes",
// Text search on vectors a plugin builds itself, with no configuration to look up.
"select ts_rank(array_to_tsvector(tags), 'a & b'::tsquery), setweight(array_to_tsvector(tags), 'A') from notes",
'select body from notes where array_to_tsvector(tags) @@ $1::tsquery',
'select coalesce(a, b), nullif(a, 0), greatest(a, b), least(a, b) from notes',
"select cast(n as numeric(10, 2)), body::varchar(20), 'now'::timestamp(3) from notes",
'select current_date, current_timestamp, localtimestamp',
@@ -115,7 +132,7 @@ describe('functions a plugin may call on Postgres', () => {
'CREATE VIEW version (a) AS SELECT 1',
'select n.version, n.user_id, "user", "current_user" from notes n',
// The refused names a table may well have as a column, after a dot.
'select n.name, n.money, n.oid, n.xid, n.xml, n.version from notes n',
'select n.name, n.money, n.oid, n.xml, n.version from notes n',
'select (n).name, $1.name from notes n',
"insert into notes (id, name) values (1, 'a') on conflict (id) do update set name = excluded.name",
'select n.body from trek_plugin_notes.notes n join trek_plugin_notes.version v on v.id = n.id',
@@ -5,6 +5,7 @@
* the way Postgres does, and what it tells the store about a statement. The
* same rules against a real database are PGPLUG-003/004 in the Postgres lane.
*/
import { PLUGIN_SQL_NUL_REFUSAL } from '../../../../../src/db/engine/plugin-data-contract';
import {
checkPlaceholders,
checkQualifiers,
@@ -57,6 +58,31 @@ describe('plugin SQL guard', () => {
'SELECT 1 -- public.users\r',
'SELECT 1 -- public.users\r\nFROM notes',
'SELECT\t1\f',
// A value of the plugin's own may carry a system column's name where it is given.
'SELECT min(lat) AS ymin, min(lng) AS xmin, max(lng) AS xmax FROM places',
'SELECT min(lng) AS "xmin" FROM places',
'WITH b(xmin, ymin) AS (SELECT 1, 2) SELECT * FROM b',
'WITH a AS (SELECT 1), b(ctid) AS NOT MATERIALIZED (SELECT 1) SELECT * FROM b',
'SELECT * FROM (SELECT 1, 2) AS b(xmin, xmax)',
// A column of the plugin's own may be called xid, without its table.
'CREATE TABLE payments (id bigserial PRIMARY KEY, xid text NOT NULL UNIQUE)',
'ALTER TABLE payments ADD COLUMN xid text',
'SELECT xid, count(*) FROM payments WHERE xid = $1 AND NOT xid IS NULL GROUP BY xid ORDER BY xid',
'INSERT INTO payments (id, xid) VALUES (1, $1) ON CONFLICT (xid) DO NOTHING',
'UPDATE payments SET xid = $1 WHERE id = $2 RETURNING xid',
'SELECT id AS xid FROM payments',
"SELECT CASE WHEN xid = 'a' THEN xid ELSE NULL END, coalesce(xid, '') FROM payments",
// The collations and access methods every server has.
'SELECT body FROM notes ORDER BY body COLLATE "C", body COLLATE "POSIX", body COLLATE "default"',
'SELECT body COLLATE ucs_basic FROM notes',
'CREATE INDEX i ON notes USING gin (tags)',
'CREATE INDEX i ON notes USING brin (id)',
'CREATE TABLE t (x int) USING heap',
'ALTER TABLE notes ADD EXCLUDE USING gist (r WITH &&)',
'ALTER TABLE notes ALTER id TYPE int USING id::int',
'SELECT * FROM notes JOIN tags USING (id)',
'DELETE FROM notes USING trash WHERE notes.id = trash.note_id',
"SELECT collation FROM notes WHERE collation = 'x'",
// Characters JavaScript reads differently are fine inside strings, quoted names and comments.
"SELECT 'a b
c\u000bd'",
'SELECT 1 AS "a b"',
@@ -149,7 +175,7 @@ describe('plugin SQL guard', () => {
expect(() => check(sql)).toThrow(reason);
});
// The two bypasses of the final review, with their variants: each was let through, and Postgres ran it.
// Bypasses an earlier guard let through and Postgres ran, with their variants.
it.each([
// A `--` comment ended by a bare CR hid the rest from the guard, which Postgres then ran.
['select 1 --\rfrom public.users', /another schema/],
@@ -179,7 +205,7 @@ 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/],
// The re-review's bypasses. A column alias named insert or merge in front of INTO made a table.
// 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/],
@@ -187,6 +213,53 @@ describe('plugin SQL guard', () => {
['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/],
// A read of a system column, quoted or not, wherever it stands.
['select xmin, xmax from notes', /"xmin" reads a Postgres system column/],
['select n.xmax from notes n', /"xmax" reads a Postgres system column/],
['select cmin, cmax from notes', /"cmin" reads a Postgres system column/],
['select ctid from notes order by 1', /"ctid" reads a Postgres system column/],
['select "tableoid" from notes', /"tableoid" reads a Postgres system column/],
['update notes set body = $1 where id = $2 and xmin = $3', /"xmin" reads a Postgres system column/],
['delete from notes returning ctid', /"ctid" reads a Postgres system column/],
['select min(id) xmin from notes', /"xmin" reads a Postgres system column/],
['WITH b(xmin) AS (SELECT 1) SELECT xmin FROM b', /"xmin" reads a Postgres system column/],
['select * from notes n, f(xmin) as (a int)', /"xmin" reads a Postgres system column/],
['select * from notes n, f(xmin, ctid) as (a int)', /"xmin" reads a Postgres system column/],
// A transaction id type where the word stands for the type.
["select age('3'::xid)", /"xid" stands for a transaction id type/],
["select cast('3' as xid8)", /"xid8" stands for a transaction id type/],
["select treat('3' as xid)", /"xid" stands for a transaction id type/],
["select age(xid '3')", /"xid" stands for a transaction id type/],
["select age(xid('3'))", /"xid" stands for a transaction id type/],
['select age($1.xid)', /"xid" stands for a transaction id type/],
["select age(u.xid) from unnest(array['3']) u", /"xid" stands for a transaction id type/],
["select age(('3').xid)", /"xid" stands for a transaction id type/],
['CREATE TABLE t (x _xid)', /"_xid" stands for a transaction id type/],
['CREATE TABLE t ("x" xid)', /"xid" stands for a transaction id type/],
["select '{}'::xid8[]", /"xid8" stands for a transaction id type/],
['select * from notes n, json_to_record(n.j) as x(a xid)', /"xid" stands for a transaction id type/],
['ALTER TABLE t ALTER COLUMN c TYPE xid', /"xid" stands for a transaction id type/],
['ALTER TABLE t ADD COLUMN c xid', /"xid" stands for a transaction id type/],
["select json_value('3', '$' returning xid)", /"xid" stands for a transaction id type/],
['CREATE TYPE r AS RANGE (subtype = xid8)', /"xid8" stands for a transaction id type/],
['CREATE TYPE c AS (a xid)', /"xid" stands for a transaction id type/],
[
'insert into pay (id, xid) values (1, $1) on conflict (id) do update set xid = excluded.xid',
/"xid" stands for a transaction id type.*excluded\.xid in an upsert/,
],
// A collation or an access method whose presence depends on the server.
[`select 'a' collate "de-x-icu"`, /a collation other than "C"/],
[`select body from notes order by body collate "de_DE.utf8"`, /a collation other than "C"/],
['select body from notes order by body collate C', /a collation other than "C"/],
[`select 'a' collate trek_plugin_notes."C"`, /a collation other than "C"/],
[`CREATE TABLE t (a text COLLATE "und-x-icu")`, /a collation other than "C"/],
[`CREATE TYPE r AS RANGE (subtype = text, collation = "de-x-icu")`, /a collation other than "C"/],
['CREATE INDEX i ON notes USING bloom (body)', /built-in access methods/],
['CREATE INDEX i ON notes USING "BTREE" (body)', /built-in access methods/],
['CREATE TABLE t (x int) USING columnar', /built-in access methods/],
['CREATE MATERIALIZED VIEW mv USING columnar AS SELECT 1', /built-in access methods/],
['ALTER TABLE notes SET ACCESS METHOD columnar', /built-in access methods/],
['ALTER TABLE notes ADD EXCLUDE USING bloom (body WITH =)', /built-in access methods/],
// 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/],
@@ -208,8 +281,6 @@ describe('plugin SQL guard', () => {
['CREATE TABLE grants (a aclitem)', /"aclitem" 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) => {
@@ -224,7 +295,6 @@ describe('plugin SQL guard', () => {
['PARAGRAPH SEPARATOR', '
', 'U+2029'],
['IDEOGRAPHIC SPACE', ' ', 'U+3000'],
['vertical tab', '\u000b', 'U+000B'],
['NUL', '\u0000', 'U+0000'],
['escape', '\u001b', 'U+001B'],
['DEL', '\u007f', 'U+007F'],
])('refuses a %s outside a string, which JavaScript and Postgres read differently', (_name, ch, code) => {
@@ -239,6 +309,19 @@ describe('plugin SQL guard', () => {
}
});
it('refuses a NUL anywhere, in a string too, with the words the stores of both engines use', () => {
// The protocol ends a statement's text at a NUL, so what Postgres would read is not what was checked.
for (const sql of [
"select 'a\u0000' -- then\nfrom public.users",
'SELECT 1\u0000FROM public.users',
'\u0000SELECT 1',
'SELECT "a\u0000b" FROM notes',
]) {
expect(() => tokenize(sql), JSON.stringify(sql)).toThrow(PLUGIN_SQL_NUL_REFUSAL);
expect(() => check(sql), JSON.stringify(sql)).toThrow(PLUGIN_SQL_NUL_REFUSAL);
}
});
it('reads nested block comments as Postgres does, so code after the inner close is still a comment', () => {
expect(() => check('SELECT 1 /* outer /* inner */ public.users */')).not.toThrow();
expect(() => check('SELECT 1 /* one */ FROM public.users')).toThrow(/another schema/);
@@ -48,8 +48,8 @@ describe('fast-xml-parser stays in place-import and the WebDAV client', () => {
'src/nest/tours/tours.service.ts',
'src/nest/maps/maps.service.ts',
'src/db/repositories/Places.repository.ts',
// The driver's own homes and the plugin sandbox's database, which the
// driver wall leaves out, and the RPC kit, which restates the rule.
// The driver's own homes, which the driver wall leaves out, the plugin
// data directories, which it holds again, and the RPC kit, which restates the rule.
'src/db/database.ts',
'src/db/connection.ts',
'src/db/orm-driver.ts',
@@ -72,8 +72,9 @@ describe('fast-xml-parser stays in place-import and the WebDAV client', () => {
});
it('keeps the services wall in the driver-exempt files and the driver wall in the RPC kit', async () => {
expect(await flags('src/nest/plugins/host/plugin-data.service.ts', SERVICES)).toBe(true);
expect(await flags('src/nest/plugins/host/plugin-data.service.ts', DRIVER)).toBe(false);
expect(await flags('src/db/connection.ts', SERVICES)).toBe(true);
expect(await flags('src/db/connection.ts', DRIVER)).toBe(false);
expect(await flags('src/nest/plugins/host/plugin-data.service.ts', DRIVER)).toBe(true);
expect(await flags('src/nest-rpc/rpc-kit/registry.ts', DRIVER)).toBe(true);
});
@@ -10,13 +10,13 @@ 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 { SqlitePluginDataStore } from '../../../src/db/engine/sqlite/plugin-data-store';
import {
PLUGIN_DATA,
PLUGIN_DATA_PROVIDERS,
PostgresPluginDataBackend,
SqlitePluginDataBackend,
} from '../../../src/nest/plugins/host/plugin-data.backend';
import { PluginDataDb } from '../../../src/nest/plugins/host/plugin-data.service';
import type { MikroORM } from '@mikro-orm/core';
import type { FactoryProvider } from '@nestjs/common';
@@ -88,7 +88,7 @@ describe('plugin data port', () => {
it("PLUGDATA-002: on SQLite a plugin's data is a file of its own, and erasing removes its directory", async () => {
const backend = new SqlitePluginDataBackend();
const store = backend.open('sqlite-one');
expect(store).toBeInstanceOf(PluginDataDb);
expect(store).toBeInstanceOf(SqlitePluginDataStore);
expect(store.engine).toBe('sqlite');
store.close();
expect(fs.existsSync(path.join(tmp, 'sqlite-one', 'plugin.db'))).toBe(true);
+79 -55
View File
@@ -1,13 +1,16 @@
/**
* The per-plugin sqlite file (#plugins, M1, db:own). Proves migrations are
* The per-plugin SQLite store (src/db/engine/sqlite/plugin-data-store.ts, db:own). Proves migrations are
* idempotent, reads/writes work against the plugin's OWN file, and the guard
* blocks statements that would let a plugin escape its file (ATTACH/PRAGMA).
*/
import {
PluginDataDb,
removePluginData,
snapshotAllPluginDataDbs,
} from '../../../src/nest/plugins/host/plugin-data.service';
PLUGIN_DATA_ERRORS,
PLUGIN_SQL_NUL_REFUSAL,
PLUGIN_VALUE_NUL_REFUSAL,
} from '../../../src/db/engine/plugin-data-contract';
import { SqlitePluginDataStore } from '../../../src/db/engine/sqlite/plugin-data-store';
import { removePluginData, snapshotAllPluginDataDbs } from '../../../src/nest/plugins/host/plugin-data.service';
import { pluginDbFile } from '../../../src/nest/plugins/paths';
import fs from 'node:fs';
import os from 'node:os';
@@ -24,9 +27,14 @@ afterAll(() => {
fs.rmSync(tmp, { recursive: true, force: true });
});
describe('PluginDataDb', () => {
/** The plugin `id`'s store, at the file the host opens it at. */
function openStore(id: string, limits: ConstructorParameters<typeof SqlitePluginDataStore>[2] = {}) {
return new SqlitePluginDataStore(id, pluginDbFile(id), limits);
}
describe('SqlitePluginDataStore', () => {
it('migrates once (idempotent by id), then reads and writes its own data', () => {
const db = new PluginDataDb('notes');
const db = openStore('notes');
expect(db.migrate('001', 'CREATE TABLE notes (id INTEGER PRIMARY KEY, body TEXT)').applied).toBe(true);
expect(db.migrate('001', 'CREATE TABLE notes (x)').applied).toBe(false); // same id -> skipped
@@ -42,10 +50,10 @@ describe('PluginDataDb', () => {
});
it('rejects statements that would escape the plugin file, DoS, or exceed limits', () => {
const db = new PluginDataDb('guard');
const db = openStore('guard');
expect(() => db.exec("ATTACH DATABASE 'trek.db' AS core")).toThrow(/not allowed/);
expect(() => db.query('PRAGMA table_info(x)')).toThrow(/not allowed/);
// WITH RECURSIVE is the unbounded-CPU vector on the synchronous host — refused
// WITH RECURSIVE is the unbounded-CPU vector on the synchronous host, so it is refused
expect(() => db.query('WITH RECURSIVE r(x) AS (SELECT 1 UNION ALL SELECT x+1 FROM r) SELECT x FROM r')).toThrow(
/not allowed/,
);
@@ -58,7 +66,7 @@ describe('PluginDataDb', () => {
});
it('row-caps a query so it cannot materialize an unbounded result set', () => {
const db = new PluginDataDb('rowcap');
const db = openStore('rowcap');
db.exec('CREATE TABLE seq (n INTEGER)');
// Insert a modest table and a self-cross-join that would explode past the cap.
const insert = 'INSERT INTO seq (n) VALUES ' + Array.from({ length: 400 }, (_, i) => `(${i})`).join(',');
@@ -68,8 +76,8 @@ describe('PluginDataDb', () => {
db.close();
});
it('tx runs a batch atomically — reads see earlier writes, and any error rolls the whole batch back', () => {
const db = new PluginDataDb('txn');
it('tx runs a batch atomically: reads see earlier writes, and any error rolls the whole batch back', () => {
const db = openStore('txn');
db.migrate('001', 'CREATE TABLE acct (id INTEGER PRIMARY KEY, bal INTEGER)');
db.exec('INSERT INTO acct (id, bal) VALUES (1, 100), (2, 0)');
@@ -135,7 +143,7 @@ describe('PluginDataDb', () => {
};
it('stops a query at the first row past its time budget', () => {
const db = new PluginDataDb('budget-query', { timeBudgetMs: 100, now: steppingClock(30) });
const db = openStore('budget-query', { timeBudgetMs: 100, now: steppingClock(30) });
db.exec('CREATE TABLE seq (n INTEGER)');
db.exec('INSERT INTO seq (n) VALUES ' + Array.from({ length: 50 }, (_, i) => `(${i})`).join(','));
// The start reads the clock and every row after the first reads it again, 30 ms
@@ -147,7 +155,7 @@ describe('PluginDataDb', () => {
});
it('holds a whole tx batch to one time budget and rolls it back when it runs out', () => {
const db = new PluginDataDb('budget-tx', { timeBudgetMs: 80, now: steppingClock(30) });
const db = openStore('budget-tx', { timeBudgetMs: 80, now: steppingClock(30) });
db.exec('CREATE TABLE acct (id INTEGER PRIMARY KEY, bal INTEGER)');
db.exec('INSERT INTO acct (id, bal) VALUES (1, 100)');
// The clock is read at the start and after each statement: 30 ms, 60 ms, then
@@ -167,7 +175,7 @@ describe('PluginDataDb', () => {
});
it('holds an exec script to the time budget between its statements', () => {
const db = new PluginDataDb('budget-exec', { timeBudgetMs: 80, now: steppingClock(30) });
const db = openStore('budget-exec', { timeBudgetMs: 80, now: steppingClock(30) });
db.exec('CREATE TABLE log (n INTEGER)');
// Start, then one read before each statement after the first: 30, 60, then 90 ms
// before the fourth insert. The script stops there and the fourth insert never
@@ -180,11 +188,10 @@ describe('PluginDataDb', () => {
).toThrow('exec exceeded its 80 ms time budget');
// One row back, so the check itself reads the clock only at its start.
expect(db.query('SELECT group_concat(n) AS ns FROM (SELECT n FROM log ORDER BY n)')).toEqual([{ ns: '1,2,3' }]);
// A script that opened its own transaction and ran out of time inside it is rolled
// back, so the connection is not left in that transaction.
// A script that would open its own transaction is refused before any of it runs.
expect(() =>
db.exec('BEGIN; INSERT INTO log VALUES (5); INSERT INTO log VALUES (6); INSERT INTO log VALUES (7); COMMIT;'),
).toThrow(/time budget/);
db.exec('INSERT INTO log VALUES (5); BEGIN; INSERT INTO log VALUES (6); INSERT INTO log VALUES (7); COMMIT;'),
).toThrow(PLUGIN_DATA_ERRORS.txControl);
expect(db.query('SELECT count(*) AS c FROM log WHERE n > 4')).toEqual([{ c: 0 }]);
db.exec('INSERT INTO log VALUES (8)');
expect(db.query('SELECT count(*) AS c FROM log WHERE n > 4')).toEqual([{ c: 1 }]);
@@ -193,22 +200,24 @@ describe('PluginDataDb', () => {
it('reports a call whose last statement or row ran past the budget as done', () => {
const clock = scriptedClock();
const db = new PluginDataDb('budget-last', { timeBudgetMs: 100, now: clock.now });
const db = openStore('budget-last', { timeBudgetMs: 100, now: clock.now });
db.exec('CREATE TABLE log (n INTEGER)');
// A single statement without args: the clock is read at the start only, so a
// slow insert that has run and committed is not reported as failed.
clock.reads = [0, 1000];
expect(db.exec('INSERT INTO log VALUES (1)')).toEqual({ changes: 0 });
// A script whose closing COMMIT is what takes the time: the reads before the
// INSERT and before the COMMIT are in budget, and nothing is read after it.
clock.reads = [0, 0, 0, 1000];
expect(db.exec('BEGIN; INSERT INTO log VALUES (2); COMMIT;')).toEqual({ changes: 0 });
// A script whose last statement is what takes the time: the reads at the start
// and before the last statement are in budget, and nothing is read after it.
clock.reads = [0, 0, 1000];
expect(db.exec('INSERT INTO log VALUES (2); DELETE FROM log WHERE n > 2;')).toEqual({ changes: 0 });
clock.reads = [0];
expect(db.query('SELECT n FROM log ORDER BY n')).toEqual([{ n: 1 }, { n: 2 }]);
// The same budget running out before the COMMIT still stops the script and rolls
// the transaction back.
clock.reads = [0, 0, 1000];
expect(() => db.exec('BEGIN; INSERT INTO log VALUES (3); COMMIT;')).toThrow('exec exceeded its 100 ms time budget');
// The same budget running out before the last statement still stops the script
// there: the insert never runs.
clock.reads = [0, 1000];
expect(() => db.exec('UPDATE log SET n = n WHERE n = 1; INSERT INTO log VALUES (3);')).toThrow(
'exec exceeded its 100 ms time budget',
);
clock.reads = [0];
expect(db.query('SELECT count(*) AS c FROM log')).toEqual([{ c: 2 }]);
// A query read to its end is returned, even when its last row came in late: the
@@ -226,7 +235,7 @@ describe('PluginDataDb', () => {
});
it('runs an exec script statement by statement with the semantics Database#exec had', () => {
const db = new PluginDataDb('exec-script');
const db = openStore('exec-script');
db.exec(`
-- a setup script: comments, a semicolon in a string, and a trigger body
CREATE TABLE notes (id INTEGER PRIMARY KEY, body TEXT); /* one; two */
@@ -251,11 +260,20 @@ describe('PluginDataDb', () => {
expect(db.query('SELECT count(*) AS n FROM notes')).toEqual([{ n: 3 }]);
// A statement left open at the end reports what Database#exec reported.
expect(() => db.exec('CREATE TRIGGER t AFTER INSERT ON notes BEGIN SELECT 1;')).toThrow('incomplete input');
// The END that closes a trigger body (after a CASE ... END too) is no transaction
// control, a COMMIT after the trigger is, and refusing it runs nothing.
db.exec('CREATE TEMP TRIGGER t2 AFTER UPDATE ON notes BEGIN SELECT CASE WHEN 1 THEN 1 END; END; SELECT 1;');
expect(() =>
db.exec(
'CREATE TRIGGER t3 AFTER DELETE ON notes BEGIN UPDATE audit SET what = CASE WHEN 1 THEN what END; END; COMMIT;',
),
).toThrow(PLUGIN_DATA_ERRORS.txControl);
expect(db.query("SELECT count(*) AS n FROM sqlite_master WHERE name = 't3'")).toEqual([{ n: 0 }]);
db.close();
});
it('applies an overridden row cap to query and tx alike', () => {
const db = new PluginDataDb('budget-rows', { maxRows: 3 });
const db = openStore('budget-rows', { maxRows: 3 });
db.exec('CREATE TABLE seq (n INTEGER)');
db.exec('INSERT INTO seq (n) VALUES (1), (2), (3), (4)');
expect(() => db.query('SELECT n FROM seq')).toThrow('query returned more than 3 rows');
@@ -264,34 +282,40 @@ describe('PluginDataDb', () => {
db.close();
});
it("binds a plugin's NUL exactly: stored rows stay findable and NUL-separated keys never collide", () => {
const db = new PluginDataDb('nul-keys');
it("refuses NUL in SQL, an argument or a migration id with the Postgres store's error, and stores nothing", () => {
const db = openStore('nul-keys');
db.exec('CREATE TABLE kv (k TEXT PRIMARY KEY, v TEXT)');
// A row a plugin wrote with a NUL in its key, through its own SQL as well as through a bound arg.
db.exec("INSERT INTO kv VALUES ('q' || char(0) || 'r', 'spelled')");
db.exec('INSERT INTO kv VALUES (?, ?)', ['trip-1\u0000slug', 'bound']);
// Keys that differ only in where the NUL sits are two keys.
db.exec('INSERT INTO kv VALUES (?, ?)', ['a\u0000bc', 'one']);
db.exec('INSERT INTO kv VALUES (?, ?)', ['ab\u0000c', 'two']);
db.tx([{ sql: 'INSERT INTO kv VALUES (?, ?)', args: ['x\u0000', 'tx'] }]);
expect(db.query('SELECT v FROM kv WHERE k = ?', ['q\u0000r'])).toEqual([{ v: 'spelled' }]);
expect(db.query('SELECT v FROM kv WHERE k = ?', ['trip-1\u0000slug'])).toEqual([{ v: 'bound' }]);
expect(db.query('SELECT v FROM kv WHERE k = ?', ['trip-1slug'])).toEqual([]);
expect(db.query('SELECT v FROM kv WHERE k IN (?, ?) ORDER BY v', ['a\u0000bc', 'ab\u0000c'])).toEqual([
{ v: 'one' },
{ v: 'two' },
]);
expect(db.tx([{ sql: 'SELECT v FROM kv WHERE k = ?', args: ['x\u0000'] }])).toEqual({
results: [{ rows: [{ v: 'tx' }] }],
});
// Stored whole: SQLite's length() of text stops at a NUL, the bytes do not.
expect(db.query('SELECT length(CAST(k AS BLOB)) AS n FROM kv WHERE v = ?', ['bound'])).toEqual([{ n: 11 }]);
const refusals: Array<[() => unknown, string]> = [
[() => db.exec('INSERT INTO kv VALUES (?, ?)', ['trip-1\u0000slug', 'bound']), PLUGIN_VALUE_NUL_REFUSAL],
[() => db.query('SELECT v FROM kv WHERE k = ?', ['a\u0000bc']), PLUGIN_VALUE_NUL_REFUSAL],
[() => db.query('SELECT v FROM kv WHERE k = :k', [{ k: 'x\u0000' }]), PLUGIN_VALUE_NUL_REFUSAL],
[() => db.exec('INSERT INTO kv VALUES (?, ?)', [['a', '\u0000'], 'nested']), PLUGIN_VALUE_NUL_REFUSAL],
[
() =>
db.tx([
{ sql: "INSERT INTO kv VALUES ('first', 'tx')" },
{ sql: 'INSERT INTO kv VALUES (?, ?)', args: ['x\u0000', 'tx'] },
]),
PLUGIN_VALUE_NUL_REFUSAL,
],
[() => db.migrate('002\u0000', 'CREATE TABLE more (x INTEGER)'), PLUGIN_VALUE_NUL_REFUSAL],
[() => db.exec("INSERT INTO kv VALUES ('a\u0000b', 'literal')"), PLUGIN_SQL_NUL_REFUSAL],
[() => db.query("SELECT v FROM kv WHERE k = 'q\u0000'"), PLUGIN_SQL_NUL_REFUSAL],
];
for (const [call, reason] of refusals) expect(call).toThrow(reason);
expect(db.query('SELECT count(*) AS n FROM kv')).toEqual([{ n: 0 }]);
expect(db.query("SELECT count(*) AS n FROM sqlite_master WHERE name = 'more'")).toEqual([{ n: 0 }]);
// Binary data with a zero byte is a BLOB, and a row an older TREK stored with a NUL is still read.
db.exec('CREATE TABLE raw (b BLOB)');
db.exec('INSERT INTO raw VALUES (?)', [Buffer.from([1, 0, 2])]);
expect(db.query('SELECT length(b) AS n FROM raw')).toEqual([{ n: 3 }]);
db.exec("INSERT INTO kv VALUES ('q' || char(0) || 'r', 'older')");
expect(db.query('SELECT length(CAST(k AS BLOB)) AS n FROM kv WHERE v = ?', ['older'])).toEqual([{ n: 3 }]);
db.close();
});
it('removePluginData deletes the whole data dir', () => {
const db = new PluginDataDb('temp');
const db = openStore('temp');
db.migrate('001', 'CREATE TABLE t (id INTEGER)');
db.close();
expect(fs.existsSync(path.join(tmp, 'temp'))).toBe(true);
@@ -300,7 +324,7 @@ describe('PluginDataDb', () => {
});
it('snapshots a closed plugin.db together with its -wal/-shm sidecars (no data loss after an unclean shutdown)', () => {
const srcDir = path.join(tmp, 'wal-plugin'); // no open PluginDataDb handle → treated as closed
const srcDir = path.join(tmp, 'wal-plugin'); // no open store → treated as closed
fs.mkdirSync(srcDir, { recursive: true });
fs.writeFileSync(path.join(srcDir, 'plugin.db'), 'DB');
fs.writeFileSync(path.join(srcDir, 'plugin.db-wal'), 'WAL-committed');
@@ -310,7 +334,7 @@ describe('PluginDataDb', () => {
snapshotAllPluginDataDbs(dest);
const outDir = path.join(dest, 'wal-plugin');
expect(fs.existsSync(path.join(outDir, 'plugin.db'))).toBe(true);
// No writer, so the WAL is a consistent set with the .db and must be copied —
// No writer, so the WAL is a consistent set with the .db and must be copied:
// otherwise committed-but-uncheckpointed rows in the WAL are lost from the backup.
expect(fs.readFileSync(path.join(outDir, 'plugin.db-wal'), 'utf8')).toBe('WAL-committed');
expect(fs.existsSync(path.join(outDir, 'plugin.db-shm'))).toBe(true);
+2 -2
View File
@@ -1,8 +1,8 @@
/**
* splitAfterSemicolons: where a plugin's exec() script is cut into statements, so
* the time budget can be read between them (plugin-data.service.ts).
* the time budget can be read between them (src/db/engine/sqlite/plugin-data-store.ts).
*/
import { splitAfterSemicolons } from '../../../src/nest/plugins/host/sql-script';
import { splitAfterSemicolons } from '../../../src/db/engine/sqlite/sql-script';
import { describe, expect, it } from 'vitest';