@voltro/data-transfer 0.85.0 → 0.87.0

package/dist/casAssetPhase.js

@@ -0,0 +1,87 @@
+import { BundleError as e } from "./errors.js";
+import { admitFilesystemPath as t } from "./filesystemAdmission.js";
+import { assertPreparedAssets as n, decodeAssetEntry as r, decodeAssetSourceInfo as i, prepareAssetEntries as a } from "./assetAdmission.js";
+import { applyAdmittedAsset as o, writeAssetToCas as s } from "./assets.js";
+import { Effect as c, Stream as l } from "effect";
+import { constants as u } from "node:fs";
+import { open as d } from "node:fs/promises";
+import { fromNodeReadable as f } from "@voltro/plugin-storage";
+import { storageAddressIdentity as p } from "@voltro/plugin-storage/errors";
+//#region src/casAssetPhase.ts
+var m = {
+	done: () => !1,
+	mark: () => c.void
+}, h = (e) => typeof e == "object" && !!e && e.status === 404, g = (t) => c.gen(function* () {
+	let n = t.progress ?? m, r = 0, a = 0, o = 0, u = 0, d = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Map(), g = [], _ = (t) => {
+		o++;
+		let r = p(t), i = f.get(r);
+		return i === void 0 ? (f.set(r, t), n.done(r) ? c.logDebug("Revalidating previously recorded source asset").pipe(c.andThen(v(t, r))) : v(t, r)) : i.size !== t.size || i.contentType !== t.contentType || i.sha256 !== void 0 && t.sha256 !== void 0 && i.sha256 !== t.sha256 ? c.fail(new e({ reason: "duplicate asset address has contradictory source metadata" })) : i.sha256 === void 0 && t.sha256 !== void 0 ? v(t, r) : c.void;
+	}, v = (i, o) => t.source.open(i).pipe(c.map((e) => e), c.catchIf(h, () => c.sync(() => {
+		g.push(o);
+	})), c.flatMap((l) => l === void 0 ? c.void : s(l, t.assetsDir).pipe(c.flatMap((t) => {
+		let s = {
+			destination: i.destination,
+			tenantId: i.tenantId,
+			key: i.key,
+			sha256: t.sha256,
+			size: t.size,
+			contentType: t.contentType
+		};
+		return t.size !== i.size || t.contentType !== i.contentType || i.sha256 !== void 0 && t.sha256 !== i.sha256 ? c.fail(new e({ reason: "asset bytes contradict their source metadata" })) : (f.set(o, {
+			...i,
+			sha256: t.sha256
+		}), r++, a += t.size, d.has(t.sha256) || (d.add(t.sha256), u += t.size), n.mark(o, s));
+	}))));
+	return yield* l.runForEach(t.source.list().pipe(l.mapEffect(i)), _).pipe(c.mapError((t) => t instanceof e ? t : new e({ reason: `asset export failed: ${String(t)}` }))), {
+		count: r,
+		totalBytes: a,
+		references: o,
+		objects: d.size,
+		objectBytes: u,
+		missing: g
+	};
+}), _ = (n) => l.unwrap(c.gen(function* () {
+	let r = yield* c.acquireRelease(c.tryPromise({
+		try: async () => {
+			await t(n, "file");
+			let e = await d(n, u.O_RDONLY | u.O_NOFOLLOW | u.O_NONBLOCK);
+			try {
+				if (!(await e.stat()).isFile()) throw Error("asset index must be a regular file");
+				return e;
+			} catch (t) {
+				throw await e.close(), t;
+			}
+		},
+		catch: () => new e({
+			reason: "asset index could not be admitted",
+			path: n
+		})
+	}), (e) => c.promise(() => e.close()));
+	return f("bundle", () => r.createReadStream({ autoClose: !1 }));
+})).pipe(l.decodeText(), l.splitLines, l.filter((e) => e.trim().length > 0), l.mapEffect((t) => c.try({
+	try: () => JSON.parse(t),
+	catch: () => new e({
+		reason: "asset index contains invalid JSON",
+		path: n
+	})
+}).pipe(c.flatMap(r))), l.mapError((t) => t instanceof e ? t : new e({
+	reason: `asset index unreadable: ${String(t)}`,
+	path: n
+}))), v = (e) => c.scoped(c.gen(function* () {
+	let t = e.prepared ?? (yield* y(e));
+	yield* n(t, e.sink);
+	let r = e.progress ?? m, i = 0, a = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+	for (let n of t.entries) {
+		let l = p(n);
+		s.has(l) || (s.add(l), r.done(l) && (yield* c.logDebug("Revalidating previously recorded destination asset")), (yield* e.sink.matches(n)) || (yield* o(e.sink, t, n), i++, a.add(n.sha256)), yield* r.mark(l, n));
+	}
+	return {
+		count: i,
+		objects: a.size
+	};
+})), y = (e) => l.runCollect(_(e.indexPath)).pipe(c.flatMap((t) => a({
+	...e,
+	entries: Array.from(t)
+})));
+//#endregion
+export { g as captureAssetsToCas, m as noAssetProgress, y as prepareAssetsFromCas, _ as readAssetIndex, v as restoreAssetsFromCas };

package/dist/compress.js

@@ -0,0 +1,6 @@
+import { PassThrough as e } from "node:stream";
+import * as t from "node:zlib";
+//#region src/compress.ts
+var n = () => typeof t.createZstdCompress == "function", r = (e) => e === "none" ? "none" : e === "gzip" ? "gzip" : n() ? "zstd" : "gzip", i = (e) => e === "zstd" ? ".zst" : e === "gzip" ? ".gz" : "", a = (n) => n === "zstd" ? t.createZstdCompress() : n === "gzip" ? t.createGzip() : new e(), o = (n) => n === "zstd" ? t.createZstdDecompress() : n === "gzip" ? t.createGunzip() : new e();
+//#endregion
+export { i as compressionExt, n as hasZstd, a as makeCompressor, o as makeDecompressor, r as pickCompression };

package/dist/consistency.js

@@ -0,0 +1,14 @@
+//#region src/consistency.ts
+var e = (e) => {
+	switch (e) {
+		case "postgres": return ["SET TRANSACTION ISOLATION LEVEL REPEATABLE READ"];
+		case "mysql":
+		case "mariadb": return ["SET TRANSACTION ISOLATION LEVEL REPEATABLE READ"];
+		case "mssql": return ["SET TRANSACTION ISOLATION LEVEL SNAPSHOT"];
+		case "sqlite":
+		case "turso": return [];
+		default: return [];
+	}
+};
+//#endregion
+export { e as snapshotPrelude };

package/dist/crossDialect.js

@@ -0,0 +1,58 @@
+//#region src/crossDialect.ts
+var e = (e) => {
+	switch (e) {
+		case "id":
+		case "text":
+		case "enum": return e === "enum" ? "enum" : "string";
+		case "integer": return "integer";
+		case "real": return "float";
+		case "boolean": return "boolean";
+		case "timestamp": return "datetime";
+		case "date": return "date";
+		case "json": return "json";
+		case "bytes": return "binary";
+		case "reference": return "reference";
+		case "vector": return "vector";
+		case "array": return "array";
+		case "interval": return "interval";
+		case "raw": return "raw";
+		default: return "string";
+	}
+}, t = {
+	vector: /* @__PURE__ */ new Set(["postgres"]),
+	array: /* @__PURE__ */ new Set(["postgres"]),
+	interval: /* @__PURE__ */ new Set(["postgres"])
+}, n = (n, r, i, a) => {
+	let o = e(i);
+	if (o === "raw") return {
+		table: n,
+		column: r,
+		type: i,
+		severity: "block",
+		reason: `raw() is verbatim source-dialect SQL — it cannot be assumed valid on ${a}`
+	};
+	let s = t[o];
+	return !s || s.has(a) ? null : o === "array" || o === "interval" ? {
+		table: n,
+		column: r,
+		type: i,
+		severity: "warn",
+		reason: `${o} is native to postgres; ${a} will represent it as json/text — verify downstream reads`
+	} : {
+		table: n,
+		column: r,
+		type: i,
+		severity: "block",
+		reason: `${o} columns require a ${[...s].join("/")} target; ${a} has no compatible column type`
+	};
+}, r = (e, t, r) => {
+	if (t === r) return [];
+	let i = [];
+	for (let t of e) for (let [e, a] of Object.entries(t.columnTypes)) {
+		let o = n(t.name, e, a, r);
+		o && i.push(o);
+	}
+	return i;
+}, i = (e) => `[${e.severity}] ${e.table}.${e.column} (${e.type}): ${e.reason}`;
+//#endregion
+export { e as canonicalType, r as checkPortability, i as formatIssue };

package/dist/driftClassification.js

@@ -0,0 +1,58 @@
+//#region src/driftClassification.ts
+var e = (e, t) => {
+	let n = new Map(t.map((e) => [e.name, e])), r = [], i = {};
+	for (let t of e) {
+		let e = n.get(t.name);
+		if (e === void 0) {
+			r.push({
+				verdict: "refuse",
+				table: t.name,
+				detail: `the bundle carries '${t.name}' and the target schema has no such table — nowhere to put ${t.name}'s rows`
+			});
+			continue;
+		}
+		let a = new Map(e.columns.map((e) => [e.name, e])), o = new Map(t.columns.map((e) => [e.name, e])), s = [];
+		for (let e of t.columns) {
+			let n = a.get(e.name);
+			n === void 0 ? (s.push(e.name), r.push({
+				verdict: "value-dropped",
+				table: t.name,
+				column: e.name,
+				detail: `'${t.name}.${e.name}' is in the bundle and not in the schema — its values are DISCARDED`
+			})) : n.type !== e.type && r.push({
+				verdict: "refuse",
+				table: t.name,
+				column: e.name,
+				detail: `'${t.name}.${e.name}' changed type (${e.type} → ${n.type}) — the bundle's values would be written through a codec that no longer matches them`
+			});
+		}
+		for (let n of e.columns) o.has(n.name) || (n.nullable || n.hasDefault ? r.push({
+			verdict: "filled-by-default",
+			table: t.name,
+			column: n.name,
+			detail: `'${t.name}.${n.name}' is in the schema and not in the bundle — every imported row gets ${n.hasDefault ? "its default" : "NULL"}`
+		}) : r.push({
+			verdict: "refuse",
+			table: t.name,
+			column: n.name,
+			detail: `'${t.name}.${n.name}' is NOT NULL with no default and the bundle has no value for it`
+		}));
+		s.length > 0 && (i[t.name] = s);
+	}
+	return {
+		findings: r,
+		skipColumns: i,
+		refuse: r.some((e) => e.verdict === "refuse")
+	};
+}, t = (e) => {
+	if (e.findings.length === 0) return ["  schema matches the bundle"];
+	let t = {
+		safe: "✓",
+		"value-dropped": "⊖",
+		"filled-by-default": "⊕",
+		refuse: "✗"
+	}, n = e.findings.map((e) => `  ${t[e.verdict]} ${e.detail}`), r = (t) => e.findings.filter((e) => e.verdict === t).length;
+	return n.push(""), n.push(`  discarded: ${r("value-dropped")}   defaulted: ${r("filled-by-default")}   refused: ${r("refuse")}`), e.refuse && (n.push(""), n.push("  REFUSED — no row was written. These are the differences that would make"), n.push("  imported rows WRONG rather than merely incomplete.")), n;
+};
+//#endregion
+export { e as classifyImportDrift, t as formatImportDrift };