@rebasepro/server 0.23.0 → 0.24.1-canary.g56af4a4

package/dist/backup-5d7XhLX3.js

@@ -0,0 +1,581 @@
+import { createRequire as __rebaseCreateRequire } from "module";
+import __rebaseProcess from "process";
+globalThis.process ??= __rebaseProcess;
+__rebaseCreateRequire(import.meta.url);
+import { n as __exportAll } from "./rolldown-runtime-dW7B1o5h.js";
+import "./src-CatHFUym.js";
+import { a as parseEnvBoolean, r as isAlreadyExecutingSkip } from "./cron-scheduler-C2vbETMo.js";
+import { r as logger } from "./logger-D-S-hO5e.js";
+import { r as errorHandler, t as ApiError } from "./errors-D6_y86c5.js";
+import { C as verifyPurposeToken, g as isJwtConfigured, v as signPurposeToken } from "./jwt-Bqcu7cGt.js";
+import { t as S3StorageController } from "./S3StorageController-D_vKs4kP.js";
+import { t as GCSStorageController } from "./GCSStorageController-DivE9bAx.js";
+import fs from "fs";
+import path from "path";
+import { Hono } from "hono";
+//#region src/backup/backup-common.ts
+/**
+* Storage-generic backup helpers used by the admin backup routes.
+*
+* These live in server (which owns {@link StorageController}) so the
+* admin API can list backups without depending on the Postgres driver —
+* `server` must not import from `server-postgres`. The `pg_dump`-side
+* copies of the tiny pure parsers live in `@rebasepro/server-postgres`;
+* keep the two in sync if the naming scheme ever changes.
+*/
+/** Parse a destination string (`s3://…`, `gs://…`, or a local path). */
+function parseBackupDestination(out) {
+	const s3 = out.match(/^s3:\/\/([^/]+)\/?(.*)$/);
+	if (s3) return {
+		kind: "s3",
+		bucket: s3[1],
+		prefix: s3[2].replace(/\/+$/, "")
+	};
+	const gcs = out.match(/^gs:\/\/([^/]+)\/?(.*)$/);
+	if (gcs) return {
+		kind: "gcs",
+		bucket: gcs[1],
+		prefix: gcs[2].replace(/\/+$/, "")
+	};
+	return {
+		kind: "local",
+		path: out
+	};
+}
+/**
+* Recover the UTC creation time encoded in a `rebase-<db>-<ts>.dump` name.
+* Returns `null` for names that don't match, so foreign objects are ignored.
+*/
+function parseBackupTimestamp(fileName) {
+	const match = (fileName.split("/").pop() ?? fileName).match(/-(\d{8})T(\d{6})Z\.dump$/);
+	if (!match) return null;
+	const [, ymd, hms] = match;
+	const iso = `${ymd.slice(0, 4)}-${ymd.slice(4, 6)}-${ymd.slice(6, 8)}T${hms.slice(0, 2)}:${hms.slice(2, 4)}:${hms.slice(4, 6)}Z`;
+	const date = new Date(iso);
+	return Number.isNaN(date.getTime()) ? null : date;
+}
+/**
+* A backup is two files: the `.dump`, and beside it a `.globals.sql` holding
+* the cluster roles the dump's GRANTs and RLS policies name. Without that
+* sidecar a restore into a fresh cluster stops at the first GRANT to a role
+* that does not exist there. The CLI uploads, restores and prunes the two as
+* a pair. This listing used to know only the `.dump`, so a backup downloaded
+* from Studio arrived without its roles.
+*
+* The suffix mirrors `globalsFileForDump` in `@rebasepro/server-postgres`.
+*/
+var DUMP_SUFFIX = ".dump";
+var GLOBALS_SUFFIX = ".globals.sql";
+function globalsKeyFor(dumpKey) {
+	return dumpKey.slice(0, -5) + GLOBALS_SUFFIX;
+}
+/** The only files the download route will serve. */
+function isBackupFile(key) {
+	return key.endsWith(DUMP_SUFFIX) || key.endsWith(GLOBALS_SUFFIX);
+}
+/**
+* How many pages of an object-storage listing to read before giving up — at
+* the providers' 1,000 keys a page, 100,000 objects, or 50,000 backups.
+*/
+var MAX_LIST_PAGES = 100;
+/**
+* Every key under a prefix, across pages.
+*
+* S3 and GCS answer a listing a page at a time, in ascending key order, and a
+* backup's key is `rebase-<db>-<UTC timestamp>`. Reading one page therefore
+* returned the OLDEST thousand objects: with retention unset and an hourly
+* schedule, the newest backup the panel and `rebase db backups list` showed
+* stopped advancing after about three weeks, which reads as "backups stopped".
+*/
+async function listAllObjectKeys(storage, prefix, bucket) {
+	const keys = [];
+	let pageToken;
+	for (let page = 0; page < MAX_LIST_PAGES; page++) {
+		const result = await storage.listObjects(prefix, {
+			bucket,
+			maxResults: 1e3,
+			pageToken
+		});
+		for (const item of result.items) keys.push(item.fullPath);
+		pageToken = result.nextPageToken;
+		if (!pageToken) return keys;
+	}
+	logger.warn(`[backups] Stopped listing ${bucket}/${prefix} after ${MAX_LIST_PAGES} pages (${keys.length} objects). Set BACKUP_RETENTION_DAYS so old backups are pruned, or give the backups a prefix of their own.`);
+	return keys;
+}
+/**
+* Whether an object key is one the backup routes may serve: a backup file, at
+* the destination's prefix and nowhere else.
+*
+* The local branch has always been held to the backup directory; this branch
+* checked only the suffix, so any `.dump` in the bucket — `uploads/x.dump`, a
+* neighbouring `nightlyish/` prefix — was readable by naming it. A key is taken
+* as written, so a scheme (`s3://other-bucket/…`, which S3StorageController
+* would follow) or a `.`/`..`/empty segment (which a filesystem-backed or
+* S3-compatible store may resolve) is refused rather than interpreted.
+*/
+function isObjectBackupKey(dest, key) {
+	if (!isBackupFile(key) || /^[a-z][a-z0-9+.-]*:\/\//i.test(key)) return false;
+	if (key.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) return false;
+	return dest.prefix === "" || key.startsWith(`${dest.prefix}/`);
+}
+/**
+* List the backups at a destination as {@link BackupInfo}, newest first.
+* One entry per `.dump`, with its `.globals.sql` sidecar attached as
+* `globalsKey` when there is one.
+*/
+async function listBackupObjects(dest, storage) {
+	if (dest.kind === "local") {
+		const stat = await fs.promises.stat(dest.path).catch(() => null);
+		if (!stat) return [];
+		const dir = stat.isDirectory() ? dest.path : path.dirname(dest.path);
+		const files = await fs.promises.readdir(dir);
+		const present = new Set(files);
+		const dumps = files.filter((f) => f.endsWith(DUMP_SUFFIX));
+		const stats = await mapBounded(dumps, LOCAL_STAT_CONCURRENCY, (f) => fs.promises.stat(path.join(dir, f)));
+		return dumps.map((f, i) => {
+			const full = path.join(dir, f);
+			const st = stats[i];
+			const createdAt = parseBackupTimestamp(f) ?? st.mtime;
+			const globals = globalsKeyFor(f);
+			return {
+				key: full,
+				name: f,
+				sizeBytes: st.size,
+				createdAt: createdAt.toISOString(),
+				destinationKind: "local",
+				...present.has(globals) ? { globalsKey: path.join(dir, globals) } : {}
+			};
+		}).sort(byNewest);
+	}
+	if (!storage) throw new Error(noControllerFor(dest));
+	const keys = await listAllObjectKeys(storage, dest.prefix ? `${dest.prefix}/` : "", dest.bucket);
+	const present = new Set(keys);
+	return keys.filter((key) => key.endsWith(DUMP_SUFFIX)).map((key) => {
+		const createdAt = parseBackupTimestamp(key);
+		const globals = globalsKeyFor(key);
+		return {
+			key,
+			name: key.split("/").pop() || key,
+			createdAt: createdAt ? createdAt.toISOString() : void 0,
+			destinationKind: dest.kind,
+			...present.has(globals) ? { globalsKey: globals } : {}
+		};
+	}).sort(byNewest);
+}
+/** Stats in flight at once while listing a local backup folder. */
+var LOCAL_STAT_CONCURRENCY = 32;
+/** `fn` over `items`, at most `limit` at a time; results in input order. */
+async function mapBounded(items, limit, fn) {
+	const results = new Array(items.length);
+	let next = 0;
+	const worker = async () => {
+		while (next < items.length) {
+			const i = next++;
+			results[i] = await fn(items[i]);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+	return results;
+}
+function noControllerFor(dest) {
+	return `No storage controller for ${dest.kind === "s3" ? "s3" : "gs"}://${dest.bucket}${dest.prefix ? `/${dest.prefix}` : ""}, so its backups cannot be read.`;
+}
+function byNewest(a, b) {
+	const ta = a.createdAt ? Date.parse(a.createdAt) : 0;
+	return (b.createdAt ? Date.parse(b.createdAt) : 0) - ta;
+}
+/**
+* The absolute path of a local backup file, or `null` for anything the download
+* route must not serve: a path outside the backup directory, a file that is not
+* a backup, or one that does not exist.
+*/
+function resolveLocalBackupFile(dest, key) {
+	const dir = (fs.existsSync(dest.path) ? fs.statSync(dest.path) : null)?.isDirectory() ? dest.path : path.dirname(dest.path);
+	const resolvedDir = path.resolve(dir);
+	const resolved = path.resolve(key);
+	if (!resolved.startsWith(resolvedDir + path.sep) || !isBackupFile(resolved)) return null;
+	return fs.existsSync(resolved) ? resolved : null;
+}
+/** Read a single backup's bytes. Guards against path traversal for local. */
+async function readBackupBytes(dest, key, storage) {
+	if (dest.kind === "local") {
+		const resolved = resolveLocalBackupFile(dest, key);
+		if (!resolved) return null;
+		return {
+			bytes: new Uint8Array(fs.readFileSync(resolved)),
+			name: path.basename(resolved)
+		};
+	}
+	if (!storage) throw new Error(noControllerFor(dest));
+	if (!isObjectBackupKey(dest, key)) return null;
+	const file = await storage.getObject(key, dest.bucket);
+	if (!file) return null;
+	return {
+		bytes: new Uint8Array(await file.arrayBuffer()),
+		name: key.split("/").pop() || key
+	};
+}
+/**
+* Whether `key` names a backup the download route would serve, without
+* opening it: the same guards as {@link openBackupStream}, and the file or
+* object is there. An object store without `statObject` is taken at its key —
+* reading the object to find out would be the download itself.
+*/
+async function findBackup(dest, key, storage) {
+	if (dest.kind === "local") {
+		const resolved = resolveLocalBackupFile(dest, key);
+		return resolved ? { name: path.basename(resolved) } : null;
+	}
+	if (!storage) throw new Error(noControllerFor(dest));
+	if (!isObjectBackupKey(dest, key)) return null;
+	if (storage.statObject && !await storage.statObject(key, dest.bucket)) return null;
+	return { name: key.split("/").pop() || key };
+}
+/**
+* A single backup, opened for streaming, with its size. Same guards as
+* {@link readBackupBytes}.
+*
+* What the download route serves. A dump is the size of the database, and
+* reading it whole put all of it on the API process's heap — twice for a local
+* destination (`readFileSync`, then a copy) and on top of the controller's own
+* buffer for object storage — and a file over 2 GiB never downloaded at all:
+* `readFileSync` throws `ERR_FS_FILE_TOO_LARGE` there.
+*
+* A local file is read from disk as the response is written, and so is an
+* object through a controller with `getObjectStream` (the built-in S3 and GCS
+* ones). A custom controller without it still arrives through
+* {@link StorageController.getObject}, a buffered `File` by contract;
+* streaming that avoids the second copy.
+*/
+async function openBackupStream(dest, key, storage) {
+	if (dest.kind === "local") {
+		const resolved = resolveLocalBackupFile(dest, key);
+		if (!resolved) return null;
+		const { size } = await fs.promises.stat(resolved);
+		return {
+			stream: fileStream(resolved),
+			size,
+			name: path.basename(resolved)
+		};
+	}
+	if (!storage) throw new Error(noControllerFor(dest));
+	if (!isObjectBackupKey(dest, key)) return null;
+	const name = key.split("/").pop() || key;
+	if (storage.getObjectStream) {
+		const object = await storage.getObjectStream(key, { bucket: dest.bucket });
+		return object ? {
+			stream: object.stream,
+			size: object.size,
+			name
+		} : null;
+	}
+	const file = await storage.getObject(key, dest.bucket);
+	if (!file) return null;
+	return {
+		stream: file.stream(),
+		size: file.size,
+		name
+	};
+}
+/** A file on disk as a web stream, read a chunk at a time as the response is written. */
+function fileStream(filePath) {
+	const file = fs.createReadStream(filePath);
+	const chunks = file[Symbol.asyncIterator]();
+	return new ReadableStream({
+		async pull(controller) {
+			const next = await chunks.next();
+			if (next.done) controller.close();
+			else controller.enqueue(next.value);
+		},
+		cancel() {
+			file.destroy();
+		}
+	});
+}
+//#endregion
+//#region src/backup/backup-storage.ts
+/**
+* The storage controller that reads a backup bucket.
+*
+* A backup destination is its own bucket, named by `BACKUP_DESTINATION`, and
+* the documented backup cron writes to it through a controller it builds from
+* the `S3_*` variables (GCS: application default credentials) — as
+* `rebase db backups list` does. The admin routes have to read it the same way.
+* The app's file storage is not that controller: it is configured for the
+* uploads bucket, it is a local directory in development, and in production
+* without an uploads bucket there is none at all.
+*/
+/** The destination `BACKUP_DESTINATION` names, or `null` when it is unset. */
+function backupDestinationFromEnv(env) {
+	const out = env.BACKUP_DESTINATION?.trim();
+	return out ? parseBackupDestination(out) : null;
+}
+/** The destination as `BACKUP_DESTINATION` spells it. */
+function describeBackupDestination(dest) {
+	if (dest.kind === "local") return dest.path;
+	return `${dest.kind === "s3" ? "s3" : "gs"}://${dest.bucket}${dest.prefix ? `/${dest.prefix}` : ""}`;
+}
+/**
+* A controller for an object-storage destination's bucket, built from the
+* environment the way the backup cron and `rebase db backups list` build
+* theirs. Throws when an S3 destination has no credentials to read it with.
+*/
+function backupStorageFromEnv(dest, env) {
+	if (dest.kind === "gcs") return new GCSStorageController({
+		type: "gcs",
+		bucket: dest.bucket
+	});
+	if (!env.S3_ACCESS_KEY_ID || !env.S3_SECRET_ACCESS_KEY) throw new Error("An S3 backup destination needs S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY in the environment — the same S3_* variables the backup cron uses.");
+	return new S3StorageController({
+		type: "s3",
+		bucket: dest.bucket,
+		region: env.S3_REGION || "auto",
+		accessKeyId: env.S3_ACCESS_KEY_ID,
+		secretAccessKey: env.S3_SECRET_ACCESS_KEY,
+		endpoint: env.S3_ENDPOINT,
+		forcePathStyle: parseEnvBoolean(env.S3_FORCE_PATH_STYLE)
+	});
+}
+//#endregion
+//#region src/backup/backup-routes.ts
+/** Why a destination could not be read, as the answer says it. */
+function unreadable(dest, err) {
+	const reason = err instanceof Error ? err.message : String(err);
+	return ApiError.serviceUnavailable(`Cannot read the backups at ${describeBackupDestination(dest)}: ${reason}`);
+}
+/**
+* The `purpose` of a download link's token. {@link verifyAccessToken} refuses
+* any token with a purpose, and the storage, MFA and MCP verifiers each demand
+* their own, so a link is never a session or any other credential, and none of
+* those is a link.
+*/
+var BACKUP_DOWNLOAD_PURPOSE = "backup-download";
+/** The token's audience: the one route that redeems it. */
+var BACKUP_DOWNLOAD_AUDIENCE = "rebase:admin/backups/download";
+/** What a link grants: one backup, at one destination. */
+function linkScope(dest, key) {
+	return `backup:${describeBackupDestination(dest)}:${key}`;
+}
+/** Whether `token` is a live link for `key` at `dest`. Never throws: anything else is a no. */
+async function linkGrants(token, dest, key) {
+	if (!isJwtConfigured()) return false;
+	const claims = await verifyPurposeToken(BACKUP_DOWNLOAD_PURPOSE, token).catch(() => null);
+	return claims?.aud === BACKUP_DOWNLOAD_AUDIENCE && claims.scope === linkScope(dest, key);
+}
+/** The configured destination, or the 400 every backup route answers without one. */
+function destinationOf(config) {
+	const dest = config.getDestination();
+	if (!dest) throw ApiError.badRequest("Backups are not configured (set BACKUP_DESTINATION).");
+	return dest;
+}
+/** {@link BackupRoutesConfig.storageFor}, with its default, for a destination that has a controller. */
+function storageResolver(config) {
+	const storageFor = config.storageFor ?? ((dest) => backupStorageFromEnv(dest, process.env));
+	/** The controller for `dest`, or none for a local one. A destination it cannot read is an error, never `[]`. */
+	return (dest) => {
+		if (dest.kind === "local") return void 0;
+		try {
+			return storageFor(dest);
+		} catch (err) {
+			throw unreadable(dest, err);
+		}
+	};
+}
+/** One backup's bytes as the response, streamed: a dump is the size of the database. See `openBackupStream`. */
+async function serveBackup(c, dest, key, storage) {
+	const result = await openBackupStream(dest, key, storage);
+	if (!result) throw ApiError.notFound(`Backup not found: ${key}`);
+	c.header("Content-Type", "application/octet-stream");
+	c.header("Content-Length", String(result.size));
+	c.header("Content-Disposition", `attachment; filename="${result.name}"`);
+	c.header("Cache-Control", "no-store");
+	return c.body(result.stream);
+}
+/**
+* `GET /download?key=…&token=…`: a download link spent in place of the bearer
+* header, for the one backup it names.
+*
+* Mount it at the backups prefix AHEAD of every gate on the admin prefix: the
+* auth adapter's own admin routers authenticate everything under `/admin`
+* before the Backups gate is reached. A request with no `token` passes
+* through untouched; one with a token is answered here — the backup, or a
+* 401 — and never falls through to the header: a bad link is a bad link.
+*
+* A browser cannot put a header on a navigation, so before links the SDK
+* fetched the dump and held it whole in the tab as a Blob. With a link the
+* browser streams it to disk.
+*/
+function createBackupLinkRoutes(config) {
+	const router = new Hono();
+	router.onError(errorHandler);
+	const storageOf = storageResolver(config);
+	router.get("/download", async (c, next) => {
+		const token = c.req.query("token");
+		if (token === void 0) return next();
+		const dest = destinationOf(config);
+		const key = c.req.query("key") ?? "";
+		if (!await linkGrants(token, dest, key)) throw ApiError.unauthenticated(`This download link is not valid for this backup, or it has expired. Links last 60 seconds: ask for a new one.`);
+		return serveBackup(c, dest, key, storageOf(dest));
+	});
+	return router;
+}
+/**
+* Admin REST routes for the Backups panel.
+*
+* Routes (mounted under `/admin/backups`, admin-guarded by the caller):
+*   GET  /              → list available backups, and the scheduled job's last run
+*   GET  /download      → download a backup's bytes (?key=…)
+*   POST /download-url  → a 60-second link to one backup, `{ key }` → {@link BackupDownloadLink}
+*
+* The link is spent at `GET /download?key=…&token=…`, which
+* {@link createBackupLinkRoutes} answers ahead of the gate.
+*/
+function createBackupRoutes(config) {
+	const router = new Hono();
+	router.onError(errorHandler);
+	const storageOf = storageResolver(config);
+	router.get("/", async (c) => {
+		const schedule = config.getSchedule ? await config.getSchedule() : null;
+		const dest = config.getDestination();
+		if (!dest) return c.json({
+			backups: [],
+			destinationKind: "local",
+			configured: false,
+			schedule
+		});
+		const backups = await listBackupObjects(dest, storageOf(dest)).catch((err) => {
+			throw unreadable(dest, err);
+		});
+		const localDiskOfThisProcess = dest.kind === "local" && config.scheduledElsewhere === true && schedule !== null;
+		return c.json({
+			backups,
+			destinationKind: dest.kind,
+			configured: true,
+			schedule,
+			...localDiskOfThisProcess ? { localDiskOfThisProcess } : {}
+		});
+	});
+	router.get("/download", async (c) => {
+		const dest = destinationOf(config);
+		const key = c.req.query("key");
+		if (!key) throw ApiError.badRequest("Missing 'key' query parameter.");
+		return serveBackup(c, dest, key, storageOf(dest));
+	});
+	router.post("/download-url", async (c) => {
+		const dest = destinationOf(config);
+		const body = await c.req.json().catch(() => null);
+		const key = typeof body === "object" && body !== null && "key" in body ? body.key : void 0;
+		if (typeof key !== "string" || !key) throw ApiError.badRequest("Send the backup's key: { \"key\": \"…\" }.");
+		if (!await findBackup(dest, key, storageOf(dest))) throw ApiError.notFound(`Backup not found: ${key}`);
+		if (!isJwtConfigured()) throw ApiError.serviceUnavailable("Download links are signed with the JWT secret, and this server has none (auth.jwtSecret). Download through GET /download with the Authorization header instead.");
+		const token = await signPurposeToken(BACKUP_DOWNLOAD_PURPOSE, {
+			aud: BACKUP_DOWNLOAD_AUDIENCE,
+			scope: linkScope(dest, key)
+		}, 60);
+		const download = new URL("download", c.req.url).pathname;
+		return c.json({
+			url: `${download}?key=${encodeURIComponent(key)}&token=${encodeURIComponent(token)}`,
+			token,
+			expiresIn: 60
+		});
+	});
+	return router;
+}
+//#endregion
+//#region src/backup/backup-schedule.ts
+/**
+* The mark `createBackupCron` (in `@rebasepro/server-postgres`) puts on the
+* definition it returns.
+*
+* A registry symbol, so it is the same value across two installed copies of
+* either package, and neither package has to import the other: `server` must
+* not depend on `server-postgres`. The job cannot be recognised any other way —
+* its id is the cron file's name and its display name is configurable.
+*/
+var BACKUP_CRON_MARK = Symbol.for("rebase.backupCron");
+/** Whether a cron definition is the scheduled backup. */
+function isBackupCronDefinition(definition) {
+	return Reflect.get(definition, BACKUP_CRON_MARK) === true;
+}
+/**
+* How many recent log entries to look through for the last scheduled run. A
+* skip — a slot that found the previous run still going — is logged as a
+* success with nothing done, and must not stand in for the run it skipped; nor
+* may a run someone started by hand, which is not the schedule's.
+*/
+var RECENT_RUNS = 50;
+/** A log entry as the panel reports a run. */
+function outcomeOf(entry) {
+	return {
+		startedAt: entry.startedAt,
+		finishedAt: entry.finishedAt,
+		success: entry.success,
+		...entry.success || !entry.error ? {} : { error: entry.error },
+		manual: entry.manual === true
+	};
+}
+/**
+* The scheduled backup job and its last run, or `null` when the deployment
+* has none — registered or refused.
+*/
+async function readBackupSchedule(source) {
+	const [jobId] = source.jobIdsWhere(isBackupCronDefinition);
+	if (jobId === void 0) {
+		const [refused] = source.rejectedJobsWhere(isBackupCronDefinition);
+		return refused ? {
+			jobId: refused.id,
+			name: refused.name,
+			schedule: refused.schedule,
+			enabled: false,
+			refused: refused.reason
+		} : null;
+	}
+	const job = await source.fetchJob(jobId);
+	if (!job) return null;
+	const disabledInCode = !job.enabled && source.jobIdsWhere((definition) => isBackupCronDefinition(definition) && definition.enabled === false).includes(jobId);
+	let recent;
+	let historyError;
+	try {
+		recent = await source.getJobLogsFromDb(jobId, RECENT_RUNS);
+	} catch (err) {
+		logger.error(`[backups] Could not read the run history of the backup job "${jobId}"`, { error: err });
+		recent = [];
+		historyError = "The backup job's run history could not be read. The server log has the reason.";
+	}
+	const runs = recent.filter((entry) => !isAlreadyExecutingSkip(entry));
+	const lastScheduled = runs.find((entry) => entry.manual !== true);
+	const lastManual = runs.find((entry) => entry.manual === true);
+	const manualSince = lastManual && (!lastScheduled || lastManual.startedAt > lastScheduled.startedAt) ? lastManual : void 0;
+	return {
+		jobId,
+		name: job.name,
+		schedule: job.schedule,
+		enabled: job.enabled,
+		...disabledInCode ? { disabledInCode } : {},
+		...job.nextRunAt ? { nextRunAt: job.nextRunAt } : {},
+		...historyError ? { historyError } : {},
+		...lastScheduled ? { lastRun: outcomeOf(lastScheduled) } : {},
+		...manualSince ? { lastManualRun: outcomeOf(manualSince) } : {}
+	};
+}
+//#endregion
+//#region src/backup/index.ts
+var backup_exports = /* @__PURE__ */ __exportAll({
+	BACKUP_DOWNLOAD_LINK_TTL_SECONDS: () => 60,
+	backupDestinationFromEnv: () => backupDestinationFromEnv,
+	createBackupLinkRoutes: () => createBackupLinkRoutes,
+	createBackupRoutes: () => createBackupRoutes,
+	findBackup: () => findBackup,
+	listAllObjectKeys: () => listAllObjectKeys,
+	listBackupObjects: () => listBackupObjects,
+	openBackupStream: () => openBackupStream,
+	parseBackupDestination: () => parseBackupDestination,
+	parseBackupTimestamp: () => parseBackupTimestamp,
+	readBackupBytes: () => readBackupBytes,
+	readBackupSchedule: () => readBackupSchedule
+});
+//#endregion
+export { listBackupObjects as a, readBackupBytes as c, backupStorageFromEnv as i, createBackupLinkRoutes as n, parseBackupDestination as o, createBackupRoutes as r, parseBackupTimestamp as s, backup_exports as t };
+
+//# sourceMappingURL=backup-5d7XhLX3.js.map