@voltro/database 0.84.0 → 0.86.0

package/dist/migrations/fileDiscovery.js

@@ -0,0 +1,318 @@
+import { causeBranches as e, classifyConstraintViolation as t, extractDbCause as n } from "../dbCause.js";
+import { FILE_MIGRATION_PATTERN as r, IrreversibleMigrationError as i, MigrationExpectationFailed as a, MigrationSkipped as o, TransactionBrokenByBodyError as s, irreversibleReason as c, isFileMigration as l } from "./fileBased.js";
+import { acquireMigrationLock as u } from "./lock.js";
+import { MIGRATION_OPS_TABLE as d, dialectOf as f } from "./resumeLedger.js";
+import { migrationTableExists as p } from "./migrationTableExists.js";
+import { appliedAtValue as m } from "./appliedAtValue.js";
+import { ensureLedgerTable as h, ensurePlanLedgerTable as g } from "./applier.js";
+import { isFileMigrationRow as _ } from "./ledgerRows.js";
+import { failedExpectations as v, makeFileMigrationContext as y } from "./fileContext.js";
+import { withSchemaProbeRecorder as b } from "./fileSkipProbes.js";
+import { Effect as x } from "effect";
+import { createHash as S } from "node:crypto";
+import { SqlClient as C } from "effect/sql";
+import { createLogger as w } from "@voltro/logger";
+import { promises as T } from "node:fs";
+import { join as E } from "node:path";
+import { pathToFileURL as D } from "node:url";
+//#region src/migrations/fileDiscovery.ts
+var O = w({ scope: "voltro:migrate" }), k = (e) => S("sha256").update(e).digest("hex").slice(0, 16), A = [{
+	codemod: "0.78.0/01_file-migration-phase",
+	inverse: (e) => {
+		let t = /\n {2}phase: 'before-schema',\n {2}/g, n = /\n {2}phase: 'before-schema'(?=\r?\n[ \t]*\})/g, r = e.includes("\r\n") ? "\r\n" : "\n", i = (t) => {
+			let n = e.lastIndexOf("\n", t - 1) + 1;
+			return /^[ \t]*/.exec(e.slice(n, t))[0];
+		};
+		return [e.replace(t, (e, t) => r + i(t)).replace(n, ""), e.replace(t, " ").replace(n, "")];
+	}
+}], j = (e) => new Set([e, ...A.flatMap((t) => t.inverse(e))].map(k)), M = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".turbo",
+	".vite",
+	".next",
+	".git",
+	".framework"
+]), N = async (e) => {
+	let t = [], n = async (e) => {
+		let i = await T.readdir(e, { withFileTypes: !0 }).catch(() => []);
+		for (let a of i) {
+			if (M.has(a.name)) continue;
+			let i = E(e, a.name);
+			a.isDirectory() ? await n(i) : a.isFile() && r.test(a.name) && t.push(i);
+		}
+	};
+	return await n(e), t.sort((e, t) => {
+		let n = e.split("/").pop() ?? e, r = t.split("/").pop() ?? t;
+		return n.localeCompare(r);
+	});
+}, P = async (e) => await import(D(e).href), F = async (e, t = P) => {
+	let n = [];
+	for (let r of e) {
+		let e = (await t(r)).default;
+		if (!l(e)) {
+			O.warn("migration file has no default-exported `migration(...)` — skipped", { file: r });
+			continue;
+		}
+		let i = await T.readFile(r, "utf8").catch(() => "");
+		n.push({
+			file: r,
+			migration: e,
+			hash: k(i),
+			accepted: j(i)
+		});
+	}
+	return n;
+}, I = "_voltro_migration_plans", L = (e) => R(e).pipe(x.map((e) => e.map((e) => e.id))), R = (e) => p(e, I).pipe(x.flatMap((t) => t ? e`
+          SELECT ${e("id")}, ${e("fingerprint")}
+          FROM ${e(I)}
+          WHERE ${_(e)}
+        `.pipe(x.map((e) => e.map((e) => ({
+	id: e.id,
+	hash: e.fingerprint ?? ""
+})))) : x.succeed([]))), z = (e, t) => t.filter((t) => {
+	let n = e.get(t.migration.id);
+	return n !== void 0 && n !== "" && !t.accepted.has(n);
+}).map((e) => e.migration.id), B = /* @__PURE__ */ new Set(), V = (e) => t(n(e))?.kind === "unique", H = class extends Error {
+	migrationId;
+	file;
+	cause;
+	_tag = "FileMigrationLedgerError";
+	constructor(e, t, n) {
+		super(V(n) ? `migration ${e}: up() SUCCEEDED here, and ANOTHER process had already recorded the same migration.\n  The body has run TWICE. The ledger row is correct — do not delete it; the next run will not apply ${t} again.\n  Two processes applied it without being serialised by the migration lock: check that both reach the same database and lock schema.\n  Cause: ${n instanceof Error ? n.message : String(n)}` : `migration ${e}: up() SUCCEEDED but the ledger row could not be written.\n  The change IS in the database. It is NOT recorded, so the next run would apply it AGAIN.\n  Do not re-run ${t} until this is resolved.\n  Cause: ${n instanceof Error ? n.message : String(n)}`), this.migrationId = e, this.file = t, this.cause = n, this.name = "FileMigrationLedgerError";
+	}
+}, U = (e, t, n) => x.gen(function* () {
+	let r = yield* m(e, n.appliedAtIso);
+	yield* e`
+      INSERT INTO ${e("_voltro_migration_plans")}
+        (${e("id")}, ${e("fingerprint")}, ${e("operations")},
+         ${e("appliedBy")}, ${e("environment")}, ${e("source")},
+         ${e("durationMs")}, ${e("appliedAt")}, ${e("notes")})
+      VALUES
+        (${t.migration.id}, ${t.hash}, ${JSON.stringify([{
+		kind: "file",
+		file: t.file,
+		phase: t.migration.phase
+	}])},
+         ${n.appliedBy}, ${n.env}, ${"file"},
+         ${n.durationMs}, ${r}, ${n.notes})
+    `.pipe(x.mapError((e) => new H(t.migration.id, t.file, e)));
+}), W = (t) => {
+	for (let n of e(t)) if (n instanceof o) return n.reason;
+}, G = (e, t, n) => x.gen(function* () {
+	let r = b(t), i = r.ctx, o = e.migration.up(i), s = !x.isEffect(o), c = yield* (x.isEffect(o) ? o : x.tryPromise({
+		try: () => o,
+		catch: (e) => e
+	})).pipe(x.as(void 0), x.catch((e) => {
+		let t = W(e);
+		return t === void 0 ? x.fail(e) : x.succeed(t);
+	}));
+	if (c === void 0) {
+		let t = yield* v(n);
+		if (t.length > 0) return yield* x.fail(new a(e.migration.id, t));
+	}
+	return {
+		skipped: c,
+		promiseForm: s,
+		absent: r.absent()
+	};
+}), K = (e, t, n, r, i, a, o, c) => x.gen(function* () {
+	let l = Date.now(), u = (/* @__PURE__ */ new Date()).toISOString(), p = f(e), m = `migrations:file:${n.migration.id}`, g = (e) => ({
+		durationMs: Date.now() - l,
+		notes: e.skipped === void 0 ? n.migration.description : `skipped: ${e.skipped}`
+	});
+	if (n.migration.transactional !== !1 && !a) {
+		if (t.run === void 0) return yield* x.fail(/* @__PURE__ */ Error(`migration ${n.migration.id}: transactional: true needs a SQL-backed store`));
+		let a = p === "mysql" || p === "mariadb", l = `probe_${n.migration.id}_${Date.now().toString(36)}`;
+		a && (yield* h(e, p, o));
+		let f = (e) => e.executeUnprepared(`SELECT COUNT(*) AS n FROM \`${d}\` WHERE \`runId\` = ?`, [l], void 0), _ = () => (c === void 0 ? x.scoped(x.flatMap(e.reserve, f)) : f(c)).pipe(x.map((e) => Number(e[0]?.n ?? 0) > 0)), v = yield* x.tryPromise({
+			try: () => t.transactional(async (t) => {
+				a && await t.run(e`INSERT INTO ${e(d)} (${e("id")}, ${e("runId")}, ${e("planFingerprint")}, ${e("opIndex")}, ${e("status")}, ${e("opKind")}, ${e("opTarget")}, ${e("payload")})
+              VALUES (${`mop_${l}`}, ${l}, ${""}, ${0}, ${"pending"}, ${"probe"}, ${""}, ${"{}"})`);
+				let { ctx: o, expectations: s } = y({
+					sql: e,
+					store: t,
+					dialect: p,
+					migrationId: n.migration.id,
+					appliedAt: u
+				}), c = await t.run(G(n, o, s)), f = a && await x.runPromise(_().pipe(x.provideService(C.SqlClient, e))), { durationMs: m, notes: h } = g(c);
+				return await t.run(U(e, n, {
+					env: r,
+					appliedBy: i,
+					durationMs: m,
+					appliedAtIso: u,
+					notes: f ? `${h} — transactional guarantee broken by the body (DDL on ${p})` : h
+				})), a && await t.run(e`DELETE FROM ${e(d)} WHERE ${e("runId")} = ${l}`), {
+					...c,
+					durationMs: m,
+					broken: f
+				};
+			}),
+			catch: (e) => e
+		});
+		return v.broken ? yield* x.fail(new s(n.migration.id, p)) : (v.skipped !== void 0 && (yield* x.logInfo(`migration ${n.migration.id} skipped: ${v.skipped}`).pipe(x.annotateLogs({ scope: m }))), {
+			durationMs: v.durationMs,
+			skip: v.skipped === void 0 ? void 0 : {
+				id: n.migration.id,
+				reason: v.skipped,
+				absent: v.absent
+			}
+		});
+	}
+	let { ctx: _, expectations: v } = y({
+		sql: e,
+		store: t,
+		dialect: p,
+		migrationId: n.migration.id,
+		appliedAt: u
+	}), b = yield* G(n, _, v), { durationMs: S, notes: w } = g(b);
+	return b.promiseForm && b.skipped === void 0 && S < 2 && (yield* x.logWarning(`migration ${n.migration.id}: up() resolved in ${S}ms — did the body \`await\` an \`effect/sql\` Effect by accident? \`sql.unsafe(...)\` returns an Effect, not a Promise; \`await\` on it is a silent no-op. Switch the body to \`Effect.gen(function* () { yield* sql.unsafe(...) })\` form.`).pipe(x.annotateLogs({ scope: m }))), b.skipped !== void 0 && (yield* x.logInfo(`migration ${n.migration.id} skipped: ${b.skipped}`).pipe(x.annotateLogs({ scope: m }))), yield* U(e, n, {
+		env: r,
+		appliedBy: i,
+		durationMs: S,
+		appliedAtIso: u,
+		notes: w
+	}), {
+		durationMs: S,
+		skip: b.skipped === void 0 ? void 0 : {
+			id: n.migration.id,
+			reason: b.skipped,
+			absent: b.absent
+		}
+	};
+}), q = (e, t, n, r) => x.gen(function* () {
+	let i = yield* x.tryPromise({
+		try: () => N(E(t, "migrations")),
+		catch: (e) => e
+	});
+	if (i.length === 0) return {
+		pending: [],
+		alreadyApplied: [],
+		drifted: []
+	};
+	let a = yield* x.tryPromise({
+		try: () => F(i, r),
+		catch: (e) => e
+	});
+	if (a.length === 0) return {
+		pending: [],
+		alreadyApplied: [],
+		drifted: []
+	};
+	let o = new Map((yield* R(e)).map((e) => [e.id, e.hash])), s = z(o, a), c = s.length >= 32 ? /* @__PURE__ */ new Map() : void 0;
+	if (c !== void 0) for (let e of a) c.has(e.migration.id) || c.set(e.migration.id, e);
+	for (let e of s) {
+		let t = c === void 0 ? a.find((t) => t.migration.id === e) : c.get(e), n = `${t?.file ?? e}:${t?.hash ?? ""}`;
+		B.has(n) || (B.add(n), O.warn("file migration: the body on disk is not the one that was applied — the file no longer describes this database", {
+			id: e,
+			file: t?.file
+		}));
+	}
+	let l = n === void 0 ? a : a.filter((e) => e.migration.phase === n);
+	return {
+		pending: l.filter((e) => !o.has(e.migration.id)),
+		alreadyApplied: l.filter((e) => o.has(e.migration.id)),
+		drifted: s
+	};
+}), J = (e, t, n, r) => q(e, t, n, r).pipe(x.map((e) => e.pending.map((e) => e.migration.id))), Y = (e, t, n) => q(e, t, n).pipe(x.map((e) => e.pending.map((e) => ({
+	id: e.migration.id,
+	phase: e.migration.phase,
+	irreversible: c(e.migration.down)
+})))), X = (e, t) => q(e, t).pipe(x.map((e) => {
+	let t = new Set(e.drifted);
+	return [...e.alreadyApplied.map((e) => ({
+		id: e.migration.id,
+		phase: e.migration.phase,
+		applied: !0,
+		bodyChanged: t.has(e.migration.id)
+	})), ...e.pending.map((e) => ({
+		id: e.migration.id,
+		phase: e.migration.phase,
+		applied: !1,
+		bodyChanged: !1
+	}))].sort((e, t) => e.id < t.id ? -1 : 1);
+})), Z = (e, t) => x.gen(function* () {
+	let { pending: n, alreadyApplied: r } = yield* q(e, t.projectRoot, t.phase), i = r.map((e) => e.migration.id);
+	if (n.length === 0) return {
+		applied: [],
+		skipped: i,
+		skips: []
+	};
+	yield* g(e, f(e), t.charset);
+	let a = yield* x.acquireUseRelease(u(e, { schema: t.lockSchema }), (r) => x.gen(function* () {
+		let i = new Set((yield* R(e)).map((e) => e.id)), a = n.filter((e) => !i.has(e.migration.id));
+		a.length < n.length && (yield* x.logInfo("file-based migrations applied by another process while this one waited for the migration lock").pipe(x.annotateLogs({
+			scope: "voltro:migrate",
+			ids: n.filter((e) => i.has(e.migration.id)).map((e) => e.migration.id).join(",")
+		})));
+		let o = [];
+		a.length > 0 && t.beforeExecute !== void 0 && (yield* t.beforeExecute);
+		let s = [];
+		for (let n of a) {
+			yield* x.logInfo("file-based migration applying").pipe(x.annotateLogs({
+				scope: "voltro:migrate",
+				id: n.migration.id,
+				file: n.file,
+				phase: n.migration.phase
+			}));
+			let { durationMs: i, skip: a } = yield* K(e, t.store, n, t.env, t.appliedBy, t.enclosed === !0, t.charset, r.connection);
+			o.push({
+				id: n.migration.id,
+				durationMs: i
+			}), a !== void 0 && s.push(a), yield* x.logInfo("file-based migration applied").pipe(x.annotateLogs({
+				scope: "voltro:migrate",
+				id: n.migration.id,
+				durationMs: i,
+				phase: n.migration.phase
+			}));
+		}
+		return {
+			done: o,
+			skips: s
+		};
+	}), (e) => e.release.pipe(x.orDie));
+	return {
+		applied: a.done,
+		skipped: i,
+		skips: a.skips
+	};
+}), Q = (e, t) => e`
+    SELECT ${e("id")}
+    FROM ${e("_voltro_migration_plans")}
+    WHERE ${e("id")} = ${t} AND ${e("source")} = 'file'
+  `, $ = (e, t) => x.gen(function* () {
+	if (!(yield* Q(e, t.id))[0]) return yield* x.fail(/* @__PURE__ */ Error(`rollback: ${t.id} not found in _voltro_migration_plans (file source)`));
+	let n = yield* x.tryPromise({
+		try: () => N(E(t.projectRoot, "migrations")),
+		catch: (e) => e
+	}), r = (yield* x.tryPromise({
+		try: () => F(n),
+		catch: (e) => e
+	})).find((e) => e.migration.id === t.id);
+	if (!r) return yield* x.fail(/* @__PURE__ */ Error(`rollback: file for migration ${t.id} not found on disk under ${t.projectRoot}/migrations/`));
+	let a = c(r.migration.down);
+	return a === void 0 ? yield* x.acquireUseRelease(u(e, { schema: t.lockSchema }), () => x.gen(function* () {
+		if ((yield* Q(e, t.id))[0] === void 0) return yield* x.fail(/* @__PURE__ */ Error(`rollback: ${t.id} was rolled back by another process while this one waited for the migration lock — nothing to do`));
+		let n = Date.now(), { ctx: i } = y({
+			sql: e,
+			store: t.store,
+			dialect: f(e),
+			migrationId: t.id,
+			appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		t.beforeExecute !== void 0 && (yield* t.beforeExecute);
+		let a = r.migration.down(i);
+		x.isEffect(a) ? yield* a : yield* x.tryPromise({
+			try: () => a,
+			catch: (e) => e
+		});
+		let o = Date.now() - n;
+		return yield* e`DELETE FROM ${e("_voltro_migration_plans")} WHERE ${e("id")} = ${t.id} AND ${e("source")} = 'file'`, {
+			id: t.id,
+			durationMs: o
+		};
+	}), (e) => e.release.pipe(x.orDie)) : yield* x.fail(new i(t.id, a));
+});
+//#endregion
+export { r as FILE_MIGRATION_PATTERN, A as FRAMEWORK_MIGRATION_EDITS, H as FileMigrationLedgerError, j as acceptedBodyHashes, L as appliedFileMigrationIds, R as appliedFileMigrations, X as fileMigrationStatus, k as migrationBodyHash, J as pendingFileMigrationIds, Y as pendingFileMigrationSummary, $ as rollbackFileBasedMigration, Z as runFileBasedMigrations, N as walkMigrationFiles };

package/dist/migrations/fileSkipProbes.js

@@ -0,0 +1,117 @@
+import { Effect as e } from "effect";
+//#region src/migrations/fileSkipProbes.ts
+var t = (e) => e.kind === "table" ? e.table : `${e.table}.${e.name}`, n = (e, n) => e.kind === n.kind && e.table === n.table && t(e) === t(n), r = (e) => JSON.stringify([
+	e.kind,
+	e.table,
+	e.kind === "table" ? null : e.name
+]), i = (e) => {
+	if (Object.getPrototypeOf(e) !== Object.prototype) return !1;
+	let t = Object.getOwnPropertyDescriptor(e, "kind");
+	if (t === void 0 || !("value" in t) || typeof t.value != "string") return !1;
+	for (let n of ["table", ...t.value === "table" ? [] : ["name"]]) {
+		let t = Object.getOwnPropertyDescriptor(e, n);
+		if (t === void 0 || !("value" in t) || typeof t.value != "string") return !1;
+	}
+	return !0;
+}, a = (t) => {
+	let i = [], a = /* @__PURE__ */ new Set(), o = !1, s = (e) => (t) => {
+		if (!t) {
+			if (o) i.some((t) => n(t, e)) || i.push(e);
+			else {
+				let t = r(e);
+				a.has(t) || (a.add(t), i.push(e));
+			}
+		}
+		return t;
+	}, c = (t, n) => (...r) => t(...r).pipe(e.map(s(n(...r)))), l = {
+		tableExists: c(t.schema.tableExists, (e) => ({
+			kind: "table",
+			table: e
+		})),
+		columnExists: c(t.schema.columnExists, (e, t) => ({
+			kind: "column",
+			table: e,
+			name: t
+		})),
+		indexExists: c(t.schema.indexExists, (e, t) => ({
+			kind: "index",
+			table: e,
+			name: t
+		})),
+		foreignKeyExists: c(t.schema.foreignKeyExists, (e, t) => ({
+			kind: "foreign-key",
+			table: e,
+			name: t
+		}))
+	};
+	return {
+		ctx: {
+			...t,
+			schema: {
+				...t.schema,
+				...l
+			}
+		},
+		absent: () => (o = !0, i.slice())
+	};
+}, o = (e) => {
+	let t = [], n = /* @__PURE__ */ new Set(), i = (e) => {
+		let i = r(e);
+		n.has(i) || (n.add(i), t.push(e));
+	};
+	for (let t of e.operations) {
+		let e = t.op;
+		switch (e.kind) {
+			case "create-table":
+				i({
+					kind: "table",
+					table: e.table
+				});
+				for (let t of e.columns) i({
+					kind: "column",
+					table: e.table,
+					name: t.name
+				});
+				for (let t of e.indexes) i({
+					kind: "index",
+					table: e.table,
+					name: t.name
+				});
+				break;
+			case "add-column":
+				i({
+					kind: "column",
+					table: e.table,
+					name: e.column.name
+				});
+				break;
+			case "add-index":
+				i({
+					kind: "index",
+					table: e.table,
+					name: e.index.name
+				});
+				break;
+			case "add-foreign-key": i({
+				kind: "foreign-key",
+				table: e.table,
+				name: e.column
+			});
+		}
+	}
+	return t;
+}, s = (e, t) => {
+	let a = o(t);
+	if (a.length === 0) return [];
+	let s = a.length >= 32 ? new Set(a.map(r)) : void 0;
+	return e.flatMap((e) => {
+		let t = e.absent.filter((e) => s !== void 0 && i(e) ? s.has(r(e)) : a.some((t) => n(t, e)));
+		return t.length === 0 ? [] : [{
+			id: e.id,
+			reason: e.reason,
+			created: t
+		}];
+	});
+};
+//#endregion
+export { t as describeProbe, s as permanentSkips, o as plannedCreations, a as withSchemaProbeRecorder };

package/dist/migrations/fingerprint.js

@@ -0,0 +1,46 @@
+import { isSoftDropSnapshotName as e } from "./frameworkLiveTables.js";
+import { canonicalIdColumn as t, comparableDefault as n, comparableIndex as r, comparableSpatial as i, isPgSequenceDefault as a, isSolePrimaryKeyId as o, normRef as s } from "./columnEquivalence.js";
+import { createHash as c } from "node:crypto";
+//#region src/migrations/fingerprint.ts
+var l = (e) => {
+	if (e == null) return e;
+	if (Array.isArray(e)) return e.map(l);
+	if (typeof e != "object") return e;
+	let t = {};
+	for (let n of Object.keys(e).sort()) {
+		let r = e[n];
+		r !== void 0 && (t[n] = l(r));
+	}
+	return t;
+}, u = (e) => {
+	if (!e.idScheme && !e.sensitive && !e.safe && !e.generatedAs && !e.jsonChecks && !e.narrowedFrom && !e.rawDdl && !e.charset) return e;
+	let { idScheme: t, sensitive: n, safe: r, generatedAs: i, jsonChecks: a, narrowedFrom: o, rawDdl: s, charset: c, ...l } = e;
+	return l;
+}, d = (e) => {
+	let t = u((() => {
+		if (e.storageType === void 0) return e;
+		let { storageType: t, enumValues: n, enumName: r, arrayElement: i, ...a } = e;
+		return {
+			...a,
+			type: t
+		};
+	})()), { references: r, defaultValue: o, hasDefault: c, oneOf: l, spatial: d, enumValues: f, ...p } = t, m = t.type === "id" && a(t) ? null : n(t), h = s(t.references);
+	return {
+		...p,
+		hasDefault: m !== null,
+		...m === null ? {} : { defaultValue: m },
+		...h === null ? {} : { references: h },
+		...t.oneOf !== void 0 && t.oneOf.length > 0 ? { oneOf: [...t.oneOf].sort() } : {},
+		...t.spatial === void 0 ? {} : { spatial: i(t.spatial) },
+		...t.enumValues === void 0 ? {} : { enumValues: [...t.enumValues].sort() }
+	};
+}, f = (n) => n.columns.filter((t) => !e(t.name)).map((e) => d(t(e, o(n, e)))).sort((e, t) => e.name.localeCompare(t.name)), p = (e) => [...e].map(r).sort((e, t) => e.name.localeCompare(t.name)), m = (t) => [...t].filter((t) => !e(t.name)).map((e) => ({
+	name: e.name,
+	columns: f(e),
+	indexes: p(e.indexes)
+})).sort((e, t) => e.name.localeCompare(t.name)), h = (e) => {
+	let t = { tables: m(e.tables) }, n = JSON.stringify(l(t));
+	return c("sha256").update(n).digest("hex");
+}, g = (e) => e.slice(0, 16);
+//#endregion
+export { h as fingerprintSchema, g as shortFingerprint };

package/dist/migrations/fkCycles.js

@@ -0,0 +1,13 @@
+//#region src/migrations/fkCycles.ts
+var e = (e, t) => `${e}::${t}`, t = (t, n) => {
+	let r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = (t) => {
+		r.add(t);
+		let s = [...n(t)].filter((e) => e.target !== t).sort((e, t) => e.column.localeCompare(t.column));
+		for (let n of s) r.has(n.target) ? a.add(e(t, n.column)) : i.has(n.target) || o(n.target);
+		r.delete(t), i.add(t);
+	};
+	for (let e of [...t].sort()) i.has(e) || o(e);
+	return a;
+};
+//#endregion
+export { t as findCyclicFkBackEdges, e as fkEdgeKey };

package/dist/migrations/frameworkLiveTables.js

@@ -0,0 +1,25 @@
+//#region src/migrations/frameworkLiveTables.ts
+var e = /* @__PURE__ */ new Set(["voltro_isr_cache"]), t = (t) => e.has(t) || t.startsWith("_voltro_") || t.startsWith("_cloud_") || t.startsWith("cluster_") || t.startsWith("__turso_internal_"), n = "_voltro_staging_", r = (e) => e.startsWith(n), i = /__dropped_\d{14}$/, a = (e) => i.test(e), o = 7, s = (e) => {
+	let t = /__dropped_(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/.exec(e);
+	if (t === null) return;
+	let [, n, r, i, a, o, s] = t;
+	return new Date(Date.UTC(Number(n), Number(r) - 1, Number(i), Number(a), Number(o), Number(s)));
+}, c = (e, t = {}) => {
+	let n = t.now ?? /* @__PURE__ */ new Date(), r = t.retentionDays ?? 7, i = [], o = (e, t) => {
+		let a = s(e);
+		if (a === void 0) return;
+		let o = Math.floor((n.getTime() - a.getTime()) / 864e5);
+		o >= r && i.push({
+			name: t,
+			droppedAt: a,
+			ageDays: o
+		});
+	};
+	for (let t of e.tables) if (o(t.name, t.name), !a(t.name)) for (let e of t.columns ?? []) o(e.name, `${t.name}.${e.name}`);
+	return i;
+}, l = (e, t) => {
+	let n = e.reduce((e, t) => e.ageDays >= t.ageDays ? e : t), r = (/* @__PURE__ */ new Date(Date.now() - t * 864e5)).toISOString().slice(0, 10);
+	return `${e.length} soft-drop snapshot(s) older than ${t} day(s) still hold the dropped data (oldest: ${n.name}, ${n.ageDays}d) — ${e.map((e) => e.name).join(", ")}. Restore with \`voltro db restore-snapshot\` or reclaim with \`voltro db gc-snapshots --before ${r}\`; the window is \`database.softDropRetentionDays\` in app.config.`;
+}, u = (e, n) => e.filter((e) => !t(e.name) || n.has(e.name));
+//#endregion
+export { o as DEFAULT_SOFT_DROP_RETENTION_DAYS, e as FRAMEWORK_LIVE_TABLES, n as STAGING_TABLE_PREFIX, c as agedSoftDropSnapshots, l as describeAgedSoftDropSnapshots, t as isFrameworkOwnedLiveTable, a as isSoftDropSnapshotName, r as isStagingTableName, u as plannableLiveTables, s as softDropSnapshotStamp };

package/dist/migrations/idempotentDdl.js

@@ -0,0 +1,37 @@
+//#region src/migrations/idempotentDdl.ts
+var e = (e) => {
+	let t = e;
+	for (let e = 0; e < 6 && typeof t == "object" && t; e++) {
+		let e = t;
+		if (typeof e.errno == "number") return e.errno;
+		t = e.cause;
+	}
+}, t = (e) => {
+	let t = [], n = e;
+	for (let e = 0; e < 6 && typeof n == "object" && n; e++) {
+		let e = n;
+		typeof e.message == "string" && t.push(e.message), n = e.cause;
+	}
+	return t.join(" | ");
+}, n = (n, r) => {
+	if (r.length === 0) return !1;
+	let i = e(n), a = t(n);
+	return r.some((e) => e.errno !== void 0 && i !== void 0 && e.errno.includes(i) || e.messageIncludes !== void 0 && e.messageIncludes.some((e) => a.includes(e)));
+}, r = {
+	why: "mysql has no CREATE INDEX IF NOT EXISTS; 1061 is exactly that condition",
+	errno: [1061]
+}, i = {
+	why: "mysql has no DROP COLUMN IF EXISTS; 1091 is exactly that condition",
+	errno: [1091]
+}, a = {
+	why: "sqlite has no DROP COLUMN IF EXISTS, and reports the absent column only in the message",
+	messageIncludes: ["no such column"]
+}, o = {
+	why: "mysql/mariadb DROP CONSTRAINT has no portable IF EXISTS; 1091 / 3940 are exactly \"already gone\"",
+	errno: [1091, 3940]
+}, s = {
+	why: "mysql/mariadb ADD CONSTRAINT has no IF NOT EXISTS; 1826 is exactly \"already there\"",
+	errno: [1826]
+};
+//#endregion
+export { i as MYSQL_COLUMN_OR_INDEX_ABSENT, o as MYSQL_CONSTRAINT_ABSENT, s as MYSQL_FOREIGN_KEY_EXISTS, r as MYSQL_INDEX_EXISTS, a as SQLITE_COLUMN_ABSENT, n as isAlreadySatisfied };

package/dist/migrations/indexPredicate.js

@@ -0,0 +1,50 @@
+//#region src/migrations/indexPredicate.ts
+var e = /'(?:''|[^'])*'|"(?:""|[^"])*"|\[(?:\]\]|[^\]])*\]|`(?:``|[^`])*`|[A-Za-z_][A-Za-z_0-9$]*|\d+(?:\.\d+)?|::|<>|!=|<=|>=|\|\||[^\s]/g, t = (t) => {
+	let n = 0;
+	for (let r of t.matchAll(e)) if (r[0] === "(" && n++, r[0] === ")" && n--, n === 0 && r[0].toLowerCase() === "where") return t.slice(r.index + r[0].length).trim().replace(/;$/, "").trim();
+}, n = (t) => {
+	if (t === void 0) return;
+	let n = t.match(e) ?? [], r = "(?:'(?:''|[^'])*'(?:\\s*::\\s*text)?|[0-9]+)", i = RegExp(`^\\s*${r}(?:\\s*,\\s*${r})*\\s*$`, "i");
+	for (let t = 0; t < n.length - 5; t++) {
+		let r = n[t + 4];
+		n[t] === "=" && n[t + 1]?.toLowerCase() === "any" && n[t + 2] === "(" && n[t + 3]?.toLowerCase() === "array" && r.startsWith("[") && r.endsWith("]") && n[t + 5] === ")" && i.test(r.slice(1, -1)) && n.splice(t, 6, "in", "(", ...r.slice(1, -1).match(e) ?? [], ")");
+	}
+	let a = n.filter((e, t) => !(e === "::" && n[t - 1]?.startsWith("'") && n[t + 1]?.toLowerCase() === "text" || e.toLowerCase() === "text" && n[t - 1] === "::" && n[t - 2]?.startsWith("'"))).map((e) => {
+		if (e.startsWith("'")) return e;
+		if (e.startsWith("\"") || e.startsWith("[") || e.startsWith("`")) {
+			let t = e.slice(1, -1).replace(/""/g, "\"").replace(/\]\]/g, "]").replace(/``/g, "`");
+			return /^[a-z_][a-z_0-9$]*$/.test(t) ? t : JSON.stringify(t);
+		}
+		return e.toLowerCase();
+	}), o = (e) => {
+		let t = e, n = () => {
+			if (t[0] !== "(" || t.at(-1) !== ")") return !1;
+			let e = 0;
+			for (let n = 0; n < t.length - 1; n++) if (t[n] === "(" && e++, t[n] === ")" && e--, e === 0) return !1;
+			return !0;
+		};
+		for (; n();) t = t.slice(1, -1);
+		if (!t.includes("between")) for (let e of ["or", "and"]) {
+			let n = 0, r = [[]];
+			for (let i of t) i === "(" && n++, i === ")" && n--, n === 0 && i === e ? r.push([]) : r[r.length - 1].push(i);
+			if (r.length > 1) return [e, ...r.map(o)];
+		}
+		let r = [];
+		for (let e = 0; e < t.length; e++) t[e] === "(" && t[e + 2] === ")" && t[e + 1] !== "(" && t[e + 1] !== ")" && (e === 0 || [
+			"=",
+			"<>",
+			"!=",
+			"<",
+			">",
+			"<=",
+			">=",
+			"is",
+			"not",
+			"("
+		].includes(t[e - 1])) ? (r.push(t[e + 1]), e += 2) : r.push(t[e]);
+		return r;
+	};
+	return JSON.stringify(o(a));
+};
+//#endregion
+export { t as extractIndexPredicate, n as normalizeIndexPredicate };