@voltro/cli 0.12.0 → 0.14.0

package/dist/seedRunner-D6eu-u5U.js

@@ -0,0 +1,229 @@
+import { join as e } from "node:path";
+import { pathToFileURL as t } from "node:url";
+import { promises as n } from "node:fs";
+import { createRequire as r } from "node:module";
+import { _voltroSeedsTable as i, and as a, eq as o, generateId as s, isSeedDefinition as c } from "@voltro/database";
+import { createHash as l } from "node:crypto";
+//#region src/dialectDriver.ts
+var u = {
+	postgres: "@voltro/sql-postgres",
+	sqlite: "@voltro/sql-sqlite",
+	mysql: "@voltro/sql-mysql",
+	mariadb: "@voltro/sql-mysql",
+	mssql: "@voltro/sql-mssql",
+	turso: "@voltro/sql-turso"
+}, d = [...new Set(Object.values(u))], f = {
+	postgres: "postgresDialect",
+	sqlite: "sqliteDialect",
+	mysql: "mysqlDialect",
+	mariadb: "mariadbDialect",
+	mssql: "mssqlDialect",
+	turso: "tursoDialect"
+}, p = /* @__PURE__ */ new Map(), m = (e, t) => {
+	p.set(e, t);
+}, h = async (n) => {
+	let i = p.get(n);
+	if (i) return i;
+	try {
+		return await import(t(r(e(process.cwd(), "package.json")).resolve(n)).href);
+	} catch {
+		try {
+			return await import(n);
+		} catch {
+			throw Error(`The '${n}' database driver is not installed.\n\nEvery Voltro app declares the driver for its DB dialect as a dependency (a memory store needs none). Install it in the app:\n\n  pnpm add ${n}\n`);
+		}
+	}
+}, g = async (e) => {
+	let t = u[e];
+	if (!t) throw Error(`Unsupported DB_DIALECT='${e}'. Supported: memory, postgres, sqlite, mysql, mariadb, mssql, turso.`);
+	return (await h(t))[f[e]];
+}, _ = async (e, r) => {
+	let i = [];
+	for (let a of e) {
+		let e;
+		try {
+			e = await import(t(a).href);
+		} catch (e) {
+			r.warn("seed: failed to import", { file: a }, e);
+			continue;
+		}
+		let o = (e.default && c(e.default) ? e.default : void 0) ?? Object.values(e).find(c);
+		if (!o) {
+			r.warn("seed: no defineSeed export", { file: a });
+			continue;
+		}
+		let s = await n.readFile(a, "utf8").catch(() => ""), u = o.fingerprint ? o.fingerprint({ src: s }) : l("sha256").update(s).digest("hex").slice(0, 16);
+		i.push({
+			file: a,
+			definition: o,
+			fingerprint: u
+		});
+	}
+	return i;
+}, v = (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)
+}), y = (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 s;
+	if (i.length === 1) {
+		let e = i[0];
+		s = o(e, n[e]);
+	} else s = a(...i.map((e) => o(e, n[e])));
+	let c = (await e.query({
+		table: t,
+		order: [],
+		predicate: s
+	}))[0];
+	if (c) {
+		let n = c.id;
+		return {
+			row: await e.update(t, n, r) ?? c,
+			created: !1
+		};
+	}
+	return {
+		row: await e.insert(t, r),
+		created: !0
+	};
+}, b = (e, t) => {
+	let n = y(e);
+	return {
+		store: v(e),
+		upsertByUnique: n,
+		progress: (e, n) => t.debug("seed progress", {
+			done: e,
+			total: n
+		})
+	};
+}, x = "_voltro_seeds", S = () => {
+	let e = i.fields.id?.idScheme;
+	return (e ? s(e, x) : null) ?? s({
+		kind: "typeid",
+		prefix: "seed"
+	}, x);
+}, C = {
+	isUnchanged: () => !1,
+	record: async () => {}
+}, w = async (e, t) => {
+	let n;
+	try {
+		n = await e.query({
+			table: x,
+			order: [],
+			predicate: void 0,
+			projection: void 0,
+			skip: void 0,
+			take: void 0
+		});
+	} catch (e) {
+		return t.warn("seeds: ledger unreadable — every boot seed will run", {
+			table: x,
+			error: String(e)
+		}), C;
+	}
+	let r = new Map(n.map((e) => [e.name, e]));
+	return {
+		isUnchanged: (e) => {
+			let t = r.get(e.definition.id);
+			return t?.lastRunStatus === "succeeded" && t.fingerprint === e.fingerprint;
+		},
+		record: async (n, i) => {
+			let a = {
+				name: n.definition.id,
+				lifecycle: n.definition.lifecycle,
+				fingerprint: n.fingerprint,
+				lastRunStatus: i.status,
+				lastRunAt: /* @__PURE__ */ new Date(),
+				lastRunDurationMs: i.durationMs,
+				lastRunRowsTouched: i.rowsTouched,
+				lastError: i.error?.message ?? null
+			};
+			try {
+				let t = r.get(n.definition.id);
+				t ? await e.update(x, t.id, a) : await e.insert(x, {
+					id: S(),
+					...a
+				});
+			} catch (e) {
+				t.warn("seeds: could not record the ledger row — this seed will re-run on every boot", {
+					seedId: n.definition.id,
+					table: x,
+					error: String(e)
+				});
+			}
+		}
+	};
+}, T = async (e, t, n) => {
+	let r = Date.now(), i = b(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
+	};
+}, E = async (e, t, n, r = {}) => {
+	let i = e.filter((e) => e.definition.lifecycle === "boot");
+	if (i.length === 0) return [];
+	let a = await w(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 T(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;
+}, D = 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 T(i, n, r);
+	return await (await w(n, r)).record(i, a), a;
+}, O = /\.seed\.ts$/;
+//#endregion
+export { d as a, m as c, D as i, _ as n, h as o, E as r, g as s, O as t };