@rebasepro/server-postgres 0.24.1-canary.gcb918fc → 0.25.0-canary.g70dad01

package/dist/{backup-service-BTBB7RXn.js → backup-service-DytMimsL.js}

@@ -1,8 +1,8 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { r as __exportAll } from "./__vite-browser-external-BnuHet1e.js";
-import { F as resolveLocalBin } from "./cli-errors-CaI4ntyD.js";
-import { o as execa, s as forLibpq } from "./rls-bootstrap-sql-RQUljnJ1.js";
+import { n as __exportAll } from "./rolldown-runtime-V7rFbMRe.js";
+import { Q as forLibpq, R as resolveLocalBin, et as splitPassword } from "./cli-errors-CJTKAKax.js";
+import { o as execa } from "./rls-bootstrap-sql-Bd-hJk08.js";
 import path from "path";
 import fs from "fs";
 import os from "os";
@@ -235,6 +235,111 @@ function buildPgRestoreArgs(opts) {
 function buildPgRestoreListArgs(inputFile) {
 	return ["--list", inputFile];
 }
+/** `<id>; <catalog oid> <oid> <description> <namespace> <tag…> <owner>`, the shape of a TOC entry. */
+var TOC_ENTRY = /^\d+;\s+\d+\s+\d+\s+(SCHEMA|TABLE)\s+(?!DATA\s)(\S+)\s+(.+)\s+(\S+)$/;
+/** A TOC entry for a relation of any kind. `TABLE DATA`, `SEQUENCE SET` and `SEQUENCE OWNED BY` are not relations. */
+var TOC_RELATION = /^\d+;\s+\d+\s+\d+\s+(?:FOREIGN TABLE|MATERIALIZED VIEW|TABLE|VIEW|SEQUENCE)\s+(?!DATA\s|SET\s|OWNED BY\s)(\S+)\s+(.+)\s+(\S+)$/;
+/**
+* The schemas and tables in `pg_restore --list` output: the objects a
+* restore without `--clean` fails on when the target already has them.
+*
+* A TOC line ends in the object's owner, after its namespace and its name;
+* a schema's namespace is `-`. The name is what lies between the two, so a
+* name with a space in it (`Odd Name`) reads whole. `TABLE DATA` and every
+* other kind of entry are not objects of their own here.
+*/
+function parseDumpObjects(list) {
+	const objects = {
+		schemas: [],
+		tables: [],
+		relations: []
+	};
+	for (const line of list.split("\n")) {
+		const trimmed = line.trim();
+		const relation = TOC_RELATION.exec(trimmed);
+		if (relation) objects.relations.push({
+			schema: relation[1],
+			name: relation[2]
+		});
+		const entry = TOC_ENTRY.exec(trimmed);
+		if (!entry) continue;
+		const [, kind, namespace, name] = entry;
+		if (kind === "SCHEMA") objects.schemas.push(name);
+		else objects.tables.push({
+			schema: namespace,
+			table: name
+		});
+	}
+	return objects;
+}
+/** A Postgres identifier, double-quoted. */
+function quoteIdentifier(name) {
+	return `"${name.replace(/"/g, "\"\"")}"`;
+}
+/**
+* How long `restore --clean` waits for a lock before it gives up.
+*
+* A `rebase dev` serving from the database holds connections, and one inside a
+* transaction would otherwise make the restore wait without a word. The dump's
+* own script sets `lock_timeout = 0` after this, for the objects it creates.
+*/
+var CLEAN_LOCK_TIMEOUT = "15s";
+/**
+* What `restore --clean` runs first, in the transaction the restore runs in:
+* every schema the dump creates, dropped with `CASCADE`, and every table it
+* creates in a schema it does not (`public`), the same.
+*
+* `CASCADE`, which `pg_restore --clean` never uses: a table the backup lacks
+* in one of its schemas — `rebase.atlas_schema_revisions` from `rebase db
+* migrate`, a table a newer runtime added — is exactly what stopped its plain
+* `DROP SCHEMA rebase`, and a table that references one of the backup's is what
+* stops a plain `DROP TABLE`. The dump's script follows, with its own `DROP …
+* IF EXISTS` for everything else it creates.
+*/
+function cleanRestorePrelude(objects) {
+	const schemas = objects.schemas.filter((schema) => schema !== "public");
+	const dropped = new Set(schemas);
+	const tables = objects.tables.filter((table) => !dropped.has(table.schema));
+	return [
+		"SET client_min_messages = warning",
+		`SET lock_timeout = '15s'`,
+		...schemas.map((schema) => `DROP SCHEMA IF EXISTS ${quoteIdentifier(schema)} CASCADE`),
+		...tables.map((table) => `DROP TABLE IF EXISTS ${quoteIdentifier(table.schema)}.${quoteIdentifier(table.table)} CASCADE`)
+	];
+}
+/**
+* `pg_restore` writing the dump as a SQL script on stdout, with the `DROP …
+* IF EXISTS` that `--clean` adds, for `psql` to run. See {@link buildPsqlScriptArgs}.
+*/
+function buildPgRestoreScriptArgs(opts) {
+	return [
+		"--format=custom",
+		"--clean",
+		"--if-exists",
+		...opts.noOwner ? ["--no-owner"] : [],
+		"--file=-",
+		opts.inputFile
+	];
+}
+/**
+* `psql` running a script read from stdin, stopping at its first error.
+*
+* `-X`, so no `.psqlrc` changes what runs; `-q`, so it prints errors and
+* warnings, not a command tag per statement. The transaction is the script's
+* own: `restore --clean` writes the `BEGIN`, and the `COMMIT` only once
+* `pg_restore` has written the whole dump.
+*/
+function buildPsqlScriptArgs(connectionString) {
+	return [
+		"-X",
+		"-q",
+		"--no-password",
+		"-v",
+		"ON_ERROR_STOP=1",
+		`--dbname=${forLibpq(connectionString)}`,
+		"--file=-"
+	];
+}
 /**
 * Assemble the `pg_dumpall --globals-only` argument vector. Roles (and other
 * cluster-wide objects) live outside any single database, so a per-database
@@ -331,13 +436,14 @@ function selectBackupsToPrune(backups, options) {
 var OVERRIDE_VARIABLE = {
 	pg_dump: "PG_DUMP_PATH",
 	pg_restore: "PG_RESTORE_PATH",
-	pg_dumpall: "PG_DUMPALL_PATH"
+	pg_dumpall: "PG_DUMPALL_PATH",
+	psql: "PSQL_PATH"
 };
 /** The variable that points at `tool` when it is not on the PATH. */
 function pgToolVariable(tool) {
 	return OVERRIDE_VARIABLE[tool];
 }
-/** Locate `pg_dump` / `pg_restore` / `pg_dumpall`, honouring an env override. */
+/** Locate `pg_dump` / `pg_restore` / `pg_dumpall` / `psql`, honouring an env override. */
 function resolvePgBinary(tool, env = process.env) {
 	const override = env[OVERRIDE_VARIABLE[tool]];
 	if (override && fs.existsSync(override)) return override;
@@ -432,21 +538,45 @@ function discardPartialDumpWith(exists, remove, file) {
 */
 var backup_service_exports = /* @__PURE__ */ __exportAll({
 	BackupToolError: () => BackupToolError,
+	CleanRestoreFailed: () => CleanRestoreFailed,
 	applyGlobals: () => applyGlobals,
 	createDump: () => createDump,
 	detectToolMajor: () => detectToolMajor,
 	discardPartialDump: () => discardPartialDump,
 	ensureDatabaseExists: () => ensureDatabaseExists,
+	findCleanExtras: () => findCleanExtras,
+	findRestoreConflicts: () => findRestoreConflicts,
 	getServerVersionMajor: () => getServerVersionMajor,
 	listBackups: () => listBackups,
 	preflight: () => preflight,
 	pruneBackups: () => pruneBackups,
+	readDumpObjects: () => readDumpObjects,
+	resetSharedSession: () => resetSharedSession,
 	resolvePgBinary: () => resolvePgBinary,
 	restoreDump: () => restoreDump,
+	restoreDumpReplacing: () => restoreDumpReplacing,
 	uploadBackup: () => uploadBackup,
 	validateDump: () => validateDump
 });
 /**
+* How a libpq tool is invoked for a connection string: the URL its command
+* line carries, and the environment it runs in.
+*
+* The password goes in `PGPASSWORD`, never on the command line, where every
+* process listing could read it and every failure printed it back (execa's
+* error repeats the command). See {@link splitPassword}.
+*/
+function libpqInvocation(connectionString, env) {
+	const split = splitPassword(connectionString);
+	const toolEnv = {};
+	for (const [key, value] of Object.entries(env)) if (value !== void 0) toolEnv[key] = value;
+	if (split.password !== null) toolEnv.PGPASSWORD = split.password;
+	return {
+		connectionString: split.connectionString,
+		env: toolEnv
+	};
+}
+/**
 * Remove a dump artifact abandoned by a failed tool run. See
 * {@link discardPartialDumpWith} for why this exists and why the logic lives
 * in the execa-free module.
@@ -483,6 +613,43 @@ async function getServerVersionMajor(connectionString) {
 		await client.end();
 	}
 }
+/** PGlite names itself in `version()`: `PostgreSQL 18.3 (PGlite 0.5.6) on wasm32-…`. */
+var SHARED_SESSION_ENGINE = /\(PGlite\b/i;
+/**
+* Put back what a client tool left set on a database that is one session
+* every connection shares, and do nothing on any other.
+*
+* The managed development database is PGlite: one session behind a socket
+* server, so what `pg_dump` sets for itself — `search_path` emptied,
+* `row_security` off, `PREPARE dumpEnumType …` — stays set for every client
+* after it, a running `rebase dev` included. One `rebase db backup` there left
+* every API request answering 500 "table does not exist", a restart did not
+* help (the database outlives `rebase dev`), and the next backup failed on
+* `prepared statement "dumpenumtype" already exists`.
+*
+* `RESET ALL` and `DEALLOCATE ALL`, not `DISCARD ALL`: that would also drop
+* the `LISTEN` a running `rebase dev`'s realtime holds on the same session.
+* Best effort: it runs after the tool, whose own outcome is what the caller
+* reports.
+*/
+async function resetSharedSession(connectionString) {
+	const { Client } = await import("pg");
+	const client = new Client({
+		connectionString,
+		connectionTimeoutMillis: 1e4,
+		query_timeout: 15e3
+	});
+	client.on("error", () => void 0);
+	try {
+		await client.connect();
+		const { rows } = await client.query("SELECT version() AS version");
+		if (!SHARED_SESSION_ENGINE.test(rows[0]?.version ?? "")) return;
+		await client.query("RESET ALL");
+		await client.query("DEALLOCATE ALL");
+	} catch {} finally {
+		await client.end().catch(() => void 0);
+	}
+}
 /**
 * Verify the requested client tool exists and its major version is
 * compatible with the live server. Throws {@link BackupToolError} — with a
@@ -517,20 +684,26 @@ async function createDump(opts) {
 	const outDir = opts.outDir ?? fs.mkdtempSync(path.join(os.tmpdir(), "rebase-backup-"));
 	fs.mkdirSync(outDir, { recursive: true });
 	const localFile = path.join(outDir, fileName);
+	createOwnerOnly(localFile);
+	const tool = libpqInvocation(opts.connectionString, env);
 	const args = buildPgDumpArgs({
-		connectionString: opts.connectionString,
+		connectionString: tool.connectionString,
 		outFile: localFile,
 		excludeSchemas: opts.excludeSchemas,
 		noOwner: opts.noOwner,
 		rowSecurity: opts.rowSecurity
 	});
-	const dumpEnv = { ...env };
+	const dumpEnv = { ...tool.env };
 	if (opts.rowSecurity) dumpEnv.PGOPTIONS = [env.PGOPTIONS, buildRowSecurityPgOptions(opts.rowSecurity)].filter(Boolean).join(" ");
 	try {
-		await execa(bin, args, {
-			stdio: opts.inheritStdio ? "inherit" : "pipe",
-			env: dumpEnv
-		});
+		try {
+			await execa(bin, args, {
+				stdio: opts.inheritStdio ? "inherit" : "pipe",
+				env: dumpEnv
+			});
+		} finally {
+			await resetSharedSession(opts.connectionString);
+		}
 	} catch (error) {
 		discardPartialDump(localFile);
 		const diagnosis = diagnoseRowSecurityDumpFailure(error);
@@ -546,14 +719,19 @@ async function createDump(opts) {
 		const dumpallBin = resolvePgBinary("pg_dumpall", env);
 		if (!dumpallBin) throw new BackupToolError("Could not find the 'pg_dumpall' binary needed to capture cluster roles.", "Install the PostgreSQL client tools or set PG_DUMPALL_PATH. To take a role-incomplete backup anyway, pass includeGlobals: false.");
 		const globalsFile = globalsFileForDump(localFile);
+		createOwnerOnly(globalsFile);
 		try {
-			await execa(dumpallBin, buildPgDumpallGlobalsArgs({
-				connectionString: opts.connectionString,
-				outFile: globalsFile
-			}), {
-				stdio: opts.inheritStdio ? "inherit" : "pipe",
-				env: { ...env }
-			});
+			try {
+				await execa(dumpallBin, buildPgDumpallGlobalsArgs({
+					connectionString: tool.connectionString,
+					outFile: globalsFile
+				}), {
+					stdio: opts.inheritStdio ? "inherit" : "pipe",
+					env: tool.env
+				});
+			} finally {
+				await resetSharedSession(opts.connectionString);
+			}
 		} catch (error) {
 			discardPartialDump(globalsFile);
 			discardPartialDump(localFile);
@@ -565,6 +743,21 @@ async function createDump(opts) {
 	return result;
 }
 /**
+* Create `file` empty and readable by its owner only, before a tool writes it.
+*
+* A dump holds every row, and the `.globals.sql` sidecar every role's password
+* hash. pg_dump and pg_dumpall create their `--file=` target with the
+* process's umask — 0644 on most machines, readable by every user — and keep
+* the mode of a file that is already there. Created 0600 first, the file is
+* never readable by anyone else, not even while the dump runs; chmod-ing it
+* afterwards would leave it open for as long as that takes. A file that
+* already existed is narrowed too.
+*/
+function createOwnerOnly(file) {
+	fs.closeSync(fs.openSync(file, "w", 384));
+	fs.chmodSync(file, 384);
+}
+/**
 * Cheap integrity check on a freshly written dump: it must be non-empty and
 * `pg_restore --list` must parse its table of contents without error. Used
 * before pruning older backups so a corrupt-but-exit-0 dump never becomes
@@ -634,16 +827,213 @@ async function restoreDump(opts) {
 	const env = opts.env ?? process.env;
 	const bin = resolvePgBinary("pg_restore", env);
 	if (!bin) throw new BackupToolError("Could not find the 'pg_restore' binary.", "Install the PostgreSQL client tools or set PG_RESTORE_PATH.");
-	await execa(bin, buildPgRestoreArgs({
-		connectionString: opts.connectionString,
+	const tool = libpqInvocation(opts.connectionString, env);
+	const args = buildPgRestoreArgs({
+		connectionString: tool.connectionString,
 		inputFile: opts.inputFile,
 		clean: opts.clean,
 		noOwner: opts.noOwner,
 		exitOnError: opts.exitOnError
+	});
+	try {
+		await execa(bin, args, {
+			stdio: opts.inheritStdio ? "inherit" : "pipe",
+			env: tool.env
+		});
+	} finally {
+		await resetSharedSession(opts.connectionString);
+	}
+}
+/**
+* A `restore --clean` that stopped, and so was rolled back whole.
+*
+* `tool` is the one that stopped it: `pg_restore`, writing the dump's script,
+* or `psql`, running it. `lockTimeout` when what `psql` stopped on was the
+* wait for a lock — `CLEAN_LOCK_TIMEOUT` in `pg-tools.ts`.
+*/
+var CleanRestoreFailed = class extends Error {
+	tool;
+	exitCode;
+	lockTimeout;
+	constructor(tool, exitCode, lockTimeout) {
+		super(`${tool} exited with code ${exitCode ?? "unknown"}`);
+		this.tool = tool;
+		this.exitCode = exitCode;
+		this.lockTimeout = lockTimeout;
+		this.name = "CleanRestoreFailed";
+	}
+};
+/**
+* Restore a dump over what the database holds, as one transaction:
+* {@link cleanRestorePrelude} first, then the dump as `pg_restore` writes it
+* for `psql`, and the `COMMIT` only after the last of it.
+*
+* One unit, so it either replaces what the dump holds or changes nothing:
+* `pg_restore --clean` runs each statement on its own, so the drops it starts
+* with had all happened when a later one failed — and its plain `DROP SCHEMA
+* rebase` fails on any table the backup lacks, which left a database with
+* every table dropped and nothing restored. Here a failure anywhere —
+* `pg_restore` cannot read the archive, a statement fails, the connection
+* drops — ends the transaction without a `COMMIT`, and Postgres rolls it back.
+*
+* Throws {@link CleanRestoreFailed} when it did not commit.
+*/
+async function restoreDumpReplacing(opts) {
+	const env = opts.env ?? process.env;
+	const restoreBin = resolvePgBinary("pg_restore", env);
+	const psqlBin = resolvePgBinary("psql", env);
+	if (!restoreBin || !psqlBin) {
+		const tool = restoreBin ? "psql" : "pg_restore";
+		throw new BackupToolError(`Could not find the '${tool}' binary${tool === "psql" ? ", which runs a --clean restore as one transaction" : ""}.`, `Install the PostgreSQL client tools or set ${pgToolVariable(tool)}.`);
+	}
+	const tool = libpqInvocation(opts.connectionString, env);
+	const script = execa(restoreBin, buildPgRestoreScriptArgs({
+		inputFile: opts.inputFile,
+		noOwner: opts.noOwner
 	}), {
-		stdio: opts.inheritStdio ? "inherit" : "pipe",
-		env: { ...env }
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: opts.inheritStdio ? "inherit" : "ignore",
+		buffer: false,
+		reject: false,
+		env: tool.env
+	});
+	const apply = execa(psqlBin, buildPsqlScriptArgs(tool.connectionString), {
+		stdin: "pipe",
+		stdout: "ignore",
+		stderr: opts.inheritStdio ? ["pipe", "inherit"] : "pipe",
+		reject: false,
+		env: tool.env
+	});
+	const sink = apply.stdin;
+	const source = script.stdout;
+	if (!sink || !source) throw new BackupToolError("Could not connect pg_restore to psql.");
+	sink.on("error", () => void 0);
+	apply.once("exit", () => {
+		source.unpipe(sink);
+		source.resume();
+		script.kill();
+	});
+	sink.write(["BEGIN", ...cleanRestorePrelude(opts.objects)].map((statement) => `${statement};\n`).join(""));
+	source.pipe(sink, { end: false });
+	const written = await script;
+	const committed = written.exitCode === 0 && sink.writable;
+	sink.end(committed ? "COMMIT;\n" : void 0);
+	const applied = await apply;
+	await resetSharedSession(opts.connectionString);
+	if (applied.exitCode !== 0) {
+		const stderr = typeof applied.stderr === "string" ? applied.stderr : "";
+		throw new CleanRestoreFailed("psql", applied.exitCode, /lock timeout/i.test(stderr));
+	}
+	if (!committed) throw new CleanRestoreFailed("pg_restore", written.exitCode, false);
+}
+/**
+* What `restore --clean` drops that the backup does not hold, so it can say
+* so before it runs: the tables and views in a schema the backup replaces
+* whole that it has no copy of, and the views and foreign keys elsewhere that
+* reference one of the relations it replaces. As `<kind> <name>`.
+*
+* None for a database that does not exist yet.
+*/
+async function findCleanExtras(connectionString, objects) {
+	const schemas = objects.schemas.filter((schema) => schema !== "public");
+	if (schemas.length === 0 && objects.relations.length === 0) return [];
+	const { Client } = await import("pg");
+	const client = new Client({ connectionString });
+	try {
+		await client.connect();
+	} catch (err) {
+		if (err instanceof Error && "code" in err && err.code === "3D000") return [];
+		throw err;
+	}
+	try {
+		const { rows } = await client.query(`WITH dumped AS (
+                 SELECT c.oid
+                   FROM pg_class c
+                   JOIN pg_namespace n ON n.oid = c.relnamespace
+                   JOIN unnest($2::text[], $3::text[]) AS d(schema_name, rel_name)
+                     ON d.schema_name = n.nspname AND d.rel_name = c.relname
+             )
+             SELECT kind, name FROM (
+                 SELECT CASE c.relkind WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view'
+                                       WHEN 'f' THEN 'foreign table' ELSE 'table' END AS kind,
+                        n.nspname || '.' || c.relname AS name
+                   FROM pg_class c
+                   JOIN pg_namespace n ON n.oid = c.relnamespace
+                  WHERE n.nspname = ANY($1::text[])
+                    AND c.relkind IN ('r', 'p', 'v', 'm', 'f')
+                    AND c.oid NOT IN (SELECT oid FROM dumped)
+                 UNION
+                 SELECT 'view', vn.nspname || '.' || v.relname
+                   FROM pg_depend dep
+                   JOIN pg_rewrite r ON r.oid = dep.objid AND dep.classid = 'pg_rewrite'::regclass
+                   JOIN pg_class v ON v.oid = r.ev_class
+                   JOIN pg_namespace vn ON vn.oid = v.relnamespace
+                  WHERE dep.refobjid IN (SELECT oid FROM dumped)
+                    AND v.oid NOT IN (SELECT oid FROM dumped)
+                    AND NOT vn.nspname = ANY($1::text[])
+                 UNION
+                 SELECT 'foreign key', con.conname || ' on ' || cn.nspname || '.' || cr.relname
+                   FROM pg_constraint con
+                   JOIN pg_class cr ON cr.oid = con.conrelid
+                   JOIN pg_namespace cn ON cn.oid = cr.relnamespace
+                  WHERE con.contype = 'f'
+                    AND con.confrelid IN (SELECT oid FROM dumped)
+                    AND con.conrelid NOT IN (SELECT oid FROM dumped)
+                    AND NOT cn.nspname = ANY($1::text[])
+             ) extra
+             ORDER BY name`, [
+			schemas,
+			objects.relations.map((r) => r.schema),
+			objects.relations.map((r) => r.name)
+		]);
+		return rows.map((row) => `${row.kind} ${row.name}`);
+	} finally {
+		await client.end();
+	}
+}
+/** The schemas and tables a dump creates, from `pg_restore --list`. See {@link parseDumpObjects}. */
+async function readDumpObjects(inputFile, env = process.env) {
+	const bin = resolvePgBinary("pg_restore", env);
+	if (!bin) throw new BackupToolError("Could not find the 'pg_restore' binary.", "Install the PostgreSQL client tools or set PG_RESTORE_PATH.");
+	const toolEnv = Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== void 0));
+	const { stdout } = await execa(bin, buildPgRestoreListArgs(inputFile), {
+		stdio: "pipe",
+		env: toolEnv
 	});
+	return parseDumpObjects(stdout);
+}
+/**
+* Which of a dump's schemas and tables the target database already holds,
+* as `schema <name>` / `table <schema>.<name>`: what a restore without
+* `--clean` would stop on. `public` is left out of the schemas — every
+* database has it, and pg_restore does not create it. None for a database
+* that does not exist yet.
+*/
+async function findRestoreConflicts(connectionString, objects) {
+	const schemas = objects.schemas.filter((schema) => schema !== "public");
+	if (schemas.length === 0 && objects.tables.length === 0) return [];
+	const { Client } = await import("pg");
+	const client = new Client({ connectionString });
+	try {
+		await client.connect();
+	} catch (err) {
+		if (err instanceof Error && "code" in err && err.code === "3D000") return [];
+		throw err;
+	}
+	try {
+		const existingSchemas = await client.query("SELECT nspname FROM pg_namespace WHERE nspname = ANY($1::text[]) ORDER BY nspname", [schemas]);
+		const existingTables = await client.query(`SELECT n.nspname, c.relname
+               FROM pg_class c
+               JOIN pg_namespace n ON n.oid = c.relnamespace
+               JOIN unnest($1::text[], $2::text[]) AS d(schema_name, table_name)
+                 ON d.schema_name = n.nspname AND d.table_name = c.relname
+              WHERE c.relkind IN ('r', 'p')
+              ORDER BY n.nspname, c.relname`, [objects.tables.map((t) => t.schema), objects.tables.map((t) => t.table)]);
+		return [...existingSchemas.rows.map((row) => `schema ${row.nspname}`), ...existingTables.rows.map((row) => `table ${row.nspname}.${row.relname}`)];
+	} finally {
+		await client.end();
+	}
 }
 /**
 * Create a database (if absent) by connecting to the maintenance
@@ -742,6 +1132,6 @@ async function pruneBackups(dest, options, storage) {
 	return toDelete;
 }
 //#endregion
-export { parseDbNameFromUrl as A, buildRowSecurityPgOptions as C, joinStorageKey as D, globalsFileForDump as E, withDatabaseName as F, resolveConnectionString as M, serverVersionNumToMajor as N, parseBackupDestination as O, splitGlobalsStatements as P, buildPgRestoreListArgs as S, diagnoseRowSecurityDumpFailure as T, selectBackupsToPrune as _, detectToolMajor as a, buildPgDumpallGlobalsArgs as b, getServerVersionMajor as c, pruneBackups as d, restoreDump as f, resolvePgBinary as g, pgToolVariable as h, createDump as i, parsePgToolMajor as j, parseBackupTimestamp as k, listBackups as l, validateDump as m, applyGlobals as n, discardPartialDump as o, uploadBackup as p, backup_service_exports as r, ensureDatabaseExists as s, BackupToolError as t, preflight as u, buildBackupFilename as v, checkToolServerCompatibility as w, buildPgRestoreArgs as x, buildPgDumpArgs as y };
+export { buildPgRestoreScriptArgs as A, parseDbNameFromUrl as B, selectBackupsToPrune as C, buildPgDumpallGlobalsArgs as D, buildPgDumpArgs as E, diagnoseRowSecurityDumpFailure as F, splitGlobalsStatements as G, parsePgToolMajor as H, globalsFileForDump as I, withDatabaseName as K, joinStorageKey as L, buildRowSecurityPgOptions as M, checkToolServerCompatibility as N, buildPgRestoreArgs as O, cleanRestorePrelude as P, parseBackupDestination as R, resolvePgBinary as S, buildBackupFilename as T, resolveConnectionString as U, parseDumpObjects as V, serverVersionNumToMajor as W, restoreDump as _, createDump as a, validateDump as b, ensureDatabaseExists as c, getServerVersionMajor as d, listBackups as f, resetSharedSession as g, readDumpObjects as h, backup_service_exports as i, buildPsqlScriptArgs as j, buildPgRestoreListArgs as k, findCleanExtras as l, pruneBackups as m, CleanRestoreFailed as n, detectToolMajor as o, preflight as p, applyGlobals as r, discardPartialDump as s, BackupToolError as t, findRestoreConflicts as u, restoreDumpReplacing as v, CLEAN_LOCK_TIMEOUT as w, pgToolVariable as x, uploadBackup as y, parseBackupTimestamp as z };
 
-//# sourceMappingURL=backup-service-BTBB7RXn.js.map
+//# sourceMappingURL=backup-service-DytMimsL.js.map