@rebasepro/server-postgres 0.15.0 → 0.16.0

package/dist/backup/backup-logic.d.ts

@@ -21,3 +21,23 @@ export declare function applyGlobalsWith(runStatement: (sql: string) => Promise<
  * `deleteObject` removes one key and rejects if it cannot (e.g. not found).
  */
 export declare function pruneWith(keys: string[], deleteObject: (key: string) => Promise<void>): Promise<void>;
+/**
+ * Remove a dump artifact abandoned by a failed tool run.
+ *
+ * `pg_dump` creates its `--file=` target before it finishes connecting, so any
+ * failure — a URL libpq rejects, a dropped connection, a full disk — leaves a
+ * 0-byte file behind. That corpse is not inert: `rebase db backups list` used
+ * to show it as an ordinary entry, and `selectBackupsToPrune` ranks by
+ * timestamp alone, so it occupies a protected `keepMinimum` slot and can push
+ * a real backup out of retention.
+ *
+ * Best-effort on purpose: the caller is already throwing, and a failed unlink
+ * must not replace the real diagnosis with an ENOENT/EPERM from the cleanup.
+ *
+ * Lives here rather than in `backup-service.ts` for the reason at the top of
+ * this file — that module's top-level `execa` import makes it unloadable under
+ * jest, so anything placed there cannot be unit-tested.
+ *
+ * `remove` deletes one file and throws if it cannot; `exists` reports presence.
+ */
+export declare function discardPartialDumpWith(exists: (file: string) => boolean, remove: (file: string) => void, file: string): void;

package/dist/backup/backup-service.d.ts

@@ -1,6 +1,12 @@
 import type { StorageController } from "@rebasepro/server";
 import { BackupDestination, type RowSecurityIdentity, VersionCompatibility } from "./pg-tools";
 import { BackupObject, RetentionOptions } from "./retention";
+/**
+ * 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.
+ */
+export declare function discardPartialDump(file: string): void;
 export declare class BackupToolError extends Error {
     readonly hint?: string | undefined;
     constructor(message: string, hint?: string | undefined);

package/dist/backup/retention.d.ts

@@ -6,6 +6,17 @@ export interface BackupObject {
      * timestamp encoded in the key by `buildBackupFilename`.
      */
     createdAt?: Date;
+    /**
+     * Size on disk, when the lister knows it (local destinations always do).
+     *
+     * Reported so an empty artifact cannot masquerade as a backup in
+     * `rebase db backups list`. Deliberately NOT consulted by
+     * {@link selectBackupsToPrune}: retention decides by age, and a rule that
+     * silently skipped small files would make a genuinely tiny dump immortal.
+     * Visibility is the fix here; the artifacts themselves are now removed at
+     * the point of failure by `discardPartialDump`.
+     */
+    sizeBytes?: number;
 }
 export interface RetentionOptions {
     /** Delete backups older than this many days. `0`/negative disables age pruning. */

package/dist/{backup-service-czK-OAuG.js → backup-service-BZoixhVl.js}

@@ -344,7 +344,10 @@ function globalsFileForDump(dumpPath) {
 * abort the rest. Drops `--` comment lines and blank statements.
 */
 function splitGlobalsStatements(sql) {
-	return sql.split("\n").filter((line) => !line.trim().startsWith("--")).join("\n").split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+	return sql.split("\n").filter((line) => {
+		const trimmed = line.trim();
+		return !trimmed.startsWith("--") && !trimmed.startsWith("\\");
+	}).join("\n").split(";").map((s) => s.trim()).filter((s) => s.length > 0);
 }
 /**
 * Resolve the Postgres connection string the backup commands should use,
@@ -8696,6 +8699,30 @@ async function pruneWith(keys, deleteObject) {
 		} catch {}
 	}
 }
+/**
+* Remove a dump artifact abandoned by a failed tool run.
+*
+* `pg_dump` creates its `--file=` target before it finishes connecting, so any
+* failure — a URL libpq rejects, a dropped connection, a full disk — leaves a
+* 0-byte file behind. That corpse is not inert: `rebase db backups list` used
+* to show it as an ordinary entry, and `selectBackupsToPrune` ranks by
+* timestamp alone, so it occupies a protected `keepMinimum` slot and can push
+* a real backup out of retention.
+*
+* Best-effort on purpose: the caller is already throwing, and a failed unlink
+* must not replace the real diagnosis with an ENOENT/EPERM from the cleanup.
+*
+* Lives here rather than in `backup-service.ts` for the reason at the top of
+* this file — that module's top-level `execa` import makes it unloadable under
+* jest, so anything placed there cannot be unit-tested.
+*
+* `remove` deletes one file and throws if it cannot; `exists` reports presence.
+*/
+function discardPartialDumpWith(exists, remove, file) {
+	try {
+		if (exists(file)) remove(file);
+	} catch {}
+}
 //#endregion
 //#region src/backup/backup-service.ts
 /**
@@ -8712,6 +8739,7 @@ var backup_service_exports = /* @__PURE__ */ __exportAll({
 	applyGlobals: () => applyGlobals,
 	createDump: () => createDump,
 	detectToolMajor: () => detectToolMajor,
+	discardPartialDump: () => discardPartialDump,
 	ensureDatabaseExists: () => ensureDatabaseExists,
 	getServerVersionMajor: () => getServerVersionMajor,
 	listBackups: () => listBackups,
@@ -8722,6 +8750,14 @@ var backup_service_exports = /* @__PURE__ */ __exportAll({
 	uploadBackup: () => uploadBackup,
 	validateDump: () => validateDump
 });
+/**
+* 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.
+*/
+function discardPartialDump(file) {
+	discardPartialDumpWith((f) => fs.existsSync(f), (f) => fs.unlinkSync(f), file);
+}
 var BackupToolError = class extends Error {
 	hint;
 	constructor(message, hint) {
@@ -8806,6 +8842,7 @@ async function createDump(opts) {
 			env: dumpEnv
 		});
 	} catch (error) {
+		discardPartialDump(localFile);
 		const diagnosis = diagnoseRowSecurityDumpFailure(error);
 		if (!diagnosis) throw error;
 		throw new BackupToolError(diagnosis, "Run `rebase db backup --help` for the flag, and read what it says about partial dumps.");
@@ -8819,13 +8856,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);
-		await execa(dumpallBin, buildPgDumpallGlobalsArgs({
-			connectionString: opts.connectionString,
-			outFile: globalsFile
-		}), {
-			stdio: opts.inheritStdio ? "inherit" : "pipe",
-			env: { ...env }
-		});
+		try {
+			await execa(dumpallBin, buildPgDumpallGlobalsArgs({
+				connectionString: opts.connectionString,
+				outFile: globalsFile
+			}), {
+				stdio: opts.inheritStdio ? "inherit" : "pipe",
+				env: { ...env }
+			});
+		} catch (error) {
+			discardPartialDump(globalsFile);
+			discardPartialDump(localFile);
+			throw error;
+		}
 		result.globalsFile = globalsFile;
 		result.globalsSizeBytes = fs.existsSync(globalsFile) ? fs.statSync(globalsFile).size : 0;
 	}
@@ -8962,9 +9005,11 @@ async function listBackups(dest, storage) {
 		const dir = fs.statSync(dest.path).isDirectory() ? dest.path : path.dirname(dest.path);
 		return fs.readdirSync(dir).filter((f) => f.endsWith(".dump")).map((f) => {
 			const full = path.join(dir, f);
+			const stats = fs.statSync(full);
 			return {
 				key: full,
-				createdAt: parseBackupTimestamp(f) ?? fs.statSync(full).mtime
+				createdAt: parseBackupTimestamp(f) ?? stats.mtime,
+				sizeBytes: stats.size
 			};
 		}).sort((a, b) => (b.createdAt?.getTime() ?? 0) - (a.createdAt?.getTime() ?? 0));
 	}
@@ -8993,6 +9038,6 @@ async function pruneBackups(dest, options, storage) {
 	return toDelete;
 }
 //#endregion
-export { parsePgToolMajor as A, checkToolServerCompatibility as C, parseBackupDestination as D, joinStorageKey as E, serverVersionNumToMajor as M, splitGlobalsStatements as N, parseBackupTimestamp as O, withDatabaseName as P, buildRowSecurityPgOptions as S, globalsFileForDump as T, buildBackupFilename as _, detectToolMajor as a, buildPgRestoreArgs as b, listBackups as c, resolvePgBinary as d, restoreDump as f, selectBackupsToPrune as g, require_source as h, createDump as i, resolveConnectionString as j, parseDbNameFromUrl as k, preflight as l, validateDump as m, applyGlobals as n, ensureDatabaseExists as o, uploadBackup as p, backup_service_exports as r, getServerVersionMajor as s, BackupToolError as t, pruneBackups as u, buildPgDumpArgs as v, diagnoseRowSecurityDumpFailure as w, buildPgRestoreListArgs as x, buildPgDumpallGlobalsArgs as y };
+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, resolvePgBinary as f, require_source as g, validateDump as h, createDump as i, parsePgToolMajor as j, parseBackupTimestamp as k, listBackups as l, uploadBackup as m, applyGlobals as n, discardPartialDump as o, restoreDump 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 };
 
-//# sourceMappingURL=backup-service-czK-OAuG.js.map
+//# sourceMappingURL=backup-service-BZoixhVl.js.map