@voltro/cli 0.33.0 → 0.34.0

package/dist/evolveCommand-DHpkgjgH.js

@@ -0,0 +1,281 @@
+import { n as e } from "./cliOutput-D1tSBoRM.js";
+import { t } from "./checkCommand-Dv8r9tGO.js";
+import { i as n, n as r } from "./codemodRunner-DRRqXR74.js";
+import { basename as i, join as a, resolve as o } from "node:path";
+import { branchNamespaceName as s, planBranchProvision as c } from "@voltro/database";
+import { readFile as l } from "node:fs/promises";
+import { Node as u, SyntaxKind as d } from "ts-morph";
+//#region src/schemaEvolve.ts
+var f = (e) => e === void 0 ? [] : typeof e == "string" ? [e] : e, p = (e, t, n) => {
+	let r = e.table, i = /* @__PURE__ */ new Map();
+	if (t !== null) for (let e of t.edges) {
+		if (e.table !== r) continue;
+		let t = i.get(e.tag) ?? /* @__PURE__ */ new Set();
+		t.add(e.op), i.set(e.tag, t);
+	}
+	let a = new Set(t?.exercised ?? []), o = /* @__PURE__ */ new Map();
+	for (let e of n) (f(e.source).includes(r) || (e.targets ?? []).some((e) => e.table === r)) && o.set(e.tag, e);
+	let s = /* @__PURE__ */ new Set([...i.keys(), ...o.keys()]), c = new Map(n.map((e) => [e.tag, e.kind])), l = [...s].sort().map((e) => ({
+		tag: e,
+		kind: c.get(e) ?? "unknown",
+		ops: [...i.get(e) ?? []].sort(),
+		observed: i.has(e),
+		declared: o.has(e)
+	})), u = [...o.keys()].filter((e) => !a.has(e)).sort();
+	return {
+		table: r,
+		...e.column === void 0 ? {} : { column: e.column },
+		procedures: l,
+		unexercised: u,
+		hasObservation: t !== null
+	};
+}, m = (e, t) => {
+	for (let n of e.getDescendantsOfKind(d.CallExpression)) {
+		let e = n.getExpression();
+		if (!u.isIdentifier(e) || e.getText() !== "table") continue;
+		let [r, i] = n.getArguments();
+		if (!(r === void 0 || !u.isStringLiteral(r) || r.getLiteralValue() !== t) && i !== void 0 && u.isObjectLiteralExpression(i)) return i;
+	}
+}, h = (e, t, n, r) => {
+	let i = m(e, t);
+	if (i === void 0 || !u.isObjectLiteralExpression(i)) return 0;
+	for (let e of i.getProperties()) {
+		if (!u.isPropertyAssignment(e) || e.getNameNode().getText() !== n) continue;
+		e.getNameNode().replaceWithText(r);
+		let t = e.getInitializer();
+		return t !== void 0 && !t.getText().includes(".renamedFrom(") && t.replaceWithText(`${t.getText()}.renamedFrom('${n}')`), 1;
+	}
+	return 0;
+}, g = (e, t, n, r) => {
+	if (!e.getFullText().includes(t) || m(e, t) !== void 0) return 0;
+	let i = /* @__PURE__ */ new Map(), a = (e) => {
+		let t = e.getFirstAncestorByKind(d.ExpressionStatement) ?? e.getFirstAncestorByKind(d.VariableStatement) ?? e.getFirstAncestorByKind(d.ReturnStatement) ?? e.getFirstAncestorByKind(d.PropertyAssignment);
+		t !== void 0 && i.set(t.getStart(), t);
+	};
+	for (let t of e.getDescendantsOfKind(d.StringLiteral)) t.getLiteralValue() === n && a(t);
+	for (let t of e.getDescendantsOfKind(d.PropertyAccessExpression)) t.getName() === n && a(t);
+	let o = 0;
+	for (let e of [...i.values()].sort((e, t) => t.getStart() - e.getStart())) e.replaceWithText(`// TODO(voltro-migration): column '${t}.${n}' renamed to '${r}' — update this reference\n${e.getText()}`), o++;
+	return o;
+}, _ = (e) => `${e.kind}-${e.table}${e.column ? `-${e.column}` : ""}`.replace(/[^a-z0-9-]/gi, "-"), v = (e) => {
+	let t = `0.0.1/${_(e)}`;
+	if (e.kind === "rename-column" && e.column !== void 0 && e.to !== void 0) {
+		let { table: r, column: i, to: a } = e;
+		return {
+			summary: [`entity: rename '${r}.${i}' → '${a}' and add .renamedFrom('${i}') (catalog rename — data preserved)`, `handlers: annotate every reference to '${i}' in files that touch '${r}' with a review marker`],
+			codemod: n({
+				version: "0.0.1",
+				id: t,
+				title: `Rename column ${r}.${i} → ${a}`,
+				kind: "transform",
+				transform: (e) => {
+					let t = 0, n = 0;
+					for (let o of e.project.getSourceFiles()) t += h(o, r, i, a), n += g(o, r, i, a);
+					e.log(`rename-column: renamed ${t} field, annotated ${n} handler site(s)`);
+				}
+			})
+		};
+	}
+	let r = y(e);
+	return {
+		summary: [`manual: ${e.kind} on '${e.table}${e.column ? `.${e.column}` : ""}' — see the printed steps`],
+		codemod: n({
+			version: "0.0.1",
+			id: t,
+			title: `${e.kind} ${e.table}${e.column ? `.${e.column}` : ""}`,
+			kind: "manual",
+			note: r
+		})
+	};
+}, y = (e) => {
+	let t = `${e.table}.${e.column ?? ""}`;
+	switch (e.kind) {
+		case "retype-column": return [
+			`Retype ${t} → ${e.to}.`,
+			"",
+			`1. In the entity, change the column builder's type to ${e.to}.`,
+			"2. `voltro db plan` — a widening retype classifies `safe`; a narrowing one is",
+			"   `needs-backfill` and prints the count query to run first.",
+			"3. Backfill values that do not fit the new type BEFORE applying (see the backfill plan).",
+			"4. Update every handler that reads/writes the column to the new type."
+		].join("\n");
+		case "split-column": return [
+			`Split ${t} into ${(e.into ?? []).join(", ")}.`,
+			"",
+			`1. Add the new columns (${(e.into ?? []).join(", ")}) to the entity, nullable at first.`,
+			"2. Backfill them from the old column on a branch (see the backfill plan), then verify.",
+			`3. Update handlers to write the new columns; keep '${e.column}' until reads are migrated.`,
+			`4. Once nothing reads '${e.column}', drop it in a follow-up change (drop-column).`
+		].join("\n");
+		case "drop-column": return [
+			`Drop ${t}.`,
+			"",
+			"1. Confirm the blast radius: NO exercised handler still reads/writes it.",
+			"2. Remove the field from the entity. On MySQL/MariaDB the drop forces ALGORITHM=COPY",
+			"   (a table rebuild) — plan for the lock on a large table.",
+			"3. `voltro db plan` then `voltro db apply`."
+		].join("\n");
+		case "rename-table": return [
+			`Rename table '${e.table}' → '${e.to}'.`,
+			"",
+			`1. In the entity: table('${e.to}', { … }).renamedFrom('${e.table}') — a catalog rename.`,
+			"2. Update every handler source/target and predicate that names the old table.",
+			"3. `voltro db plan` then `voltro db apply` (catalog-only on every dialect)."
+		].join("\n");
+		default: return `Manual migration for ${e.kind} on ${t}.`;
+	}
+}, b = (e) => `"${e.replace(/"/g, "\"\"")}"`, x = (e, t, n, r, i = "copy") => {
+	let a = [];
+	switch (e.kind) {
+		case "rename-column":
+		case "rename-table":
+			a.push({
+				detail: "catalog rename — no row backfill needed (data preserved in place)",
+				safety: "safe"
+			});
+			break;
+		case "retype-column":
+			a.push({
+				detail: `cast existing values in '${e.table}.${e.column}' to ${e.to}; verify none fail`,
+				sql: `UPDATE ${b(e.table)} SET ${b(e.column ?? "")} = CAST(${b(e.column ?? "")} AS ${e.to}) WHERE ${b(e.column ?? "")} IS NOT NULL`,
+				safety: "needs-backfill"
+			});
+			break;
+		case "split-column":
+			for (let t of e.into ?? []) a.push({
+				detail: `backfill '${t}' from '${e.column}' (edit the expression to your split logic)`,
+				sql: `UPDATE ${b(e.table)} SET ${b(t)} = ${b(e.column ?? "")} /* TODO: split expression */`,
+				safety: "manual"
+			});
+			break;
+		case "drop-column":
+			a.push({
+				detail: `no backfill — verify the blast radius first, then drop '${e.column}'`,
+				safety: "safe"
+			});
+			break;
+	}
+	return {
+		steps: a,
+		branchId: t,
+		branchPlan: c(t, n, i, r)
+	};
+}, S = (e, t, n, r) => {
+	let i = p(e, t, n), a = /* @__PURE__ */ new Set([e.table]);
+	if (t !== null) {
+		let e = new Set(i.procedures.map((e) => e.tag));
+		for (let n of t.edges) e.has(n.tag) && a.add(n.table);
+	}
+	return {
+		change: e,
+		blastRadius: i,
+		proposal: v(e),
+		backfill: x(e, r.branchId, [...a].sort(), r.parentNamespace, r.seed),
+		verify: "voltro check --offline"
+	};
+}, C = [
+	"rename-column",
+	"retype-column",
+	"drop-column",
+	"split-column",
+	"rename-table"
+], w = (e, t) => {
+	let n = e.indexOf(t);
+	return n === -1 ? void 0 : e[n + 1];
+}, T = (e) => {
+	let t = e.filter((e) => !e.startsWith("-")), n = t[0];
+	if (n === void 0 || !C.includes(n)) return { error: `expected one of ${C.join(" | ")} as the first argument` };
+	let r = t[1];
+	if (r === void 0) return { error: `${n}: missing <table>${n === "rename-table" ? "" : ".<column>"}` };
+	let i = w(e, "--to"), a = w(e, "--into"), o = a === void 0 ? void 0 : a.split(",").map((e) => e.trim()).filter(Boolean);
+	if (n === "rename-table") return i === void 0 ? { error: "rename-table: --to <newName> is required" } : { change: {
+		kind: n,
+		table: r,
+		to: i
+	} };
+	let [s, c] = r.split(".");
+	return s === void 0 || c === void 0 || c === "" ? { error: `${n}: expected <table>.<column> (got "${r}")` } : (n === "rename-column" || n === "retype-column") && i === void 0 ? { error: `${n}: --to <${n === "retype-column" ? "type" : "newName"}> is required` } : n === "split-column" && (o === void 0 || o.length < 2) ? { error: "split-column: --into a,b (at least two target columns) is required" } : { change: {
+		kind: n,
+		table: s,
+		column: c,
+		...i === void 0 ? {} : { to: i },
+		...o === void 0 ? {} : { into: o }
+	} };
+}, E = async (e) => {
+	try {
+		let t = await l(a(e, "app.graph.observed.generated.json"), "utf8"), n = JSON.parse(t);
+		return n?.version !== 1 || !Array.isArray(n.edges) || !Array.isArray(n.exercised) ? null : n;
+	} catch {
+		return null;
+	}
+}, D = async (e) => {
+	try {
+		let { manifest: n } = await t(e);
+		return (n.procedures ?? []).map((e) => ({
+			tag: e.tag,
+			kind: e.kind,
+			...e.source === void 0 ? {} : { source: e.source },
+			...e.targets === void 0 ? {} : { targets: e.targets }
+		}));
+	} catch {
+		return [];
+	}
+}, O = (e) => {
+	let t = e.blastRadius, n = [];
+	n.push(`change: ${e.change.kind} ${e.change.table}${e.change.column ? `.${e.change.column}` : ""}${e.change.to ? ` → ${e.change.to}` : ""}`), n.push(""), n.push(`blast radius (${t.hasObservation ? "observed + declared" : "declared only — no run recorded"}):`), t.procedures.length === 0 && n.push("  (no handler touches this table)");
+	for (let e of t.procedures) {
+		let t = e.observed ? `observed ${e.ops.join(",")}` : "declared only";
+		n.push(`  ${e.kind}(${e.tag}) — ${t}`);
+	}
+	t.unexercised.length > 0 && n.push(`  ⚠ ${t.unexercised.length} declared but NEVER exercised — column use UNKNOWN: ${t.unexercised.join(", ")}`), n.push(""), n.push("codemod:");
+	for (let t of e.proposal.summary) n.push(`  ${t}`);
+	if (e.proposal.codemod.kind === "manual") {
+		n.push("  steps:");
+		for (let t of (e.proposal.codemod.note ?? "").split("\n")) n.push(`    ${t}`);
+	}
+	n.push(""), n.push(`backfill (dry-runs on branch ${e.backfill.branchId}):`);
+	for (let t of e.backfill.steps) n.push(`  [${t.safety}] ${t.detail}`), t.sql !== void 0 && n.push(`    ${t.sql}`);
+	return n.push(`  branch provision: ${e.backfill.branchPlan.map((e) => e.kind).join(" → ")}`), n.push(""), n.push(`verify: ${e.verify}`), n.join("\n");
+}, k = async (t) => {
+	let n = t.includes("--json"), a = t.includes("--write"), c = T(t);
+	if (c.error !== void 0) return console.error(`voltro evolve: ${c.error}`), console.error("  e.g. voltro evolve rename-column notes.title --to heading [--write] [--json]"), 1;
+	let l = c.change, u = /* @__PURE__ */ new Set([
+		"--to",
+		"--into",
+		"--threshold"
+	]), d = [];
+	for (let e = 0; e < t.length; e++) {
+		let n = t[e];
+		if (n.startsWith("-")) {
+			u.has(n) && e++;
+			continue;
+		}
+		d.push(n);
+	}
+	let f = o(d[2] ?? process.cwd()), [p, m] = await Promise.all([E(f), D(f)]), h = S(l, p, m, {
+		branchId: s(i(f), 0),
+		parentNamespace: "public"
+	}), g = await r({
+		root: f,
+		from: "0.0.0",
+		to: "0.0.1",
+		codemods: [h.proposal.codemod],
+		dryRun: !a,
+		log: n ? () => {} : (e) => console.log(`  ${e}`)
+	});
+	if (n) e({
+		plan: h,
+		applied: g,
+		written: a
+	});
+	else if (console.log(O(h)), console.log(""), a) {
+		let e = g.applied.flatMap((e) => [...e.changedFiles, ...e.renamedFiles]);
+		console.log(e.length > 0 ? `applied — changed ${e.length} file(s):` : "applied — no files changed");
+		for (let t of e) console.log(`  ${t}`);
+		for (let e of g.manual) console.log(`  manual: ${e.title} (see steps above)`);
+		console.log("\nnext: review the annotated handlers, then `voltro check` and `voltro db apply`.");
+	} else console.log("dry-run (no files changed). Re-run with --write to apply the codemod.");
+	return 0;
+};
+//#endregion
+export { k as runEvolveCommand };