@voltro/cli 0.11.3 → 0.12.0

package/dist/dbCommand-DNrkb58g.js

@@ -0,0 +1,862 @@
+import { G as e, a as t, i as n, m as r, n as i, r as a, t as o } from "./seedRunner-DZmhoqNt.js";
+import { a as s, n as c, t as l } from "./cliArgs-qdZSElM3.js";
+import { basename as u, join as d, relative as f, resolve as p } from "node:path";
+import { pathToFileURL as m } from "node:url";
+import { Effect as h } from "effect";
+import { createLogger as ee } from "@voltro/logger";
+import { promises as g, writeSync as te } from "node:fs";
+import { InMemoryDataStore as ne } from "@voltro/runtime";
+import { SqlClient as _ } from "@effect/sql";
+import { actorsTable as v, frameworkTables as y, isMigrationDefinition as b, registerCoreTables as re } from "@voltro/database";
+import { createHash as ie } from "node:crypto";
+import { applyPlan as x, applySchema as S, declaredSnapshot as ae, fingerprintSchema as C, ignoreTablesFromEnv as w, introspectSchema as oe, planMigrations as T, rollbackFileBasedMigration as E, runFileBasedMigrations as D, shortFingerprint as O, squashMigrationPlans as se } from "@voltro/database/sql";
+//#region src/cliError.ts
+var k = class extends Error {
+	isCliError = !0;
+	code;
+	constructor(e, t = 1) {
+		super(e), this.name = "CliError", this.code = t;
+	}
+}, ce = (e) => typeof e == "object" && !!e && e.isCliError === !0, A = /\.migration\.ts$/, j = async (e, t) => {
+	let n = [];
+	for (let r of e) {
+		let e;
+		try {
+			e = await import(m(r).href);
+		} catch (e) {
+			t.warn("migration: failed to import", { file: r }, e);
+			continue;
+		}
+		let i = (e.default && b(e.default) ? e.default : void 0) ?? Object.values(e).find(b);
+		if (!i) {
+			t.warn("migration: no defineMigration export", { file: r });
+			continue;
+		}
+		i.id !== u(r).replace(/\.migration\.ts$/, "") && t.warn("migration: id does not match filename — id wins for ordering, but rename the file for clarity", {
+			file: r,
+			idInFile: i.id,
+			idFromFile: u(r).replace(/\.migration\.ts$/, "")
+		});
+		let a = await g.readFile(r, "utf8").catch(() => ""), o = ie("sha256").update(a).digest("hex").slice(0, 16);
+		n.push({
+			file: r,
+			definition: i,
+			hash: o
+		});
+	}
+	return [...n].sort((e, t) => e.definition.id < t.definition.id ? -1 : 1);
+}, M = (e) => {
+	let t = (process.env.DB_DIALECT ?? "postgres").toLowerCase(), n = t === "memory" ? "postgres" : t;
+	return h.runPromise(S(y, n).pipe(h.provide(e)));
+}, N = (e) => h.runPromise(h.gen(function* () {
+	let e = yield* (yield* _.SqlClient)`SELECT id, status, hash, "appliedAt" FROM "_voltro_migrations"`.pipe(h.orElseSucceed(() => []));
+	return new Map(e.map((e) => [e.id, e]));
+}).pipe(h.provide(e))), P = (e, t) => h.runPromise(h.gen(function* () {
+	yield* (yield* _.SqlClient)`
+        INSERT INTO "_voltro_migrations"
+          (id, name, hash, status, "appliedAt", "durationMs", "errorMessage", "errorStack")
+        VALUES
+          (${t.id}, ${t.name}, ${t.hash}, ${t.status}, ${t.appliedAt}, ${t.durationMs}, ${t.errorMessage}, ${t.errorStack})
+        ON CONFLICT (id) DO UPDATE SET
+          name          = EXCLUDED.name,
+          hash          = EXCLUDED.hash,
+          status        = EXCLUDED.status,
+          "appliedAt"   = EXCLUDED."appliedAt",
+          "durationMs"  = EXCLUDED."durationMs",
+          "errorMessage"= EXCLUDED."errorMessage",
+          "errorStack"  = EXCLUDED."errorStack",
+          "updatedAt"   = now()
+      `;
+}).pipe(h.provide(e))), le = async (e, t, n) => {
+	if (e.length === 0) return {
+		applied: [],
+		failed: null,
+		skipped: []
+	};
+	await M(t);
+	let r = await N(t), i = [], a = [], o = null;
+	for (let s of e) {
+		let e = r.get(s.definition.id);
+		if (e && e.status === "applied") {
+			e.hash !== s.hash && n.warn("migration: applied migration has a different hash on disk", {
+				id: s.definition.id,
+				appliedHash: e.hash,
+				fileHash: s.hash
+			}), a.push({
+				migrationId: s.definition.id,
+				status: "skipped",
+				durationMs: 0,
+				steps: []
+			});
+			continue;
+		}
+		n.info("migration: applying", {
+			id: s.definition.id,
+			name: s.definition.name
+		});
+		let c = Date.now(), l = [];
+		await P(t, {
+			id: s.definition.id,
+			name: s.definition.name,
+			hash: s.hash,
+			status: "running",
+			appliedAt: null,
+			durationMs: null,
+			errorMessage: null,
+			errorStack: null
+		});
+		let u = !1;
+		for (let e of s.definition.steps) {
+			let n = Date.now();
+			try {
+				await h.runPromise(e.apply.pipe(h.provide(t))), l.push({
+					stepName: e.name,
+					status: "applied",
+					durationMs: Date.now() - n
+				});
+			} catch (r) {
+				let a = r, d = {
+					stepName: e.name,
+					status: "failed",
+					durationMs: Date.now() - n,
+					error: {
+						message: a.message,
+						...a.stack ? { stack: a.stack } : {}
+					}
+				};
+				l.push(d), u = !0;
+				let f = {
+					migrationId: s.definition.id,
+					status: "failed",
+					durationMs: Date.now() - c,
+					steps: l,
+					error: {
+						stepName: e.name,
+						message: a.message,
+						...a.stack ? { stack: a.stack } : {}
+					}
+				};
+				o = f, i.push(f), await P(t, {
+					id: s.definition.id,
+					name: s.definition.name,
+					hash: s.hash,
+					status: "failed",
+					appliedAt: null,
+					durationMs: Date.now() - c,
+					errorMessage: a.message,
+					errorStack: a.stack ?? null
+				});
+				break;
+			}
+		}
+		if (u) break;
+		i.push({
+			migrationId: s.definition.id,
+			status: "applied",
+			durationMs: Date.now() - c,
+			steps: l
+		}), await P(t, {
+			id: s.definition.id,
+			name: s.definition.name,
+			hash: s.hash,
+			status: "applied",
+			appliedAt: /* @__PURE__ */ new Date(),
+			durationMs: Date.now() - c,
+			errorMessage: null,
+			errorStack: null
+		}), n.info("migration: applied", {
+			id: s.definition.id,
+			durationMs: Date.now() - c,
+			stepCount: l.length
+		});
+	}
+	return {
+		applied: i.filter((e) => e.status === "applied"),
+		failed: o,
+		skipped: a
+	};
+}, ue = async (e, t, n, r = {}) => {
+	await M(t);
+	let i = await N(t), a = e.filter((e) => i.get(e.definition.id)?.status === "applied");
+	if (a.length === 0) return n.info("migration: nothing to roll back"), {
+		applied: [],
+		failed: null,
+		skipped: []
+	};
+	let o = [];
+	for (let e = a.length - 1; e >= 0; e--) {
+		let t = a[e];
+		if (o.push(t), !r.to && o.length === 1 || r.to && t.definition.id === r.to) break;
+	}
+	let s = [], c = null;
+	for (let e of o) {
+		n.info("migration: rolling back", { id: e.definition.id });
+		let r = Date.now(), i = [], a = !1;
+		for (let n = e.definition.steps.length - 1; n >= 0; n--) {
+			let o = e.definition.steps[n], s = Date.now();
+			try {
+				await h.runPromise(o.undo.pipe(h.provide(t))), i.push({
+					stepName: o.name,
+					status: "applied",
+					durationMs: Date.now() - s
+				});
+			} catch (t) {
+				let n = t;
+				i.push({
+					stepName: o.name,
+					status: "failed",
+					durationMs: Date.now() - s,
+					error: {
+						message: n.message,
+						...n.stack ? { stack: n.stack } : {}
+					}
+				}), a = !0, c = {
+					migrationId: e.definition.id,
+					status: "failed",
+					durationMs: Date.now() - r,
+					steps: i,
+					error: {
+						stepName: o.name,
+						message: n.message,
+						...n.stack ? { stack: n.stack } : {}
+					}
+				};
+				break;
+			}
+		}
+		if (a) break;
+		s.push({
+			migrationId: e.definition.id,
+			status: "applied",
+			durationMs: Date.now() - r,
+			steps: i
+		}), await P(t, {
+			id: e.definition.id,
+			name: e.definition.name,
+			hash: e.hash,
+			status: "reverted",
+			appliedAt: null,
+			durationMs: Date.now() - r,
+			errorMessage: null,
+			errorStack: null
+		}), n.info("migration: rolled back", { id: e.definition.id });
+	}
+	return {
+		applied: s,
+		failed: c,
+		skipped: []
+	};
+}, F = async (e, t) => {
+	await M(t);
+	let n = await N(t);
+	return e.map((e) => {
+		let t = n.get(e.definition.id);
+		return t ? {
+			id: e.definition.id,
+			name: e.definition.name,
+			status: t.status === "running" ? "failed" : t.status,
+			appliedAt: t.appliedAt,
+			hashMatches: t.hash === e.hash
+		} : {
+			id: e.definition.id,
+			name: e.definition.name,
+			status: "pending",
+			appliedAt: null,
+			hashMatches: !0
+		};
+	});
+}, I = (e) => {
+	if (!e.failed) return "";
+	let t = e.failed, n = [
+		`✗ Migration failed: ${t.migrationId} / step '${t.error?.stepName ?? "?"}'`,
+		`  Reason: ${t.error?.message ?? "unknown"}`,
+		"",
+		"Next steps:",
+		"  voltro db status                          # full migration timeline",
+		"  voltro db rollback                        # revert to last good state",
+		"  voltro db migrate                         # retry after fixing the cause",
+		""
+	];
+	return e.applied.length > 0 && n.unshift("", `(${e.applied.length} migration(s) applied successfully before the failure.)`), n.join("\n");
+}, L = ee({ scope: "voltro:db" }), de = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".turbo",
+	".vite",
+	".next",
+	".git"
+]), R = async (e, t) => {
+	let n = [], r = async (e) => {
+		let i = await g.readdir(e, { withFileTypes: !0 }).catch(() => []);
+		for (let a of i) {
+			if (de.has(a.name)) continue;
+			let i = d(e, a.name);
+			a.isDirectory() ? await r(i) : a.isFile() && t.test(a.name) && n.push(i);
+		}
+	};
+	return await r(e), n;
+}, z = (e) => p(e.find((e) => !e.startsWith("-")) ?? process.cwd()), B = () => {
+	let e = process.env.DB_MAX_CONNECTIONS ?? process.env.PG_MAX_CONNECTIONS, t = e !== void 0 && e !== "" ? Number(e) : NaN, n = Number.isInteger(t) && t > 0 ? { maxConnections: t } : {}, r = process.env.DB_SCHEMA, i = r && r.length > 0 ? { schema: r } : {}, a = process.env.DB_DIRECT_URL ?? process.env.DB_MIGRATE_URL ?? process.env.DB_URL ?? process.env.DB_PRIMARY_URL;
+	return a ? {
+		url: a,
+		...n,
+		...i
+	} : {
+		host: process.env.DB_HOST ?? process.env.PG_HOST ?? "localhost",
+		port: Number(process.env.DB_PORT ?? process.env.PG_PORT ?? 5432),
+		username: process.env.DB_USER ?? process.env.PG_USER ?? "app",
+		password: process.env.DB_PASSWORD ?? process.env.PG_PASSWORD ?? "app",
+		database: process.env.DB_DATABASE ?? process.env.PG_DATABASE ?? "app",
+		...n,
+		...i
+	};
+}, V = (e) => {
+	let t = e;
+	if (typeof t != "object" || !t) return !1;
+	if (t.code === "ERR_OUT_OF_RANGE" || t.cause?.code === "ERR_OUT_OF_RANGE") return !0;
+	let n = `${t.message ?? ""} ${t.cause?.message ?? ""} ${t.stack ?? ""}`;
+	return /ERR_OUT_OF_RANGE|out of range/i.test(n) && /pg-protocol|parseDataRow|buffer-reader|BufferReader/i.test(n);
+}, H = "Live-DB introspection got a corrupt / misaligned response from the database. This happens when `voltro db plan` / `apply` / `drift` / `migrate` runs through a connection POOLER (Supabase Supavisor / PgBouncer) on a LARGE schema — the pooler mis-frames a big catalog response. The introspection already batches by table to keep responses small; if a batch still trips it:\n  1. Lower the batch: set `VOLTRO_INTROSPECT_BATCH` to a smaller number of tables (default 20 — try 5 or 1). This keeps `db plan` on the normal pooler, no direct connection needed.\n  2. Or use a DIRECT (non-pooler) connection: set `DB_DIRECT_URL` (or `DB_MIGRATE_URL`) to the direct database URL — the runtime keeps `DB_URL`, so only the migration path is affected. (Supabase: direct = `db.<project-ref>.supabase.co` [IPv6-only on newer projects]; pooler = `aws-0-<region>.pooler.supabase.com`.)", U = () => {
+	let e = (process.env.DB_DIALECT ?? "postgres").toLowerCase();
+	if (e === "memory") throw new k("voltro db: subcommands require a real dialect, not DB_DIALECT=memory.");
+	return e;
+}, W = async () => (await e(U())).makeSqlLayer(B()), fe = async (e) => {
+	let t = z(e), n = e.includes("--dry-run"), r = await j(await R(t, A), L);
+	if (r.length === 0) return L.info("no migrations found", { root: t }), 0;
+	if (n) {
+		let e = /* @__PURE__ */ new Set();
+		try {
+			let t = await F(r, await W());
+			e = new Set(t.filter((e) => e.status === "applied").map((e) => e.id));
+		} catch {
+			L.warn("migrate --dry-run: could not read the migration ledger — showing ALL as pending");
+		}
+		let t = r.filter((t) => !e.has(t.definition.id));
+		if (t.length === 0) return L.info("migrate --dry-run: nothing pending — every migration is applied"), 0;
+		L.info(`migrate --dry-run: ${t.length} pending (nothing applied)`);
+		for (let e of t) console.log(`  pending  ${e.definition.id}`);
+		return 0;
+	}
+	let i = await le(r, await W(), L);
+	return i.failed ? (process.stderr.write(I(i) + "\n"), 1) : (L.info("migrate complete", {
+		applied: i.applied.length,
+		skipped: i.skipped.length
+	}), 0);
+}, pe = async (e) => {
+	let t = z(e), n = c(e, "--to"), r = await j(await R(t, A), L);
+	if (r.length === 0) return L.info("no migrations found", { root: t }), 0;
+	let i = await ue(r, await W(), L, n ? { to: n } : {});
+	return i.failed ? (process.stderr.write(I(i) + "\n"), 1) : (L.info("rollback complete", { reverted: i.applied.length }), 0);
+}, me = async (e) => {
+	let t = await j(await R(z(e), A), L);
+	if (t.length === 0) return console.log("no migrations found"), 0;
+	let n = await F(t, await W());
+	for (let e of n) {
+		let t = e.status === "applied" ? "✓" : e.status === "failed" ? "✗" : e.status === "reverted" ? "↩" : "·", n = e.hashMatches ? "" : " (hash drift!)", r = e.appliedAt ? ` @ ${e.appliedAt.toISOString()}` : "";
+		console.log(`  ${t} ${e.id}  [${e.status}]  ${e.name}${r}${n}`);
+	}
+	return 0;
+}, he = async (t) => {
+	let n = (c(t, "--store") ?? process.env.DB_DIALECT ?? "postgres").toLowerCase();
+	if (n === "memory") return L.warn("voltro db seed: using in-memory store (explicit opt-in via --store memory / DB_DIALECT=memory)"), L.warn("  rows written by this run will NOT persist beyond the process. set DB_DIALECT=postgres or unset to seed the real DB."), {
+		store: new ne(),
+		dispose: async () => {},
+		dialectId: "memory"
+	};
+	let r = await e(n);
+	L.info(`voltro db seed: target store=${r.id} — rows will persist`);
+	let i = await r.makeStore({
+		sqlLayer: r.makeSqlLayer(B()),
+		changeStrategy: "inline"
+	}), a = i;
+	return {
+		store: i,
+		dispose: async () => {
+			typeof a.close == "function" && await a.close(5e3);
+		},
+		dialectId: r.id
+	};
+}, ge = async (e) => {
+	let t = z(e), r = c(e, "--id"), s = c(e, "--lifecycle"), l = await i(await R(t, o), L);
+	if (l.length === 0) return L.info("no seeds found", { root: t }), 0;
+	let { store: u, dispose: d, dialectId: f } = await he(e);
+	try {
+		return r ? +((await n(l, r, u, L)).status === "failed") : +((await a((s ? l.filter((e) => e.definition.lifecycle === s) : l.filter((e) => e.definition.lifecycle === "boot")).map((e) => ({
+			...e,
+			definition: {
+				...e.definition,
+				lifecycle: "boot"
+			}
+		})), u, L, { force: !0 })).filter((e) => e.status === "failed").length > 0);
+	} finally {
+		await d().catch((e) => {
+			L.warn("voltro db seed: store dispose failed", { error: String(e) });
+		});
+	}
+}, _e = (e) => typeof e == "object" && !!e && "tableName" in e && "fields" in e && typeof e.tableName == "string", G = async (e) => {
+	let t = await R(e, r), n = [];
+	for (let r of t) {
+		let t;
+		try {
+			t = await import(m(r).href);
+		} catch (t) {
+			L.warn("db: failed to import schema file", {
+				file: f(e, r),
+				error: String(t)
+			});
+			continue;
+		}
+		for (let e of Object.values(t)) _e(e) && n.push(e);
+	}
+	return n;
+}, K = (e) => {
+	let t = new Map(e.map((e) => [e.tableName, e]));
+	t.has("actors") || t.set("actors", v);
+	let n = t.get("actors"), r = t.get("tenants");
+	return re({
+		actors: () => n,
+		...r === void 0 ? {} : { tenants: () => r }
+	}), [...t.values()];
+}, q = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = n.tableName;
+		e !== void 0 && !t.has(e) && t.set(e, n);
+	}
+	return [...t.values()];
+}, J = async (e, t) => h.runPromise(t.pipe(h.provide(e))), Y = async (e) => {
+	try {
+		return await J(e, _.SqlClient.pipe(h.flatMap(oe)));
+	} catch (e) {
+		let t = String(e?.message ?? e);
+		if (V(e) || /connection error/i.test(t)) {
+			let n = /* @__PURE__ */ Error(`${H}\n\nOriginal error: ${t}`);
+			throw n.cause = e, n;
+		}
+		throw e;
+	}
+}, ve = {
+	safe: "\x1B[32m✓\x1B[0m",
+	"needs-default": "\x1B[32m⊕\x1B[0m",
+	"needs-backfill": "\x1B[33m⊕\x1B[0m",
+	"needs-rename-annotation": "\x1B[33m⟲\x1B[0m",
+	lossy: "\x1B[31m✗\x1B[0m",
+	"online-required": "\x1B[36m◷\x1B[0m",
+	"multi-step": "\x1B[35m⇉\x1B[0m"
+}, ye = (e) => {
+	let t = e.op, n;
+	switch (t.kind) {
+		case "create-table":
+			n = `CREATE TABLE ${t.table} (${t.columns.length} cols)`;
+			break;
+		case "drop-table":
+			n = `DROP TABLE ${t.table}`;
+			break;
+		case "add-column":
+			n = `ALTER TABLE ${t.table} ADD COLUMN ${t.column.name} ${t.column.type}${t.column.nullable ? "" : " NOT NULL"}`;
+			break;
+		case "drop-column":
+			n = `ALTER TABLE ${t.table} DROP COLUMN ${t.column}`;
+			break;
+		case "rename-column":
+			n = `ALTER TABLE ${t.table} RENAME COLUMN ${t.from} TO ${t.to}`;
+			break;
+		case "alter-column-nullability":
+			n = `ALTER TABLE ${t.table} ALTER COLUMN ${t.column} ${t.toNullable ? "DROP NOT NULL" : "SET NOT NULL"}`;
+			break;
+		case "alter-column-type":
+			n = `ALTER TABLE ${t.table} ALTER COLUMN ${t.column} TYPE ${t.to}`;
+			break;
+		case "alter-column-default":
+			n = `ALTER TABLE ${t.table} ALTER COLUMN ${t.column} ${t.hasDefault ? `SET DEFAULT ${JSON.stringify(t.defaultValue)}` : "DROP DEFAULT"}`;
+			break;
+		case "add-index":
+			n = `CREATE INDEX ${t.index.name} ON ${t.table} (${t.index.columns.join(", ")})`;
+			break;
+		case "drop-index":
+			n = `DROP INDEX ${t.index}`;
+			break;
+		case "add-unique":
+			n = `ALTER TABLE ${t.table} ADD UNIQUE (${t.column})`;
+			break;
+		case "drop-unique":
+			n = `ALTER TABLE ${t.table} DROP UNIQUE (${t.column})`;
+			break;
+		case "add-unique-composite":
+			n = `ALTER TABLE ${t.table} ADD CONSTRAINT ${t.name} UNIQUE (${t.fields.join(", ")})`;
+			break;
+		case "drop-unique-composite":
+			n = `ALTER TABLE ${t.table} DROP CONSTRAINT ${t.name}`;
+			break;
+		case "add-foreign-key":
+			n = `ALTER TABLE ${t.table} ADD FK ${t.column} → ${t.targetTable}.${t.targetColumn}`;
+			break;
+		case "drop-foreign-key":
+			n = `ALTER TABLE ${t.table} DROP FK ${t.column}`;
+			break;
+		case "add-check":
+			n = `ALTER TABLE ${t.table} ADD CHECK (${t.column} IN (${t.values.join(", ")}))`;
+			break;
+		case "drop-check":
+			n = `ALTER TABLE ${t.table} DROP CHECK ${t.column}`;
+			break;
+	}
+	let r = ve[e.classification], i = e.reason ? `  # ${e.reason}` : "", a = e.blocked ? `\n    ! ${e.blocked.fix}` : "";
+	return `  ${r} ${n}${i}${a}`;
+}, X = (e) => {
+	let t = e.summary, n = e.operations.length;
+	if (console.log(`\nschema diff: ${n} operation${n === 1 ? "" : "s"}, ${t.blocked} blocked\n`), n === 0) {
+		console.log("  (schema is up to date)\n");
+		return;
+	}
+	for (let t of e.operations) console.log(ye(t));
+	console.log(), console.log(`  safe: ${t.safe}   needs-default: ${t.needsDefault}   needs-backfill: ${t.needsBackfill}`), console.log(`  rename: ${t.needsRenameAnnotation}   lossy: ${t.lossy}   blocked: ${t.blocked}`), console.log(`  fingerprint: ${e.fromFingerprint.slice(0, 16)} → ${e.toFingerprint.slice(0, 16)}\n`);
+}, Z = (e) => {
+	let t = c(e, "--online-after") ?? process.env.VOLTRO_ONLINE_THRESHOLD;
+	if (t === void 0) return;
+	let n = Number(t);
+	if (!Number.isInteger(n) || n < 0) throw Error(`--online-after / VOLTRO_ONLINE_THRESHOLD must be a non-negative integer, got "${t}"`);
+	return n;
+}, be = async (e) => {
+	let n = Z(e), r = z(e), i = await G(r);
+	if (i.length === 0) return L.warn("db plan: no schema files found", {
+		root: r,
+		hint: "looked for *.entity.ts / *.schema.ts / schema.ts"
+	}), 1;
+	let a = await t({ root: r }), o = K(q([
+		...i,
+		...y,
+		...a
+	])), s = c(e, "--against");
+	if (s) {
+		let t = s, r = c(e, "--token") ?? process.env.VOLTRO_INSPECT_TOKEN, i = { accept: "application/json" };
+		r && (i.authorization = `Bearer ${r}`);
+		try {
+			let e = t.endsWith("/_voltro/inspect/migrations") ? t : `${t.replace(/\/+$/, "")}/_voltro/inspect/migrations`, r = await fetch(e, { headers: i });
+			if (!r.ok) return L.error(`db plan --against: remote returned ${r.status}`, { url: e }), 1;
+			let a = (await r.json()).drift?.liveSnapshot;
+			if (!a) return L.error("db plan --against: remote inspect payload missing drift.liveSnapshot", { url: e }), 1;
+			let s = T({
+				declared: o,
+				live: a,
+				dialect: U(),
+				...w(),
+				...n === void 0 ? {} : { onlineAfter: n }
+			});
+			return console.log(`\n[--against ${e}] — diff vs remote live schema:\n`), X(s), s.summary.blocked > 0 ? 2 : 0;
+		} catch (e) {
+			return L.error(`db plan --against: ${e.message}`), 1;
+		}
+	}
+	let l = T({
+		declared: o,
+		live: await Y(await W()),
+		dialect: U(),
+		...w(),
+		...n === void 0 ? {} : { onlineAfter: n }
+	});
+	return e.includes("--json") ? (te(1, `${JSON.stringify(l, null, 2)}\n`), l.summary.blocked > 0 ? 2 : 0) : (X(l), l.summary.blocked > 0 ? 2 : 0);
+}, xe = async (e, n, r) => {
+	let i;
+	try {
+		let t = await g.readFile(p(e), "utf8");
+		i = JSON.parse(t);
+	} catch (t) {
+		return L.error(`db apply --plan: cannot read/parse plan file '${e}': ${t.message}`), 1;
+	}
+	if (!Array.isArray(i?.operations) || typeof i?.fromFingerprint != "string" || typeof i?.toFingerprint != "string") return L.error(`db apply --plan: '${e}' is not a valid plan file (expected the output of \`voltro db plan --json\`).`), 1;
+	let a = await G(r);
+	if (a.length === 0) return L.warn("db apply --plan: no schema files found", { root: r }), 1;
+	let o = await t({ root: r }), s = K(q([
+		...a,
+		...y,
+		...o
+	])), l = await W();
+	await J(l, S(y, U()));
+	let u = T({
+		declared: s,
+		live: await Y(l),
+		dialect: U(),
+		...w()
+	});
+	if (u.fromFingerprint !== i.fromFingerprint) return L.error("db apply --plan: refusing — the live schema has drifted since this plan was generated."), console.error(`  plan.from=${i.fromFingerprint.slice(0, 16)}  live=${u.fromFingerprint.slice(0, 16)}`), console.error("  Regenerate against the current live schema: `voltro db plan --json > plan.json`"), 2;
+	if (u.toFingerprint !== i.toFingerprint) return L.error("db apply --plan: refusing — the declared schema differs from what this plan targets."), console.error(`  plan.to=${i.toFingerprint.slice(0, 16)}  declared=${u.toFingerprint.slice(0, 16)}`), console.error("  The schema files changed since the plan was generated. Regenerate the plan."), 2;
+	if (u.summary.blocked > 0) return X(u), L.error(`db apply --plan: refusing — ${u.summary.blocked} blocked operation(s). See the fix hints above.`), 2;
+	if (u.operations.length === 0) return L.info("db apply --plan: schema is up to date — nothing to apply"), 0;
+	X(u);
+	let d = (process.env.NODE_ENV ?? "dev").toLowerCase(), f = c(n, "--note"), m = await J(l, _.SqlClient.pipe(h.flatMap((e) => x(e, u, {
+		declared: s,
+		appliedBy: process.env.USER ? `cli:${process.env.USER}` : "cli:plan",
+		environment: d === "production" ? "prod" : d === "staging" ? "staging" : "dev",
+		source: "file",
+		...f ? { notes: f } : {}
+	}))));
+	return L.info(`db apply --plan: applied ${u.operations.length} op(s) in ${m.durationMs}ms`, {
+		id: m.id,
+		fingerprint: m.fingerprint.slice(0, 16)
+	}), 0;
+}, Se = async (e) => {
+	let n = z(e), r = Z(e), i = c(e, "--plan");
+	if (i) return xe(i, e, n);
+	if ((process.env.NODE_ENV ?? "").toLowerCase() === "production") return L.error("voltro db apply: refusing — auto-apply on prod is not allowed."), console.error("In production, schema changes go through `voltro db plan --json > plan.json`"), console.error("then `voltro db apply --plan plan.json` as an explicit step in your deploy pipeline."), 3;
+	let a = await G(n);
+	if (a.length === 0) return L.warn("db apply: no schema files found", { root: n }), 1;
+	let o = await t({ root: n }), s = K(q([
+		...a,
+		...y,
+		...o
+	])), l = await W();
+	await J(l, S(y, U()));
+	let u = T({
+		declared: s,
+		live: await Y(l),
+		dialect: U(),
+		...w(),
+		...r === void 0 ? {} : { onlineAfter: r }
+	});
+	if (X(u), u.summary.blocked > 0) return L.error(`db apply: refusing — ${u.summary.blocked} blocked operation(s). See the fix hints above.`), 2;
+	if (u.operations.length === 0) return L.info("db apply: schema is up to date — nothing to apply"), 0;
+	let d = c(e, "--note"), f = await J(l, _.SqlClient.pipe(h.flatMap((e) => x(e, u, {
+		declared: s,
+		appliedBy: process.env.USER ? `cli:${process.env.USER}` : "cli:user",
+		environment: (process.env.NODE_ENV ?? "dev").toLowerCase() === "staging" ? "staging" : "dev",
+		source: "auto-diff",
+		...d ? { notes: d } : {}
+	}))));
+	return L.info(`db apply: applied ${u.operations.length} op(s) in ${f.durationMs}ms`, {
+		id: f.id,
+		fingerprint: f.fingerprint.slice(0, 16)
+	}), 0;
+}, Ce = async (e) => {
+	let t = Math.max(1, Number(c(e, "--limit") ?? "20")), n = await J(await W(), _.SqlClient.pipe(h.flatMap((e) => e`
+        SELECT ${e("id")}, ${e("fingerprint")}, ${e("operations")}::text AS ${e("operations")},
+               ${e("appliedBy")}, ${e("environment")}, ${e("source")},
+               ${e("durationMs")}, ${e("notes")}, ${e("appliedAt")}::text AS ${e("appliedAt")}
+        FROM ${e("_voltro_migration_plans")}
+        ORDER BY ${e("appliedAt")} DESC
+        LIMIT ${t}
+      `)));
+	if (n.length === 0) return L.info("db plans: no planner-based migrations applied yet"), console.log("Run `voltro db apply` after a schema change to start a plan history."), 0;
+	console.log(`\n${n.length} plan${n.length === 1 ? "" : "s"} (newest first):\n`);
+	for (let e of n) {
+		let t = 0;
+		try {
+			t = JSON.parse(e.operations).length;
+		} catch {}
+		console.log(`  ${e.id}  fp=${O(e.fingerprint)}  env=${e.environment}  src=${e.source}  ${t} op(s)  ${e.durationMs}ms  ${e.appliedAt}  by=${e.appliedBy}`), e.notes && console.log(`    [2mnote: ${e.notes}[0m`);
+	}
+	return console.log(), 0;
+}, we = async (e) => {
+	let t = e[0];
+	if (!t) return console.error("voltro db restore-snapshot <plan-id>"), console.error("  Renames soft-dropped columns/tables from a plan back to their original names."), console.error("  Requires the plan to have been applied with VOLTRO_SOFT_DROP=1."), 2;
+	let n = await W(), r = await J(n, _.SqlClient.pipe(h.flatMap((e) => e`SELECT ${e("id")}, ${e("operations")}::text AS ${e("operations")}
+                   FROM ${e("_voltro_migration_plans")} WHERE ${e("id")} = ${t}`)));
+	if (r.length === 0) return console.error(`restore-snapshot: plan '${t}' not found`), 1;
+	let i;
+	try {
+		i = JSON.parse(r[0].operations);
+	} catch {
+		return console.error(`restore-snapshot: plan '${t}' has corrupted operations JSON`), 1;
+	}
+	let a = [];
+	for (let e of i) e.op?.kind === "drop-column" && e.op.table && e.op.column && a.push({
+		table: e.op.table,
+		column: e.op.column
+	});
+	let o = [];
+	for (let e of i) e.op?.kind === "drop-table" && e.op.table && o.push({ table: e.op.table });
+	if (a.length === 0 && o.length === 0) return console.log(`restore-snapshot: plan '${t}' has no drop-column / drop-table ops to restore`), 0;
+	let s = 0;
+	for (let e of a) {
+		let t = await J(n, _.SqlClient.pipe(h.flatMap((t) => t`
+          SELECT column_name FROM information_schema.columns
+          WHERE table_schema = 'public'
+            AND table_name   = ${e.table}
+            AND column_name LIKE ${e.column + "__dropped_%"}
+          ORDER BY column_name DESC LIMIT 1
+        `)));
+		if (t.length === 0) {
+			console.warn(`restore-snapshot: no snapshot found for ${e.table}.${e.column} — was the plan applied with VOLTRO_SOFT_DROP=1?`);
+			continue;
+		}
+		let r = t[0].column_name;
+		await J(n, _.SqlClient.pipe(h.flatMap((t) => t.unsafe(`ALTER TABLE "${e.table}" RENAME COLUMN "${r}" TO "${e.column}"`)))), s++, console.log(`  ↩ restored ${e.table}.${e.column} (from ${r})`);
+	}
+	let c = 0;
+	for (let e of o) {
+		let t = await J(n, _.SqlClient.pipe(h.flatMap((t) => t`
+          SELECT table_name FROM information_schema.tables
+          WHERE table_schema = 'public'
+            AND table_name LIKE ${e.table + "__dropped_%"}
+          ORDER BY table_name DESC LIMIT 1
+        `)));
+		if (t.length === 0) {
+			console.warn(`restore-snapshot: no snapshot found for table ${e.table} — was the plan applied with VOLTRO_SOFT_DROP=1?`);
+			continue;
+		}
+		let r = t[0].table_name;
+		await J(n, _.SqlClient.pipe(h.flatMap((t) => t.unsafe(`ALTER TABLE "${r}" RENAME TO "${e.table}"`)))), c++, console.log(`  ↩ restored table ${e.table} (from ${r})`);
+	}
+	return console.log(`\n✓ restored ${s} column(s) + ${c} table(s) from plan '${t}'\n`), 0;
+}, Te = async (e) => {
+	let t = c(e, "--before");
+	if (!t) return console.error("voltro db gc-snapshots --before <date> [--dry-run]"), console.error("  Permanently drops soft-dropped columns/tables (<name>__dropped_<ts>) older than <date>."), console.error("  <date> is ISO — e.g. 2026-01-01 or 2026-01-01T00:00:00Z. NOT reversible."), 2;
+	let n = t.replace(/[^0-9]/g, "");
+	if (n.length < 8) return console.error(`gc-snapshots: --before must be at least a full date (YYYY-MM-DD), got "${t}"`), 2;
+	let r = (n + "00000000000000").slice(0, 14), i = e.includes("--dry-run"), a = await W(), o = await J(a, _.SqlClient.pipe(h.flatMap((e) => e`
+        SELECT table_name, column_name FROM information_schema.columns
+        WHERE table_schema = 'public' AND column_name LIKE ${"%__dropped_%"}
+      `))), s = await J(a, _.SqlClient.pipe(h.flatMap((e) => e`
+        SELECT table_name FROM information_schema.tables
+        WHERE table_schema = 'public' AND table_name LIKE ${"%__dropped_%"}
+      `))), l = (e) => {
+		let t = /__dropped_(\d{14})$/.exec(e);
+		return t ? t[1] : null;
+	}, u = 0;
+	for (let e of o) {
+		let t = l(e.column_name);
+		t === null || t >= r || (console.log(`  ${i ? "[dry-run] would drop column" : "dropping column"} ${e.table_name}.${e.column_name}`), i || await J(a, _.SqlClient.pipe(h.flatMap((t) => t.unsafe(`ALTER TABLE "${e.table_name}" DROP COLUMN "${e.column_name}"`)))), u++);
+	}
+	for (let e of s) {
+		let t = l(e.table_name);
+		t === null || t >= r || (console.log(`  ${i ? "[dry-run] would drop table" : "dropping table"} ${e.table_name}`), i || await J(a, _.SqlClient.pipe(h.flatMap((t) => t.unsafe(`DROP TABLE "${e.table_name}"`)))), u++);
+	}
+	return console.log(`\n${i ? `[dry-run] ${u} snapshot(s) would be dropped` : `✓ dropped ${u} snapshot(s)`} (older than ${r}).\n`), 0;
+}, Q = async (e) => {
+	let n = c(e, "--before");
+	if (!n) return console.error("voltro db squash --before <iso-date> [--note \"<text>\"]"), 2;
+	let r = n;
+	if (Number.isNaN(new Date(r).getTime())) return console.error(`voltro db squash: --before '${r}' is not a valid ISO date`), 2;
+	let i = c(e, "--note"), a = z(e), o = await G(a);
+	if (o.length === 0) return L.warn("db squash: no schema files found", { root: a }), 1;
+	let s = await t({ root: a }), l = C(ae(K(q([
+		...o,
+		...y,
+		...s
+	])))), u = await W();
+	try {
+		let e = await J(u, se({
+			before: r,
+			fingerprint: l,
+			appliedBy: process.env.USER ?? "cli",
+			environment: process.env.NODE_ENV === "production" ? "prod" : "dev",
+			...i === void 0 ? {} : { note: i }
+		}));
+		return console.log(`\n✓ squashed ${e.squashedCount} migration plan(s)\n  snapshot id: ${e.snapshotId}\n  fingerprint: ${O(e.snapshotFingerprint)}\n`), 0;
+	} catch (e) {
+		return console.error(`squash refused: ${e.message}`), 1;
+	}
+}, Ee = async (e) => {
+	let t = await W(), n = await J(t, _.SqlClient.pipe(h.flatMap((e) => e`
+        SELECT ${e("id")}, ${e("fingerprint")}, ${e("appliedAt")}::text AS ${e("appliedAt")}
+        FROM ${e("_voltro_migration_plans")}
+        ORDER BY ${e("appliedAt")} DESC
+        LIMIT 1
+      `))), r = C({ tables: (await Y(t)).tables.filter((e) => !e.name.startsWith("_voltro_")) });
+	if (n.length === 0) return L.info("db drift: no _voltro_migration_plans rows yet"), console.log(`live user-schema fingerprint: ${O(r)}`), console.log("No baseline to compare against. Run `voltro db apply` to lock in the current state."), 0;
+	let i = n[0];
+	return i.fingerprint === r ? (L.info(`db drift: live matches last applied (${O(r)})`), 0) : (L.error("db drift: live schema DIVERGED from last applied state"), console.log(), console.log(`  last applied:  ${O(i.fingerprint)}  at ${i.appliedAt}  (${i.id})`), console.log(`  live now:      ${O(r)}`), console.log(), console.log("Probable causes:"), console.log("  - manual DDL ran out-of-band (psql session, another tool)"), console.log("  - someone applied a plan but the row never made it into _voltro_migration_plans"), console.log(), console.log("To reconcile, run `voltro db plan` to see what your code expects vs the live DB."), 4);
+}, De = async (e) => {
+	let t = z(e), n = await W(), r = (process.env.NODE_ENV ?? "").toLowerCase() === "production" ? "prod" : (process.env.NODE_ENV ?? "").toLowerCase() === "staging" ? "staging" : "dev";
+	await J(n, S(y, U()));
+	let i = await J(n, _.SqlClient.pipe(h.flatMap((e) => D(e, {
+		projectRoot: t,
+		env: r,
+		appliedBy: process.env.USER ? `cli:${process.env.USER}` : "cli:user"
+	}))));
+	return i.applied.length === 0 ? (L.info(`db files: no pending file-based migrations (${i.skipped.length} already applied)`), 0) : (L.info(`db files: applied ${i.applied.length} migration(s)`, {
+		applied: i.applied.map((e) => `${e.id} (${e.durationMs}ms)`),
+		skipped: i.skipped.length
+	}), 0);
+}, Oe = async (e) => {
+	let t = z(e), n = e.find((e) => !e.startsWith("--"));
+	if (!n) return L.error("voltro db rollback-file <migration-id>"), 2;
+	if ((process.env.NODE_ENV ?? "").toLowerCase() === "production") return L.error("voltro db rollback-file: refusing on prod — schema rollback runs as an explicit deploy step."), 3;
+	let r = await J(await W(), _.SqlClient.pipe(h.flatMap((e) => E(e, {
+		projectRoot: t,
+		id: n
+	}))));
+	return L.info(`db rollback-file: rolled back ${r.id} in ${r.durationMs}ms`), 0;
+}, ke = () => {
+	let e = /* @__PURE__ */ new Date();
+	return [
+		e.getUTCFullYear(),
+		String(e.getUTCMonth() + 1).padStart(2, "0"),
+		String(e.getUTCDate()).padStart(2, "0"),
+		String(e.getUTCHours()).padStart(2, "0"),
+		String(e.getUTCMinutes()).padStart(2, "0"),
+		String(e.getUTCSeconds()).padStart(2, "0")
+	].join("");
+}, Ae = (e) => e.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "migration", je = (e, t) => `import { defineMigration, SqlClient } from '@voltro/database'
+import { Effect } from 'effect'
+
+// A hand-written migration. Reach for this when the DECLARATIVE differ can't
+// express the change — a data backfill, a value re-encode, a table rename that
+// must preserve rows. For plain schema shape changes (add a column/table/index)
+// you usually DON'T need this: edit the entity + run \`voltro db apply\`, which
+// diffs your declared schema against the live DB automatically.
+//
+// \`voltro db migrate\` applies every pending *.migration.ts in timestamp order
+// and records each in \`_voltro_migrations\`; \`voltro db rollback\` runs \`undo\`.
+export default defineMigration({
+  id: '${e}',
+  name: '${t}',
+  steps: ({ step }) => [
+    step('${t}', {
+      // Forward migration. Runs inside a transaction; the SqlClient is provided.
+      apply: Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient
+        // TODO: your change, e.g.
+        // yield* sql\`ALTER TABLE widgets ADD COLUMN archived boolean NOT NULL DEFAULT false\`
+      }),
+      // The inverse — what \`voltro db rollback\` runs to undo the step. Keep it
+      // an exact reverse so a rollback restores the prior state.
+      undo: Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient
+        // TODO: reverse the apply above, e.g.
+        // yield* sql\`ALTER TABLE widgets DROP COLUMN archived\`
+      }),
+    }),
+  ],
+})
+`, $ = {
+	plan: be,
+	apply: Se,
+	plans: Ce,
+	drift: Ee,
+	files: De,
+	"rollback-file": Oe,
+	migrate: fe,
+	rollback: pe,
+	status: me,
+	seed: ge,
+	generate: async (e) => {
+		let { value: t, rest: n } = s(e, "--root"), { value: r, rest: i } = s(n, "--name"), a = t ? p(t) : process.cwd(), o = Ae(r ?? l(i) ?? "migration"), c = `${ke()}_${o}`, u = d(a, "migrations"), m = d(u, `${c}.migration.ts`);
+		return await g.mkdir(u, { recursive: !0 }), await g.writeFile(m, je(c, o), "utf8"), L.info(`created ${f(a, m)}`), console.error("Fill in the apply/undo steps, then run `voltro db migrate` (rollback with `voltro db rollback`)."), console.error("For a plain schema shape change you may not need this — `voltro db apply` diffs declared vs live."), 0;
+	},
+	squash: Q,
+	"restore-snapshot": we,
+	"gc-snapshots": Te
+}, Me = async (e) => {
+	let [t, ...n] = e;
+	if (!t) {
+		console.error("voltro db <subcommand> [args]"), console.error("subcommands:");
+		for (let e of Object.keys($)) console.error(`  ${e}`);
+		return 1;
+	}
+	let r = $[t];
+	if (!r) return console.error(`voltro db: unknown subcommand '${t}'`), 2;
+	(process.env.DB_DIRECT_URL !== void 0 || process.env.DB_MIGRATE_URL !== void 0) && L.info("using a DIRECT (non-pooler) connection for the db-command path (DB_DIRECT_URL/DB_MIGRATE_URL set)");
+	let i = (e) => {
+		V(e) ? L.error(H) : console.error(e), process.exit(1);
+	};
+	process.on("uncaughtException", i);
+	try {
+		return await r(n);
+	} finally {
+		process.off("uncaughtException", i);
+	}
+};
+//#endregion
+export { V as a, ce as c, K as i, B as n, Me as o, G as r, k as s, H as t };