From 734008735354df0488a1c69d4b7e817ebdce29fe Mon Sep 17 00:00:00 2001 From: Maurice Date: Tue, 17 Nov 2026 13:00:55 +0100 Subject: [PATCH] fix(db): carry the plugin data schemas in Postgres backups and restores pg_dump now names the trek_plugin_ schemas TREK's role owns beside its own schema. A restore reads the dump's plugin schemas from its table of contents, drops the plugin schemas the role owns, creates the dump's and loads them with TREK's schema, all in the one psql transaction. Schemas of another role and every other schema of the database are never read or dropped. The dump's migration history is read from TREK's mikro_orm_migrations only, so a plugin table of that name cannot pass for it. --- server/src/db/engine/postgres/clear-schema.ts | 24 ++++++ server/src/db/engine/postgres/pg-tools.ts | 76 ++++++++++++++----- server/tests/helpers/fake-pg-tools.ts | 20 ++++- .../unit/db/engine/postgres/pg-tools.test.ts | 58 +++++++++++++- 4 files changed, 155 insertions(+), 23 deletions(-) diff --git a/server/src/db/engine/postgres/clear-schema.ts b/server/src/db/engine/postgres/clear-schema.ts index 0020bd859..3a18d7302 100644 --- a/server/src/db/engine/postgres/clear-schema.ts +++ b/server/src/db/engine/postgres/clear-schema.ts @@ -1,3 +1,5 @@ +import { PLUGIN_SCHEMA_PREFIX, quotePluginSchema } from './plugin-schema'; + /** * Drops every table, view, sequence, routine, collation and standalone type in * the current schema, except an extension's, before a dump is loaded: a dump @@ -39,3 +41,25 @@ BEGIN END $clear$; `; + +/** + * Drops every plugin data schema TREK's role owns, then creates the ones + * `schemas` names (a dump's) empty, for the restore script to fill: the script + * holds what is in them, never the schemas themselves. Runs right after + * CLEAR_SCHEMA_SQL, in the same transaction. A schema another role owns is + * never dropped, whatever its name. + */ +export function pluginSchemasSql(schemas: readonly string[]): string { + const drop = `DO $plugins$ +DECLARE r record; +BEGIN + FOR r IN SELECT nspname FROM pg_namespace + WHERE starts_with(nspname, '${PLUGIN_SCHEMA_PREFIX}') AND pg_get_userbyid(nspowner) = current_user + LOOP + EXECUTE format('DROP SCHEMA %I CASCADE', r.nspname); + END LOOP; +END +$plugins$; +`; + return drop + schemas.map((name) => `CREATE SCHEMA ${quotePluginSchema(name)};\n`).join(''); +} diff --git a/server/src/db/engine/postgres/pg-tools.ts b/server/src/db/engine/postgres/pg-tools.ts index 01624d63c..db740a52d 100644 --- a/server/src/db/engine/postgres/pg-tools.ts +++ b/server/src/db/engine/postgres/pg-tools.ts @@ -1,6 +1,7 @@ import { CURRENT_SCHEMA_TABLES_SQL } from '../../dialect/catalog'; -import { CLEAR_SCHEMA_SQL } from './clear-schema'; +import { CLEAR_SCHEMA_SQL, pluginSchemasSql } from './clear-schema'; import { pgConnectionEnv, PgOutputLimitError, refuseClientOlderThanServer, run, runToFile } from './pg-process'; +import { isPluginSchemaName, PLUGIN_SCHEMA_PREFIX } from './plugin-schema'; import { refuseToolsWithoutRestrict } from './restore-safety'; import { PRIVILEGED_ROLE_SQL, serverMajor } from './server-checks'; @@ -37,16 +38,24 @@ interface PgSchema { /** What a dump or a restore needs to know about the server before it runs. */ interface PgServer { schema: PgSchema; + /** The plugin data schemas TREK's role owns (`plugin-schema.ts`), which a dump holds beside TREK's own. */ + pluginSchemas: string[]; /** The server's major version, which the client tools must reach. */ major: number; /** Whether TREK's role could run programs or write files on the database host (`PRIVILEGED_ROLE_SQL`). */ privileged: boolean; } -/** One line, tab-separated: the current schema, its quoted name, the server version, whether the role is privileged. */ +/** + * One line, tab-separated: the current schema, its quoted name, the server + * version, whether the role is privileged, and the plugin schemas the role + * owns, comma-separated. + */ const SERVER_SQL = "select concat_ws(E'\\t', coalesce(current_schema(), ''), coalesce(quote_ident(current_schema()), ''), " + - `current_setting('server_version_num'), (${PRIVILEGED_ROLE_SQL})::text)`; + `current_setting('server_version_num'), (${PRIVILEGED_ROLE_SQL})::text, ` + + "(select coalesce(string_agg(nspname, ',' order by nspname), '') from pg_namespace " + + `where starts_with(nspname, '${PLUGIN_SCHEMA_PREFIX}') and pg_get_userbyid(nspowner) = current_user))`; /** * The current schema of the database at `url`, the one TREK creates its @@ -62,16 +71,22 @@ async function pgServer(url: string, binDir: string | undefined): Promise `--schema=${plugin}`), ], pgConnectionEnv(url), ); @@ -131,11 +148,12 @@ async function scriptHoldsTrekSchema(script: string, schema: PgSchema): Promise< async function writeRestoreScript( source: string, script: string, - schema: PgSchema, + schemas: readonly string[], binDir: string | undefined, maxBytes: number, ): Promise { - const args = ['--no-owner', '--no-privileges', `--schema=${schema.name}`, '--file=-', '--', source]; + const only = schemas.map((name) => `--schema=${name}`); + const args = ['--no-owner', '--no-privileges', ...only, '--file=-', '--', source]; try { await runToFile('pg_restore', binDir, args, {}, script, maxBytes); } catch (err) { @@ -150,10 +168,12 @@ async function writeRestoreScript( /** * Replaces the current schema of the database at `url` with the dump at - * `source`: pg_restore turns the dump's objects in that schema into a script - * beside it (anything else the dump holds is left out), then psql clears the - * schema and runs the script in one transaction, so a restore that fails - * leaves the database as it was. Refused before anything is cleared: + * `source`, and the plugin data schemas with the dump's: pg_restore turns the + * dump's objects in those schemas into a script beside it (anything else the + * dump holds is left out), then psql clears the schema, drops the plugin + * schemas TREK's role owns, creates the dump's and runs the script, all in + * one transaction, so a restore that fails leaves the database as it was. No + * other schema of the database is touched. Refused before anything is cleared: * * - client tools without the CVE-2025-8714 fix, or older than the server; * - a role that could run programs or write files on the database host, @@ -179,9 +199,10 @@ export async function pgRestore( try { const clear = path.join(workDir, 'clear-schema.sql'); const script = path.join(workDir, 'restore.sql'); - fs.writeFileSync(clear, CLEAR_SCHEMA_SQL, { mode: 0o600 }); + const pluginSchemas = await dumpPluginSchemas(source, path.join(workDir, 'toc.txt'), binDir); + fs.writeFileSync(clear, CLEAR_SCHEMA_SQL + pluginSchemasSql(pluginSchemas), { mode: 0o600 }); createPrivateFile(script); - await writeRestoreScript(source, script, schema, binDir, maxScriptBytes); + await writeRestoreScript(source, script, [schema.name, ...pluginSchemas], binDir, maxScriptBytes); if (!(await scriptHoldsTrekSchema(script, schema))) { throw new Error(`The backup holds no TREK tables in the schema "${schema.name}"; nothing was replaced.`); } @@ -204,6 +225,23 @@ export async function pgRestore( } } +/** + * The plugin data schemas the dump at `source` holds, read from its table of + * contents (`pg_restore --list`, written to `toc`), which has a line + * `; SCHEMA - ` per schema. Only a name TREK + * gives a plugin schema counts. + */ +async function dumpPluginSchemas(source: string, toc: string, binDir: string | undefined): Promise { + createPrivateFile(toc); + await run('pg_restore', binDir, ['--list', `--file=${toc}`, '--', source], {}); + const names = new Set(); + for (const line of fs.readFileSync(toc, 'utf8').split('\n')) { + const name = /^\d+; \d+ \d+ SCHEMA - (\S+) /.exec(line)?.[1]; + if (name !== undefined && isPluginSchemaName(name)) names.add(name); + } + return [...names].sort((a, b) => a.localeCompare(b)); +} + /** The tables in the current schema of the database at `url`, read before TREK opens it. */ export async function pgTableNames(url: string, binDir: string | undefined): Promise { const out = await run( @@ -222,7 +260,11 @@ export async function pgTableNames(url: string, binDir: string | undefined): Pro */ function migrationNamesFromCopy(script: string): string[] { const lines = script.split('\n'); - const copy = lines.findIndex((line) => /^COPY \S*mikro_orm_migrations \(/.test(line)); + // A plugin may name a table of its own schema mikro_orm_migrations too; only TREK's counts. + const copy = lines.findIndex((line) => { + const match = /^COPY (?:(\S+)\.)?mikro_orm_migrations \(/.exec(line); + return match !== null && !isPluginSchemaName(match[1] ?? ''); + }); if (copy < 0) return []; const columns = /\(([^)]*)\)/ diff --git a/server/tests/helpers/fake-pg-tools.ts b/server/tests/helpers/fake-pg-tools.ts index 249c831fb..6b8a64b0a 100644 --- a/server/tests/helpers/fake-pg-tools.ts +++ b/server/tests/helpers/fake-pg-tools.ts @@ -44,16 +44,19 @@ interface FakeServer { versionNum?: string; /** Whether TREK's role could reach the database host. */ privileged?: boolean; + /** The plugin data schemas the role owns; none by default. */ + pluginSchemas?: readonly string[]; } /** * psql's answer about the server, as pgServer reads it: the schema's name, its - * quote_ident spelling, the server's version number and whether the role is - * privileged, tab-separated. + * quote_ident spelling, the server's version number, whether the role is + * privileged and the plugin schemas it owns, tab-separated. */ export function answersSchema(name = 'public', quoted = name, server: FakeServer = {}): string { - const { versionNum = '170000', privileged = false } = server; - return printsWhen('quote_ident', `${name}\t${quoted}\t${versionNum}\t${String(privileged)}\n`); + const { versionNum = '170000', privileged = false, pluginSchemas = [] } = server; + const plugins = pluginSchemas.join(','); + return printsWhen('quote_ident', `${name}\t${quoted}\t${versionNum}\t${String(privileged)}\t${plugins}\n`); } /** psql's table listing, one name per line, as pgTableNames reads it. */ @@ -71,6 +74,15 @@ export function writesRestrictedScript(table = 'public.mikro_orm_migrations'): s return writesFile(`\\restrict k1\nCREATE TABLE ${table} (\n);\n`); } +/** + * Answers a `--list` call with a table of contents holding a SCHEMA line for + * each of `schemas`, written to its `--file=`, as `pg_restore --list` does. + */ +export function listsSchemas(schemas: readonly string[]): string { + const toc = schemas.map((name, i) => `${i + 4}; 2615 ${16000 + i} SCHEMA - ${name} trek\n`).join(''); + return `case "$*" in *--list*) printf '%s' ${shellWord(toc)} > "$(fake_file_target "$@")"; exit 0;; esac`; +} + /** Answers a `--data-only` call with the COPY block of `mikro_orm_migrations`, one row per name. */ export function listsMigrations(names: readonly string[]): string { const rows = names.map((name, i) => `${i + 1}\t${name}\tx\n`).join(''); diff --git a/server/tests/unit/db/engine/postgres/pg-tools.test.ts b/server/tests/unit/db/engine/postgres/pg-tools.test.ts index 17ff0a0f8..f8a00595d 100644 --- a/server/tests/unit/db/engine/postgres/pg-tools.test.ts +++ b/server/tests/unit/db/engine/postgres/pg-tools.test.ts @@ -17,6 +17,7 @@ import { flagValues, installFakeTool, listsMigrations, + listsSchemas, printsWhen, readToolCall, touches, @@ -264,7 +265,9 @@ describe('pg-tools', () => { it('PGTOOLS-013: a restore refuses a role that could reach the database host, before it writes a script', async () => { const ran = path.join(bin, 'ran'); installFakeTool(bin, 'pg_restore', { snippets: [touches(ran)] }); - const psqlLog = installFakeTool(bin, 'psql', { snippets: [answersSchema('public', 'public', { privileged: true })] }); + const psqlLog = installFakeTool(bin, 'psql', { + snippets: [answersSchema('public', 'public', { privileged: true })], + }); await expect(pgRestore(URL_WITH_SECRET, path.join(out, 'in.pgdump'), bin, LIMIT)).rejects.toThrow( /connects as a superuser, or as a role that may run programs or write files on the database server/, ); @@ -326,7 +329,8 @@ describe('pg-tools', () => { it('PGTOOLS-017: a failed tool leaves the rows it quoted out of the error, its cause included', async () => { installFakeTool(bin, 'psql', { snippets: [answersSchema()] }); - const stderr = 'pg_dump: error: COPY failed\nDETAIL: Key (email)=(a@b.c)\nCONTEXT: COPY users, line 2: "secret-row"'; + const stderr = + 'pg_dump: error: COPY failed\nDETAIL: Key (email)=(a@b.c)\nCONTEXT: COPY users, line 2: "secret-row"'; installFakeTool(bin, 'pg_dump', { snippets: [failsWith(stderr)] }); const failure = await pgDump(URL_WITH_SECRET, path.join(out, 'x.pgdump'), bin).catch((err: unknown) => err); const printed = inspect(failure, { depth: null }); @@ -335,4 +339,54 @@ describe('pg-tools', () => { expect(printed).not.toContain('secret-row'); expect(printed).not.toContain('a@b.c'); }); + + it("PGTOOLS-018: a dump holds the plugin schemas TREK's role owns beside its own schema, and nothing else", async () => { + const plugins = ['trek_plugin_notes', 'trek_plugin_trip_weather']; + const psqlLog = installFakeTool(bin, 'psql', { + snippets: [answersSchema('public', 'public', { pluginSchemas: [...plugins, 'auth'] })], + }); + const dumpLog = installFakeTool(bin, 'pg_dump', { snippets: [writesFile('dump')] }); + await pgDump(URL_WITH_SECRET, path.join(out, 'x.pgdump'), bin); + + const args = readToolCall(dumpLog).args; + expect(flagValues(args, '--schema=')).toEqual(['"public"', ...plugins]); + const sql = readToolCall(psqlLog).args.join(' '); + expect(sql).toContain("starts_with(nspname, 'trek_plugin_')"); + expect(sql).toContain('pg_get_userbyid(nspowner) = current_user'); + }); + + it("PGTOOLS-019: a restore loads the dump's plugin schemas, after dropping the role's own and creating the dump's", async () => { + const clearCopy = path.join(bin, 'clear.sql'); + const restoreLog = installFakeTool(bin, 'pg_restore', { + snippets: [listsSchemas(['trek_plugin_notes', 'auth', 'public']), writesRestrictedScript()], + }); + installFakeTool(bin, 'psql', { + snippets: [answersSchema(), copiesFileEndingWith('clear-schema.sql', clearCopy)], + }); + const source = path.join(out, 'in.pgdump'); + await pgRestore(URL_WITH_SECRET, source, bin, LIMIT); + + expect(flagValues(readToolCall(restoreLog).args, '--schema=')).toEqual(['public', 'trek_plugin_notes']); + const clear = readFileSync(clearCopy, 'utf8'); + expect(clear).toMatch(/DROP %s IF EXISTS %s CASCADE/); + expect(clear).toContain("EXECUTE format('DROP SCHEMA %I CASCADE', r.nspname);"); + expect(clear).toContain('pg_get_userbyid(nspowner) = current_user'); + expect(clear.endsWith('CREATE SCHEMA "trek_plugin_notes";\n')).toBe(true); + expect(clear).not.toContain('CREATE SCHEMA "auth"'); + expect(readdirSync(out)).toEqual([]); + }); + + it("PGTOOLS-020: a plugin's own table named mikro_orm_migrations never passes for TREK's history", async () => { + const forged = + 'COPY trek_plugin_notes.mikro_orm_migrations (id, name) FROM stdin;\n1\tMigration29990101000000_forged\n\.\n'; + const real = + 'COPY public.mikro_orm_migrations (id, name, executed_at) FROM stdin;\n1\tMigration20200101000000_baseline_schema\tx\n\.\n'; + installFakeTool(bin, 'pg_restore', { snippets: [printsWhen('--data-only', forged + real)] }); + await expect(pgDumpMigrations('/data/in.pgdump', bin)).resolves.toEqual([ + 'Migration20200101000000_baseline_schema', + ]); + + installFakeTool(bin, 'pg_restore', { snippets: [printsWhen('--data-only', forged)] }); + await expect(pgDumpMigrations('/data/in.pgdump', bin)).resolves.toEqual([]); + }); });