@voltro/cli 0.33.0 → 0.34.0

package/dist/seedRunner-TFHHiToI.js

@@ -0,0 +1,329 @@
+import { n as e } from "./appModuleLoader-C9r9mxZt.js";
+import { promises as t } from "node:fs";
+import { Cause as n, Effect as r } from "effect";
+import { SqlClient as i } from "@effect/sql";
+import { DEFAULT_CDC_CHANNEL as a, VOLTRO_MIGRATION_LOCK_KEY as o, detectReactiveTriggerDrift as s, reactiveTriggerRepairSql as c } from "@voltro/database/sql";
+import { _voltroSeedsTable as l, and as u, eq as d, generateId as f, isSeedDefinition as p, setSchemaChangeSeedHook as m, setTenantCreateSeedHook as h } from "@voltro/database";
+import { defineSchedule as g } from "@voltro/runtime";
+import { createHash as _ } from "node:crypto";
+//#region src/reactiveTriggerBoot.ts
+var v = (e, t = process.env) => {
+	let n = (t.VOLTRO_REACTIVE_TRIGGERS ?? "").trim().toLowerCase(), r = n === "repair" || n === "report" || n === "off" ? n : e ?? "repair";
+	return r === "repair" && t.VOLTRO_AUTO_MIGRATE === "0" ? "report" : r;
+}, y = (e, t, n = a) => r.map(s(e, t, n), (e) => ({
+	drift: e,
+	statements: c({
+		tables: t,
+		dialect: "postgres",
+		channel: n,
+		...e
+	})
+})), b = (e, t) => r.gen(function* () {
+	let n = yield* i.SqlClient, { drift: s, statements: c } = yield* y(n, e, t.channel ?? a), l = {
+		missing: s.missing.length,
+		stale: s.stale.length,
+		statements: c.length
+	};
+	return c.length === 0 ? {
+		kind: "clean",
+		...l
+	} : t.mode === "report" ? {
+		kind: "reported",
+		...l
+	} : (yield* n`
+      SELECT pg_try_advisory_lock(${o.toString()}::bigint) AS got`)[0]?.got === !0 ? yield* r.gen(function* () {
+		for (let e of c) yield* n.unsafe(e);
+		return {
+			kind: "repaired",
+			...l
+		};
+	}).pipe(r.ensuring(n`SELECT pg_advisory_unlock(${o.toString()}::bigint)`.pipe(r.catchAll(() => r.void)))) : {
+		kind: "lock-held",
+		...l
+	};
+}).pipe(r.catchAllCause((e) => r.succeed({
+	kind: "failed",
+	missing: 0,
+	stale: 0,
+	statements: 0,
+	detail: n.pretty(e)
+}))), x = async (e) => {
+	let t = {
+		kind: "skipped",
+		missing: 0,
+		stale: 0,
+		statements: 0
+	};
+	if (e.dialectId !== "postgres" || e.mode === "off" || e.tables.length === 0) return t;
+	let n = await e.makeLayer(), i = await r.runPromise(b(e.tables, {
+		mode: e.mode,
+		...e.channel === void 0 ? {} : { channel: e.channel }
+	}).pipe(r.provide(n))).catch((e) => ({
+		kind: "failed",
+		missing: 0,
+		stale: 0,
+		statements: 0,
+		detail: e instanceof Error ? e.message : String(e)
+	}));
+	switch (i.kind) {
+		case "repaired":
+			e.log.info(`reactive triggers: converged at boot — installed ${i.missing}, removed ${i.stale} (${i.statements} statement(s))`, {
+				missing: i.missing,
+				stale: i.stale
+			});
+			break;
+		case "reported":
+			e.log.warn(`reactive triggers: ${i.missing} table(s) have NO change trigger and ${i.stale} carry a stale one. Writes to them do not reach another instance's subscribers — invisible on a single instance, which is why this surfaces only once you scale out. This boot is in report-only mode (VOLTRO_REACTIVE_TRIGGERS=report, or VOLTRO_AUTO_MIGRATE=0); run \`voltro db apply\` to close it.`, {
+				missing: i.missing,
+				stale: i.stale
+			});
+			break;
+		case "lock-held":
+			e.log.info("reactive triggers: drift found; another instance (or a `voltro db apply`) holds the migration lock and is converging it. Not waiting — a boot that queues on a lock is worse than a boot that re-checks on the next start.", {
+				missing: i.missing,
+				stale: i.stale
+			});
+			break;
+		case "failed":
+			e.log.warn("reactive triggers: the boot check could not run — reactivity may be silently degraded. Run `voltro db apply` to converge them explicitly.", { error: i.detail });
+			break;
+		default: break;
+	}
+	return i;
+}, S = async (n, r) => {
+	let i = [];
+	for (let a of n) {
+		let n;
+		try {
+			n = await e(a);
+		} catch (e) {
+			r.warn("seed: failed to import", { file: a }, e);
+			continue;
+		}
+		let o = (n.default && p(n.default) ? n.default : void 0) ?? Object.values(n).find(p);
+		if (!o) {
+			r.warn("seed: no defineSeed export", { file: a });
+			continue;
+		}
+		let s = await t.readFile(a, "utf8").catch(() => ""), c = o.fingerprint ? o.fingerprint({ src: s }) : _("sha256").update(s).digest("hex").slice(0, 16);
+		i.push({
+			file: a,
+			definition: o,
+			fingerprint: c
+		});
+	}
+	return i;
+}, C = (e) => ({
+	query: (t) => e.query({
+		table: t.table,
+		order: t.order ?? [],
+		...t.predicate ? { predicate: t.predicate } : {},
+		...t.take === void 0 ? {} : { take: t.take },
+		...t.skip === void 0 ? {} : { skip: t.skip },
+		...t.projection ? { projection: t.projection } : {}
+	}),
+	insert: (t, n) => e.insert(t, n),
+	insertIgnore: (t, n, r) => e.insertIgnore(t, n, r),
+	update: (t, n, r) => e.update(t, n, r),
+	delete: (t, n) => e.delete(t, n)
+}), w = (e) => async (t, n, r) => {
+	let i = Object.keys(n);
+	if (i.length === 0) throw Error("upsertByUnique: matchFields must have at least one key");
+	let a;
+	if (i.length === 1) {
+		let e = i[0];
+		a = d(e, n[e]);
+	} else a = u(...i.map((e) => d(e, n[e])));
+	let o = (await e.query({
+		table: t,
+		order: [],
+		predicate: a
+	}))[0];
+	if (o) {
+		let n = o.id;
+		return {
+			row: await e.update(t, n, r) ?? o,
+			created: !1
+		};
+	}
+	return {
+		row: await e.insert(t, r),
+		created: !0
+	};
+}, T = (e, t) => {
+	let n = w(e);
+	return {
+		store: C(e),
+		upsertByUnique: n,
+		progress: (e, n) => t.debug("seed progress", {
+			done: e,
+			total: n
+		})
+	};
+}, E = "_voltro_seeds", D = () => {
+	let e = l.fields.id?.idScheme;
+	return (e ? f(e, E) : null) ?? f({
+		kind: "typeid",
+		prefix: "seed"
+	}, E);
+}, O = {
+	isUnchanged: () => !1,
+	record: async () => {}
+}, k = (e, t) => `${e.definition.id}${t}`, A = async (e, t, n = "") => {
+	let r;
+	try {
+		r = await e.query({
+			table: E,
+			order: [],
+			predicate: void 0,
+			projection: void 0,
+			skip: void 0,
+			take: void 0
+		});
+	} catch (e) {
+		return t.warn("seeds: ledger unreadable — nothing will be skipped and nothing recorded", {
+			table: E,
+			error: String(e)
+		}), O;
+	}
+	let i = new Map(r.map((e) => [e.name, e]));
+	return {
+		isUnchanged: (e) => {
+			let t = i.get(k(e, n));
+			return t?.lastRunStatus === "succeeded" && t.fingerprint === e.fingerprint;
+		},
+		record: async (r, a) => {
+			let o = {
+				name: k(r, n),
+				lifecycle: r.definition.lifecycle,
+				fingerprint: r.fingerprint,
+				lastRunStatus: a.status,
+				lastRunAt: /* @__PURE__ */ new Date(),
+				lastRunDurationMs: a.durationMs,
+				lastRunRowsTouched: a.rowsTouched,
+				lastError: a.error?.message ?? null
+			};
+			try {
+				let t = i.get(k(r, n));
+				t ? await e.update(E, t.id, o) : await e.insert(E, {
+					id: D(),
+					...o
+				});
+			} catch (e) {
+				t.warn("seeds: could not record the ledger row — this seed will re-run on every boot", {
+					seedId: r.definition.id,
+					table: E,
+					error: String(e)
+				});
+			}
+		}
+	};
+}, j = async (e, t, n) => {
+	let r = Date.now(), i = T(t, n), a = 0;
+	for (let t of e.definition.steps) try {
+		let e = await t.body(i);
+		e && typeof e.rowsTouched == "number" && (a += e.rowsTouched);
+	} catch (i) {
+		let o = i;
+		return n.error(`seed "${e.definition.id}" failed at step "${t.name}"`, {
+			seedId: e.definition.id,
+			step: t.name
+		}, o), {
+			seedId: e.definition.id,
+			status: "failed",
+			durationMs: Date.now() - r,
+			rowsTouched: a,
+			error: {
+				message: o.message,
+				...o.stack ? { stack: o.stack } : {},
+				stepName: t.name
+			}
+		};
+	}
+	return {
+		seedId: e.definition.id,
+		status: "succeeded",
+		durationMs: Date.now() - r,
+		rowsTouched: a
+	};
+}, M = async (e, t, n, r = {}) => {
+	let i = e.filter((e) => e.definition.lifecycle === "boot");
+	if (i.length === 0) return [];
+	let a = await A(t, n), o = [], s = 0;
+	for (let e of i) {
+		if (!r.force && a.isUnchanged(e)) {
+			s++, n.debug(`seed "${e.definition.id}" unchanged — skipped`, { fingerprint: e.fingerprint }), o.push({
+				seedId: e.definition.id,
+				status: "skipped",
+				durationMs: 0,
+				rowsTouched: 0
+			});
+			continue;
+		}
+		let i = await j(e, t, n);
+		i.status === "succeeded" && n.info(`seed "${i.seedId}" applied`, {
+			durationMs: i.durationMs,
+			rowsTouched: i.rowsTouched,
+			fingerprint: e.fingerprint
+		}), await a.record(e, i), o.push(i);
+	}
+	return n.info("seeds: boot-lifecycle pass complete", {
+		ran: o.length - s,
+		skipped: s,
+		...r.force ? { forced: !0 } : {}
+	}), o;
+}, N = async (e, t, n, r) => {
+	let i = e.find((e) => e.definition.id === t);
+	if (!i) throw Error(`seed not found: ${t}`);
+	let a = await j(i, n, r);
+	return await (await A(n, r)).record(i, a), a;
+}, P = async (e, t, n, r) => {
+	let i = e.filter((e) => e.definition.lifecycle === "onTenantCreate");
+	if (i.length === 0) return [];
+	let a = n.withNamespace?.(t);
+	if (a == null) throw Error(`onTenantCreate seeds (${i.map((e) => e.definition.id).join(", ")}) cannot run for namespace "${t}": this store has no namespace scoping, so the only place to write them would be the SHARED tables — one tenant's fixture in every tenant's data. Refusing. Namespace isolation needs a dialect that has it (postgres schemas, mysql databases, mssql schemas); on a single-namespace deployment declare the seed as \`lifecycle: 'boot'\`.`);
+	let o = await A(n, r, `@${t}`), s = [];
+	for (let e of i) {
+		let n = await j(e, a, r);
+		n.status === "succeeded" && r.info(`seed "${n.seedId}" applied to new tenant namespace`, {
+			namespace: t,
+			durationMs: n.durationMs,
+			rowsTouched: n.rowsTouched
+		}), await o.record(e, n), s.push(n);
+	}
+	let c = s.filter((e) => e.status === "failed");
+	if (c.length > 0) throw Error(`tenant namespace "${t}" was created but ${c.length} of ${s.length} onTenantCreate seed(s) failed: ${c.map((e) => `${e.seedId} (${e.error?.message ?? "unknown"})`).join("; ")}. The namespace and its tables exist; re-run provisioning (it is idempotent) or \`voltro db seed --id <name>\` once the cause is fixed.`);
+	return r.info("seeds: onTenantCreate pass complete", {
+		namespace: t,
+		ran: s.length
+	}), s;
+}, F = async (e, t, n, r) => {
+	let i = new Set(t), a = e.filter((e) => e.definition.lifecycle === "onSchemaChange" && (e.definition.watchedTables ?? []).some((e) => i.has(e)));
+	if (a.length === 0) return [];
+	let o = await A(n, r), s = [];
+	for (let e of a) {
+		let t = await j(e, n, r);
+		t.status === "succeeded" && r.info(`seed "${t.seedId}" applied after a schema change`, {
+			watchedTables: e.definition.watchedTables,
+			rowsTouched: t.rowsTouched
+		}), await o.record(e, t), s.push(t);
+	}
+	let c = s.filter((e) => e.status === "failed");
+	return c.length > 0 && r.warn("one or more onSchemaChange seeds failed (the schema apply itself succeeded)", { failedIds: c.map((e) => e.seedId) }), s;
+}, I = (e, t, n) => (h(async (r) => {
+	await P(e, r.namespace, t, n);
+}), m(async (r) => {
+	await F(e, r.changedTables, t, n);
+}), () => {
+	h(null), m(null);
+}), L = "seed:", R = (e, t, n) => e.filter((e) => e.definition.lifecycle === "cron").map((r) => g({
+	name: `${L}${r.definition.id}`,
+	cron: r.definition.cron ?? "",
+	timezone: r.definition.timezone ?? "UTC",
+	description: `seed "${r.definition.name}" (${r.file})`,
+	handler: async () => {
+		await N(e, r.definition.id, t, n);
+	}
+}));
+//#endregion
+export { R as a, v as c, N as i, S as n, x as o, M as r, y as s, I as t };