@voltro/runtime 0.85.0 → 0.87.0

package/dist/eventBus.js

@@ -0,0 +1,260 @@
+import { recordEventDropped as e, recordEventPublished as t, recordEventSubscribers as n } from "./metrics.js";
+import { eventRoute as r, parseEventRoute as i } from "@voltro/protocol";
+import { createLogger as a } from "@voltro/logger";
+//#region src/eventBus.ts
+var o = a({ scope: "voltro:events" }), s = 64, c = 3e5, l = 1e4, u = class {
+	routes = /* @__PURE__ */ new Map();
+	origin;
+	ringSize;
+	ringTtlMs;
+	maxRoutes;
+	publishRemote;
+	deliveryOf;
+	interest = /* @__PURE__ */ new Map();
+	interestListeners = /* @__PURE__ */ new Set();
+	now;
+	constructor(e) {
+		this.origin = e.origin, this.ringSize = e.ringSize ?? s, this.ringTtlMs = e.ringTtlMs ?? c, this.maxRoutes = e.maxRoutes ?? l, this.publishRemote = e.publishRemote, this.deliveryOf = e.deliveryOf, this.now = e.now ?? Date.now;
+	}
+	get instanceOrigin() {
+		return this.origin;
+	}
+	onInterestChange(e) {
+		this.interestListeners.add(e);
+		for (let [t, n] of this.interest) n > 0 && e(t, !0);
+		return () => {
+			this.interestListeners.delete(e);
+		};
+	}
+	shiftInterest(e, t) {
+		let n = this.interest.get(e) ?? 0, r = n + t;
+		r <= 0 ? this.interest.delete(e) : this.interest.set(e, r), n === 0 && r === 1 ? this.notifyInterest(e, !0) : n === 1 && r === 0 && this.notifyInterest(e, !1);
+	}
+	notifyInterest(e, t) {
+		for (let n of this.interestListeners) try {
+			n(e, t);
+		} catch (n) {
+			o.warn("event interest listener threw", {
+				event: e,
+				active: t,
+				cause: n
+			});
+		}
+	}
+	activeEvents() {
+		return [...this.interest.keys()];
+	}
+	deliveryFor(e) {
+		return this.deliveryOf?.(e) ?? "each";
+	}
+	state(e) {
+		let t = this.routes.get(e);
+		if (t !== void 0) return t.lastTouched = this.now(), t;
+		this.evictIfOverCapacity();
+		let n = {
+			latest: this.deliveryOf?.(i(e).event) === "latest",
+			listeners: /* @__PURE__ */ new Set(),
+			watermark: /* @__PURE__ */ new Map(),
+			localNext: 1,
+			ring: [],
+			lastTouched: this.now()
+		};
+		return this.routes.set(e, n), n;
+	}
+	evictIfOverCapacity() {
+		if (this.routes.size < this.maxRoutes) return;
+		let e = Math.max(1, Math.floor(this.maxRoutes / 10)), t = this.coldestIdleRoutes(e), n = 0;
+		for (let r of t) {
+			if (n >= e) break;
+			this.routes.delete(r), n += 1;
+		}
+		if (n === 0) {
+			o.warn("event ring capacity reached with all routes live — replay buffers cleared", {
+				routes: this.routes.size,
+				maxRoutes: this.maxRoutes
+			});
+			for (let e of this.routes.values()) e.ring = [];
+		}
+	}
+	coldestIdleRoutes(e) {
+		let t = [], n = -Infinity, r = !0, i = Number.isFinite(e);
+		if (this.routes.forEach((a, o) => {
+			if (a.listeners.size !== 0) return;
+			let s = a.lastTouched;
+			Number.isFinite(s) || (i = !1), s < n && (r = !1), n = s, t.length < e && t.push(o);
+		}), !i) return [...this.routes.entries()].filter(([, e]) => e.listeners.size === 0).sort((e, t) => e[1].lastTouched - t[1].lastTouched).map(([e]) => e);
+		if (r) return t;
+		let a = [], o = (e, t) => e.at > t.at || e.at === t.at && e.order > t.order, s = () => {
+			let e = 0;
+			for (; e * 2 + 1 < a.length;) {
+				let t = e * 2 + 1;
+				if (t + 1 < a.length && o(a[t + 1], a[t]) && t++, !o(a[t], a[e])) break;
+				let n = a[e];
+				a[e] = a[t], a[t] = n, e = t;
+			}
+		}, c = 0;
+		return this.routes.forEach((t, n) => {
+			if (t.listeners.size !== 0) return;
+			let r = c++;
+			if (a.length < e) {
+				a.push({
+					route: n,
+					at: t.lastTouched,
+					order: r
+				});
+				let e = a.length - 1;
+				for (; e > 0;) {
+					let t = e - 1 >> 1;
+					if (!o(a[e], a[t])) break;
+					let n = a[t];
+					a[t] = a[e], a[e] = n, e = t;
+				}
+			} else {
+				let e = a[0];
+				if (t.lastTouched > e.at || t.lastTouched === e.at && r >= e.order) return;
+				e.route = n, e.at = t.lastTouched, e.order = r, s();
+			}
+		}), a.map((e) => e.route);
+	}
+	pruneRing(e) {
+		let t = this.now() - this.ringTtlMs, n = 0;
+		for (; n < e.ring.length && e.ring[n].at < t;) n += 1;
+		let r = Math.max(0, e.ring.length - n - this.ringSize), i = n + r;
+		i > 0 && e.ring.splice(0, i);
+	}
+	publish(e) {
+		let n = r(e.tenantId, e.event, e.key), i = this.state(n), a = {
+			route: n,
+			event: e.event,
+			origin: this.origin,
+			n: i.localNext,
+			emittedAt: this.now(),
+			payload: e.payload
+		};
+		if (i.localNext += 1, this.accept(i, a), t(e.event), this.publishRemote !== void 0) try {
+			this.publishRemote(a);
+		} catch (t) {
+			o.warn("event broadcast publish failed — local delivery unaffected", {
+				event: e.event,
+				cause: t
+			});
+		}
+		return a;
+	}
+	injectRemote(e) {
+		e.origin !== this.origin && this.accept(this.state(e.route), e);
+	}
+	accept(e, t) {
+		let n = e.watermark.get(t.origin) ?? 0;
+		t.n > n && e.watermark.set(t.origin, t.n);
+		let r = n;
+		e.latest ? e.ring = [{
+			envelope: t,
+			at: this.now()
+		}] : (e.ring.push({
+			envelope: t,
+			at: this.now()
+		}), this.pruneRing(e));
+		let i = {
+			kind: "event",
+			envelope: t,
+			prior: r
+		};
+		for (let n of e.listeners) try {
+			n(i);
+		} catch (e) {
+			o.warn("event listener threw — other subscribers unaffected", {
+				event: t.event,
+				cause: e
+			});
+		}
+	}
+	subscribe(e) {
+		let t = r(e.tenantId, e.event, e.key), i = this.state(t);
+		e.onAttach?.(new Map(i.watermark));
+		let a = !0, o = [], s = (t) => {
+			a ? o.push(t) : e.listener(t);
+		};
+		i.listeners.add(s), n(e.event, 1), this.shiftInterest(e.event, 1);
+		let c = e.options?.resume;
+		if (c !== void 0) this.replayForResume(i, c, e.listener);
+		else if (e.options?.rewind === !0) {
+			this.pruneRing(i);
+			for (let t of i.ring) e.listener({
+				kind: "event",
+				envelope: t.envelope,
+				prior: t.envelope.n - 1
+			});
+		}
+		a = !1;
+		for (let t of o) e.listener(t);
+		o.length = 0;
+		let l = !0;
+		return () => {
+			l && (l = !1, i.listeners.delete(s), n(e.event, -1), this.shiftInterest(e.event, -1));
+		};
+	}
+	replayForResume(t, n, r) {
+		if (t.latest) {
+			let e = t.ring[t.ring.length - 1];
+			if (e === void 0 || (n.find((t) => t.origin === e.envelope.origin)?.n ?? 0) >= e.envelope.n) return;
+			r({
+				kind: "event",
+				envelope: e.envelope,
+				prior: e.envelope.n - 1
+			});
+			return;
+		}
+		this.pruneRing(t);
+		let i = new Map(n.map((e) => [e.origin, e.n])), a = [];
+		for (let e of t.ring) {
+			let t = e.envelope;
+			t.n > (i.get(t.origin) ?? 0) && a.push(t);
+		}
+		a.sort((e, t) => e.origin === t.origin ? e.n - t.n : e.emittedAt - t.emittedAt);
+		let o = /* @__PURE__ */ new Map();
+		for (let e of a) o.set(e.origin, (o.get(e.origin) ?? 0) + 1);
+		let s = 0;
+		for (let [e, n] of t.watermark) {
+			let t = i.get(e) ?? 0, r = Math.max(0, n - t), a = o.get(e) ?? 0;
+			s += Math.max(0, r - a);
+		}
+		s > 0 && (r({
+			kind: "gap",
+			missed: s,
+			reason: "resume"
+		}), e(t.ring[0]?.envelope.event ?? "unknown", "resume", s));
+		for (let e of a) r({
+			kind: "event",
+			envelope: e,
+			prior: e.n - 1
+		});
+	}
+	stats() {
+		let e = 0, t = 0;
+		for (let n of this.routes.values()) e += n.listeners.size, t += n.ring.length;
+		return {
+			routes: this.routes.size,
+			subscribers: e,
+			buffered: t
+		};
+	}
+	snapshot() {
+		let e = [];
+		return this.routes.forEach((t, n) => {
+			let r = t.ring[t.ring.length - 1]?.envelope;
+			e.push({
+				route: n,
+				event: r?.event ?? i(n).event,
+				subscribers: t.listeners.size,
+				buffered: t.ring.length,
+				lastEmittedAt: r?.emittedAt
+			});
+		}), e;
+	}
+	clear() {
+		this.routes.clear();
+	}
+};
+//#endregion
+export { u as EventBus };

package/dist/eventPublish.js

@@ -0,0 +1,49 @@
+import { Context as e, Effect as t, Schema as n } from "effect";
+import { EventKeyInvalid as r, EventPayloadInvalid as i, EventPayloadTooLarge as a, MAX_EVENT_ENVELOPE_BYTES as o } from "@voltro/protocol";
+//#region src/eventPublish.ts
+var s = (e) => e instanceof Error ? e.message : String(e), c = (e, c, l, u) => t.gen(function* () {
+	let d = n.encodeEffect(c.key), f = n.encodeEffect(c.payload), p = yield* d(l).pipe(t.mapError((e) => new r({
+		event: c.name,
+		message: s(e)
+	}))), m = yield* f(u).pipe(t.mapError((e) => new i({
+		event: c.name,
+		message: s(e)
+	}))), h = Buffer.byteLength(JSON.stringify({
+		event: c.name,
+		key: p,
+		payload: m
+	}), "utf8");
+	if (h > o) return yield* t.fail(new a({
+		event: c.name,
+		bytes: h,
+		limit: o
+	}));
+	let g = () => e.bus.publish({
+		tenantId: e.tenantId,
+		event: c.name,
+		key: p,
+		payload: m
+	}).n;
+	if (e.deferToCommit === void 0 && e.onPublished === void 0) return {
+		n: g(),
+		deferred: !1
+	};
+	let _ = t.gen(function* () {
+		let n = e.onPublished;
+		return n !== void 0 && (yield* t.promise(async () => {
+			await n(c.name, m, c);
+		})), g();
+	});
+	return e.deferToCommit === void 0 ? {
+		n: yield* _,
+		deferred: !1
+	} : (e.deferToCommit(() => t.runPromise(t.asVoid(_))), {
+		n: -1,
+		deferred: !0
+	});
+}), l = class extends e.Service()("@voltro/OutboxEventPublisher") {}, u = (e) => {
+	let n;
+	return Object.assign(e, { then: (r, i) => (n ??= t.runPromise(e), n.then(r, i)) });
+}, d = (e) => ({ publish: (t, n, r) => u(c(e, t, n, r)) });
+//#endregion
+export { l as OutboxEventPublisher, d as makeEventPublisher, c as publishEvent };

package/dist/events.js

@@ -0,0 +1,193 @@
+import { boolean as e, eq as t, id as n, json as r, table as i, text as a, timestamp as o } from "@voltro/database";
+//#region src/events.ts
+var s = (e) => {
+	if ("on" in e) {
+		let { on: t, ...n } = e;
+		return {
+			_tag: "workflowEventTrigger",
+			event: t.name,
+			...n
+		};
+	}
+	return {
+		_tag: "workflowEventTrigger",
+		...e
+	};
+}, c = s, l = (e) => typeof e == "object" && !!e && e._tag === "workflowEventTrigger", u = () => {
+	let e = globalThis.crypto;
+	return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}, d = (e) => `${e}_${u()}`, f = (e) => e.id ?? `${e.event}->${e.workflow}`, p = i("_voltro_workflow_events", {
+	id: n({ prefix: "wfe" }),
+	name: a(),
+	payload: r(),
+	source: a(),
+	subject: r().nullable(),
+	traceId: a().nullable(),
+	occurredAt: o().default("now")
+}).index(["name"]).index(["source"]).index(["occurredAt"]), m = i("_voltro_workflow_event_deliveries", {
+	id: n({ prefix: "wfed" }),
+	eventId: a(),
+	eventName: a(),
+	triggerId: a(),
+	workflowName: a(),
+	executionId: a().nullable(),
+	status: a().oneOf([
+		"starting",
+		"started",
+		"skipped",
+		"failed"
+	]).default("starting"),
+	idempotencyKey: a().unique(),
+	skipped: e().default(!1),
+	errorMessage: a().nullable(),
+	createdAt: o().default("now"),
+	completedAt: o().nullable()
+}).index(["eventId"]).index(["eventName"]).index(["triggerId"]).index(["workflowName"]).index(["status"]), h = (e) => {
+	let n = e.makeId ?? d, r = /* @__PURE__ */ new Map();
+	for (let t of e.triggers) {
+		let e = r.get(t.event);
+		e ? e.push(t) : r.set(t.event, [t]);
+	}
+	let i = (t, n, r) => {
+		e.emit?.(t, {
+			op: n,
+			row: r
+		});
+	}, a = async (t, n, r) => {
+		let a = await e.store.insert(t, r);
+		return i(n, "insert", typeof a == "object" && a ? a : r), a;
+	}, o = async (t, n, r, a) => {
+		let o = await e.store.update(t, r, a);
+		return typeof o == "object" && o && i(n, "update", o), o;
+	}, s = (e) => {
+		let t = r.get(e) ?? [], n = e === "*" ? [] : r.get("*") ?? [];
+		return t.length === 0 ? n : [...t, ...n];
+	};
+	return { emit: async (r, i, c) => {
+		let l = c?.id ?? n("wfe"), u = /* @__PURE__ */ new Date(), d = c?.source ?? e.source, p = {
+			id: l,
+			name: r,
+			data: i,
+			occurredAt: u,
+			source: d,
+			...e.subject === void 0 ? {} : { subject: e.subject },
+			...e.traceId === void 0 ? {} : { traceId: e.traceId }
+		};
+		await a("_voltro_workflow_events", "workflowDomainEvents", {
+			id: l,
+			name: r,
+			payload: i,
+			source: d,
+			subject: e.subject ?? null,
+			traceId: e.traceId ?? null,
+			occurredAt: u
+		});
+		let m = s(r), h = [];
+		for (let s of m) {
+			let c = f(s), u = s.workflow, d, m = async (e) => {
+				let t = n("wfed");
+				await a("_voltro_workflow_event_deliveries", "workflowEventDeliveries", {
+					id: t,
+					eventId: l,
+					eventName: r,
+					triggerId: c,
+					workflowName: u,
+					executionId: null,
+					status: "skipped",
+					idempotencyKey: `${l}:${c}:skipped:${t}`,
+					skipped: !0,
+					errorMessage: e,
+					createdAt: /* @__PURE__ */ new Date(),
+					completedAt: /* @__PURE__ */ new Date()
+				}), h.push({
+					triggerId: c,
+					workflowName: u,
+					status: "skipped",
+					reason: e
+				});
+			};
+			try {
+				let f = s.idempotencyKey?.(p) ?? `${l}:${c}`;
+				if (s.filter && !await s.filter(p)) {
+					await m("filter");
+					continue;
+				}
+				if ((await e.store.query({
+					table: "_voltro_workflow_event_deliveries",
+					order: [],
+					predicate: t("idempotencyKey", f),
+					projection: ["id"],
+					skip: void 0,
+					take: 1
+				}))[0] !== void 0) {
+					await m("duplicate");
+					continue;
+				}
+				d = (await a("_voltro_workflow_event_deliveries", "workflowEventDeliveries", {
+					id: n("wfed"),
+					eventId: l,
+					eventName: r,
+					triggerId: c,
+					workflowName: u,
+					executionId: null,
+					status: "starting",
+					idempotencyKey: f,
+					skipped: !1,
+					errorMessage: null,
+					createdAt: /* @__PURE__ */ new Date(),
+					completedAt: null
+				})).id;
+				let g = s.payload ? await s.payload(p) : i, _ = await e.startWorkflow(u, g, {
+					...e.subject === void 0 ? {} : { subject: e.subject },
+					...e.traceId === void 0 ? {} : { traceId: e.traceId },
+					source: `event:${r}`,
+					...e.parentExecutionId !== void 0 && e.parentExecutionId !== null ? {
+						parentExecutionId: e.parentExecutionId,
+						parentGeneration: e.parentGeneration ?? null
+					} : {}
+				});
+				d !== void 0 && await o("_voltro_workflow_event_deliveries", "workflowEventDeliveries", d, {
+					executionId: _.executionId,
+					status: "started",
+					completedAt: /* @__PURE__ */ new Date()
+				}), h.push({
+					triggerId: c,
+					workflowName: u,
+					status: "started",
+					run: _
+				});
+			} catch (e) {
+				let t = e?.message ?? String(e);
+				d === void 0 ? await a("_voltro_workflow_event_deliveries", "workflowEventDeliveries", {
+					id: n("wfed"),
+					eventId: l,
+					eventName: r,
+					triggerId: c,
+					workflowName: u,
+					executionId: null,
+					status: "failed",
+					idempotencyKey: `${l}:${c}:failed:${n("wfed")}`,
+					skipped: !1,
+					errorMessage: t,
+					createdAt: /* @__PURE__ */ new Date(),
+					completedAt: /* @__PURE__ */ new Date()
+				}).catch(() => void 0) : await o("_voltro_workflow_event_deliveries", "workflowEventDeliveries", d, {
+					status: "failed",
+					errorMessage: t,
+					completedAt: /* @__PURE__ */ new Date()
+				}).catch(() => void 0), h.push({
+					triggerId: c,
+					workflowName: u,
+					status: "failed",
+					reason: t
+				});
+			}
+		}
+		return {
+			eventId: l,
+			triggered: h
+		};
+	} };
+};
+//#endregion
+export { m as _voltroWorkflowEventDeliveriesTable, p as _voltroWorkflowEventsTable, c as defineEventTrigger, l as isWorkflowEventTriggerDefinition, h as makeEventsFacade, s as triggerWorkflow };

package/dist/expectation.js

@@ -0,0 +1,52 @@
+import { Context as e, Effect as t } from "effect";
+//#region src/expectation.ts
+var n = /* @__PURE__ */ new Set([
+	"info",
+	"warn",
+	"critical"
+]), r = (e, t) => /* @__PURE__ */ Error(`defineExpectation(${JSON.stringify(e)}): ${t}`), i = (e) => {
+	let t = e.name;
+	if (typeof t != "string" || t.length === 0) throw Error("defineExpectation: a non-empty `name` is required");
+	if (e.on === void 0 || typeof e.on.table != "string" || e.on.table.length === 0) throw r(t, "on.table is required — the table whose writes drive the expectation");
+	if (e.on.where !== void 0 && typeof e.on.where != "function") throw r(t, "on.where, when present, must be a predicate function");
+	let i = e.invariant;
+	if (i === void 0 || typeof i.kind != "string") throw r(t, "invariant is required");
+	switch (i.kind) {
+		case "freshness":
+			if (typeof i.column != "string" || i.column.length === 0) throw r(t, "freshness invariant requires a `column` (the timestamp column)");
+			if (!(typeof i.maxAgeMs == "number" && i.maxAgeMs > 0)) throw r(t, "freshness invariant requires a positive `maxAgeMs`");
+			break;
+		case "nullRate":
+			if (typeof i.column != "string" || i.column.length === 0) throw r(t, "nullRate invariant requires a `column`");
+			if (!(typeof i.maxRate == "number" && i.maxRate >= 0 && i.maxRate <= 1)) throw r(t, "nullRate invariant requires `maxRate` in [0, 1]");
+			break;
+		case "rowCount":
+			if (i.min === void 0 && i.max === void 0) throw r(t, "rowCount invariant requires at least one of `min` / `max`");
+			if (i.min !== void 0 && i.max !== void 0 && i.min > i.max) throw r(t, "rowCount invariant: `min` must not exceed `max`");
+			break;
+		case "valueBounds":
+			if (typeof i.column != "string" || i.column.length === 0) throw r(t, "valueBounds invariant requires a `column`");
+			if (i.min === void 0 && i.max === void 0) throw r(t, "valueBounds invariant requires at least one of `min` / `max`");
+			if (i.min !== void 0 && i.max !== void 0 && i.min > i.max) throw r(t, "valueBounds invariant: `min` must not exceed `max`");
+			if (i.maxViolationRate !== void 0 && !(typeof i.maxViolationRate == "number" && i.maxViolationRate >= 0 && i.maxViolationRate <= 1)) throw r(t, "valueBounds invariant: `maxViolationRate`, when set, must be in [0, 1]");
+			break;
+		default: throw r(t, `unknown invariant kind ${JSON.stringify(i.kind)}`);
+	}
+	let a = e.severity ?? "warn";
+	if (!n.has(a)) throw r(t, `severity must be one of info | warn | critical (got ${JSON.stringify(a)})`);
+	return {
+		_voltroExpectation: !0,
+		name: t,
+		on: e.on.where === void 0 ? { table: e.on.table } : {
+			table: e.on.table,
+			where: e.on.where
+		},
+		invariant: i,
+		severity: a,
+		...e.description === void 0 ? {} : { description: e.description }
+	};
+}, a = (e) => typeof e == "object" && !!e && e._voltroExpectation === !0, o = class extends e.Service()("@voltro/ExpectationRegistry") {}, s = (e) => t.gen(function* () {
+	return (yield* o).get(e.name);
+});
+//#endregion
+export { o as ExpectationRegistry, i as defineExpectation, a as isExpectationDefinition, s as useExpectation };