@voltro/data-transfer 0.85.0 → 0.86.0

package/dist/stagedSwap.js

@@ -0,0 +1,164 @@
+import { Effect as e } from "effect";
+import { STAGING_TABLE_PREFIX as t } from "@voltro/database";
+import { SqlClient as n } from "effect/sql";
+//#region src/stagedSwap.ts
+var r = t, i = (e) => `${r}${e}`, a = (e) => typeof e.run == "function", o = (e) => `staging is not available for this run — loading directly into the target instead: ${e}\n  The load therefore holds the destructive transaction open for its whole duration, so a
+  process that dies mid-load depends on the database rolling it back. The rollback capture
+  written before the first delete is what covers that case.`, s = /^[a-zA-Z_][a-zA-Z0-9_]*$/, c = (e, t) => {
+	if (!s.test(e)) throw Error(`refusing to build SQL for the table name ${JSON.stringify(e)}: it is outside the identifier class the framework allows. A name from a bundle manifest reaches this concatenation, so it is checked here rather than assumed to still be what the declaration validated.`);
+	return t === "mysql" || t === "mariadb" ? `\`${e}\`` : t === "mssql" ? `[${e}]` : `"${e}"`;
+}, l = (e, t) => {
+	let n = c(e, t), r = c(i(e), t);
+	switch (t) {
+		case "postgres": return `CREATE TABLE ${r} (LIKE ${n})`;
+		case "mysql":
+		case "mariadb": return `CREATE TABLE ${r} LIKE ${n}`;
+		case "sqlite": return `CREATE TABLE ${r} AS SELECT * FROM ${n} WHERE 0`;
+		case "mssql": return `SELECT * INTO ${r} FROM ${n} WHERE 1 = 0`;
+	}
+}, u = (e, t) => {
+	let n = c(i(e), t);
+	return t === "mssql" ? `IF OBJECT_ID('${i(e)}', 'U') IS NOT NULL DROP TABLE ${n}` : `DROP TABLE IF EXISTS ${n}`;
+}, d = (e, t) => {
+	let n = t === "mysql" || t === "mariadb", r = [];
+	n && r.push("SET FOREIGN_KEY_CHECKS = 0");
+	for (let n of [...e].reverse()) r.push(`DELETE FROM ${c(n.name, t)}`);
+	for (let n of e) {
+		if (n.columns.length === 0) throw Error(`refusing to build a swap for '${n.name}' with no columns: an empty list would have to mean \`SELECT *\`, which is the shape that fails on a generated column.`);
+		let e = n.columns.map((e) => c(e, t)).join(", ");
+		r.push(`INSERT INTO ${c(n.name, t)} (${e}) SELECT ${e} FROM ${c(i(n.name), t)}`);
+	}
+	return n && r.push("SET FOREIGN_KEY_CHECKS = 1"), r;
+}, f = (e, t) => {
+	let n = [], r = () => {
+		for (let e of n) t.unregisterTable(e);
+	};
+	try {
+		for (let r of e) {
+			let e = t.getTable(r);
+			if (e === void 0) continue;
+			let a = i(r);
+			t.registerTable({
+				...e,
+				tableName: a,
+				isReactive: !1
+			}), n.push(a);
+		}
+	} catch (e) {
+		throw r(), e;
+	}
+	return {
+		staged: n,
+		undo: r
+	};
+}, p = (e, t) => {
+	let n = new Set(t), r = [];
+	for (let t of e.tables) {
+		if (!n.has(t.name)) continue;
+		let e = t.primaryKey?.[0] ?? "id";
+		for (let i of t.columns) {
+			let a = i.references;
+			a !== void 0 && n.has(a.table) && r.push({
+				from: t.name,
+				column: i.name,
+				to: a.table,
+				toColumn: a.column,
+				primaryKey: e
+			});
+		}
+	}
+	return r;
+}, m = (e, t) => {
+	let n = c(i(e.from), t), r = c(i(e.to), t), a = c(e.column, t), o = c(e.toColumn, t);
+	return `SELECT ${c(e.primaryKey, t)} AS pk, ${a} AS value FROM ${n} c WHERE ${a} IS NOT NULL AND NOT EXISTS (SELECT 1 FROM ${r} p WHERE p.${o} = c.${a})`;
+}, h = (e) => {
+	if (e.length === 0) return;
+	let t = e.slice(0, 20), n = t.map((e) => `    ${e.table}.${e.primaryKey}: ${e.column} = ${JSON.stringify(e.value)} — no such row in ${e.references}`);
+	return `the swap could not run: ${e.length} row(s) in the bundle reference a row the bundle does not carry.\n${n.join("\n")}\n` + (e.length > t.length ? `    … and ${e.length - t.length} more\n` : "") + "  The target is UNCHANGED — the swap runs in one transaction and none of it committed.\n  Every offending row is listed above rather than only the first, so this can be fixed in one pass.";
+}, g = async (t, r) => {
+	r.length !== 0 && await t.run(n.SqlClient.pipe(e.flatMap((t) => e.forEach(r, (e) => t.unsafe(e), { discard: !0 }))));
+}, _ = async (t, r, i) => {
+	let a = d(r, i);
+	a.length !== 0 && await t.run(n.SqlClient.pipe(e.flatMap((t) => t.withTransaction(e.forEach(a, (e) => t.unsafe(e), { discard: !0 })))));
+}, v = async (t, r, i) => {
+	let a = [];
+	for (let o of r) {
+		let r = await t.run(n.SqlClient.pipe(e.flatMap((e) => e.unsafe(m(o, i)))));
+		for (let e of r) a.push({
+			table: o.from,
+			primaryKey: String(e.pk ?? ""),
+			column: o.column,
+			value: e.value,
+			references: o.to
+		});
+	}
+	return a;
+}, y = (e, t) => {
+	let n = new Map(t.map((e, t) => [e, t]));
+	return e.filter((e) => {
+		if (e.from === e.to) return !1;
+		let t = n.get(e.from), r = n.get(e.to);
+		return t === void 0 || r === void 0 ? !1 : r > t;
+	});
+}, b = (e) => e === "mysql" || e === "mariadb", x = (e) => {
+	if (e.mode !== "replace") return {
+		active: !1,
+		tables: [],
+		blocker: `staging applies to \`replace\` only (this run is \`${e.mode}\`).`
+	};
+	let t = (() => {
+		let t = e.targetDialect;
+		return t === "postgres" || t === "mysql" || t === "mariadb" || t === "sqlite" || t === "mssql" ? t : void 0;
+	})();
+	if (t === void 0) return {
+		active: !1,
+		tables: [],
+		blocker: `the target dialect (${e.targetDialect ?? "unknown"}) is not one this build can stage on.`
+	};
+	if (!e.canRunSql) return {
+		active: !1,
+		tables: [],
+		blocker: "this store cannot send DDL (no raw-SQL channel), which a staged swap needs."
+	};
+	let n = e.targetSnapshot;
+	if (n === void 0) return {
+		active: !1,
+		tables: [],
+		blocker: "this caller did not supply a snapshot of the target schema, so the staging tables cannot be given the target's column shape."
+	};
+	let r = new Map(n.tables.map((e) => [e.name, e])), i = e.bundleTables.filter((t) => !e.isSkipped(t)), a = i.filter((e) => !r.has(e));
+	if (a.length > 0) return {
+		active: !1,
+		tables: [],
+		blocker: `the bundle carries ${a.length} table(s) the target does not have (${a.join(", ")}). Staging copies the TARGET's column shape, and there is none for those.`
+	};
+	let o = [];
+	for (let e of i) {
+		let t = r.get(e).columns.filter((e) => e.generatedAs === void 0).map((e) => e.name);
+		if (t.length === 0) return {
+			active: !1,
+			tables: [],
+			blocker: `\`${e}\` has no ordinary columns in the target (every column is generated), so a staged copy would have nothing to write.`
+		};
+		o.push({
+			name: e,
+			columns: t
+		});
+	}
+	if (o.length === 0) return {
+		active: !1,
+		tables: [],
+		blocker: "every table in the bundle is one that describes a deployment, so there is nothing for a staged swap to move."
+	};
+	let s = o.map((e) => e.name), c = b(t) ? [] : y(p(n, s), s);
+	return c.length > 0 ? {
+		active: !1,
+		tables: [],
+		blocker: `the bundle's tables reference each other in a cycle (${c.map((e) => `${e.from}.${e.column} → ${e.to}`).join(", ")}), and a bulk copy cannot satisfy both directions on this dialect.`
+	} : {
+		active: !0,
+		tables: o
+	};
+};
+//#endregion
+export { r as STAGING_PREFIX, a as canStage, l as createStagingSql, m as danglingProbeSql, h as danglingReport, x as decideStaging, u as dropStagingSql, g as execStatements, v as findDangling, y as forwardReferences, c as quoteIdent, f as registerStagingClones, _ as runSwap, p as stagedReferences, i as stagingNameFor, o as stagingUnavailable, b as suspendsIntegrity, d as swapStatements };

package/dist/subset.js

@@ -0,0 +1,90 @@
+import { Effect as e, Stream as t } from "effect";
+import { inSet as n, or as r, streamTable as i } from "@voltro/database";
+//#region src/subset.ts
+var a = (e, t) => e.tables.find((e) => e.name === t)?.columns.find((e) => e.type === "id")?.name ?? "id", o = (a, o, s) => e.gen(function* () {
+	let c = s.maxDepth ?? 12, l = new Set(s.pinned ?? []), u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
+	for (let e of o.tables) p.has(e.name) || p.set(e.name, e);
+	let m = /* @__PURE__ */ new Map();
+	for (let [e, t] of p) m.set(e, {
+		pk: t.columns.find((e) => e.type === "id")?.name ?? "id",
+		fks: t.columns.filter((e) => e.references !== void 0).map((e) => ({
+			col: e.name,
+			refTable: e.references.table
+		}))
+	});
+	let h = (e) => m.get(e)?.pk ?? "id", g = (e) => {
+		let t = d.get(e) ?? /* @__PURE__ */ new Set();
+		return d.set(e, t), t;
+	}, _ = (e, t) => {
+		if (t == null || l.has(e) || d.get(e)?.has(t)) return;
+		let n = f.get(e) ?? /* @__PURE__ */ new Set();
+		n.add(t), f.set(e, n);
+	}, v = (e, t, n) => {
+		let r = g(e), i = l.has(e) ? void 0 : u.get(e) ?? (() => {
+			let t = /* @__PURE__ */ new Set();
+			return u.set(e, t), t;
+		})();
+		return (e) => {
+			r.add(e[t]), i?.add(e[t]);
+			for (let t of n) _(t.refTable, e[t.col]);
+		};
+	}, y = (n, r) => {
+		let o = v(n, h(n), m.get(n)?.fks ?? []);
+		return t.runForEach(i(a, {
+			table: n,
+			pk: h(n),
+			...r === void 0 ? {} : { where: r }
+		}), (t) => e.sync(() => o(t)));
+	}, b = e.gen(function* () {
+		for (let e = 0; e < c && f.size > 0; e++) {
+			let e = [...f.entries()];
+			f.clear();
+			for (let [t, r] of e) {
+				let e = [...r].filter((e) => !d.get(t)?.has(e));
+				if (e.length !== 0) for (let r = 0; r < e.length; r += 500) yield* y(t, n(h(t), e.slice(r, r + 500)));
+			}
+		}
+	});
+	for (let [e, t] of Object.entries(s.seeds)) yield* y(e, t);
+	if (yield* b, s.children) {
+		let t = new Set(s.children === !0 ? [...d.keys()] : s.children.roots.filter((e) => d.has(e))), i = /* @__PURE__ */ new Map();
+		for (let a = 0; a < c; a++) {
+			let a = !1, s = [];
+			for (let c of o.tables) {
+				let o = c.name, l = c.columns.map((e) => ({
+					col: e.name,
+					refTable: e.references?.table
+				})).filter((e) => !!e.refTable && t.has(e.refTable) && (d.get(e.refTable)?.size ?? 0) > 0);
+				if (l.length === 0) continue;
+				let u = d.get(o)?.size ?? 0, f = i.get(o);
+				f === void 0 && (f = /* @__PURE__ */ new Map(), i.set(o, f));
+				let p = [], m = 0, h = () => {
+					let t = p;
+					return p = [], m = 0, t.length === 0 ? e.void : y(o, t.length === 1 ? t[0] : r(...t));
+				};
+				for (let e of l) {
+					let t = f.get(e.col);
+					t === void 0 && (t = /* @__PURE__ */ new Set(), f.set(e.col, t));
+					let r = [...d.get(e.refTable)].filter((e) => !t.has(e));
+					for (let t = 0; t < r.length; t += 500) {
+						let i = r.slice(t, t + 500);
+						m + i.length > 500 && (yield* h()), p.push(n(e.col, i)), m += i.length;
+					}
+					for (let e of r) t.add(e);
+				}
+				yield* h(), (d.get(o)?.size ?? 0) > u && !t.has(o) && s.push(o), (d.get(o)?.size ?? 0) > u && (a = !0);
+			}
+			for (let e of s) t.add(e);
+			if (yield* b, !a) break;
+		}
+	}
+	return u;
+}), s = (e, t) => ({
+	tables: [...e.keys()],
+	predicateFor: (r) => {
+		let i = e.get(r);
+		return i ? n(a(t, r), [...i]) : void 0;
+	}
+});
+//#endregion
+export { o as computeSubsetIds, a as pkOf, s as subsetToScope };

package/dist/topo.js

@@ -0,0 +1,24 @@
+//#region src/topo.ts
+var e = (e, t) => {
+	let n = new Set(e), r = /* @__PURE__ */ new Map();
+	for (let e of t.tables) {
+		if (!n.has(e.name)) continue;
+		let t = /* @__PURE__ */ new Set();
+		for (let r of e.columns) {
+			let i = r.references?.table;
+			i && i !== e.name && n.has(i) && t.add(i);
+		}
+		r.set(e.name, t);
+	}
+	let i = [], a = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), s = (e) => {
+		if (!(a.has(e) || o.has(e))) {
+			o.add(e);
+			for (let t of r.get(e) ?? []) s(t);
+			o.delete(e), a.add(e), i.push(e);
+		}
+	};
+	for (let t of e) n.has(t) && s(t);
+	return i;
+};
+//#endregion
+export { e as topoSortTables };

package/dist/typedCodec.js

@@ -0,0 +1,36 @@
+//#region src/typedCodec.ts
+var e = /* @__PURE__ */ new Set([
+	"json",
+	"array",
+	"vector"
+]), t = (e) => typeof e == "object" && !!e && !Array.isArray(e) && typeof e.$v == "string", n = (e) => Buffer.from(e).toString("base64"), r = (e) => new Uint8Array(Buffer.from(e, "base64")), i = (e) => e instanceof Date ? e.toISOString() : typeof e == "number" ? new Date(e).toISOString() : String(e), a = (t, r) => t == null ? null : r !== void 0 && e.has(r) ? t : r === "bytes" ? n(t) : r === "timestamp" || r === "date" ? i(t) : typeof t == "bigint" ? {
+	$v: "bigint",
+	d: t.toString()
+} : typeof t == "number" && !Number.isFinite(t) ? {
+	$v: "number",
+	d: String(t)
+} : t instanceof Date ? {
+	$v: "date",
+	d: t.toISOString()
+} : t instanceof Uint8Array ? {
+	$v: "bytes",
+	d: n(t)
+} : t, o = (e) => {
+	switch (e.$v) {
+		case "bigint": return BigInt(e.d);
+		case "number": return Number(e.d);
+		case "date": return new Date(e.d);
+		case "bytes": return r(e.d);
+		default: return e;
+	}
+}, s = (n, i) => n == null ? null : i !== void 0 && e.has(i) ? n : t(n) ? o(n) : i === "bytes" ? r(n) : i === "timestamp" || i === "date" ? new Date(n) : n, c = (e, t) => {
+	let n = {};
+	for (let [r, i] of Object.entries(e)) n[r] = a(i, t[r]);
+	return n;
+}, l = (e, t) => {
+	let n = {};
+	for (let [r, i] of Object.entries(e)) n[r] = s(i, t[r]);
+	return n;
+};
+//#endregion
+export { l as decodeRow, s as decodeValue, c as encodeRow, a as encodeValue };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/data-transfer",
-  "version": "0.85.0",
+  "version": "0.86.0",
   "description": "Portable export/import for a Voltro app's data + assets — typed-NDJSON row codec, content-addressed assets, framed compression, a resumable chunk ledger, and FK-ordered idempotent import. Dialect-agnostic; the resilient backbone under `voltro data export|import` and native backups.",
   "keywords": [
     "voltro",
@@ -33,8 +33,8 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.85.0",
-    "@voltro/plugin-storage": "0.85.0"
+    "@voltro/database": "0.86.0",
+    "@voltro/plugin-storage": "0.86.0"
   },
   "peerDependencies": {
     "effect": "4.0.1"