@voltro/workflow 0.85.0 → 0.87.0

package/dist/cancelOnPlan.js

@@ -0,0 +1,75 @@
+import { Result as e, Schema as t } from "effect";
+//#region src/cancelOnPlan.ts
+var n = (e) => {
+	let t = e instanceof Error ? e.message : String(e);
+	return t.length > 400 ? `${t.slice(0, 400)}…` : t;
+}, r = (r) => {
+	let i = [], a = [], o = [], s = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Set(), l = r.payloadSchema === void 0 ? (t) => e.succeed(t) : (i) => {
+		let a = t.decodeUnknownResult(r.payloadSchema)(i);
+		return e.isSuccess(a) ? e.succeed(a.success) : e.fail(n(a.failure));
+	}, u = r.runs.map((e) => ({
+		run: e,
+		decoded: l(e.payload)
+	})), d = r.intents.map((e) => ({
+		intent: e,
+		decoded: l(e.payload)
+	}));
+	for (let l of r.entries) for (let f of r.events) {
+		if (f.name !== l.event) continue;
+		let p = t.decodeUnknownResult(l.schema)(f.payload);
+		if (e.isFailure(p)) {
+			o.push({
+				kind: "event-decode",
+				workflowName: r.workflowName,
+				event: l.event,
+				subject: f.id,
+				detail: n(p.failure)
+			});
+			continue;
+		}
+		let m = p.success, h = (e) => e.getTime() > f.occurredAt.getTime() ? !1 : l.withinMs === void 0 || f.occurredAt.getTime() - e.getTime() <= l.withinMs, g = (t, i) => {
+			if (e.isFailure(t)) return o.push({
+				kind: "payload-decode",
+				workflowName: r.workflowName,
+				event: l.event,
+				subject: i,
+				detail: t.failure
+			}), !1;
+			try {
+				return l.match(m, t.success) === !0;
+			} catch (e) {
+				return o.push({
+					kind: "match-threw",
+					workflowName: r.workflowName,
+					event: l.event,
+					subject: i,
+					detail: n(e)
+				}), !1;
+			}
+		};
+		for (let { run: e, decoded: t } of u) s.has(e.runId) || h(e.startedAt) && g(t, e.runId) && (s.add(e.runId), i.push({
+			runId: e.runId,
+			executionId: e.executionId,
+			reason: l.reason,
+			event: l.event,
+			eventId: f.id
+		}));
+		for (let { intent: e, decoded: t } of d) c.has(e.intentId) || h(e.firstSeenAt) && g(t, e.intentId) && (c.add(e.intentId), a.push({
+			intentId: e.intentId,
+			reason: l.reason,
+			event: l.event,
+			eventId: f.id
+		}));
+	}
+	return {
+		cancels: i,
+		discards: a,
+		problems: o
+	};
+}, i = (e) => {
+	let t;
+	for (let n of e) (t === void 0 || n.occurredAt.getTime() > t.getTime()) && (t = n.occurredAt);
+	return t;
+};
+//#endregion
+export { i as newestEventAt, r as planCancellations };

package/dist/cancelOnSweep.js

@@ -0,0 +1,188 @@
+import { newestEventAt as e, planCancellations as t } from "./cancelOnPlan.js";
+import { and as n, eq as r, gte as i } from "@voltro/database";
+//#region src/cancelOnSweep.ts
+var a = "_voltro_workflow_watermarks", o = "_voltro_workflow_events", s = "cancelOn", c = 36e5, l = 500, u = 2e3, d = (e) => {
+	if (e instanceof Date) return e;
+	if (typeof e == "number") return new Date(e);
+	if (typeof e == "string") {
+		let t = new Date(e);
+		if (!Number.isNaN(t.getTime())) return t;
+	}
+}, f = (e) => e instanceof Error ? e.message : String(e), p = async (e, t) => d((await e.query({
+	table: a,
+	predicate: r("id", t),
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0
+}))[0]?.positionAt), m = async (e, t, n) => {
+	await e.upsert(a, {
+		id: t,
+		positionAt: n,
+		updatedAt: /* @__PURE__ */ new Date()
+	}, {
+		conflictColumns: ["id"],
+		update: (e) => {
+			let t = d(e.positionAt);
+			return t !== void 0 && t.getTime() >= n.getTime() ? {
+				positionAt: t,
+				updatedAt: /* @__PURE__ */ new Date()
+			} : {
+				positionAt: n,
+				updatedAt: /* @__PURE__ */ new Date()
+			};
+		}
+	});
+}, h = async (e, t, i) => {
+	let a = async (a) => e.query({
+		table: "_voltro_workflow_runs",
+		predicate: n(r("tag", t), r("status", a)),
+		order: [{
+			column: "startedAt",
+			direction: "asc"
+		}],
+		take: i,
+		skip: void 0,
+		projection: void 0
+	});
+	return [...await a("running"), ...await a("suspended")].flatMap((e) => {
+		let t = e, n = d(t.startedAt);
+		return typeof t.id != "string" || typeof t.executionId != "string" || n === void 0 ? [] : [{
+			runId: t.id,
+			executionId: t.executionId,
+			payload: t.payload,
+			startedAt: n
+		}];
+	});
+}, g = async (e, t, n) => (await e.query({
+	table: "_voltro_workflow_pending",
+	predicate: r("workflowName", t),
+	order: [{
+		column: "firstSeenAt",
+		direction: "asc"
+	}],
+	take: n,
+	skip: void 0,
+	projection: void 0
+})).flatMap((e) => {
+	let t = e, n = d(t.firstSeenAt);
+	return typeof t.id != "string" || n === void 0 ? [] : [{
+		intentId: t.id,
+		payload: t.payload,
+		firstSeenAt: n
+	}];
+}), _ = async (n, r) => {
+	let a = r.workflows.filter((e) => e.entries.length > 0);
+	if (a.length === 0) return {
+		examined: !1,
+		events: 0,
+		cancelled: 0,
+		discarded: 0,
+		catchingUp: !1,
+		sawFullRunPage: !1,
+		problems: [],
+		failures: [],
+		watermark: void 0
+	};
+	let c = n.now?.() ?? Date.now(), l = r.batch ?? 500, u = r.coldLookbackMs ?? 36e5, _ = /* @__PURE__ */ new Set();
+	for (let e of a) for (let t of e.entries) _.add(t.event);
+	let v = await p(n.store, s), y = v ?? new Date(c - u);
+	v === void 0 && (await m(n.store, s, y), v = y);
+	let b = await n.store.query({
+		table: o,
+		predicate: i("occurredAt", y),
+		order: [{
+			column: "occurredAt",
+			direction: "asc"
+		}],
+		take: l,
+		skip: void 0,
+		projection: void 0
+	}), x = [];
+	for (let e of b) {
+		let t = e, n = d(t.occurredAt);
+		typeof t.id == "string" && typeof t.name == "string" && n !== void 0 && _.has(t.name) && x.push({
+			id: t.id,
+			name: t.name,
+			payload: t.payload,
+			occurredAt: n
+		});
+	}
+	let S = [], C = [], w = 0, T = 0, E = !1, D = !1, O = r.runPage ?? 2e3;
+	if (x.length > 0) for (let e of a) {
+		let r = x.filter((t) => e.entries.some((e) => e.event === t.name));
+		if (r.length === 0) continue;
+		let i = [], a = [];
+		try {
+			i = await h(n.store, e.workflowName, O), a = await g(n.store, e.workflowName, O), (i.length >= O || a.length >= O) && (E = !0);
+		} catch (t) {
+			C.push({
+				subject: e.workflowName,
+				detail: f(t)
+			}), D = !0;
+			continue;
+		}
+		let o = t({
+			workflowName: e.workflowName,
+			entries: e.entries,
+			payloadSchema: e.payloadSchema,
+			events: r,
+			runs: i,
+			intents: a
+		});
+		S.push(...o.problems);
+		for (let t of o.cancels) try {
+			await n.cancelRun({
+				...t,
+				workflowName: e.workflowName
+			}), w += 1, n.log?.info("workflow.cancelOn: run cancelled", {
+				workflow: e.workflowName,
+				runId: t.runId,
+				event: t.event,
+				eventId: t.eventId
+			});
+		} catch (e) {
+			C.push({
+				subject: t.runId,
+				detail: f(e)
+			}), D = !0;
+		}
+		for (let t of o.discards) try {
+			await n.discardIntent({
+				...t,
+				workflowName: e.workflowName
+			}), T += 1;
+		} catch (e) {
+			C.push({
+				subject: t.intentId,
+				detail: f(e)
+			}), D = !0;
+		}
+	}
+	let k = e(x), A = v;
+	if (D) n.log?.warn("workflow.cancelOn: holding the watermark — evaluation or delivery remains incomplete", { failures: C.length });
+	else if (k !== void 0) try {
+		await m(n.store, s, k), A = k;
+	} catch (e) {
+		C.push({
+			subject: s,
+			detail: f(e)
+		});
+	}
+	return S.length > 0 && n.log?.warn("workflow.cancelOn: some events could not be evaluated", {
+		count: S.length,
+		first: S[0]
+	}), {
+		examined: !0,
+		events: x.length,
+		cancelled: w,
+		discarded: T,
+		catchingUp: b.length >= l,
+		sawFullRunPage: E,
+		problems: S,
+		failures: C,
+		watermark: A
+	};
+};
+//#endregion
+export { s as CANCEL_ON_WATERMARK, c as DEFAULT_COLD_LOOKBACK_MS, l as DEFAULT_EVENT_BATCH, u as DEFAULT_RUN_PAGE, o as EVENTS_TABLE, a as WATERMARKS_TABLE, p as readWatermark, _ as sweepCancelOn, m as writeWatermark };

package/dist/cancelPendingStart.js

@@ -0,0 +1,50 @@
+import { readAdmissionSubmission as e } from "./admissionSubmission.js";
+import { readWorkflowStartReceipt as t, settlePendingStartReceipts as n } from "./startReceipt.js";
+import { PENDING_TABLE as r, toPendingIntent as i } from "./admissionStore.js";
+import { eq as a } from "@voltro/database";
+//#region src/cancelPendingStart.ts
+var o = async (o, s) => {
+	if (!Number.isFinite(s.now) || !Number.isFinite(new Date(s.now).getTime())) throw Error("Queued cancellation requires a valid timestamp");
+	let c = await t(o, s.receiptId);
+	if (c === void 0 || c.workflowName !== s.workflowName || c.tenantId !== s.tenantId) throw Error("Queued cancellation receipt is missing or belongs to another workflow or tenant");
+	if (c.terminal !== null) return {
+		kind: "terminal",
+		outcome: c.terminal
+	};
+	if (c.submissionId !== null) {
+		let t = await e(o, c.submissionId);
+		if (t === void 0 || !t.receiptsBound || t.workflowName !== c.workflowName || t.tenantId !== c.tenantId || !t.intentIds.includes(c.pendingId)) throw Error("Queued cancellation receipt has no matching submission");
+		return {
+			kind: "submitted",
+			submissionId: t.id
+		};
+	}
+	let [l] = await o.query({
+		table: r,
+		predicate: a("id", c.pendingId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (l === void 0) throw Error("Queued cancellation has no pending input or submission");
+	let u = i(l);
+	if (u.workflowName !== c.workflowName || u.tenantId !== c.tenantId || u.deadLetteredAt !== void 0) throw Error("Queued cancellation input has contradictory ownership or is dead-lettered");
+	let d = {
+		kind: "cancelled",
+		at: s.now
+	};
+	if (await n(o, {
+		pendingId: c.pendingId,
+		workflowName: c.workflowName,
+		tenantId: c.tenantId,
+		terminal: d
+	}), !await o.delete("_voltro_workflow_pending", c.pendingId)) throw Error("Queued cancellation lost its pending input");
+	return {
+		kind: "terminal",
+		outcome: d
+	};
+};
+//#endregion
+export { o as cancelPendingWorkflowStartInTransaction };