@rebasepro/server-postgres 0.25.0-canary.ge06257e → 0.25.0

package/dist/{backup-service-D-UpT7DH.js → backup-service-Bb39plam.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
 import { n as __exportAll } from "./rolldown-runtime-V7rFbMRe.js";
-import { Q as forLibpq, R as resolveLocalBin, et as splitPassword } from "./cli-errors-mx4sSjB8.js";
+import { $ as forLibpq, tt as splitPassword, z as resolveLocalBin } from "./cli-errors-DwQnNATs.js";
 import { o as execa } from "./rls-bootstrap-sql-Bd-hJk08.js";
 import path from "path";
 import fs from "fs";
@@ -237,6 +237,12 @@ function buildPgRestoreListArgs(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+)$/;
+/** A function's TOC entry: its tag is the name and the argument types, `two(integer, text)`. */
+var TOC_ROUTINE = /^\d+;\s+\d+\s+\d+\s+(?:FUNCTION|PROCEDURE|AGGREGATE)\s+(\S+)\s+(.+?)\(.*\)\s+\S+$/;
+/** A type's or a domain's TOC entry. */
+var TOC_TYPE = /^\d+;\s+\d+\s+\d+\s+(?:TYPE|DOMAIN)\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.
@@ -244,15 +250,36 @@ var TOC_ENTRY = /^\d+;\s+\d+\s+\d+\s+(SCHEMA|TABLE)\s+(?!DATA\s)(\S+)\s+(.+)\s+(
 * 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.
+* other kind of entry are not objects of their own here. Its relations,
+* functions and types are read too, for what `restore --clean` would drop
+* that the dump does not hold (`findCleanExtras`).
 */
 function parseDumpObjects(list) {
 	const objects = {
 		schemas: [],
-		tables: []
+		tables: [],
+		relations: [],
+		routines: [],
+		types: []
 	};
 	for (const line of list.split("\n")) {
-		const entry = TOC_ENTRY.exec(line.trim());
+		const trimmed = line.trim();
+		const relation = TOC_RELATION.exec(trimmed);
+		if (relation) objects.relations.push({
+			schema: relation[1],
+			name: relation[2]
+		});
+		const routine = TOC_ROUTINE.exec(trimmed);
+		if (routine) objects.routines.push({
+			schema: routine[1],
+			name: routine[2]
+		});
+		const type = TOC_TYPE.exec(trimmed);
+		if (type) objects.types.push({
+			schema: type[1],
+			name: type[2]
+		});
+		const entry = TOC_ENTRY.exec(trimmed);
 		if (!entry) continue;
 		const [, kind, namespace, name] = entry;
 		if (kind === "SCHEMA") objects.schemas.push(name);
@@ -263,6 +290,74 @@ function parseDumpObjects(list) {
 	}
 	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
@@ -359,13 +454,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;
@@ -460,19 +556,23 @@ 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
 });
@@ -531,6 +631,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
@@ -577,10 +714,14 @@ async function createDump(opts) {
 	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);
@@ -598,13 +739,17 @@ async function createDump(opts) {
 		const globalsFile = globalsFileForDump(localFile);
 		createOwnerOnly(globalsFile);
 		try {
-			await execa(dumpallBin, buildPgDumpallGlobalsArgs({
-				connectionString: tool.connectionString,
-				outFile: globalsFile
-			}), {
-				stdio: opts.inheritStdio ? "inherit" : "pipe",
-				env: tool.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);
@@ -701,16 +846,208 @@ async function restoreDump(opts) {
 	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 tool = libpqInvocation(opts.connectionString, env);
-	await execa(bin, buildPgRestoreArgs({
+	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",
+		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: what a schema the backup replaces whole holds that it has
+* no copy of — tables, views, sequences, functions, procedures, aggregates,
+* types and domains — and the views and foreign keys elsewhere that reference
+* one of the relations it replaces. As `<kind> <name>`.
+*
+* A function is matched by its name, so an overload the backup lacks beside
+* one it holds is not named. Sequences a column owns go with their table,
+* and what an extension owns with the extension, so neither is named.
+*
+* 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 { routines, types } = objects;
+	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' WHEN 'S' THEN 'sequence' 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', 'S')
+                    AND c.oid NOT IN (SELECT oid FROM dumped)
+                    AND NOT (c.relkind = 'S' AND EXISTS (
+                        SELECT 1 FROM pg_depend owner
+                         WHERE owner.classid = 'pg_class'::regclass AND owner.objid = c.oid
+                           AND owner.deptype IN ('a', 'i')))
+                 UNION
+                 SELECT CASE p.prokind WHEN 'p' THEN 'procedure' WHEN 'a' THEN 'aggregate' ELSE 'function' END,
+                        n.nspname || '.' || p.proname
+                   FROM pg_proc p
+                   JOIN pg_namespace n ON n.oid = p.pronamespace
+                  WHERE n.nspname = ANY($1::text[])
+                    AND (n.nspname, p.proname) NOT IN (SELECT * FROM unnest($4::text[], $5::text[]))
+                    AND NOT EXISTS (
+                        SELECT 1 FROM pg_depend owner
+                         WHERE owner.classid = 'pg_proc'::regclass AND owner.objid = p.oid
+                           AND owner.deptype IN ('e', 'i'))
+                 UNION
+                 SELECT CASE t.typtype WHEN 'd' THEN 'domain' ELSE 'type' END,
+                        n.nspname || '.' || t.typname
+                   FROM pg_type t
+                   JOIN pg_namespace n ON n.oid = t.typnamespace
+                  WHERE n.nspname = ANY($1::text[])
+                    AND (t.typtype IN ('e', 'd', 'r')
+                         OR (t.typtype = 'c' AND EXISTS (
+                             SELECT 1 FROM pg_class tc WHERE tc.oid = t.typrelid AND tc.relkind = 'c')))
+                    AND (n.nspname, t.typname) NOT IN (SELECT * FROM unnest($6::text[], $7::text[]))
+                    AND NOT EXISTS (
+                        SELECT 1 FROM pg_depend owner
+                         WHERE owner.classid = 'pg_type'::regclass AND owner.objid = t.oid
+                           AND owner.deptype = 'e')
+                 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),
+			routines.map((r) => r.schema),
+			routines.map((r) => r.name),
+			types.map((t) => t.schema),
+			types.map((t) => t.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) {
@@ -852,6 +1189,6 @@ async function pruneBackups(dest, options, storage) {
 	return toDelete;
 }
 //#endregion
-export { parseBackupDestination as A, buildPgRestoreArgs as C, diagnoseRowSecurityDumpFailure as D, checkToolServerCompatibility as E, resolveConnectionString as F, serverVersionNumToMajor as I, splitGlobalsStatements as L, parseDbNameFromUrl as M, parseDumpObjects as N, globalsFileForDump as O, parsePgToolMajor as P, withDatabaseName as R, buildPgDumpallGlobalsArgs as S, buildRowSecurityPgOptions as T, pgToolVariable as _, detectToolMajor as a, buildBackupFilename as b, findRestoreConflicts as c, preflight as d, pruneBackups as f, validateDump as g, uploadBackup as h, createDump as i, parseBackupTimestamp as j, joinStorageKey as k, getServerVersionMajor as l, restoreDump as m, applyGlobals as n, discardPartialDump as o, readDumpObjects as p, backup_service_exports as r, ensureDatabaseExists as s, BackupToolError as t, listBackups as u, resolvePgBinary as v, buildPgRestoreListArgs as w, buildPgDumpArgs as x, selectBackupsToPrune 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-D-UpT7DH.js.map
+//# sourceMappingURL=backup-service-Bb39plam.js.map