@voltro/runtime 0.84.0 → 0.86.0

package/dist/dispatcher.js

@@ -0,0 +1,447 @@
+import { IndexedMatcher as e } from "./matcher.js";
+import { canonicalize as t } from "./fingerprint.js";
+import { SubscriptionRegistry as n } from "./subscriptionRegistry.js";
+import { resolveReactiveConfig as r } from "./reactiveConfig.js";
+import { currentRawReads as i, runWithRawReadScope as a } from "./rawReadScope.js";
+import { crdtIncrementalCell as o } from "./crdtMerge.js";
+import { resolveDependentTables as s } from "./dependencyGraph.js";
+import { isEventRelevant as c, resolveRelevantFields as l } from "./relevantFields.js";
+import { recordSubscriptionActive as u } from "./metrics.js";
+import { applyRowFilterToDescriptor as d, rowFilterRegistered as f } from "./rowFilter.js";
+import { createDispatchWireStrip as p, stripForbiddenForWire as m } from "./wireColumnStrip.js";
+import { buildSubjectKey as h } from "./rywPositionStore.js";
+import { runWithRoutingContext as g } from "./replicatedDataStore.js";
+import { committedChangeBatchOf as _ } from "@voltro/database";
+import { randomUUID as v } from "node:crypto";
+import { diffRows as y, isIdKeyed as b } from "@voltro/protocol";
+import { createLogger as x } from "@voltro/logger";
+//#region src/dispatcher.ts
+var S = /* @__PURE__ */ new Set(), C = x({ scope: "voltro:dispatcher" }), w = (e) => Array.isArray(e) ? e.length : e == null ? 0 : 1, T = (e) => typeof e == "object" && !!e && (e._tag === "ScopeError" || e._tag === "Unauthenticated" || e._tag === "RequestedTenantRefused"), E = 1e3, D = 3e4, O = Object.freeze({
+	_tag: "QueryRecomputeFailed",
+	message: "The live query could not be refreshed. Retrying automatically."
+}), k = class {
+	deps;
+	subscriptionRegistry;
+	matcher;
+	subscriptions = /* @__PURE__ */ new Map();
+	unsubscribeChange;
+	dependentByTable = /* @__PURE__ */ new Map();
+	computedSubs = /* @__PURE__ */ new Map();
+	computedByTable = /* @__PURE__ */ new Map();
+	reactive;
+	rawReadWarned = /* @__PURE__ */ new Set();
+	changeEpoch = 0;
+	committedReads = /* @__PURE__ */ new WeakMap();
+	crdtColumnsFor(e) {
+		return this.deps.crdtColumnsOf?.(e) ?? S;
+	}
+	constructor(t) {
+		this.deps = t, this.matcher = new e(), this.subscriptionRegistry = new n(this.matcher), this.reactive = r(t.reactive), this.unsubscribeChange = t.store.onChange((e) => {
+			let t = _(e), n = t === void 0 ? void 0 : this.committedReads.get(t);
+			n === void 0 && (this.changeEpoch++, t !== void 0 && (n = {
+				epoch: this.changeEpoch,
+				reads: /* @__PURE__ */ new Map()
+			}, this.committedReads.set(t, n))), this.handleChange(e, !1, n);
+		});
+	}
+	warnUndeclaredRawReads(e, t) {
+		if (t.length !== 0 && !this.rawReadWarned.has(e)) {
+			this.rawReadWarned.add(e);
+			for (let n of t) C.warn(`${e}: a raw SQL read in this live query declares no dependsOn, so no write can invalidate it — every subscriber keeps its first result until it reconnects. Declare the tables it reads: ctx.store.raw(fragment, { dependsOn: ['orders'] }) — or on the fragment itself. The read: ${n.sql}`, {
+				label: e,
+				sql: n.sql
+			});
+		}
+	}
+	async subscribe(e, t, n, r, a, o, c, p, _ = !1) {
+		let y = `sub_${v()}`, b = a ?? `subscription.${e.table}`, x = s(e);
+		if (p === void 0 && f()) throw Error(`subscription "${b}" was opened without a row-filter resolver while a row filter is registered — this would read every row the filter exists to hide. Pass the resolver from \`makeDefaultRefilter(subject)\`, or pass one returning \`NO_ROW_FILTER\` to read unfiltered deliberately.`);
+		let S = l(e);
+		e.predicate !== void 0 && this.subscriptionRegistry.subscribe(y, e.table, e.predicate, r);
+		let C = e.predicate !== void 0 && (e.dependentTables?.length ?? 0) === 0 && e.eager === void 0 && e.setOp === void 0 && e.ctes === void 0 && e.alias === void 0 && (e.joins?.length ?? 0) === 0 && x.size === 1 && x.has(e.table);
+		for (let t of x) {
+			if (C && t === e.table) continue;
+			let n = this.dependentByTable.get(t);
+			n === void 0 && (n = /* @__PURE__ */ new Set(), this.dependentByTable.set(t, n)), n.add(y);
+		}
+		let w = Date.now(), T = Array.from(x), E = () => {
+			this.subscriptionRegistry.unsubscribe(y);
+			for (let e of x) {
+				let t = this.dependentByTable.get(e);
+				t !== void 0 && (t.delete(y), t.size === 0 && this.dependentByTable.delete(e));
+			}
+		}, D, O;
+		try {
+			D = p === void 0 ? e : d(await p(), e);
+			let t = _ ? await g({
+				subjectKey: h(n.subject.id, n.clientId),
+				forcePrimary: !0
+			}, () => this.deps.store.query(D)) : this.deps.cache !== void 0 && o !== void 0 ? await this.deps.cache.wrap(o, T, () => this.deps.store.query(D)) : await this.deps.store.query(D);
+			if (c !== void 0) {
+				let e = await c();
+				if (e) throw e;
+			}
+			O = m(D.table, t, n.subject);
+		} catch (e) {
+			throw E(), e;
+		}
+		this.warnUndeclaredRawReads(b, i().filter((e) => e.dependsOn.length === 0)), this.subscriptions.set(y, {
+			id: y,
+			descriptor: D,
+			baseDescriptor: e,
+			context: n,
+			emit: t,
+			label: b,
+			dependentTables: x,
+			relevantFields: S,
+			lastDelivered: O,
+			cacheBinding: o,
+			readFromPrimary: _,
+			reauthorize: c,
+			refilter: p,
+			memoKey: void 0
+		}), u(b, 1), t({
+			_tag: "snapshot",
+			revision: 0,
+			data: O
+		});
+		let k = Date.now();
+		return this.deps.recordDelivery?.({
+			traceId: n.traceId,
+			parentSpanId: n.spanId,
+			label: b,
+			kind: "snapshot",
+			startMs: w,
+			endMs: k,
+			durationMs: k - w,
+			rowCount: O.length
+		}), () => {
+			this.subscriptions.delete(y), u(b, -1), E();
+		};
+	}
+	revokeSubscription(e, t, n = "guards no longer satisfied") {
+		this.subscriptions.delete(e.id), u(e.label, -1), this.subscriptionRegistry.unsubscribe(e.id);
+		for (let t of e.dependentTables) {
+			let n = this.dependentByTable.get(t);
+			n !== void 0 && (n.delete(e.id), n.size === 0 && this.dependentByTable.delete(t));
+		}
+		C.warn(`subscription revoked mid-stream — ${n}`, {
+			id: e.id,
+			label: e.label,
+			traceId: e.context.traceId
+		}), e.emit({
+			_tag: "error",
+			error: t
+		});
+	}
+	removeComputed(e) {
+		if (this.computedSubs.get(e.id) !== e) return !1;
+		this.computedSubs.delete(e.id), e.retryTimer !== void 0 && clearTimeout(e.retryTimer), e.retryTimer = void 0, u(e.label, -1);
+		for (let t of e.tables) {
+			let n = this.computedByTable.get(t);
+			n !== void 0 && (n.delete(e.id), n.size === 0 && this.computedByTable.delete(t));
+		}
+		return !0;
+	}
+	revokeComputed(e, t) {
+		this.removeComputed(e) && (C.warn("computed subscription revoked mid-stream — guards no longer satisfied", {
+			id: e.id,
+			label: e.label,
+			traceId: e.context.traceId
+		}), e.emit({
+			_tag: "error",
+			error: t
+		}));
+	}
+	async subscribeComputed(e, t, n, r) {
+		let o = `csub_${v()}`, s = r ?? "subscription.computed", c = i(), l = new Set(e.dependentTables);
+		for (let e of c) for (let t of e.dependsOn) l.add(t);
+		let d = Array.from(l);
+		this.warnUndeclaredRawReads(s, c.filter((e) => e.dependsOn.length === 0));
+		let f = {
+			id: o,
+			recompute: () => a(e.recompute),
+			tenantId: e.tenantId,
+			emit: t,
+			context: n,
+			label: s,
+			tables: d,
+			lastJson: A(e.value),
+			revision: 0,
+			failed: !1,
+			retryAttempts: 0,
+			retryTimer: void 0,
+			running: !1,
+			rerunRequested: !1
+		};
+		this.computedSubs.set(o, f), u(f.label, 1);
+		for (let e of d) {
+			let t = this.computedByTable.get(e);
+			t === void 0 && (t = /* @__PURE__ */ new Set(), this.computedByTable.set(e, t)), t.add(o);
+		}
+		let p = Date.now();
+		return t({
+			_tag: "snapshot",
+			revision: 0,
+			data: e.value
+		}), this.deps.recordDelivery?.({
+			traceId: n.traceId,
+			parentSpanId: n.spanId,
+			label: f.label,
+			kind: "snapshot",
+			startMs: p,
+			endMs: Date.now(),
+			durationMs: Date.now() - p,
+			rowCount: w(e.value)
+		}), () => {
+			this.removeComputed(f);
+		};
+	}
+	async recomputeComputed(e) {
+		if (this.computedSubs.get(e.id) === e) {
+			if (e.running) e.rerunRequested = !0;
+			else {
+				e.retryTimer !== void 0 && clearTimeout(e.retryTimer), e.retryTimer = void 0, e.running = !0;
+				try {
+					do {
+						e.rerunRequested = !1;
+						let t = Date.now(), n = await e.recompute();
+						if (this.computedSubs.get(e.id) !== e) return;
+						if (e.rerunRequested) continue;
+						let r = A(n), i = e.failed;
+						if (e.failed = !1, e.retryAttempts = 0, r === e.lastJson && !i) return;
+						e.lastJson = r, e.revision += 1;
+						let a = Date.now();
+						e.emit({
+							_tag: "snapshot",
+							revision: e.revision,
+							data: n
+						}), this.deps.recordDelivery?.({
+							traceId: e.context.traceId,
+							parentSpanId: e.context.spanId,
+							label: e.label,
+							kind: "delta",
+							startMs: t,
+							endMs: a,
+							durationMs: a - t,
+							rowCount: w(n)
+						}), this.deps.recordCost !== void 0 && this.deps.recordCost({
+							tenantId: e.tenantId,
+							subscriptionId: e.id,
+							unit: "recompute",
+							amount: 1,
+							traceId: e.context.traceId
+						});
+					} while (e.rerunRequested);
+				} catch (t) {
+					if (this.computedSubs.get(e.id) !== e) return;
+					if (T(t)) {
+						this.revokeComputed(e, t);
+						return;
+					}
+					e.failed || (e.failed = !0, e.emit({
+						_tag: "error",
+						error: O
+					}), C.warn("computed recompute failed; retrying with last value marked stale", {
+						id: e.id,
+						label: e.label,
+						traceId: e.context.traceId
+					}, t));
+					let n = Math.min(D, E * 2 ** Math.min(e.retryAttempts, 5));
+					if (e.retryAttempts += 1, this.computedSubs.get(e.id) !== e) return;
+					e.retryTimer = setTimeout(() => {
+						e.retryTimer = void 0, this.recomputeComputed(e);
+					}, n), e.retryTimer.unref();
+				} finally {
+					e.running = !1;
+				}
+			}
+		}
+	}
+	subscriptionSnapshot() {
+		return this.subscriptionRegistry.snapshot();
+	}
+	matcherStats() {
+		return this.matcher.stats?.() ?? { perTable: [] };
+	}
+	onSubscriptionsChange(e) {
+		return this.subscriptionRegistry.onChange(e);
+	}
+	close() {
+		this.unsubscribeChange();
+		for (let e of this.computedSubs.values()) this.removeComputed(e);
+	}
+	async refreshAll(e) {
+		let t = /* @__PURE__ */ new Set();
+		for (let e of this.subscriptions.values()) t.add(e.descriptor.table);
+		for (let e of this.computedByTable.keys()) t.add(e);
+		if (t.size !== 0) {
+			C.warn("refreshing every live subscription", {
+				reason: e,
+				tables: t.size,
+				subscriptions: this.subscriptions.size
+			});
+			for (let e of t) await this.handleChange({
+				table: e,
+				op: "insert",
+				new: {},
+				old: void 0
+			}, !0);
+		}
+	}
+	async handleChange(e, n = !1, r) {
+		n && this.changeEpoch++;
+		let i = this.computedByTable.get(e.table);
+		if (i !== void 0 && i.size > 0) for (let e of i) {
+			let t = this.computedSubs.get(e);
+			t !== void 0 && this.recomputeComputed(t);
+		}
+		let a = n || e.oversized === "tombstone" || e.oversized === "unrecovered", s = a ? [] : this.subscriptionRegistry.notify(e), l = /* @__PURE__ */ new Set();
+		for (let e of s) l.add(e.subscriberId);
+		if (a) for (let [t, n] of this.subscriptions) n.descriptor.table === e.table && l.add(t);
+		let u = this.dependentByTable.get(e.table);
+		if (u !== void 0) for (let e of u) l.add(e);
+		if (C.trace("handleChange", {
+			table: e.table,
+			op: e.op,
+			matcher: s.length,
+			dependent: u?.size ?? 0,
+			triggered: l.size
+		}), l.size === 0) return;
+		let f = Date.now(), _ = 0, v = /* @__PURE__ */ new Map(), x = l.size > 1 ? p() : void 0, w = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Map(), E = async (i) => {
+			let a = this.subscriptions.get(i);
+			if (!a) {
+				C.trace("missing subscription", { subscriberId: i });
+				return;
+			}
+			if (!n && !c(e, a.relevantFields)) {
+				_++;
+				return;
+			}
+			let s = Date.now();
+			try {
+				if (a.reauthorize !== void 0) {
+					let e = await a.reauthorize();
+					if (e) {
+						this.revokeSubscription(a, e);
+						return;
+					}
+				}
+				let n, c;
+				if (a.refilter === void 0) n = a.descriptor, a.memoKey ??= JSON.stringify(t(n)), c = a.memoKey;
+				else {
+					let e;
+					try {
+						e = await a.refilter();
+					} catch (e) {
+						this.revokeSubscription(a, e, "row filter unavailable");
+						return;
+					}
+					try {
+						n = d(e, a.baseDescriptor);
+					} catch (e) {
+						this.revokeSubscription(a, e, "row filter declaration violated");
+						return;
+					}
+					c = JSON.stringify(t(n));
+				}
+				c = `${a.readFromPrimary ? "primary" : "policy"}:${c}`;
+				let l = r?.epoch === this.changeEpoch ? r.reads : v, u = l.get(c);
+				u === void 0 && (u = a.readFromPrimary ? g({
+					subjectKey: h(a.context.subject.id, a.context.clientId),
+					forcePrimary: !0
+				}, () => this.deps.store.query(n)) : this.deps.store.query(n), l.set(c, u));
+				let p = await u;
+				if (a.reauthorize !== void 0) {
+					let e = await a.reauthorize();
+					if (e) {
+						this.revokeSubscription(a, e);
+						return;
+					}
+				}
+				let _ = x?.(n.table, p, a.context.subject), E = _?.rows ?? m(n.table, p, a.context.subject);
+				_ !== void 0 && (c = JSON.stringify([c, _.visibilityKey]));
+				let D = a.lastDelivered, O = T.get(c);
+				O === void 0 && (O = /* @__PURE__ */ new Map(), T.set(c, O));
+				let k = O.get(D);
+				if (k === void 0 && (k = !j(E, D), O.set(D, k)), !k) {
+					C.trace("suppressed no-op delta", {
+						subscriberId: i,
+						table: e.table
+					});
+					return;
+				}
+				if (a.lastDelivered = E, this.deps.cache !== void 0 && a.cacheBinding !== void 0 && this.deps.cache.put(a.cacheBinding, Array.from(a.dependentTables), E), b(D) && b(E)) {
+					let e = w.get(c);
+					e === void 0 && (e = /* @__PURE__ */ new Map(), w.set(c, e));
+					let t = e.get(D);
+					if (t === void 0) {
+						let n = this.deps.crdtColumnsOf?.(a.descriptor.table) ?? S;
+						t = n.size === 0 ? y(D, E) : y(D, E, { crdt: {
+							columns: n,
+							incremental: o
+						} }), e.set(D, t);
+					}
+					a.emit({
+						_tag: "delta",
+						revision: f,
+						emittedAt: f,
+						patch: t
+					});
+				} else a.emit({
+					_tag: "snapshot",
+					revision: f,
+					data: E
+				});
+				let A = Date.now();
+				this.deps.recordDelivery?.({
+					traceId: a.context.traceId,
+					parentSpanId: a.context.spanId,
+					label: a.label,
+					kind: "delta",
+					startMs: s,
+					endMs: A,
+					durationMs: A - s,
+					rowCount: E.length
+				}), this.deps.recordCost !== void 0 && this.deps.recordCost({
+					tenantId: a.context.subject.tenantId,
+					subscriptionId: a.id,
+					unit: "recompute",
+					amount: 1,
+					traceId: a.context.traceId
+				});
+			} catch (t) {
+				C.warn("reactive re-query failed; subscriber left on last snapshot", {
+					subscriberId: i,
+					label: a.label,
+					table: e.table,
+					traceId: a.context.traceId
+				}, t);
+			}
+		}, D = Array.from(l), O = Math.max(1, Math.min(this.reactive.deliveryConcurrency, D.length)), k = 0, A = async () => {
+			for (;;) {
+				let e = k++;
+				if (e >= D.length) return;
+				await E(D[e]);
+			}
+		};
+		await Promise.all(Array.from({ length: O }, () => A())), _ > 0 && C.trace("handleChange/prefiltered", {
+			table: e.table,
+			op: e.op,
+			skipped: _
+		});
+	}
+}, A = (e) => {
+	try {
+		return JSON.stringify(e) ?? "null";
+	} catch {
+		return String(e);
+	}
+}, j = (e, t) => {
+	if (e === t) return !0;
+	if (e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (JSON.stringify(e[n]) !== JSON.stringify(t[n])) return !1;
+	return !0;
+};
+//#endregion
+export { k as Dispatcher, w as deliveredRowCount };

package/dist/effectStore.js

@@ -0,0 +1,71 @@
+import { Context as e, Effect as t, Exit as n, Layer as r } from "effect";
+import { authoredError as i, describeDriverError as a, wireSafeCause as o } from "@voltro/database";
+import { StoreOperationFailed as s } from "@voltro/protocol";
+import { createLogger as c } from "@voltro/logger";
+//#region src/effectStore.ts
+var l = c({ scope: "store" }), u = class extends e.Service()("@voltro/EffectStore") {}, d = {
+	TenantScopeViolation: !0,
+	TenantRowNotFound: !0,
+	ServerOnlyColumnWrite: !0,
+	StoreOperationFailed: !0,
+	TableValidationFailed: !0,
+	ConstraintViolation: !0
+}, f = (e) => {
+	let t = e?._tag;
+	return typeof t == "string" && Object.hasOwn(d, t);
+}, p = (e, t) => (n) => f(n) ? n : (l.warn("store operation failed", {
+	operation: e,
+	table: t,
+	detail: a(n) ?? String(n)
+}), new s({
+	operation: e,
+	table: t,
+	cause: o(n, e)
+})), m = (e, n, r) => t.tryPromise({
+	try: r,
+	catch: p(e, n)
+}), h = (e) => ("descriptor" in e ? e.descriptor : e).table, g = (e, n) => t.tryPromise({
+	try: n,
+	catch: (t) => t?._tag === "NoRowFound" ? t : p("one", e)(t)
+}), _ = class extends Error {
+	effectCause;
+	constructor(e) {
+		super("Effect program failed inside store transaction"), this.effectCause = e;
+	}
+}, v = (e) => ({
+	query: ((t) => m("query", t.table, () => e.query(t))),
+	insert: (t, n) => m("insert", t, () => e.insert(t, n)),
+	insertMany: (t, n) => m("insertMany", t, () => e.insertMany(t, n)),
+	patchJson: (t, n, r, i, a) => m("patchJson", t, () => e.patchJson(t, n, r, i, a)),
+	update: (t, n, r) => m("update", t, () => e.update(t, n, r)),
+	updateMany: (t, n, r) => m("updateMany", t, () => e.updateMany(t, n, r)),
+	delete: (t, n) => m("delete", t, () => e.delete(t, n)),
+	deleteMany: (t, n) => m("deleteMany", t, () => e.deleteMany(t, n)),
+	upsert: (t, n, r) => m("upsert", t, () => e.upsert(t, n, r)),
+	upsertWithOutcome: (t, n, r) => m("upsertWithOutcome", t, async () => {
+		if (e.upsertWithOutcome === void 0) throw i("upsertWithOutcome: this store does not implement it — the framework's store wrapper does; a hand-written DataStore must add it");
+		return e.upsertWithOutcome(t, n, r);
+	}),
+	insertIgnore: (t, n, r) => m("insertIgnore", t, () => e.insertIgnore(t, n, r)),
+	insertIgnoreWithOutcome: (t, n, r) => m("insertIgnoreWithOutcome", t, async () => e.insertIgnoreWithOutcome(t, n, r)),
+	one: ((t) => g(h(t), () => e.one(t))),
+	maybeOne: ((t) => m("maybeOne", h(t), () => e.maybeOne(t))),
+	first: ((t) => m("first", h(t), () => e.first(t))),
+	hardDelete: (t, n) => m("hardDelete", t, () => e.hardDelete(t, n)),
+	transactional: (r) => t.flatMap(t.context(), (i) => t.callback((o) => {
+		let s;
+		e.transactional(async (e) => {
+			let a = await t.runPromiseExitWith(i)(r(v(e)));
+			if (n.isFailure(a)) throw s = a.cause, new _(a.cause);
+			return a.value;
+		}).then((e) => o(t.succeed(e)), (e) => {
+			e instanceof _ ? o(t.failCause(e.effectCause)) : s === void 0 ? o(t.fail(p("transactional", "<transaction>")(e))) : (l.warn("transaction rollback failed after the work did", { detail: a(e) ?? String(e) }), o(t.failCause(s)));
+		});
+	}))
+}), y = (e) => r.succeed(u, v(e)), b = (e) => ({
+	conflictColumns: e.conflictColumns,
+	...e.update === void 0 ? {} : { update: e.update },
+	...e.updateValues === void 0 ? {} : { updateValues: e.updateValues }
+}), x = (e, t, n) => e.insert(t.tableName, n), S = (e, t, n) => e.insertMany(t.tableName, n), C = (e, t, n, r) => e.upsert(t.tableName, n, b(r)), w = (e, t, n, r) => e.upsertWithOutcome(t.tableName, n, b(r)), T = (e, t, n, r) => e.insertIgnoreWithOutcome(t.tableName, n, { conflictColumns: r.conflictColumns });
+//#endregion
+export { u as EffectStore, T as insertIgnoreRowOutcomeEffect, S as insertManyRowsEffect, x as insertRowEffect, y as makeEffectStoreLayer, C as upsertRowEffect, w as upsertRowOutcomeEffect };