@rebasepro/server 0.24.0 → 0.24.1-canary.gcb918fc

package/dist/cron-store-CZ30ZBi-.js

@@ -0,0 +1,577 @@
+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-D5Y3N-S4.js";
+import { t as isSQLAdmin } from "./backend-DTAOsLQc.js";
+import { r as logger } from "./logger-D-S-hO5e.js";
+import { n as revokeInternalTableSql, t as REBASE_USER_ROLE } from "./internal-tables-L2t39RdT.js";
+import { n as createDdlBootstrapper, r as hasInCauseChain } from "./ddl-bootstrap-BaqMSa4Y.js";
+//#region src/cron/cron-store.ts
+var cron_store_exports = /* @__PURE__ */ __exportAll({ createCronStore: () => createCronStore });
+var TABLE = "rebase.cron_logs";
+var CLAIMS_TABLE = "rebase.cron_claims";
+var STATE_TABLE = "rebase.cron_job_state";
+/** `$1, $2, …` for `count` values, starting at `$first`. */
+function placeholders(count, first = 1) {
+	return Array.from({ length: count }, (_, i) => `$${first + i}`).join(", ");
+}
+/**
+* Claims older than this are garbage-collected — all but each job's most
+* recent one, which is kept however old it is; see `sweepClaims`.
+*/
+var CLAIM_RETENTION_DAYS = 7;
+/** Claims one retention statement deletes; a sweep repeats it until a batch comes back short. */
+var CLAIM_SWEEP_BATCH = 5e3;
+/**
+* How far ahead a claim may legitimately sit. Slots are claimed as they fire,
+* so anything beyond this is a clock-skewed peer at best and a stranded claim
+* at worst; see the sweep in `ensureTable`.
+*/
+var FUTURE_CLAIM_SKEW_MINUTES = 2;
+/**
+* How long a run stays in `cron_logs`, which is what the history panel and
+* `GET /api/admin/cron/:id/logs` show. The run and failure counts do not
+* shrink with it: they are kept on `cron_job_state` for all time.
+*
+* Nothing used to delete from `cron_logs`: twelve ordinary jobs wrote 1.5M rows
+* and 617 MB a year, and the counts were `count(*)` over all of it on every
+* poll of the Studio panel.
+*/
+var LOG_RETENTION_DAYS = 30;
+/** History rows one retention or counting statement handles; a sweep repeats it until a batch comes back short. */
+var LOG_SWEEP_BATCH = 5e3;
+/**
+* Whether the run being folded in is at least as recent as the job's last
+* one. The last-run fields only move forward: a long run is logged when it
+* ends, after the skip that started while it ran, and a counting batch can
+* hold any run of the job's history.
+*/
+var IS_NEWER_RUN = "(s.last_run_at IS NULL OR EXCLUDED.last_run_at >= s.last_run_at)";
+/**
+* Add a set of runs to their jobs' counters on `cron_job_state`, as one
+* `INSERT … ON CONFLICT`. `runs` names a relation of the runs —
+* `job_id, started_at, duration_ms, success, error` — and becomes one row per
+* job: how many, how many failed, and the most recent of them.
+*
+* Ordered by job, so two statements folding the same jobs lock their rows in
+* the same order and cannot deadlock.
+*/
+function foldIntoCounters(runs) {
+	return `
+        INSERT INTO ${STATE_TABLE} AS s
+            (job_id, total_runs, total_failures, last_run_at, last_duration_ms, last_success, last_error)
+        SELECT tally.job_id, tally.runs, tally.failures,
+               latest.started_at, latest.duration_ms, latest.success, latest.error
+        FROM (
+            SELECT job_id, count(*) AS runs, count(*) FILTER (WHERE NOT success) AS failures
+            FROM ${runs} GROUP BY job_id
+        ) AS tally
+        JOIN (
+            SELECT DISTINCT ON (job_id) job_id, started_at, duration_ms, success, error
+            FROM ${runs} ORDER BY job_id, started_at DESC
+        ) AS latest ON latest.job_id = tally.job_id
+        ORDER BY tally.job_id
+        ON CONFLICT (job_id) DO UPDATE SET
+            total_runs = s.total_runs + EXCLUDED.total_runs,
+            total_failures = s.total_failures + EXCLUDED.total_failures,
+            last_run_at = CASE WHEN ${IS_NEWER_RUN} THEN EXCLUDED.last_run_at ELSE s.last_run_at END,
+            last_duration_ms = CASE WHEN ${IS_NEWER_RUN} THEN EXCLUDED.last_duration_ms ELSE s.last_duration_ms END,
+            last_success = CASE WHEN ${IS_NEWER_RUN} THEN EXCLUDED.last_success ELSE s.last_success END,
+            last_error = CASE WHEN ${IS_NEWER_RUN} THEN EXCLUDED.last_error ELSE s.last_error END`;
+}
+/**
+* SQLSTATEs that mean the counters are not there to write to — a column or
+* table a failed boot did not create, or a privilege it did not get. A log
+* insert that meets one is written without its count; the next sweep counts
+* it. Anything else is not retried, because a statement that failed after it
+* committed would then be logged — and counted — twice.
+*/
+var COUNTERS_MISSING_SQLSTATES = /* @__PURE__ */ new Set([
+	"42703",
+	"42P01",
+	"42501"
+]);
+/**
+* Detect a unique-constraint violation anywhere in an error's cause chain.
+* Match the SQLSTATE code, never message text. Also covers SQLite
+* ("UNIQUE constraint failed") and MySQL (ER_DUP_ENTRY 1062) for future SQL
+* drivers.
+*
+* Distinct from `isConcurrentDdlRace` in `boot/ddl-bootstrap.ts`, which shares
+* the 23505 code but asks a different question — that one is about a losing
+* `CREATE`, this one is about a losing claim, and only the latter means
+* "another instance already has this slot".
+*/
+function isUniqueViolation(err) {
+	return hasInCauseChain(err, (e) => e.code === "23505" || e.errno === 1062 || typeof e.message === "string" && e.message.includes("UNIQUE constraint failed"));
+}
+/**
+* The setup each database is going through right now, in this process. The
+* scheduler, the expired-token sweep and the history retention sweep each make
+* a store on the same driver, and three setups at once ran the same REVOKEs
+* concurrently — which Postgres can answer with "tuple concurrently updated",
+* failing a security control at boot. Keyed on the driver, so a second
+* database gets a setup of its own.
+*
+* Only the attempt in flight is shared. A later call runs the setup again —
+* every statement in it is idempotent — because the tables can be gone by
+* then: a database reset under a running server, or a suite that drops the
+* schema between tests. A process that remembered "set up" would never bring
+* them back.
+*/
+var setUpsInFlight = /* @__PURE__ */ new WeakMap();
+/** Databases this process has already said "ready" for, so it says so once. */
+var announcedReady = /* @__PURE__ */ new WeakSet();
+function ensureSharedInFlight(driver, setUp) {
+	const current = setUpsInFlight.get(driver);
+	if (current) return current;
+	const attempt = setUp().then(() => void 0).finally(() => {
+		if (setUpsInFlight.get(driver) === attempt) setUpsInFlight.delete(driver);
+	});
+	setUpsInFlight.set(driver, attempt);
+	return attempt;
+}
+function createCronStore(driver) {
+	const admin = driver.admin;
+	if (!isSQLAdmin(admin)) {
+		logger.warn("⚠️ [cron-store] DataDriver does not support SQL admin — cron logs will not be persisted.");
+		return;
+	}
+	const exec = (sqlText, options) => admin.executeSql(sqlText, options?.params ? { params: options.params } : void 0);
+	const ddl = createDdlBootstrapper(exec, "cron-store");
+	/** Whether `rebase.<table>` has `column`. False when it cannot tell, so the idempotent ALTER still runs. */
+	const hasColumn = async (table, column) => {
+		try {
+			return (await exec(`SELECT 1 FROM information_schema.columns
+                 WHERE table_schema = 'rebase' AND table_name = $1 AND column_name = $2`, { params: [table, column] }) ?? []).length > 0;
+		} catch {
+			return false;
+		}
+	};
+	/**
+	* Whether a boot has nothing to do: the three tables, the three indexes and
+	* the run-counter columns are there, the dropped index is gone, and the
+	* end-user role holds no privilege on any of the tables. One catalogue
+	* read, where every boot used to run eleven statements — `CREATE … IF NOT
+	* EXISTS` takes its table's lock before it finds the object there, and a
+	* `REVOKE` rewrites the table's catalogue row even when nothing is granted.
+	* Anything missing, or a read that fails, and the boot runs them all.
+	*/
+	const bootIsCurrent = async () => {
+		const objects = [
+			"cron_logs",
+			"cron_claims",
+			"cron_job_state",
+			"idx_cron_logs_job",
+			"idx_cron_logs_uncounted",
+			"idx_cron_logs_started"
+		];
+		const columns = ["cron_logs.counted", ...[
+			"total_runs",
+			"total_failures",
+			"last_run_at",
+			"last_duration_ms",
+			"last_success",
+			"last_error"
+		].map((c) => `cron_job_state.${c}`)];
+		const quoted = (names) => names.map((name) => `'${name}'`).join(", ");
+		try {
+			const row = (await exec(`
+                WITH objects AS (
+                    SELECT c.oid, c.relname, c.relkind, c.relrowsecurity, c.relacl FROM pg_class c
+                    WHERE c.relnamespace = to_regnamespace('rebase')
+                ), target AS (
+                    SELECT oid FROM pg_roles WHERE rolname = '${REBASE_USER_ROLE}'
+                )
+                SELECT
+                    (SELECT count(*) FROM objects WHERE relname IN (${quoted(objects)}))::int AS present,
+                    (SELECT count(*) FROM objects WHERE relname = 'idx_cron_logs_job_failures')::int AS stale,
+                    (SELECT count(*) FROM information_schema.columns
+                     WHERE table_schema = 'rebase' AND table_name || '.' || column_name IN (${quoted(columns)}))::int AS columns,
+                    (SELECT count(*) FROM objects o
+                     WHERE o.relkind = 'r' AND o.relname IN ('cron_logs', 'cron_claims', 'cron_job_state')
+                       AND NOT o.relrowsecurity AND EXISTS (SELECT 1 FROM target)
+                       AND (o.relacl IS NULL OR EXISTS (
+                           SELECT 1 FROM aclexplode(o.relacl) a WHERE a.grantee = (SELECT oid FROM target)
+                       )))::int AS granted
+            `))?.[0];
+			return Number(row?.present) === objects.length && Number(row?.stale) === 0 && Number(row?.columns) === columns.length && Number(row?.granted) === 0;
+		} catch {
+			return false;
+		}
+	};
+	/**
+	* Drop claims for slots that have not happened yet. A slot is claimed at
+	* the moment it fires, so a future one can only come from a timer that
+	* woke early — and because claims are permanent, that claim would silently
+	* skip the real run when it finally came due. The margin keeps a legitimate
+	* claim made moments early by a clock-skewed peer.
+	*/
+	const releaseFutureClaims = () => ddl.step("Future-slot claim sweep", async () => {
+		const stranded = await exec(`DELETE FROM ${CLAIMS_TABLE}
+             WHERE slot > now() + make_interval(mins => $1)
+             RETURNING job_id, slot`, { params: [FUTURE_CLAIM_SKEW_MINUTES] });
+		for (const row of stranded ?? []) logger.warn(`[cron-store] Released a claim on the future slot ${new Date(row.slot).toISOString()} for "${row.job_id}" — it was claimed by a timer that fired early, and would otherwise have skipped that run`);
+	});
+	/** Run one sweep statement until a batch comes back short. Resolves with the total of `column`. */
+	const inBatches = async (sqlText, params, column) => {
+		let total = 0;
+		for (;;) {
+			const rows = await exec(sqlText, { params });
+			const done = Number((rows?.[0])?.[column] ?? 0);
+			total += done;
+			if (done < LOG_SWEEP_BATCH) return total;
+		}
+	};
+	/**
+	* The boot setup. Resolves with whether every table came up and was locked
+	* away; anything short of that has been reported, and is worth another try.
+	*/
+	const announceReady = () => {
+		if (announcedReady.has(driver)) return;
+		announcedReady.add(driver);
+		logger.info("✅ Cron logs table ready");
+	};
+	const setUp = async () => {
+		if (await bootIsCurrent()) {
+			await releaseFutureClaims();
+			announceReady();
+			return true;
+		}
+		await ddl.ensureObject("Creating schema rebase", "CREATE SCHEMA IF NOT EXISTS rebase");
+		await ddl.ensureObject(`Creating ${TABLE}`, `
+            CREATE TABLE IF NOT EXISTS ${TABLE} (
+                id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
+                job_id TEXT NOT NULL,
+                started_at TIMESTAMPTZ NOT NULL,
+                finished_at TIMESTAMPTZ NOT NULL,
+                duration_ms INTEGER NOT NULL,
+                success BOOLEAN NOT NULL DEFAULT true,
+                error TEXT,
+                result JSONB,
+                logs JSONB,
+                manual BOOLEAN NOT NULL DEFAULT false
+            )
+        `);
+		await ddl.ensureObject("Creating idx_cron_logs_job", `
+            CREATE INDEX IF NOT EXISTS idx_cron_logs_job
+            ON ${TABLE}(job_id, started_at DESC)
+        `);
+		if (!await hasColumn("cron_logs", "counted")) await ddl.ensureObject(`Adding ${TABLE}.counted`, `
+                ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS counted BOOLEAN
+            `);
+		await ddl.ensureObject("Creating idx_cron_logs_uncounted", `
+            CREATE INDEX IF NOT EXISTS idx_cron_logs_uncounted
+            ON ${TABLE}(job_id, started_at DESC) WHERE counted IS NULL
+        `);
+		await ddl.ensureObject("Creating idx_cron_logs_started", `
+            CREATE INDEX IF NOT EXISTS idx_cron_logs_started
+            ON ${TABLE}(started_at)
+        `);
+		await ddl.ensureObject("Dropping idx_cron_logs_job_failures", "DROP INDEX IF EXISTS rebase.idx_cron_logs_job_failures");
+		await ddl.ensureObject(`Creating ${CLAIMS_TABLE}`, `
+            CREATE TABLE IF NOT EXISTS ${CLAIMS_TABLE} (
+                job_id TEXT NOT NULL,
+                slot TIMESTAMPTZ NOT NULL,
+                claimed_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+                PRIMARY KEY (job_id, slot)
+            )
+        `);
+		await ddl.ensureObject(`Creating ${STATE_TABLE}`, `
+            CREATE TABLE IF NOT EXISTS ${STATE_TABLE} (
+                job_id TEXT PRIMARY KEY,
+                enabled BOOLEAN,
+                updated_at TIMESTAMPTZ,
+                updated_by TEXT,
+                running_until TIMESTAMPTZ,
+                running_by TEXT
+            )
+        `);
+		if (!await hasColumn("cron_job_state", "total_runs")) await ddl.ensureObject(`Adding the run counters to ${STATE_TABLE}`, `
+                ALTER TABLE ${STATE_TABLE}
+                    ADD COLUMN IF NOT EXISTS total_runs BIGINT NOT NULL DEFAULT 0,
+                    ADD COLUMN IF NOT EXISTS total_failures BIGINT NOT NULL DEFAULT 0,
+                    ADD COLUMN IF NOT EXISTS last_run_at TIMESTAMPTZ,
+                    ADD COLUMN IF NOT EXISTS last_duration_ms INTEGER,
+                    ADD COLUMN IF NOT EXISTS last_success BOOLEAN,
+                    ADD COLUMN IF NOT EXISTS last_error TEXT
+            `);
+		const [logsReady, claimsReady, stateReady] = await Promise.all([
+			ddl.isReadable(TABLE),
+			ddl.isReadable(CLAIMS_TABLE),
+			ddl.isReadable(STATE_TABLE)
+		]);
+		if (claimsReady) await releaseFutureClaims();
+		if (logsReady) await ddl.step("Revoking end-user access to cron_logs", () => exec(revokeInternalTableSql("rebase", "cron_logs")));
+		if (claimsReady) await ddl.step("Revoking end-user access to cron_claims", () => exec(revokeInternalTableSql("rebase", "cron_claims")));
+		if (stateReady) await ddl.step("Revoking end-user access to cron_job_state", () => exec(revokeInternalTableSql("rebase", "cron_job_state")));
+		if (logsReady && claimsReady && stateReady) {
+			announceReady();
+			return true;
+		}
+		if (!claimsReady) logger.error(`❌ [cron-store] ${CLAIMS_TABLE} is unavailable — scheduled runs cannot be coordinated. With more than one app instance, every instance will now run every job on every tick.`);
+		if (!logsReady) logger.warn(`⚠️ [cron-store] ${TABLE} is unavailable — cron run history will not be persisted.`);
+		if (!stateReady) logger.warn(`⚠️ [cron-store] ${STATE_TABLE} is unavailable — pausing a job reaches only the process that served the request, and jobs run as their code declares on every other one. A manual trigger is not kept off a run another process is making.`);
+		return false;
+	};
+	return {
+		ensureTable: () => ensureSharedInFlight(driver, setUp),
+		async sweepClaims() {
+			let total = 0;
+			for (;;) {
+				const rows = await exec(`WITH swept AS (
+                         DELETE FROM ${CLAIMS_TABLE}
+                         WHERE (job_id, slot) IN (
+                             SELECT c.job_id, c.slot FROM ${CLAIMS_TABLE} AS c
+                             WHERE c.claimed_at < now() - make_interval(days => $1)
+                               AND c.slot < (
+                                   SELECT max(latest.slot) FROM ${CLAIMS_TABLE} AS latest
+                                   WHERE latest.job_id = c.job_id
+                                     AND latest.slot <= now() + make_interval(mins => $2)
+                               )
+                             LIMIT $3
+                             FOR UPDATE SKIP LOCKED
+                         )
+                         RETURNING 1
+                     )
+                     SELECT count(*)::int AS deleted FROM swept`, { params: [
+					CLAIM_RETENTION_DAYS,
+					FUTURE_CLAIM_SKEW_MINUTES,
+					CLAIM_SWEEP_BATCH
+				] });
+				const deleted = Number((rows?.[0])?.deleted ?? 0);
+				total += deleted;
+				if (deleted < CLAIM_SWEEP_BATCH) return total;
+			}
+		},
+		async sweepLogs() {
+			return {
+				deleted: await inBatches(`WITH gone AS (
+                     DELETE FROM ${TABLE}
+                     WHERE id IN (
+                         SELECT id FROM ${TABLE}
+                         WHERE started_at < now() - make_interval(days => $1)
+                         ORDER BY started_at
+                         LIMIT $2
+                         FOR UPDATE SKIP LOCKED
+                     )
+                     RETURNING job_id, counted, started_at, duration_ms, success, error
+                 ), uncounted AS (
+                     SELECT job_id, started_at, duration_ms, success, error FROM gone WHERE counted IS NULL
+                 ), folded AS (
+                     ${foldIntoCounters("uncounted")}
+                     RETURNING 1
+                 )
+                 SELECT count(*)::int AS deleted FROM gone`, [LOG_RETENTION_DAYS, LOG_SWEEP_BATCH], "deleted"),
+				counted: await inBatches(`WITH batch AS (
+                     SELECT id FROM ${TABLE}
+                     WHERE counted IS NULL
+                     ORDER BY job_id, started_at DESC
+                     LIMIT $1
+                     FOR UPDATE SKIP LOCKED
+                 ), marked AS (
+                     UPDATE ${TABLE} AS l SET counted = true
+                     FROM batch WHERE l.id = batch.id
+                     RETURNING l.job_id, l.started_at, l.duration_ms, l.success, l.error
+                 ), folded AS (
+                     ${foldIntoCounters("marked")}
+                     RETURNING 1
+                 )
+                 SELECT count(*)::int AS counted FROM marked`, [LOG_SWEEP_BATCH], "counted")
+			};
+		},
+		async insertLog(entry) {
+			const resultJson = entry.result !== void 0 ? JSON.stringify(entry.result) : null;
+			const logsJson = entry.logs.length > 0 ? JSON.stringify(entry.logs) : null;
+			const params = [
+				entry.jobId,
+				entry.startedAt,
+				entry.finishedAt,
+				entry.durationMs,
+				entry.success,
+				entry.error || null,
+				resultJson,
+				logsJson,
+				entry.manual
+			];
+			const columns = "job_id, started_at, finished_at, duration_ms, success, error, result, logs, manual";
+			const values = "$1, $2, $3, $4, $5, $6, $7::jsonb, $8::jsonb, $9";
+			try {
+				try {
+					await exec(`WITH logged AS (
+                             INSERT INTO ${TABLE} (${columns}, counted)
+                             VALUES (${values}, true)
+                             RETURNING job_id, started_at, duration_ms, success, error
+                         )
+                         ${foldIntoCounters("logged")}`, { params });
+				} catch (err) {
+					if (!hasInCauseChain(err, (e) => typeof e.code === "string" && COUNTERS_MISSING_SQLSTATES.has(e.code))) throw err;
+					await exec(`INSERT INTO ${TABLE} (${columns}) VALUES (${values})`, { params });
+				}
+			} catch (err) {
+				logger.error(`[cron-store] Failed to persist log for "${entry.jobId}"`, { error: err });
+			}
+		},
+		async fetchLogs(jobId, limit = 50) {
+			return (await exec(`SELECT job_id, started_at, finished_at, duration_ms, success, error, result, logs, manual
+                 FROM ${TABLE}
+                 WHERE job_id = $1
+                 ORDER BY started_at DESC
+                 LIMIT $2`, { params: [jobId, limit] })).map(rowToLogEntry);
+		},
+		async fetchJobStats() {
+			const stats = /* @__PURE__ */ new Map();
+			try {
+				const rows = await exec(`
+                    SELECT job_id, total_runs, total_failures, last_run_at
+                    FROM ${STATE_TABLE}
+                    WHERE total_runs > 0
+                `);
+				for (const row of rows ?? []) stats.set(String(row.job_id), {
+					totalRuns: Number(row.total_runs),
+					totalFailures: Number(row.total_failures),
+					lastRunAt: toIsoString(row.last_run_at)
+				});
+			} catch (err) {
+				logger.error("[cron-store] Failed to fetch job stats", { error: err });
+			}
+			return stats;
+		},
+		async tryClaimRun(jobId, slot) {
+			try {
+				return (await exec(`INSERT INTO ${CLAIMS_TABLE} (job_id, slot)
+                     VALUES ($1, $2)
+                     ON CONFLICT (job_id, slot) DO NOTHING
+                     RETURNING job_id`, { params: [jobId, slot] })).length > 0;
+			} catch (err) {
+				if (isUniqueViolation(err)) return false;
+				throw err;
+			}
+		},
+		async saveEnabledOverride(jobId, enabled, updatedBy) {
+			await exec(`INSERT INTO ${STATE_TABLE} (job_id, enabled, updated_at, updated_by)
+                 VALUES ($1, $2::boolean, now(), $3)
+                 ON CONFLICT (job_id) DO UPDATE
+                     SET enabled = EXCLUDED.enabled, updated_at = now(), updated_by = EXCLUDED.updated_by`, { params: [
+				jobId,
+				enabled,
+				updatedBy ?? null
+			] });
+		},
+		async fetchJobStates(jobIds) {
+			const states = /* @__PURE__ */ new Map();
+			if (jobIds.length === 0) return states;
+			const rows = await exec(`SELECT job_id, enabled,
+                        CASE WHEN running_until > now() THEN running_by END AS running_by
+                 FROM ${STATE_TABLE}
+                 WHERE job_id IN (${placeholders(jobIds.length)})`, { params: [...jobIds] });
+			for (const row of rows ?? []) states.set(String(row.job_id), {
+				enabled: typeof row.enabled === "boolean" ? row.enabled : null,
+				runningBy: typeof row.running_by === "string" ? row.running_by : void 0
+			});
+			return states;
+		},
+		async tryAcquireRunLease(jobId, holder, ttlSeconds) {
+			const row = (await exec(`WITH attempt AS (
+                     INSERT INTO ${STATE_TABLE} AS s (job_id, running_until, running_by)
+                     VALUES ($1, now() + make_interval(secs => $2::double precision), $3)
+                     ON CONFLICT (job_id) DO UPDATE
+                         SET running_until = EXCLUDED.running_until, running_by = EXCLUDED.running_by
+                         WHERE s.running_until IS NULL OR s.running_until <= now()
+                     RETURNING s.job_id
+                 )
+                 SELECT EXISTS (SELECT 1 FROM attempt) AS acquired,
+                        (SELECT running_by FROM ${STATE_TABLE}
+                         WHERE job_id = $1 AND running_until > now()) AS holder`, { params: [
+				jobId,
+				ttlSeconds,
+				holder
+			] }))?.[0];
+			if (!row) throw new Error(`The run lease for "${jobId}" got no answer from the database`);
+			if (row.acquired === true) return { acquired: true };
+			return {
+				acquired: false,
+				holder: typeof row.holder === "string" ? row.holder : void 0
+			};
+		},
+		async releaseRunLease(jobId, holder) {
+			await exec(`UPDATE ${STATE_TABLE}
+                 SET running_until = NULL, running_by = NULL
+                 WHERE job_id = $1 AND running_by = $2`, { params: [jobId, holder] });
+		},
+		async fetchRunSummaries(jobIds) {
+			const summaries = /* @__PURE__ */ new Map();
+			if (jobIds.length === 0) return summaries;
+			const rows = await exec(`SELECT j.job_id,
+                        COALESCE(s.total_runs, 0) + COALESCE(pending.runs, 0) AS total_runs,
+                        COALESCE(s.total_failures, 0) + COALESCE(pending.failures, 0) AS total_failures,
+                        CASE WHEN newer.later THEN pending_last.started_at ELSE s.last_run_at END AS started_at,
+                        CASE WHEN newer.later THEN pending_last.duration_ms ELSE s.last_duration_ms END AS duration_ms,
+                        CASE WHEN newer.later THEN pending_last.success ELSE s.last_success END AS success,
+                        CASE WHEN newer.later THEN pending_last.error ELSE s.last_error END AS error
+                 FROM (VALUES ${jobIds.map((_, i) => `($${i + 1}::text)`).join(", ")}) AS j(job_id)
+                 LEFT JOIN ${STATE_TABLE} AS s ON s.job_id = j.job_id
+                 LEFT JOIN LATERAL (
+                     SELECT count(*) AS runs, count(*) FILTER (WHERE NOT l.success) AS failures
+                     FROM ${TABLE} l
+                     WHERE l.job_id = j.job_id AND l.counted IS NULL
+                 ) AS pending ON true
+                 LEFT JOIN LATERAL (
+                     SELECT l.started_at, l.duration_ms, l.success, l.error
+                     FROM ${TABLE} l
+                     WHERE l.job_id = j.job_id AND l.counted IS NULL
+                     ORDER BY l.started_at DESC
+                     LIMIT 1
+                 ) AS pending_last ON true
+                 CROSS JOIN LATERAL (
+                     SELECT pending_last.started_at IS NOT NULL
+                        AND (s.last_run_at IS NULL OR pending_last.started_at >= s.last_run_at) AS later
+                 ) AS newer`, { params: [...jobIds] });
+			for (const row of rows ?? []) {
+				const summary = {
+					totalRuns: Number(row.total_runs ?? 0),
+					totalFailures: Number(row.total_failures ?? 0)
+				};
+				const lastRunAt = toIsoString(row.started_at);
+				if (lastRunAt) {
+					summary.lastRunAt = lastRunAt;
+					summary.lastDurationMs = Number(row.duration_ms);
+					summary.lastSuccess = row.success === true;
+					if (typeof row.error === "string") summary.lastError = row.error;
+				}
+				summaries.set(String(row.job_id), summary);
+			}
+			return summaries;
+		}
+	};
+}
+/** A TIMESTAMPTZ as the driver returned it — a `Date` or a string — in ISO form. */
+function toIsoString(value) {
+	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "string" || typeof value === "number") return new Date(value).toISOString();
+}
+function rowToLogEntry(row) {
+	return {
+		jobId: row.job_id,
+		startedAt: new Date(row.started_at).toISOString(),
+		finishedAt: new Date(row.finished_at).toISOString(),
+		durationMs: row.duration_ms,
+		success: row.success,
+		error: row.error ?? void 0,
+		result: row.result ?? void 0,
+		logs: Array.isArray(row.logs) ? row.logs : row.logs ? (() => {
+			try {
+				return JSON.parse(row.logs);
+			} catch {
+				return [];
+			}
+		})() : [],
+		manual: row.manual
+	};
+}
+//#endregion
+export { cron_store_exports as n, createCronStore as t };
+
+//# sourceMappingURL=cron-store-CZ30ZBi-.js.map