@voltro/runtime 0.85.0 → 0.86.0

package/dist/crdtHistory.js

@@ -0,0 +1,138 @@
+import { crdtCompactMaxBytes as e, crdtMaxDocumentBytes as t, crdtMaxUpdateBytes as n, crdtMigrationsFor as r, crdtRebaseMaxBytes as i, describeCrdtState as a } from "./crdtMerge.js";
+import { CRDT_VERSIONS_TABLE as o } from "./crdtVersionsTable.js";
+import { and as s, eq as c } from "@voltro/database";
+import { ValidationError as l } from "@voltro/protocol";
+import { crdtSchemaVersionOf as u, decodeSealedLog as d, defaultCrdtBackend as f, emptyCrdtState as p, latestCrdtSchemaVersion as m, sealedLogEpoch as h } from "@voltro/local-first";
+//#region src/crdtHistory.ts
+var g = (e, t, n, r) => e.query({
+	table: t,
+	predicate: n,
+	order: [{
+		column: "createdAt",
+		direction: "desc"
+	}],
+	take: r,
+	skip: void 0,
+	projection: void 0
+}), _ = async (e, t) => {
+	let n = (await e.query({
+		table: t.table,
+		predicate: {
+			column: "id",
+			op: "eq",
+			value: t.id
+		},
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0];
+	if (n === void 0) return;
+	let r = n[t.column];
+	return { state: r instanceof Uint8Array ? r : void 0 };
+}, v = (e) => ({
+	id: String(e.id),
+	reason: e.reason,
+	label: e.label ?? null,
+	epoch: e.epoch ?? null,
+	createdBy: e.createdBy ?? null,
+	createdAt: e.createdAt instanceof Date ? e.createdAt : new Date(String(e.createdAt))
+}), y = (e) => {
+	let t = a(e);
+	return t === void 0 ? d(e) === void 0 ? null : h(e) || null : t.epoch;
+}, b = async (e, t, n, r, i, a) => v(await e.insert(o, {
+	tableName: t.table,
+	rowId: t.id,
+	columnName: t.column,
+	state: n,
+	reason: r,
+	label: i ?? null,
+	epoch: y(n),
+	createdBy: a ?? null
+})), x = async (e, t) => {
+	let n = await _(e, t);
+	if (n !== void 0) return b(e, t, n.state ?? p(), "snapshot", t.label, t.createdBy);
+}, S = async (e, t) => await _(e, t) === void 0 ? [] : (await g(e, o, s(c("tableName", t.table), c("rowId", t.id), c("columnName", t.column)))).map(v), C = async (e, t) => {
+	let n = (await g(e, o, c("id", t.versionId), 1))[0];
+	if (n === void 0) return;
+	let r = {
+		table: String(n.tableName),
+		id: String(n.rowId),
+		column: String(n.columnName)
+	}, i = await _(e, r);
+	if (i === void 0) return;
+	let s = n.state;
+	if (!(s instanceof Uint8Array)) return;
+	let u = i.state ?? p();
+	if (a(u) === void 0 || a(s) === void 0) throw new l({
+		field: r.column,
+		message: "crdt.sealedRestoreIsClientSide",
+		params: { table: r.table }
+	});
+	let d = await b(e, r, u, "restore", `before restoring ${t.versionId}`, t.createdBy);
+	return await e.update(r.table, r.id, { [r.column]: f.restoreTo(u, s) }), d;
+}, w = async (e, t) => {
+	let n = (await g(e, o, c("id", t.versionId), 1))[0];
+	if (n === void 0) return;
+	let r = {
+		table: String(n.tableName),
+		id: String(n.rowId),
+		column: String(n.columnName)
+	}, i = await _(e, r);
+	if (i === void 0) return;
+	let s = n.state;
+	if (s instanceof Uint8Array) {
+		if (a(s) !== void 0) throw new l({
+			field: r.column,
+			message: "crdt.openRestoreIsServerSide",
+			params: { table: r.table }
+		});
+		return {
+			undoPoint: await b(e, r, i.state ?? p(), "restore", `before restoring ${t.versionId}`, t.createdBy),
+			versionLog: s
+		};
+	}
+}, T = async (r, l) => {
+	let u = await _(r, l);
+	if (u === void 0) return;
+	let d = u.state, f = await g(r, o, s(c("tableName", l.table), c("rowId", l.id), c("columnName", l.column)));
+	return {
+		bytes: d?.length ?? 0,
+		epoch: d === void 0 ? null : y(d),
+		authors: d === void 0 ? 0 : a(d)?.authors ?? 0,
+		versions: f.length,
+		limits: {
+			compactMaxBytes: e(),
+			rebaseMaxBytes: i(),
+			maxDocumentBytes: t(),
+			maxUpdateBytes: n()
+		}
+	};
+}, E = async (e, t) => {
+	let n = m(r(t.table, t.column)), i = t.batchSize ?? 200, a = 0, o = 0;
+	for (let r = 0;; r += i) {
+		let s = await e.query({
+			table: t.table,
+			predicate: void 0,
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: i,
+			skip: r,
+			projection: void 0
+		});
+		for (let r of s) {
+			a += 1;
+			let i = r[t.column];
+			i instanceof Uint8Array && i.length !== 0 && (u(i) >= n || (await e.update(t.table, r.id, { [t.column]: p() }), o += 1));
+		}
+		if (s.length < i) break;
+	}
+	return {
+		scanned: a,
+		migrated: o
+	};
+};
+//#endregion
+export { T as crdtCellStats, S as listCrdtVersions, E as migrateCrdtColumn, w as prepareSealedCrdtRestore, C as restoreCrdtVersion, x as snapshotCrdt };

package/dist/crdtMerge.js

@@ -0,0 +1,179 @@
+import { ValidationError as e } from "@voltro/protocol";
+import { applyCrdtMigrations as t, applySealedFrame as n, defaultCrdtBackend as r, emptyCrdtState as i, mergeCrdtStates as a, setDefaultCrdtBackend as o } from "@voltro/local-first";
+//#region src/crdtMerge.ts
+var s = 524288, c = Symbol.for("@voltro/runtime:crdt-compact-max-bytes"), l = (e) => {
+	let t = globalThis;
+	t[c] = e;
+}, u = () => {
+	let e = globalThis[c];
+	if (e != null) return e;
+	let t = process.env.VOLTRO_CRDT_COMPACT_MAX_BYTES;
+	if (t !== void 0 && t !== "") {
+		let e = Number(t);
+		if (Number.isFinite(e) && e >= 0) return e;
+	}
+	return s;
+}, d = (e, t, n) => {
+	if (n instanceof Uint8Array && t instanceof Uint8Array) try {
+		let e = r.createDoc(t), i = r.createDoc(n);
+		return e.epoch() === i.epoch() ? i.encodeUpdateSince(e.stateVector()) : void 0;
+	} catch {
+		return;
+	}
+}, f = (e, t, n) => {
+	if (!(n instanceof Uint8Array) || !(t instanceof Uint8Array)) return n;
+	try {
+		return a(t, n);
+	} catch {
+		return n;
+	}
+}, p = 1048576, m = 16777216, h = 4194304, g = Symbol.for("@voltro/runtime:crdt-admission"), _ = (e) => {
+	globalThis[g] = e;
+}, v = () => globalThis[g] ?? {}, y = (e, t, n) => {
+	if (e != null) return e;
+	let r = process.env[t];
+	if (r !== void 0 && r !== "") {
+		let e = Number(r);
+		if (Number.isFinite(e) && e >= 0) return e;
+	}
+	return n;
+}, b = () => y(v().maxUpdateBytes, "VOLTRO_CRDT_MAX_UPDATE_BYTES", p), x = () => y(v().maxDocumentBytes, "VOLTRO_CRDT_MAX_DOCUMENT_BYTES", m), S = () => y(v().rebaseMaxBytes, "VOLTRO_CRDT_REBASE_MAX_BYTES", h), C = (t, n, o) => {
+	if (!(o instanceof Uint8Array)) return;
+	let s = b();
+	if (s > 0 && o.length > s) throw new e({
+		field: n,
+		message: "crdt.updateTooLarge",
+		params: {
+			table: t,
+			bytes: o.length,
+			maxBytes: s
+		}
+	});
+	try {
+		a(i(), o);
+	} catch {
+		try {
+			r.authorsOf(o);
+		} catch {
+			throw new e({
+				field: n,
+				message: "crdt.updateNotDecodable",
+				params: { table: t }
+			});
+		}
+	}
+}, w = (e) => {
+	let t = u();
+	if (t === 0 || e.length <= t) return e;
+	let n = r.compact(e);
+	return n.length < e.length ? n : e;
+}, T = (n, o, s, c = "", l) => {
+	if (n.size === 0) return s;
+	let u;
+	for (let d of n) {
+		if (!(d in s)) continue;
+		let n = s[d];
+		if (!(n instanceof Uint8Array)) continue;
+		let f = o?.[d], p = f instanceof Uint8Array ? f : void 0;
+		C(c, d, n);
+		let m;
+		try {
+			m = w(a(p ?? i(), n));
+		} catch {
+			throw new e({
+				field: d,
+				message: "crdt.updateNotDecodable",
+				params: { table: c }
+			});
+		}
+		if (p !== void 0 && r.missingDependencies?.(m) === !0 && r.missingDependencies(p) !== !0) throw new e({
+			field: d,
+			message: "crdt.updateNotDecodable",
+			params: { table: c }
+		});
+		let h = v().migrations?.[c]?.[d];
+		if (h !== void 0) {
+			let e = r.carryReplaced?.(m, n);
+			e !== void 0 && (m = a(m, e)), m = t(m, h) ?? m;
+		}
+		let g = S();
+		l !== void 0 && g > 0 && m.length > g && (l(d, m), m = r.rebase(m, crypto.randomUUID()));
+		let _ = x();
+		if (_ > 0 && m.length > _) throw new e({
+			field: d,
+			message: "crdt.documentTooLarge",
+			params: {
+				table: c,
+				bytes: m.length,
+				maxBytes: _
+			}
+		});
+		let y = v().validate?.({
+			table: c,
+			column: d,
+			state: m,
+			previous: p,
+			update: n
+		});
+		if (y !== void 0) throw new e({
+			field: d,
+			message: y,
+			params: { table: c }
+		});
+		u === void 0 && (u = { ...s }), u[d] = m;
+	}
+	return u ?? s;
+}, E = (e, t) => {
+	if (e.size === 0) return !1;
+	for (let n of e) if (n in t) return !0;
+	return !1;
+}, D = (e) => {
+	try {
+		return {
+			epoch: r.epochOf(e) ?? null,
+			authors: r.authorsOf(e).size
+		};
+	} catch {
+		return;
+	}
+}, O = (t, r, i, a) => {
+	if (!(a instanceof Uint8Array)) throw new e({
+		field: r,
+		message: "crdt.sealedFrameInvalid",
+		params: { table: t }
+	});
+	let o = b();
+	if (o > 0 && a.length > o) throw new e({
+		field: r,
+		message: "crdt.updateTooLarge",
+		params: {
+			table: t,
+			bytes: a.length,
+			maxBytes: o
+		}
+	});
+	let s = n(i instanceof Uint8Array ? i : void 0, a);
+	if ("refused" in s) {
+		let n = s.refused === "stale-lineage" ? "crdt.staleLineage" : s.refused === "snapshot-stale" ? "crdt.sealedSnapshotStale" : "crdt.sealedFrameInvalid";
+		throw new e({
+			field: r,
+			message: n,
+			params: { table: t }
+		});
+	}
+	let c = x();
+	if (c > 0 && s.log.length > c) throw new e({
+		field: r,
+		message: "crdt.documentTooLarge",
+		params: {
+			table: t,
+			bytes: s.log.length,
+			maxBytes: c
+		}
+	});
+	return s;
+}, k = (e) => {
+	o(e);
+}, A = (e, t) => v().migrations?.[e]?.[t] ?? [];
+//#endregion
+export { s as DEFAULT_CRDT_COMPACT_MAX_BYTES, m as DEFAULT_CRDT_MAX_DOCUMENT_BYTES, p as DEFAULT_CRDT_MAX_UPDATE_BYTES, h as DEFAULT_CRDT_REBASE_MAX_BYTES, O as applySealedWrite, C as assertCrdtUpdateAdmissible, u as crdtCompactMaxBytes, f as crdtFoldCell, d as crdtIncrementalCell, x as crdtMaxDocumentBytes, b as crdtMaxUpdateBytes, A as crdtMigrationsFor, S as crdtRebaseMaxBytes, D as describeCrdtState, T as mergeCrdtColumnsIntoPatch, E as patchTouchesCrdt, _ as setCrdtAdmission, k as setCrdtBackend, l as setCrdtCompactMaxBytes };

package/dist/crdtVersionsTable.js

@@ -0,0 +1,25 @@
+import { bytes as e, id as t, table as n, text as r, timestamp as i } from "@voltro/database";
+//#region src/crdtVersionsTable.ts
+var a = "_voltro_crdt_versions", o = n(a, {
+	id: t({ prefix: "crdtv" }),
+	tableName: r(),
+	rowId: r(),
+	columnName: r(),
+	state: e().serverOnly(),
+	reason: r().oneOf([
+		"snapshot",
+		"restore",
+		"rebase"
+	]),
+	label: r().nullable(),
+	epoch: r().nullable(),
+	createdBy: r().nullable(),
+	createdAt: i().default("now")
+}).index("_voltro_crdt_versions_cell_created_idx", [
+	"tableName",
+	"rowId",
+	"columnName",
+	"createdAt"
+]);
+//#endregion
+export { a as CRDT_VERSIONS_TABLE, o as _voltroCrdtVersionsTable };

package/dist/credentialBound.js

@@ -0,0 +1,12 @@
+import { Duration as e, Effect as t, Ref as n, Stream as r } from "effect";
+//#region src/credentialBound.ts
+var i = (i, a, o, s) => {
+	if (a === void 0) return i;
+	let c = a * 1e3 - Date.now();
+	return c <= 0 ? o : s === void 0 ? r.interruptWhen(i, t.sleep(e.millis(c))) : r.unwrap(t.gen(function* () {
+		let a = yield* n.make(!1), o = t.sleep(e.millis(c)).pipe(t.andThen(n.set(a, !0)));
+		return r.concat(r.interruptWhen(i, o), r.unwrap(n.get(a).pipe(t.map((e) => e ? s : r.empty))));
+	}));
+};
+//#endregion
+export { i as boundByCredential };

package/dist/crud.js

@@ -0,0 +1,72 @@
+import { getTable as e, serverOnlyColumns as t } from "@voltro/database";
+import { ServerOnlyColumnWrite as n } from "@voltro/protocol";
+//#region src/crud.ts
+var r = (e, t) => {
+	if (t === void 0 || t.length === 0) return e;
+	let n = { ...e };
+	for (let e of t) delete n[e];
+	return n;
+}, i = (n, r) => {
+	let i = e(n), a = i === void 0 ? [] : t(i);
+	return a.length === 0 ? r ?? [] : r === void 0 ? a : [...r, ...a];
+}, a = (r, i) => {
+	let a = e(r);
+	if (a === void 0) return;
+	let o = t(a).filter((e) => i[e] !== void 0);
+	if (o.length !== 0) throw new n({
+		table: r,
+		columns: o
+	});
+}, o = (e, t) => t.length === 0 ? e : e.map((e) => r(e, t)), s = (e, t, n, r, i) => {
+	let a = {
+		...t?.(r) ?? {},
+		...n?.(i) ?? {}
+	}, o = e;
+	for (let [e, t] of Object.entries(a)) t !== void 0 && (o = o.where(e, t));
+	return o;
+}, c = 1e3, l = (e, t = c) => {
+	let n = (e) => typeof e == "number" && Number.isFinite(e) ? e : void 0, r = (e) => Math.max(1, Math.min(Math.floor(e), t)), i = n(e.page);
+	if (i !== void 0) {
+		let t = r(n(e.pageSize) ?? 100);
+		return {
+			limit: t,
+			offset: Math.max(0, Math.floor(i) - 1) * t
+		};
+	}
+	return {
+		limit: r(n(e.limit) ?? 100),
+		offset: Math.max(0, Math.floor(n(e.offset) ?? 0))
+	};
+}, u = {
+	list: (e, t = {}) => async (n, r) => {
+		let a = n ?? {}, c = r.store.select(e);
+		if (t.columns !== void 0 && t.columns.length > 0) {
+			let n = new Set(i(e, void 0)), r = t.columns.filter((e) => !n.has(e));
+			r.length > 0 && (c = c.select(...r));
+		}
+		t.include !== void 0 && (c = c.with(t.include)), c = s(c, t.filter, t.scope, a, r);
+		for (let e of t.sort ?? []) c = c.orderBy(e.column, e.direction ?? "asc");
+		if (t.paginate === !0) {
+			let { limit: e, offset: n } = l(a, t.maxPageSize);
+			c = c.limit(e).offset(n);
+		}
+		return o(await c.all(), i(e, t.redact));
+	},
+	getById: (e, t = {}) => async (n, a) => {
+		let o = a.store.select(e).where("id", n.id);
+		t.include !== void 0 && (o = o.with(t.include));
+		let s = await o.first();
+		return s === null ? null : r(s, i(e, t.redact));
+	},
+	create: (e, t = {}) => async (n, o) => (a(e, n), r(await o.store.insert(e, n), i(e, t.redact))),
+	update: (e, t = {}) => async (n, o) => {
+		let { id: s, ...c } = n;
+		a(e, c);
+		let l = await o.store.update(e, s, c);
+		return l === null ? null : r(l, i(e, t.redact));
+	},
+	count: (e, t = {}) => async (n, r) => s(r.store.select(e), t.filter, t.scope, n ?? {}, r).count(),
+	remove: (e) => async (t, n) => ({ deleted: await n.store.delete(e, t.id) })
+};
+//#endregion
+export { u as crud, o as redactColumns };