@voltro/workflow 0.84.0 → 0.86.0

package/dist/admissionGate.js

@@ -0,0 +1,115 @@
+import { resolveAdmissionKeys as e } from "./admission.js";
+import { decodePendingPayload as t, evaluateAdmission as n, persistDefer as r, recordAdmission as i } from "./admissionStore.js";
+import { and as a, eq as o } from "@voltro/database";
+//#region src/admissionGate.ts
+var s = async (t) => {
+	let { store: a, control: o, now: s } = t, l = e(o, t.payload), u = await n({
+		store: a,
+		control: o,
+		keys: l,
+		paused: t.paused,
+		now: s,
+		reconsidering: !1
+	});
+	if (u.kind === "drop") return await i({
+		store: a,
+		control: o,
+		keys: l,
+		outcome: "dropped",
+		mode: "rateLimit",
+		reason: `rate limit reached; retry after ${u.retryAfterMs}ms`,
+		collapsed: 1,
+		waitedMs: 0,
+		executionId: null,
+		runId: null,
+		tenantId: t.tenantId,
+		now: s
+	}), {
+		kind: "dropped",
+		retryAfterMs: u.retryAfterMs
+	};
+	if (u.kind === "skip") return await i({
+		store: a,
+		control: o,
+		keys: l,
+		outcome: "skipped",
+		mode: "singleton",
+		reason: `singleton key held by ${u.incumbent.executionId}`,
+		collapsed: 1,
+		waitedMs: 0,
+		executionId: u.incumbent.executionId,
+		runId: u.incumbent.runId || null,
+		tenantId: t.tenantId,
+		now: s
+	}), {
+		kind: "skipped",
+		executionId: u.incumbent.executionId,
+		runId: u.incumbent.runId
+	};
+	if (u.kind === "defer") return {
+		kind: "queued",
+		intentId: await r({
+			store: a,
+			control: o,
+			decision: u,
+			payload: t.payload,
+			callerContext: t.callerContext,
+			tenantId: t.tenantId,
+			now: s,
+			...t.queuedAppVersion === void 0 ? {} : { queuedAppVersion: t.queuedAppVersion },
+			...t.queuedSchemaFingerprint === void 0 ? {} : { queuedSchemaFingerprint: t.queuedSchemaFingerprint }
+		}),
+		mode: u.mode,
+		dueAt: u.dueAt
+	};
+	let d = t.payload, f = [], p = 1;
+	if (o.batch !== void 0 && l.batchKey !== void 0) {
+		let e = await c(a, o.workflowName, l.batchKey, o.batch.maxSize);
+		d = { items: [...e.map((e) => e.payload), t.payload] }, f = e.map((e) => e.id), p = e.length + 1;
+	}
+	return {
+		kind: "start",
+		ledgerId: await i({
+			store: a,
+			control: o,
+			keys: l,
+			outcome: "admitted",
+			mode: t.waiting ? "immediate" : null,
+			reason: u.reason,
+			collapsed: p,
+			waitedMs: 0,
+			executionId: null,
+			runId: null,
+			tenantId: t.tenantId,
+			now: s
+		}),
+		keys: l,
+		payload: d,
+		consume: f,
+		collapsed: p,
+		...u.evict === void 0 ? {} : { evict: {
+			executionId: u.evict.executionId,
+			runId: u.evict.runId
+		} }
+	};
+}, c = async (e, n, r, i) => (await e.query({
+	table: "_voltro_workflow_pending",
+	predicate: a(o("workflowName", n), o("controlKey", r), o("mode", "batch")),
+	order: [{
+		column: "firstSeenAt",
+		direction: "asc"
+	}],
+	take: i,
+	skip: void 0,
+	projection: void 0
+})).map((r) => ({
+	id: String(r.id),
+	payload: t(e, n, r.payload)
+})), l = async (e, t, n, r) => {
+	await e.update("_voltro_workflow_admissions", t, {
+		executionId: n,
+		runId: r
+	});
+};
+//#endregion
+export { s as admitStart, l as linkExecution };

package/dist/admissionStore.js

@@ -0,0 +1,347 @@
+import { openErrorText as e, sealErrorText as t } from "./journalEncryption.js";
+import { withAdmissionTransaction as n } from "./admissionTransaction.js";
+import { comparePendingOrder as r, decideAdmission as i } from "./admission.js";
+import { settlePendingStartReceipts as a } from "./startReceipt.js";
+import { and as o, eq as s, gt as c, isNull as l, or as u } from "@voltro/database";
+import { createHash as d, randomUUID as f } from "node:crypto";
+//#region src/admissionStore.ts
+var p = "_voltro_workflow_pending", m = "_voltro_workflow_admissions", h = "_voltro_workflow_pauses", g = (e) => o(l("releasedAt"), u(l("executionId"), c("expiresAt", new Date(e)))), _ = (e, t, n) => e.encodeWorkflowPayload === void 0 ? n : e.encodeWorkflowPayload(t, n), v = (e, t, n) => e.decodeWorkflowPayload === void 0 ? n : e.decodeWorkflowPayload(t, n), y = 864e5, b = (e, t, n) => `wfp_${d("sha256").update(`${e}\u0000${t}\u0000${n}`).digest("hex").slice(0, 40)}`, x = (e) => {
+	if (e instanceof Date) return e.getTime();
+	if (typeof e == "number") return e;
+	let t = Date.parse(String(e));
+	return Number.isNaN(t) ? 0 : t;
+}, S = (e, t) => {
+	let n = typeof e == "number" ? e : Number(e);
+	return Number.isFinite(n) ? Math.trunc(n) : t;
+}, C = (t) => ({
+	id: String(t.id),
+	tenantId: t.tenantId === null || t.tenantId === void 0 ? null : String(t.tenantId),
+	workflowName: String(t.workflowName),
+	controlKey: String(t.controlKey ?? ""),
+	mode: String(t.mode),
+	payload: t.payload,
+	callerContext: t.callerContext ?? null,
+	queuedAppVersion: t.queuedAppVersion === null || t.queuedAppVersion === void 0 ? null : String(t.queuedAppVersion),
+	queuedSchemaFingerprint: t.queuedSchemaFingerprint === null || t.queuedSchemaFingerprint === void 0 ? null : String(t.queuedSchemaFingerprint),
+	priority: S(t.priority, 0),
+	dueAt: x(t.dueAt),
+	deadlineAt: t.deadlineAt === null || t.deadlineAt === void 0 ? void 0 : x(t.deadlineAt),
+	collapsed: S(t.collapsed, 1),
+	firstSeenAt: x(t.firstSeenAt),
+	attempts: S(t.attempts, 0),
+	lastError: t.lastError === null || t.lastError === void 0 ? null : e(String(t.lastError)),
+	deadLetteredAt: t.deadLetteredAt === null || t.deadLetteredAt === void 0 ? void 0 : x(t.deadLetteredAt)
+}), w = (e, t, n, r) => ({
+	table: e,
+	predicate: t,
+	order: n,
+	take: r,
+	skip: void 0,
+	projection: void 0
+}), T = async (e) => {
+	let t = await e.query(w(h, void 0, [], 1e3));
+	return new Set(t.map((e) => String(e.id)));
+}, E = async (e, t, n, r) => {
+	await e.upsert(h, {
+		id: t,
+		pausedAt: /* @__PURE__ */ new Date(),
+		pausedBy: n,
+		reason: r
+	}, {
+		conflictColumns: ["id"],
+		update: [
+			"pausedAt",
+			"pausedBy",
+			"reason"
+		]
+	});
+}, D = async (e, t) => e.delete(h, t), O = async (e) => {
+	let { store: t, control: n, keys: r, now: i } = e, a = { paused: e.paused }, l = [];
+	n.debounce !== void 0 && r.debounceKey !== void 0 && l.push((async () => {
+		let e = (await t.query(w(p, o(s("workflowName", n.workflowName), s("controlKey", r.debounceKey), s("mode", "debounce")), [], 1)))[0];
+		if (e === void 0) return;
+		let i = e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 : x(e.deadlineAt);
+		a.debouncePending = {
+			firstSeenAt: x(e.firstSeenAt),
+			collapsed: S(e.collapsed, 1),
+			...i === void 0 ? {} : { deadlineAt: i }
+		};
+	})()), n.batch !== void 0 && r.batchKey !== void 0 && l.push((async () => {
+		let e = await t.query(w(p, o(s("workflowName", n.workflowName), s("controlKey", r.batchKey), s("mode", "batch")), [{
+			column: "firstSeenAt",
+			direction: "asc"
+		}], n.batch.maxSize + 1));
+		e.length !== 0 && (a.batchPending = {
+			count: e.length,
+			firstSeenAt: x(e[0].firstSeenAt)
+		});
+	})()), n.singleton !== void 0 && r.singletonKey !== void 0 && l.push((async () => {
+		let e = await k(t, n.workflowName, r.singletonKey, i);
+		e === "unacknowledged" ? a.singletonUnacknowledged = !0 : e !== void 0 && (a.singletonHolder = e);
+	})()), n.concurrency !== void 0 && r.concurrencyKey !== void 0 && l.push((async () => {
+		let e = n.concurrency.pool === void 0 ? [s("workflowName", n.workflowName)] : [], c = await t.query(w(m, o(...e, s("concurrencyKey", r.concurrencyKey), g(i)), [], n.concurrency.limit));
+		a.inFlight = c.length;
+	})());
+	let u = n.rateLimit ?? n.throttle, d = r.rateLimitKey ?? r.throttleKey;
+	return u !== void 0 && d !== void 0 && l.push((async () => {
+		let e = await t.query(w(m, o(s("workflowName", n.workflowName), s("rateKey", d), s("outcome", "admitted"), c("admittedAt", new Date(i - u.periodMs))), [{
+			column: "admittedAt",
+			direction: "desc"
+		}], u.limit));
+		a.recentAdmissions = e.map((e) => x(e.admittedAt));
+	})()), await Promise.all(l), a;
+}, k = async (e, t, n, r) => {
+	if ((await e.query(w("_voltro_workflow_admissions", o(s("workflowName", t), s("singletonKey", n), g(r), l("executionId")), [], 1))).length > 0) return "unacknowledged";
+	let i = (await e.query(w(m, o(s("workflowName", t), s("singletonKey", n), g(r)), [{
+		column: "admittedAt",
+		direction: "desc"
+	}], 1)))[0];
+	if (i === void 0) return;
+	let a = i.executionId;
+	if (a != null) return {
+		executionId: String(a),
+		runId: i.runId === null || i.runId === void 0 ? "" : String(i.runId),
+		admittedAt: x(i.admittedAt)
+	};
+}, A = async (e) => {
+	let { store: t, control: n, decision: r, now: i } = e, o = M(r.mode, r.keys);
+	if (r.collapse === "hold") {
+		let a = e.existingId ?? b(n.workflowName, r.mode, o);
+		if (r.dueAt <= i) return a;
+		let c = await t.query(w(p, s("id", a), [], 1));
+		return c[0] === void 0 || x(c[0].dueAt) === r.dueAt || await t.update(p, a, {
+			dueAt: new Date(r.dueAt),
+			updatedAt: new Date(i)
+		}), a;
+	}
+	if (r.collapse === "replace") {
+		let s = b(n.workflowName, r.mode, o);
+		return await a(t, {
+			pendingId: s,
+			workflowName: n.workflowName,
+			tenantId: e.tenantId,
+			terminal: {
+				kind: "superseded",
+				at: i
+			}
+		}), await t.upsert(p, {
+			id: s,
+			tenantId: e.tenantId,
+			workflowName: n.workflowName,
+			controlKey: o,
+			mode: r.mode,
+			payload: _(t, n.workflowName, e.payload),
+			callerContext: e.callerContext ?? null,
+			queuedAppVersion: e.queuedAppVersion ?? null,
+			queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? null,
+			priority: r.keys.priority,
+			dueAt: new Date(r.dueAt),
+			deadlineAt: r.deadlineAt === void 0 ? null : new Date(r.deadlineAt),
+			collapsed: 1,
+			firstSeenAt: new Date(i),
+			updatedAt: new Date(i),
+			attempts: 0,
+			lastError: null,
+			deadLetteredAt: null
+		}, {
+			conflictColumns: ["id"],
+			update: (a) => ({
+				payload: _(t, n.workflowName, e.payload),
+				callerContext: e.callerContext ?? null,
+				queuedAppVersion: e.queuedAppVersion ?? null,
+				queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? null,
+				priority: r.keys.priority,
+				dueAt: new Date(r.dueAt),
+				deadlineAt: r.deadlineAt === void 0 ? a.deadlineAt ?? null : new Date(r.deadlineAt),
+				collapsed: S(a.collapsed, 1) + 1,
+				updatedAt: new Date(i),
+				attempts: 0,
+				lastError: null,
+				deadLetteredAt: null
+			})
+		}), s;
+	}
+	let c = await t.insert(p, {
+		id: `wfpi_${f()}`,
+		tenantId: e.tenantId,
+		workflowName: n.workflowName,
+		controlKey: o,
+		mode: r.mode,
+		payload: _(t, n.workflowName, e.payload),
+		callerContext: e.callerContext ?? null,
+		queuedAppVersion: e.queuedAppVersion ?? null,
+		queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? null,
+		priority: r.keys.priority,
+		dueAt: new Date(r.dueAt),
+		deadlineAt: r.deadlineAt === void 0 ? null : new Date(r.deadlineAt),
+		collapsed: 1,
+		firstSeenAt: new Date(i),
+		updatedAt: new Date(i),
+		attempts: 0,
+		lastError: null,
+		deadLetteredAt: null
+	});
+	return String(c.id);
+}, j = async (e) => {
+	let t = await e.store.insert(p, {
+		id: `wfpi_${f()}`,
+		tenantId: e.tenantId,
+		workflowName: e.workflowName,
+		controlKey: "",
+		mode: "delayed",
+		payload: _(e.store, e.workflowName, e.payload),
+		callerContext: e.callerContext ?? null,
+		queuedAppVersion: e.queuedAppVersion ?? null,
+		queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? null,
+		priority: 0,
+		dueAt: new Date(e.at),
+		deadlineAt: null,
+		collapsed: 1,
+		firstSeenAt: new Date(e.now),
+		updatedAt: new Date(e.now),
+		attempts: 0,
+		lastError: null,
+		deadLetteredAt: null
+	});
+	return {
+		intentId: String(t.id),
+		dueAt: e.at
+	};
+}, M = (e, t) => {
+	switch (e) {
+		case "debounce": return t.debounceKey ?? "";
+		case "batch": return t.batchKey ?? "";
+		case "throttle": return t.throttleKey ?? "";
+		case "concurrency": return t.concurrencyKey ?? "";
+		case "singleton": return t.singletonKey ?? "";
+		default: return "";
+	}
+}, N = async (e) => {
+	let { control: t, keys: n, now: r } = e, i = t.timeouts?.finishMs ?? 864e5, a = await e.store.insert(m, {
+		id: `wfad_${f()}`,
+		tenantId: e.tenantId,
+		workflowName: t.workflowName,
+		outcome: e.outcome,
+		mode: e.mode,
+		reason: e.reason,
+		collapsed: e.collapsed,
+		waitedMs: e.waitedMs,
+		executionId: e.executionId,
+		runId: e.runId,
+		singletonKey: n.singletonKey ?? null,
+		concurrencyKey: n.concurrencyKey ?? null,
+		concurrencyReservation: t.concurrency === void 0 ? null : {
+			pool: t.concurrency.pool ?? null,
+			key: n.concurrencyKey ?? null,
+			limit: t.concurrency.limit
+		},
+		rateKey: n.rateLimitKey ?? n.throttleKey ?? null,
+		admittedAt: new Date(r),
+		expiresAt: e.outcome === "admitted" ? new Date(r + i) : null,
+		releasedAt: e.outcome === "admitted" ? null : new Date(r)
+	});
+	return String(a.id);
+}, P = async (e, t, n) => {
+	let r = !1;
+	for (;;) {
+		let i = await e.query(w(m, o(s("executionId", t), s("outcome", "admitted"), l("releasedAt")), [], 10));
+		if (i.length === 0) return r;
+		for (let t of i) if (await e.update("_voltro_workflow_admissions", String(t.id), { releasedAt: new Date(n) }) === null) throw Error("Admission lease disappeared during release");
+		r = !0;
+	}
+}, F = async (e, t, n) => (await I(e, t, n)).due, I = async (e, t, n) => {
+	let i = (await e.query(w(p, l("deadLetteredAt"), [{
+		column: "priority",
+		direction: "desc"
+	}, {
+		column: "firstSeenAt",
+		direction: "asc"
+	}], n))).map(C), a;
+	for (let e of i) e.dueAt <= t || (a === void 0 || e.dueAt < a) && (a = e.dueAt);
+	return {
+		due: i.filter((e) => e.dueAt <= t).sort(r),
+		nextDueAt: a
+	};
+}, L = async (e, t) => (await e.query(w(p, void 0, [{
+	column: "firstSeenAt",
+	direction: "asc"
+}], t))).map(C), R = async (e, t) => e.delete(p, t), z = async (e, t, r, i) => n(e, (e) => B(e, t, r, i)), B = async (e, t, n, r) => {
+	let i = (await e.query(w(p, s("id", t), [], 1)))[0];
+	if (i === void 0) return !1;
+	let o = C(i);
+	if (await e.insert(m, {
+		id: `wfa_${f()}`,
+		tenantId: o.tenantId,
+		workflowName: o.workflowName,
+		outcome: "discarded",
+		mode: o.mode,
+		reason: n,
+		collapsed: o.collapsed,
+		waitedMs: Math.max(0, r - o.firstSeenAt),
+		executionId: null,
+		runId: null,
+		singletonKey: null,
+		concurrencyKey: o.controlKey === "" ? null : o.controlKey,
+		rateKey: null,
+		admittedAt: new Date(r),
+		expiresAt: null,
+		releasedAt: new Date(r)
+	}), await a(e, {
+		pendingId: t,
+		workflowName: o.workflowName,
+		tenantId: o.tenantId,
+		terminal: {
+			kind: "cancelled",
+			at: r
+		}
+	}), !await e.delete("_voltro_workflow_pending", t)) throw Error("Pending intent disappeared during discard");
+	return !0;
+}, V = (e, t = Math.random) => {
+	let n = Math.min(1e3 * 2 ** Math.max(0, e - 1), 3e5);
+	return Math.round(n / 2 + t() * (n / 2));
+}, H = async (e, n, r, i) => {
+	let a = n.attempts + 1;
+	await e.update(p, n.id, {
+		attempts: a,
+		lastError: t(n.workflowName, r.slice(0, 500)),
+		dueAt: new Date(i + V(a)),
+		updatedAt: new Date(i)
+	});
+}, U = async (e, n, r, i) => await e.update(p, n.id, {
+	attempts: n.attempts + 1,
+	lastError: t(n.workflowName, r.slice(0, 500)),
+	deadLetteredAt: new Date(i),
+	updatedAt: new Date(i)
+}) !== null, W = async (e, t, n) => {
+	let r = (await e.query(w(p, s("id", t), [], 1)))[0];
+	return r === void 0 || r.deadLetteredAt === null || r.deadLetteredAt === void 0 ? !1 : await e.update(p, t, {
+		attempts: 0,
+		lastError: null,
+		deadLetteredAt: null,
+		dueAt: new Date(n),
+		updatedAt: new Date(n)
+	}) !== null;
+}, G = async (e) => {
+	let t = await O({
+		store: e.store,
+		control: e.control,
+		keys: e.keys,
+		now: e.now,
+		paused: e.paused
+	});
+	return i({
+		control: e.control,
+		keys: e.keys,
+		state: t,
+		now: e.now,
+		reconsidering: e.reconsidering
+	});
+}, K = async (e, t, n = 1e3) => {
+	let r = await e.query(w(m, void 0, [{
+		column: "admittedAt",
+		direction: "asc"
+	}], n)), i = t.getTime(), a = r.filter((e) => e.releasedAt != null && x(e.admittedAt) < i);
+	return await Promise.all(a.map((t) => e.delete(m, String(t.id)))), a.length;
+};
+//#endregion
+export { m as ADMISSIONS_TABLE, y as DEFAULT_LEASE_MS, h as PAUSES_TABLE, p as PENDING_TABLE, g as admissionLeaseHeldPredicate, L as allIntents, U as deadLetterIntent, v as decodePendingPayload, R as deleteIntent, z as discardIntent, B as discardIntentInTransaction, F as dueIntents, _ as encodePendingPayload, G as evaluateAdmission, H as noteIntentAttempt, j as parkDelayedStart, E as pauseWorkflow, b as pendingSlotId, I as pendingWindow, A as persistDefer, K as pruneAdmissions, O as readAdmissionState, T as readPausedWorkflows, N as recordAdmission, P as releaseLease, D as resumeWorkflow, V as retryBackoffMs, W as retryDeadLetterIntent, C as toPendingIntent };