@voltro/database 0.85.0 → 0.87.0

package/dist/migrations/fileDiscovery.js

@@ -0,0 +1,332 @@
+import { causeBranches as e, classifyConstraintViolation as t, extractDbCause as n } from "../dbCause.js";
+import { derivedRowId as r } from "../derivedRowId.js";
+import { FILE_MIGRATION_PATTERN as i, IrreversibleMigrationError as a, MigrationExpectationFailed as o, MigrationSkipped as s, TransactionBrokenByBodyError as c, irreversibleReason as l, isFileMigration as u } from "./fileBased.js";
+import { acquireMigrationLock as d } from "./lock.js";
+import { MIGRATION_OPS_TABLE as f, dialectOf as p } from "./resumeLedger.js";
+import { migrationTableExists as m } from "./migrationTableExists.js";
+import { appliedAtValue as h } from "./appliedAtValue.js";
+import { ensureLedgerTable as g, ensurePlanLedgerTable as _ } from "./applier.js";
+import { isFileMigrationRow as v } from "./ledgerRows.js";
+import { failedExpectations as y, makeFileMigrationContext as b } from "./fileContext.js";
+import { withSchemaProbeRecorder as x } from "./fileSkipProbes.js";
+import { Effect as S } from "effect";
+import { createHash as C } from "node:crypto";
+import { SqlClient as w } from "effect/sql";
+import { createLogger as T } from "@voltro/logger";
+import { promises as E } from "node:fs";
+import { join as D } from "node:path";
+import { pathToFileURL as O } from "node:url";
+//#region src/migrations/fileDiscovery.ts
+var k = T({ scope: "voltro:migrate" }), A = (e) => C("sha256").update(e).digest("hex").slice(0, 16), j = [{
+	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, "")];
+	}
+}], M = (e) => new Set([e, ...j.flatMap((t) => t.inverse(e))].map(A)), N = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".turbo",
+	".vite",
+	".next",
+	".git",
+	".framework"
+]), P = async (e) => {
+	let t = [], n = async (e) => {
+		let r = await E.readdir(e, { withFileTypes: !0 }).catch(() => []);
+		for (let a of r) {
+			if (N.has(a.name)) continue;
+			let r = D(e, a.name);
+			a.isDirectory() ? await n(r) : a.isFile() && i.test(a.name) && t.push(r);
+		}
+	};
+	return await n(e), t.sort((e, t) => {
+		let n = e.split("/").pop() ?? e, r = t.split("/").pop() ?? t;
+		return n.localeCompare(r);
+	});
+}, F = async (e) => await import(O(e).href), I = async (e, t = F) => {
+	let n = [];
+	for (let r of e) {
+		let e = (await t(r)).default;
+		if (!u(e)) {
+			k.warn("migration file has no default-exported `migration(...)` — skipped", { file: r });
+			continue;
+		}
+		let i = await E.readFile(r, "utf8").catch(() => "");
+		n.push({
+			file: r,
+			migration: e,
+			hash: A(i),
+			accepted: M(i)
+		});
+	}
+	return n;
+}, L = "_voltro_migration_plans", R = (e) => z(e).pipe(S.map((e) => e.map((e) => e.id))), z = (e) => m(e, L).pipe(S.flatMap((t) => t ? e`
+          SELECT ${e("id")}, ${e("fingerprint")}
+          FROM ${e(L)}
+          WHERE ${v(e)}
+        `.pipe(S.map((e) => e.map((e) => ({
+	id: e.id,
+	hash: e.fingerprint ?? ""
+})))) : S.succeed([]))), B = (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), V = /* @__PURE__ */ new Set(), H = (e) => t(n(e))?.kind === "unique", U = class extends Error {
+	migrationId;
+	file;
+	cause;
+	_tag = "FileMigrationLedgerError";
+	constructor(e, t, n) {
+		super(H(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";
+	}
+}, W = /* @__PURE__ */ new Set([
+	"mysql",
+	"mariadb",
+	"mssql"
+]), G = (e, t) => W.has(e) ? t.filter((e) => e.length > 64) : [], K = class extends Error {
+	dialect;
+	migrationIds;
+	_tag = "MigrationIdTooLongError";
+	constructor(e, t) {
+		super(`migration id(s) longer than 64 characters cannot be recorded on ${e}: ` + t.map((e) => `${e} (${e.length})`).join(", ") + ". Nothing was applied. Rename the migration file and its `id` to at most 64 characters."), this.dialect = e, this.migrationIds = t, this.name = "MigrationIdTooLongError";
+	}
+}, q = (e, t, n) => S.gen(function* () {
+	let r = yield* h(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(S.mapError((e) => new U(t.migration.id, t.file, e)));
+}), J = (t) => {
+	for (let n of e(t)) if (n instanceof s) return n.reason;
+}, Y = (e, t, n) => S.gen(function* () {
+	let r = x(t), i = r.ctx, a = e.migration.up(i), s = !S.isEffect(a), c = yield* (S.isEffect(a) ? a : S.tryPromise({
+		try: () => a,
+		catch: (e) => e
+	})).pipe(S.as(void 0), S.catch((e) => {
+		let t = J(e);
+		return t === void 0 ? S.fail(e) : S.succeed(t);
+	}));
+	if (c === void 0) {
+		let t = yield* y(n);
+		if (t.length > 0) return yield* S.fail(new o(e.migration.id, t));
+	}
+	return {
+		skipped: c,
+		promiseForm: s,
+		absent: r.absent()
+	};
+}), X = (e, t, n, i, a, o, s, l) => S.gen(function* () {
+	let u = Date.now(), d = (/* @__PURE__ */ new Date()).toISOString(), m = p(e), h = `migrations:file:${n.migration.id}`, _ = (e) => ({
+		durationMs: Date.now() - u,
+		notes: e.skipped === void 0 ? n.migration.description : `skipped: ${e.skipped}`
+	});
+	if (n.migration.transactional !== !1 && !o) {
+		if (t.run === void 0) return yield* S.fail(/* @__PURE__ */ Error(`migration ${n.migration.id}: transactional: true needs a SQL-backed store`));
+		let o = m === "mysql" || m === "mariadb", u = `probe_${n.migration.id}_${Date.now().toString(36)}`;
+		o && (yield* g(e, m, s));
+		let p = (e) => e.executeUnprepared(`SELECT COUNT(*) AS n FROM \`${f}\` WHERE \`runId\` = ?`, [u], void 0), v = () => (l === void 0 ? S.scoped(S.flatMap(e.reserve, p)) : p(l)).pipe(S.map((e) => Number(e[0]?.n ?? 0) > 0)), y = yield* S.tryPromise({
+			try: () => t.transactional(async (t) => {
+				o && await t.run(e`INSERT INTO ${e(f)} (${e("id")}, ${e("runId")}, ${e("planFingerprint")}, ${e("opIndex")}, ${e("status")}, ${e("opKind")}, ${e("opTarget")}, ${e("payload")})
+              VALUES (${r("mop", u)}, ${u}, ${""}, ${0}, ${"pending"}, ${"probe"}, ${""}, ${"{}"})`);
+				let { ctx: s, expectations: c } = b({
+					sql: e,
+					store: t,
+					dialect: m,
+					migrationId: n.migration.id,
+					appliedAt: d
+				}), l = await t.run(Y(n, s, c)), p = o && await S.runPromise(v().pipe(S.provideService(w.SqlClient, e))), { durationMs: h, notes: g } = _(l);
+				return await t.run(q(e, n, {
+					env: i,
+					appliedBy: a,
+					durationMs: h,
+					appliedAtIso: d,
+					notes: p ? `${g} — transactional guarantee broken by the body (DDL on ${m})` : g
+				})), o && await t.run(e`DELETE FROM ${e(f)} WHERE ${e("runId")} = ${u}`), {
+					...l,
+					durationMs: h,
+					broken: p
+				};
+			}),
+			catch: (e) => e
+		});
+		return y.broken ? yield* S.fail(new c(n.migration.id, m)) : (y.skipped !== void 0 && (yield* S.logInfo(`migration ${n.migration.id} skipped: ${y.skipped}`).pipe(S.annotateLogs({ scope: h }))), {
+			durationMs: y.durationMs,
+			skip: y.skipped === void 0 ? void 0 : {
+				id: n.migration.id,
+				reason: y.skipped,
+				absent: y.absent
+			}
+		});
+	}
+	let { ctx: v, expectations: y } = b({
+		sql: e,
+		store: t,
+		dialect: m,
+		migrationId: n.migration.id,
+		appliedAt: d
+	}), x = yield* Y(n, v, y), { durationMs: C, notes: T } = _(x);
+	return x.promiseForm && x.skipped === void 0 && C < 2 && (yield* S.logWarning(`migration ${n.migration.id}: up() resolved in ${C}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(S.annotateLogs({ scope: h }))), x.skipped !== void 0 && (yield* S.logInfo(`migration ${n.migration.id} skipped: ${x.skipped}`).pipe(S.annotateLogs({ scope: h }))), yield* q(e, n, {
+		env: i,
+		appliedBy: a,
+		durationMs: C,
+		appliedAtIso: d,
+		notes: T
+	}), {
+		durationMs: C,
+		skip: x.skipped === void 0 ? void 0 : {
+			id: n.migration.id,
+			reason: x.skipped,
+			absent: x.absent
+		}
+	};
+}), Z = (e, t, n, r) => S.gen(function* () {
+	let i = yield* S.tryPromise({
+		try: () => P(D(t, "migrations")),
+		catch: (e) => e
+	});
+	if (i.length === 0) return {
+		pending: [],
+		alreadyApplied: [],
+		drifted: []
+	};
+	let a = yield* S.tryPromise({
+		try: () => I(i, r),
+		catch: (e) => e
+	});
+	if (a.length === 0) return {
+		pending: [],
+		alreadyApplied: [],
+		drifted: []
+	};
+	let o = new Map((yield* z(e)).map((e) => [e.id, e.hash])), s = B(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 ?? ""}`;
+		V.has(n) || (V.add(n), k.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
+	};
+}), Q = (e, t, n, r) => Z(e, t, n, r).pipe(S.map((e) => e.pending.map((e) => e.migration.id))), ee = (e, t, n) => Z(e, t, n).pipe(S.map((e) => e.pending.map((e) => ({
+	id: e.migration.id,
+	phase: e.migration.phase,
+	irreversible: l(e.migration.down)
+})))), te = (e, t) => Z(e, t).pipe(S.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);
+})), ne = (e, t) => S.gen(function* () {
+	let { pending: n, alreadyApplied: r } = yield* Z(e, t.projectRoot, t.phase), i = r.map((e) => e.migration.id);
+	if (n.length === 0) return {
+		applied: [],
+		skipped: i,
+		skips: []
+	};
+	let a = G(p(e), n.map((e) => e.migration.id));
+	if (a.length > 0) return yield* S.fail(new K(p(e), a));
+	yield* _(e, p(e), t.charset);
+	let o = yield* S.acquireUseRelease(d(e, { schema: t.lockSchema }), (r) => S.gen(function* () {
+		let i = new Set((yield* z(e)).map((e) => e.id)), a = n.filter((e) => !i.has(e.migration.id));
+		a.length < n.length && (yield* S.logInfo("file-based migrations applied by another process while this one waited for the migration lock").pipe(S.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* S.logInfo("file-based migration applying").pipe(S.annotateLogs({
+				scope: "voltro:migrate",
+				id: n.migration.id,
+				file: n.file,
+				phase: n.migration.phase
+			}));
+			let { durationMs: i, skip: a } = yield* X(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* S.logInfo("file-based migration applied").pipe(S.annotateLogs({
+				scope: "voltro:migrate",
+				id: n.migration.id,
+				durationMs: i,
+				phase: n.migration.phase
+			}));
+		}
+		return {
+			done: o,
+			skips: s
+		};
+	}), (e) => e.release.pipe(S.orDie));
+	return {
+		applied: o.done,
+		skipped: i,
+		skips: o.skips
+	};
+}), $ = (e, t) => e`
+    SELECT ${e("id")}
+    FROM ${e("_voltro_migration_plans")}
+    WHERE ${e("id")} = ${t} AND ${e("source")} = 'file'
+  `, re = (e, t) => S.gen(function* () {
+	if (!(yield* $(e, t.id))[0]) return yield* S.fail(/* @__PURE__ */ Error(`rollback: ${t.id} not found in _voltro_migration_plans (file source)`));
+	let n = yield* S.tryPromise({
+		try: () => P(D(t.projectRoot, "migrations")),
+		catch: (e) => e
+	}), r = (yield* S.tryPromise({
+		try: () => I(n),
+		catch: (e) => e
+	})).find((e) => e.migration.id === t.id);
+	if (!r) return yield* S.fail(/* @__PURE__ */ Error(`rollback: file for migration ${t.id} not found on disk under ${t.projectRoot}/migrations/`));
+	let i = l(r.migration.down);
+	return i === void 0 ? yield* S.acquireUseRelease(d(e, { schema: t.lockSchema }), () => S.gen(function* () {
+		if ((yield* $(e, t.id))[0] === void 0) return yield* S.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 } = b({
+			sql: e,
+			store: t.store,
+			dialect: p(e),
+			migrationId: t.id,
+			appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		t.beforeExecute !== void 0 && (yield* t.beforeExecute);
+		let a = r.migration.down(i);
+		S.isEffect(a) ? yield* a : yield* S.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(S.orDie)) : yield* S.fail(new a(t.id, i));
+});
+//#endregion
+export { i as FILE_MIGRATION_PATTERN, j as FRAMEWORK_MIGRATION_EDITS, U as FileMigrationLedgerError, K as MigrationIdTooLongError, M as acceptedBodyHashes, R as appliedFileMigrationIds, z as appliedFileMigrations, te as fileMigrationStatus, A as migrationBodyHash, Q as pendingFileMigrationIds, ee as pendingFileMigrationSummary, re as rollbackFileBasedMigration, ne as runFileBasedMigrations, G as unrecordableMigrationIds, P 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 };