@voltro/runtime 0.85.0 → 0.87.0

package/dist/aggregate.js

@@ -0,0 +1,42 @@
+import { classifyShape as e } from "./ivm.js";
+import { Context as t, Effect as n, Schema as r } from "effect";
+//#region src/aggregate.ts
+var i = (t) => {
+	let n = typeof t.refresh == "string" ? { interval: t.refresh } : t.refresh, r = t.strategy ?? "replace";
+	if (r === "merge" && (t.mergeKey === void 0 || t.mergeKey.length === 0)) throw Error(`defineAggregate("${t.name}"): strategy: 'merge' requires mergeKey — the property on each row to upsert by`);
+	if (t.incremental !== void 0) {
+		let n = e({
+			aggregations: [{
+				op: t.incremental.op,
+				...t.incremental.column === void 0 ? {} : { column: t.incremental.column }
+			}],
+			...t.incremental.groupBy === void 0 ? {} : { groupBy: t.incremental.groupBy }
+		});
+		if (!n.maintainable) throw Error(`defineAggregate("${t.name}"): incremental shape is not maintainable — ${n.reason}. Drop \`incremental\` to use the scheduled full-recompute path.`);
+		if (t.incremental.source.length === 0) throw Error(`defineAggregate("${t.name}"): incremental.source (the CDC table) is required`);
+	}
+	return {
+		_voltroAggregate: !0,
+		name: t.name,
+		refresh: n,
+		output: t.output,
+		indexes: t.indexes ?? [],
+		bootRefresh: t.bootRefresh ?? "persistent",
+		strategy: r,
+		...t.mergeKey === void 0 ? {} : { mergeKey: t.mergeKey },
+		build: t.build,
+		...t.incremental === void 0 ? {} : { incremental: t.incremental }
+	};
+}, a = (e) => typeof e == "object" && !!e && e._voltroAggregate === !0, o = class extends r.TaggedError()("AggregateStale", {
+	name: r.String,
+	ageMs: r.Number,
+	maxAgeMs: r.Number
+}) {}, s = class extends r.TaggedError()("AggregateNotFound", { name: r.String }) {}, c = class extends r.TaggedError()("AggregateError", {
+	name: r.String,
+	operation: r.String,
+	cause: r.String
+}) {}, l = class extends t.Service()("@voltro/AggregateRegistry") {}, u = (e) => n.gen(function* () {
+	return (yield* l).getHandle(e);
+});
+//#endregion
+export { c as AggregateError, s as AggregateNotFound, l as AggregateRegistry, o as AggregateStale, i as defineAggregate, a as isAggregateDefinition, u as useAggregate };

package/dist/aggregateExtrema.js

@@ -0,0 +1,80 @@
+import { RangeIndex as e } from "./rangeIndex.js";
+import { groupKeyOf as t } from "./ivm.js";
+//#region src/aggregateExtrema.ts
+var n = Symbol("unavailable"), r = (e, r) => {
+	let i = Object.getPrototypeOf(r);
+	if (i !== Object.prototype && i !== null) return;
+	let a = (e) => {
+		let t = Object.getOwnPropertyDescriptor(r, e);
+		return t === void 0 ? e in r ? n : void 0 : "value" in t ? t.value : n;
+	}, o = a("id");
+	if (typeof o != "string" && (typeof o != "number" || !Number.isFinite(o))) return;
+	let s = e.column === void 0 ? 0 : a(e.column);
+	if (s === n || typeof s == "object" && s || typeof s == "function" || typeof s == "symbol") return;
+	let c = Number(s ?? 0);
+	if (!Number.isFinite(c) || Object.is(c, -0)) return;
+	for (let t of e.groupBy ?? []) {
+		let e = a(t);
+		if (e === n || typeof e == "object" && e || typeof e == "function" || typeof e == "symbol" || typeof e == "bigint") return;
+	}
+	let l = /* @__PURE__ */ new Set([
+		"id",
+		...e.column === void 0 ? [] : [e.column],
+		...e.groupBy ?? []
+	]), u = Object.fromEntries([...l].map((e) => [e, a(e)]));
+	return {
+		id: `${typeof o}:${String(o)}`,
+		key: t(r, e.groupBy),
+		value: c,
+		image: u
+	};
+}, i = class t {
+	shape;
+	static capacity = 1e5;
+	rows = /* @__PURE__ */ new Map();
+	groups = /* @__PURE__ */ new Map();
+	constructor(e) {
+		this.shape = e;
+	}
+	static seed(e, n) {
+		if (e.op !== "min" && e.op !== "max" || n.length > t.capacity) return;
+		let i = new t(e);
+		for (let t of n) {
+			let n = r(e, t);
+			if (n === void 0 || i.rows.has(n.id)) return;
+			i.add(n);
+		}
+		return i;
+	}
+	add(t) {
+		let n = this.groups.get(t.key);
+		n === void 0 && (n = new e(), this.groups.set(t.key, n)), n.add(t.id, t.value), this.rows.set(t.id, t);
+	}
+	withPreviousRow(e) {
+		if (e.op !== "update" || e.old != null || e.new == null) return e;
+		let t = r(this.shape, e.new), n = t === void 0 ? void 0 : this.rows.get(t.id);
+		return n === void 0 ? e : {
+			...e,
+			old: n.image
+		};
+	}
+	apply(e) {
+		let n = e.op === "insert" ? void 0 : e.old, i = e.op === "delete" ? void 0 : e.new, a = n == null ? void 0 : r(this.shape, n), o = i == null ? void 0 : r(this.shape, i);
+		if (n != null && a === void 0 || i != null && o === void 0) return !1;
+		if (a !== void 0) {
+			let e = this.rows.get(a.id);
+			if (e === void 0 || e.key !== a.key || e.value !== a.value) return !1;
+		}
+		if (o !== void 0 && o.id !== a?.id && this.rows.has(o.id) || this.rows.size - (a === void 0 ? 0 : 1) + (o === void 0 ? 0 : 1) > t.capacity) return !1;
+		if (a !== void 0) {
+			let e = this.groups.get(a.key);
+			e.delete(a.id), e.size === 0 && this.groups.delete(a.key), this.rows.delete(a.id);
+		}
+		return o !== void 0 && this.add(o), !0;
+	}
+	value(e) {
+		return this.groups.get(e)?.numericExtreme(this.shape.op);
+	}
+};
+//#endregion
+export { i as AggregateExtrema };

package/dist/aggregateIvm.js

@@ -0,0 +1,115 @@
+import { applyDeltaInto as e, buildIvmState as t, groupKeyOf as n, ivmValue as r, materializeIvm as i, resolveRescanInto as a } from "./ivm.js";
+import { AggregateExtrema as o } from "./aggregateExtrema.js";
+//#region src/aggregateIvm.ts
+var s = class {
+	shape;
+	state = /* @__PURE__ */ new Map();
+	extrema;
+	groups = /* @__PURE__ */ new Map();
+	positions = /* @__PURE__ */ new Map();
+	nextPosition = 0;
+	constructor(e) {
+		this.shape = e;
+	}
+	seed(e) {
+		this.extrema = o.seed(this.shape, e), this.state = new Map(t(this.shape, e)), this.groups.clear(), this.positions.clear(), this.nextPosition = 0;
+		for (let e of this.state.keys()) this.positions.set(e, this.nextPosition++);
+		for (let t of e) {
+			let e = n(t, this.shape.groupBy);
+			this.groups.has(e) || this.groups.set(e, this.groupValues(t));
+		}
+	}
+	applyChange(t) {
+		let r = t.op === "update" && t.old == null;
+		t = this.extrema?.withPreviousRow(t) ?? t;
+		let i = r && t.old != null && t.new != null && n(t.old, this.shape.groupBy) !== n(t.new, this.shape.groupBy), a = r && t.old == null && (this.shape.op === "min" || this.shape.op === "max"), o = t.new;
+		if (o) {
+			let e = n(o, this.shape.groupBy);
+			this.groups.has(e) || this.groups.set(e, this.groupValues(o));
+		}
+		let s = this.extrema !== void 0 && !this.extrema.apply(t);
+		s && (this.extrema = void 0);
+		let c = e(this.shape, this.state, t, {
+			removed: (e) => {
+				this.positions.delete(e);
+			},
+			added: (e) => {
+				this.positions.set(e, this.nextPosition++);
+			}
+		});
+		for (let e of [t.old, t.new]) {
+			if (e == null) continue;
+			let t = n(e, this.shape.groupBy);
+			this.state.has(t) || this.groups.delete(t);
+		}
+		if ((i || a) && (this.extrema = void 0), this.extrema !== void 0) {
+			for (let e of [t.old, t.new]) {
+				if (e == null) continue;
+				let t = n(e, this.shape.groupBy), r = this.state.get(t);
+				r !== void 0 && this.state.set(t, {
+					...r,
+					extreme: this.extrema.value(t)
+				});
+			}
+			return [];
+		}
+		if (s || i || a) {
+			let e = new Set(a ? this.state.keys() : c.rescanGroups);
+			for (let r of [t.op === "insert" ? void 0 : t.old, t.op === "delete" ? void 0 : t.new]) r != null && e.add(n(r, this.shape.groupBy));
+			return [...e];
+		}
+		return c.rescanGroups;
+	}
+	resolveRescan(e, t) {
+		if (e.length === 0) return;
+		this.extrema = void 0, a(this.shape, this.state, e, t);
+		let r = new Set(e);
+		for (let e of t) {
+			let t = n(e, this.shape.groupBy);
+			r.has(t) && this.state.has(t) && !this.groups.has(t) && this.groups.set(t, this.groupValues(e));
+		}
+		for (let e of r) this.state.has(e) ? this.positions.has(e) || this.positions.set(e, this.nextPosition++) : (this.groups.delete(e), this.positions.delete(e));
+	}
+	materializeGroups(e) {
+		let t = [], n, i, a = 0;
+		for (let t of e) a === 0 ? n = t : (i === void 0 && (i = /* @__PURE__ */ new Set(), i.add(n)), i.add(t)), a += 1;
+		let o = (e) => {
+			let n = this.state.get(e);
+			n !== void 0 && t.push({
+				groupKey: e,
+				group: this.groups.get(e) ?? {},
+				value: r(this.shape, n),
+				rowIndex: this.positions.get(e)
+			});
+		};
+		if (i !== void 0) for (let e of i) o(e);
+		else a !== 0 && o(n);
+		return t;
+	}
+	materialize() {
+		let e = Object.getOwnPropertyDescriptor(this.shape, "op");
+		if (Object.getPrototypeOf(this.shape) === Object.prototype && e !== void 0 && "value" in e) {
+			let e = [];
+			for (let [t, n] of this.state) e.push({
+				groupKey: t,
+				group: this.groups.get(t) ?? {},
+				value: r(this.shape, n)
+			});
+			return e;
+		}
+		return i(this.shape, this.state).map((e) => ({
+			groupKey: e.groupKey,
+			group: this.groups.get(e.groupKey) ?? {},
+			value: e.value
+		}));
+	}
+	groupValues(e) {
+		let t = this.shape.groupBy;
+		if (t === void 0 || t.length === 0) return {};
+		let n = {};
+		for (let r of t) n[r] = e[r];
+		return n;
+	}
+};
+//#endregion
+export { s as AggregateMaintainer };

package/dist/analyticsMirror.js

@@ -0,0 +1,228 @@
+import { Cause as e, Duration as t, Effect as n, Metric as r, Schedule as i } from "effect";
+import { eq as a } from "@voltro/database";
+//#region src/analyticsMirror.ts
+var o = r.counter("voltro_analytics_mirror_forwarded_total", { description: "Reactive-table changes successfully applied to the analytics mirror." }), s = r.counter("voltro_analytics_mirror_retries_total", { description: "Analytics-mirror write attempts that failed (each is retried until the budget runs out)." }), c = r.counter("voltro_analytics_mirror_repair_queued_total", { description: "Analytics-mirror changes whose retries were exhausted and were queued for repair." }), l = r.counter("voltro_analytics_mirror_dropped_total", { description: "Analytics-mirror changes provably lost (repair queue overflow)." }), u = (e) => {
+	n.runSync(r.update(e, 1));
+}, d = (t) => e.pretty(t), f = {
+	retryAttempts: 5,
+	retryBaseDelayMs: 100,
+	retryMaxDelayMs: 3e4,
+	repairIntervalMs: 6e4,
+	repairQueueLimit: 1e4,
+	versionStateLimit: 1e5
+}, p = (e) => {
+	let t = process.env[e];
+	if (t === void 0 || t.trim() === "") return;
+	let n = Number(t);
+	return Number.isFinite(n) && n >= 0 ? n : void 0;
+}, m = (e) => {
+	let t = f, n = e ?? {};
+	return {
+		retryAttempts: Math.max(1, n.retryAttempts ?? p("VOLTRO_ANALYTICS_MIRROR_RETRY_ATTEMPTS") ?? t.retryAttempts),
+		retryBaseDelayMs: n.retryBaseDelayMs ?? p("VOLTRO_ANALYTICS_MIRROR_RETRY_BASE_MS") ?? t.retryBaseDelayMs,
+		retryMaxDelayMs: n.retryMaxDelayMs ?? p("VOLTRO_ANALYTICS_MIRROR_RETRY_MAX_MS") ?? t.retryMaxDelayMs,
+		repairIntervalMs: n.repairIntervalMs ?? p("VOLTRO_ANALYTICS_MIRROR_REPAIR_INTERVAL_MS") ?? t.repairIntervalMs,
+		repairQueueLimit: Math.max(1, n.repairQueueLimit ?? p("VOLTRO_ANALYTICS_MIRROR_REPAIR_QUEUE_LIMIT") ?? t.repairQueueLimit),
+		versionStateLimit: Math.max(1, n.versionStateLimit ?? p("VOLTRO_ANALYTICS_MIRROR_VERSION_STATE_LIMIT") ?? t.versionStateLimit)
+	};
+}, h = {
+	tables: [],
+	detach: () => {},
+	flush: () => Promise.resolve(),
+	repair: () => Promise.resolve(0),
+	stats: () => ({
+		forwarded: 0,
+		pending: 0,
+		awaitingRepair: 0,
+		dropped: 0
+	})
+}, g = (e, t) => `${e}\u0000${String(t)}`, _ = (e) => {
+	let { store: r, sink: f, log: p } = e, _ = f.mirror;
+	if (_ === void 0 || _.tables.length === 0) return h;
+	let v = m(e), y = e.run ?? ((e) => n.runPromise(e)), b = _.primaryKey ?? "id", x = new Set(_.tables), S = f.info.provider, C = r.changeScope === "fleet", w = 0, T = () => {
+		let e = Date.now() * 1e3;
+		return w = e > w ? e : w + 1, w;
+	}, E = /* @__PURE__ */ new Map(), D = /* @__PURE__ */ new Set(), O = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Set(), A = 0, j = 0, M = /* @__PURE__ */ new Map(), N = (e) => {
+		let t = M.get(e);
+		if (t === void 0 ? t = {
+			baseline: null,
+			ordinal: 0
+		} : M.delete(e), M.set(e, t), M.size > v.versionStateLimit) for (let t of M.keys()) {
+			if (M.size <= v.versionStateLimit) break;
+			t !== e && (E.has(t) || D.has(t) || O.has(t) || M.delete(t));
+		}
+		return t;
+	}, P = (e, t) => n.suspend(() => {
+		let r = M.get(e);
+		return r === void 0 ? n.fail(/* @__PURE__ */ Error(`analytics-mirror: no version state for ${t.table}`)) : r.baseline === null ? _.maxVersion({
+			table: t.table,
+			primaryKeyValue: t.pk
+		}).pipe(n.map((e) => (r.baseline = e ?? 0, r.baseline))) : n.succeed(r.baseline);
+	}), F = (e, t, r) => r.kind === "clock" ? n.succeed(r.version) : P(e, t).pipe(n.map((e) => e + r.ordinal)), I = i.exponential(t.millis(Math.max(1, v.retryBaseDelayMs)), 2), L = i.max([i.min([I, i.spaced(t.millis(Math.max(1, v.retryMaxDelayMs)))]), i.recurs(v.retryAttempts - 1)]), R = (e, t) => n.gen(function* () {
+		let n = yield* F(g(e.table, e.pk), e, t.stamp);
+		yield* t.kind === "upsert" ? _.upsert({
+			table: e.table,
+			row: t.row,
+			version: n
+		}) : _.remove({
+			table: e.table,
+			primaryKeyValue: e.pk,
+			version: n
+		});
+	}), z = (e) => e instanceof Error ? `${e.name}: ${e.message}` : String(e), B = (e, t) => R(e, t).pipe(n.tapCause(() => n.sync(() => {
+		u(s);
+	})), n.retry(L), n.matchCauseEffect({
+		onSuccess: () => n.sync(() => {
+			A += 1, u(o);
+		}),
+		onFailure: (r) => n.sync(() => {
+			V(e, t, d(r));
+		})
+	})), V = (e, t, n) => {
+		let r = g(e.table, e.pk);
+		for (p.warn("analytics-mirror: change forward failed, queued for repair", {
+			provider: S,
+			table: e.table,
+			op: t.kind,
+			attempts: v.retryAttempts,
+			err: n
+		}), O.set(r, e), u(c); O.size > v.repairQueueLimit;) {
+			let e = O.keys().next();
+			if (e.done === !0) break;
+			let t = O.get(e.value);
+			O.delete(e.value), j += 1, u(l), p.error("analytics-mirror: repair queue full — change dropped, mirror is diverged", {
+				provider: S,
+				table: t?.table ?? "<unknown>",
+				limit: v.repairQueueLimit
+			});
+		}
+	}, H = (e) => {
+		let t = E.get(e);
+		if (t === void 0) D.delete(e);
+		else return E.delete(e), t;
+	}, U = (e, t) => n.gen(function* () {
+		for (;;) {
+			let r = yield* n.sync(() => H(e));
+			if (r === void 0) return;
+			yield* B(t, r);
+		}
+	}), W = (e) => {
+		let t = Promise.resolve(y(e)).catch((e) => {
+			p.error("analytics-mirror: mirror worker crashed", {
+				provider: S,
+				err: z(e)
+			});
+		});
+		k.add(t), t.finally(() => {
+			k.delete(t);
+		});
+	}, G = (e, t) => {
+		let n = g(e.table, e.pk);
+		E.set(n, t), !D.has(n) && (D.add(n), W(U(n, e)));
+	}, K = (e) => n.tryPromise({
+		try: () => r.query({
+			table: e.table,
+			predicate: a(b, e.pk),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		}),
+		catch: (e) => e
+	}).pipe(n.map((e) => e[0] ?? null)), q = (e, t) => n.gen(function* () {
+		let n = C ? (yield* P(e, t)) + (M.get(e)?.ordinal ?? 0) : T(), r = yield* K(t);
+		return yield* r === null ? _.remove({
+			table: t.table,
+			primaryKeyValue: t.pk,
+			version: n
+		}) : _.upsert({
+			table: t.table,
+			row: r,
+			version: n
+		}), O.delete(e), A += 1, u(o), !0;
+	}).pipe(n.catchCause((e) => n.sync(() => (p.warn("analytics-mirror: repair pass failed, key stays queued", {
+		provider: S,
+		table: t.table,
+		err: d(e)
+	}), !1)))), J = () => n.gen(function* () {
+		let e = [...O.entries()];
+		if (e.length === 0) return 0;
+		let t = 0;
+		for (let [n, r] of e) (yield* q(n, r)) && (t += 1);
+		return t;
+	}), Y = () => {
+		let e = 0;
+		return Promise.resolve(y(J().pipe(n.tap((t) => n.sync(() => {
+			e = t;
+		})), n.asVoid))).then(() => e).catch((e) => (p.error("analytics-mirror: repair pass crashed", {
+			provider: S,
+			err: z(e)
+		}), 0));
+	}, X = v.repairIntervalMs > 0 ? setInterval(() => {
+		Y();
+	}, v.repairIntervalMs) : void 0;
+	X?.unref?.();
+	let Z = (e) => {
+		if (!C) return {
+			kind: "clock",
+			version: T()
+		};
+		let t = N(g(e.table, e.pk));
+		return t.ordinal += 1, {
+			kind: "ordinal",
+			ordinal: t.ordinal
+		};
+	}, Q = (e) => {
+		if (e.op === "delete") {
+			let t = e.old;
+			if (t === null) return;
+			let n = t[b];
+			if (n === void 0) return;
+			let r = {
+				table: e.table,
+				pk: n
+			};
+			G(r, {
+				kind: "remove",
+				stamp: Z(r)
+			});
+			return;
+		}
+		let t = e.new;
+		if (t === null) return;
+		let n = t[b];
+		if (n === void 0) return;
+		let r = {
+			table: e.table,
+			pk: n
+		};
+		G(r, {
+			kind: "upsert",
+			row: t,
+			stamp: Z(r)
+		});
+	}, $ = r.onChange((e) => {
+		x.has(e.table) && Q(e);
+	});
+	return {
+		tables: _.tables,
+		detach: () => {
+			$(), X !== void 0 && clearInterval(X);
+		},
+		flush: async () => {
+			for (let e = 0; e < 1e3; e++) {
+				if (k.size === 0 && E.size === 0) return;
+				await Promise.all([...k]);
+			}
+		},
+		repair: Y,
+		stats: () => ({
+			forwarded: A,
+			pending: E.size,
+			awaitingRepair: O.size,
+			dropped: j
+		})
+	};
+};
+//#endregion
+export { f as DEFAULT_ANALYTICS_MIRROR_TUNABLES, _ as attachAnalyticsMirror };

package/dist/analyticsSink.js

@@ -0,0 +1,32 @@
+import { Context as e, Effect as t, Option as n } from "effect";
+import { SubjectService as r } from "@voltro/protocol";
+import { AnalyticsCapabilityNotSupported as i, AnalyticsError as a } from "@voltro/kv/analytics";
+//#region src/analyticsSink.ts
+var o = class extends e.Service()("@voltro/AnalyticsSink") {}, s = (e, t) => ({
+	info: e.info,
+	track: (n) => e.track(n.tenantId === void 0 ? {
+		...n,
+		tenantId: t
+	} : n),
+	aggregate: (n) => e.aggregate(n.tenantId === void 0 ? {
+		...n,
+		tenantId: t
+	} : n),
+	timeseries: (n) => e.timeseries(n.tenantId === void 0 ? {
+		...n,
+		tenantId: t
+	} : n),
+	topN: (n) => e.topN(n.tenantId === void 0 ? {
+		...n,
+		tenantId: t
+	} : n),
+	...e.mirror === void 0 ? {} : { mirror: e.mirror }
+}), c = () => t.gen(function* () {
+	let e = yield* o, i = yield* t.serviceOption(r), a = n.match(i, {
+		onNone: () => null,
+		onSome: (e) => e.tenantId ?? null
+	});
+	return a === null ? e : s(e, a);
+});
+//#endregion
+export { i as AnalyticsCapabilityNotSupported, a as AnalyticsError, o as AnalyticsSink, c as useAnalytics };

package/dist/apiKeyUsage.js

@@ -0,0 +1,33 @@
+//#region src/apiKeyUsage.ts
+var e = (e) => {
+	let t = e.now ?? Date.now, n = e.intervalMs ?? 3e4, r = e.maxPending ?? 500, i = /* @__PURE__ */ new Map(), a = !1, o = async () => {
+		if (i.size === 0) return;
+		let t = i;
+		i = /* @__PURE__ */ new Map();
+		for (let [n, r] of t) try {
+			await e.flush(n, {
+				requests: r.requests,
+				lastUsedAt: r.lastUsedAt
+			});
+		} catch {}
+	}, s = setInterval(() => {
+		o();
+	}, n);
+	return s.unref?.(), {
+		touch: (e, n = t()) => {
+			if (a) return;
+			let s = i.get(e);
+			s === void 0 ? i.set(e, {
+				requests: 1,
+				lastUsedAt: n
+			}) : (s.requests += 1, n > s.lastUsedAt && (s.lastUsedAt = n)), i.size >= r && o();
+		},
+		flushNow: o,
+		shutdown: async () => {
+			a || (a = !0, clearInterval(s), await o());
+		},
+		pending: () => i.size
+	};
+};
+//#endregion
+export { e as makeApiKeyUsageBuffer };