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