@voltro/workflow 0.84.0 → 0.86.0

package/dist/controlMonitor.js

@@ -0,0 +1,13 @@
+import { readPendingWorkflowCancellation as e } from "./controlRequest.js";
+import { Effect as t } from "effect";
+import { WorkflowInstance as n } from "effect/workflow/WorkflowEngine";
+//#region src/controlMonitor.ts
+var r = (r, i, a) => t.gen(function* () {
+	let o = yield* n;
+	for (;;) {
+		if (yield* t.tryPromise(() => e(i, r)).pipe(t.catch(() => t.sync(() => (a(), !1))))) return o.interrupted = !0, yield* t.interrupt;
+		yield* t.sleep(1e3);
+	}
+});
+//#endregion
+export { r as awaitWorkflowCancellation };

package/dist/controlRequest.js

@@ -0,0 +1,367 @@
+import { isWorkflowEncrypted as e, sealErrorText as t, sealJournalValue as n } from "./journalEncryption.js";
+import { Schema as r } from "effect";
+import { and as i, derivedRowId as a, eq as o, gt as s, or as c } from "@voltro/database";
+//#region src/controlRequest.ts
+var l = "_voltro_workflow_control_requests", u = r.String.pipe(r.check(r.isMinLength(1))), d = r.Struct({
+	kind: r.Literals(["confirmed", "already-terminal"]),
+	status: r.Literals([
+		"succeeded",
+		"failed",
+		"cancelled"
+	]),
+	completedAt: r.Number.pipe(r.check(r.isFinite())),
+	output: r.Unknown,
+	errorTag: r.NullOr(r.String),
+	errorMessage: r.NullOr(r.String)
+}), f = r.Struct({
+	kind: r.Literal("confirmed"),
+	status: r.Literal("running"),
+	enteredAt: r.Number.pipe(r.check(r.isFinite())),
+	generation: u
+}), p = r.Union([d, f]), m = r.Struct({
+	reason: r.NonEmptyString,
+	detail: r.optional(r.Record(r.String, r.Unknown))
+}), h = r.Struct({ tenantId: r.NullOr(r.String) }), g = r.Struct({
+	requestId: r.String.pipe(r.check(r.isPattern(/^[1-9]\d*$/))),
+	replyId: r.String.pipe(r.check(r.isPattern(/^[1-9]\d*$/))),
+	restartToken: r.NullOr(r.NonEmptyString)
+}), _ = r.Struct({
+	id: u,
+	runId: u,
+	workflowName: u,
+	executionId: u,
+	generation: u,
+	operation: r.Literals([
+		"cancel",
+		"terminate",
+		"resume"
+	]),
+	requestedAt: r.Number.pipe(r.check(r.isFinite())),
+	owner: r.NullOr(h),
+	cause: r.optional(r.NullOr(m)),
+	dispatchAttempts: r.Number.pipe(r.check(r.isInt()), r.check(r.isGreaterThanOrEqualTo(0))),
+	resumeJournal: r.NullOr(g),
+	result: r.NullOr(p)
+}), v = r.Struct({
+	..._.fields,
+	requestedAt: r.Date
+}), y = (e) => {
+	let t = r.decodeUnknownSync(v)(e);
+	return r.decodeUnknownSync(_)({
+		...t,
+		requestedAt: t.requestedAt.getTime()
+	});
+}, b = async (e, t, n, r) => {
+	if (await e.update("_voltro_workflow_control_requests", t.id, { result: n }) === null) throw Error("Workflow control request disappeared during settlement");
+	await e.insert("_voltro_workflow_run_events", {
+		id: a("wfev", JSON.stringify(["control-settled", t.id])),
+		runId: t.runId,
+		eventType: "control-settled",
+		occurredAt: new Date(r),
+		stepName: null,
+		attempt: null,
+		payload: {
+			requestId: t.id,
+			operation: t.operation,
+			workflowName: t.workflowName,
+			executionId: t.executionId,
+			generation: t.generation,
+			cause: t.cause ?? null,
+			kind: n.kind,
+			status: n.status,
+			..."generation" in n ? { enteredGeneration: n.generation } : {}
+		}
+	});
+}, x = async (e, t) => {
+	let n = [], r;
+	for (;;) {
+		let a = await e({
+			table: l,
+			predicate: i(o("runId", t.runId), o("workflowName", t.workflowName), o("executionId", t.executionId), o("generation", t.generation), c(o("operation", "cancel"), o("operation", "terminate")), ...r === void 0 ? [] : [s("id", r)]),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let e of a) {
+			let t = y(e);
+			t.result === null && n.push(t);
+		}
+		if (a.length < 100) return n;
+		r = y(a[a.length - 1]).id;
+	}
+}, S = async (e, t) => (await x(e, t)).length > 0, C = (e, t) => S((t) => e.query({
+	...t,
+	lock: "update"
+}), t), w = {
+	source: "flow-control",
+	timeout: "finish"
+}, T = r.Struct({
+	reason: r.NonEmptyString,
+	detail: r.Struct({
+		source: r.Literal("flow-control"),
+		timeout: r.Literal("finish"),
+		onFailure: r.NullOr(r.NonEmptyString)
+	})
+}), E = (e) => {
+	let t = r.decodeUnknownOption(T)(e.cause);
+	return t._tag === "Some" ? t.value : void 0;
+}, D = async (e, t) => {
+	let [n] = await e.query({
+		table: l,
+		predicate: o("id", t),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (n !== void 0) return y(n);
+}, O = async (e, t) => {
+	let n;
+	for (;;) {
+		let r = await e.query({
+			table: l,
+			predicate: i(o("parentClosureId", t), ...n === void 0 ? [] : [s("id", n)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let e of r) {
+			let r = y(e);
+			if (r.cause?.reason !== "parent-close" || r.cause.detail?.closureId !== t || r.operation === "resume") throw Error("Parent closure control has contradictory ownership");
+			if (r.result === null) return !0;
+			n = r.id;
+		}
+		if (r.length < 100) return !1;
+	}
+}, k = async (e, t) => {
+	let n = r.decodeUnknownSync(_)({
+		...t,
+		owner: null,
+		cause: t.cause ?? null,
+		dispatchAttempts: 0,
+		resumeJournal: null,
+		result: null
+	}), i = await D(e, n.id);
+	if (i !== void 0) {
+		if (i.runId !== n.runId || i.workflowName !== n.workflowName || i.executionId !== n.executionId || i.generation !== n.generation || i.operation !== n.operation) throw Error("Workflow control identity belongs to a different target or operation");
+		return i;
+	}
+	let a = new Date(n.requestedAt);
+	if (!Number.isFinite(a.getTime())) throw Error("Workflow control timestamp is outside the supported date range");
+	let [s] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: o("id", n.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (s !== void 0 && (s.tag !== n.workflowName || s.executionId !== n.executionId)) throw Error("Workflow control target does not match its resident run");
+	let c = r.decodeUnknownOption(h)(s?.runnerGeneration === n.generation ? s.subject : void 0), u = {
+		...n,
+		owner: c._tag === "Some" ? c.value : null
+	}, d = s !== void 0 && s.runnerGeneration === n.generation && (s.status === "succeeded" || s.status === "failed" || s.status === "cancelled") ? {
+		...u,
+		result: r.decodeUnknownSync(p)({
+			kind: "already-terminal",
+			status: s.status,
+			completedAt: r.decodeUnknownSync(r.Date)(s.completedAt).getTime(),
+			output: s.output,
+			errorTag: s.errorTag,
+			errorMessage: s.errorMessage
+		})
+	} : u, f = d.cause?.reason === "parent-close" ? r.decodeUnknownSync(r.NonEmptyString)(d.cause.detail?.closureId) : null;
+	return await e.insert(l, {
+		...d,
+		requestedAt: a,
+		parentClosureId: f
+	}), d.result !== null && await b(e, d, d.result, n.requestedAt), d;
+}, A = async (e, t, n) => {
+	let i = await D(e, t);
+	if (i === void 0) throw Error("Workflow control request is missing");
+	if (i.operation !== "resume") throw Error("Only resume controls can bind a suspension journal");
+	if (i.result !== null) return {
+		kind: "settled",
+		request: i
+	};
+	let [a] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: o("id", i.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (a === void 0) return {
+		kind: "unknown",
+		request: i
+	};
+	if (a.tag !== i.workflowName || a.executionId !== i.executionId) throw Error("Workflow control target does not match its resident run");
+	if (a.runnerGeneration !== i.generation) return {
+		kind: "superseded",
+		request: i
+	};
+	if (a.status !== "suspended" || a.runnerEnteredAt !== null) return {
+		kind: "not-suspended",
+		request: i
+	};
+	let s = r.decodeUnknownSync(r.NullOr(r.Struct({
+		requestId: g.fields.requestId,
+		restartToken: g.fields.restartToken
+	})))(a.engineDelivery);
+	if (s === null) return {
+		kind: "unknown",
+		request: i
+	};
+	if (i.resumeJournal !== null) {
+		if (i.resumeJournal.requestId !== s.requestId || i.resumeJournal.restartToken !== s.restartToken) throw Error("Resume journal binding does not match its resident delivery");
+		return {
+			kind: "bound",
+			request: i
+		};
+	}
+	if (i.dispatchAttempts !== 0) return {
+		kind: "unknown",
+		request: i
+	};
+	let c = await n({
+		workflowName: i.workflowName,
+		executionId: i.executionId,
+		...s
+	});
+	if (c === void 0) return {
+		kind: "waiting-journal",
+		request: i
+	};
+	let l = r.decodeUnknownSync(g)(c);
+	if (l.requestId !== s.requestId || l.restartToken !== s.restartToken) throw Error("Observed suspension belongs to another engine delivery");
+	if (await e.update("_voltro_workflow_control_requests", i.id, { resumeJournal: l }) === null) throw Error("Workflow control request disappeared during suspension binding");
+	return {
+		kind: "bound",
+		request: {
+			...i,
+			resumeJournal: l
+		}
+	};
+}, j = async (e, t) => {
+	let n = await D(e, t);
+	if (n === void 0) throw Error("Workflow control request is missing");
+	if (n.result !== null) return {
+		kind: "settled",
+		request: n
+	};
+	let [r] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: o("id", n.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r === void 0) return {
+		kind: "unknown",
+		request: n
+	};
+	if (r.tag !== n.workflowName || r.executionId !== n.executionId) throw Error("Workflow control target does not match its resident run");
+	if (r.runnerGeneration !== n.generation) return {
+		kind: "superseded",
+		request: n
+	};
+	if (r.status === "succeeded" || r.status === "failed" || r.status === "cancelled") return {
+		kind: "already-terminal",
+		request: n,
+		run: r
+	};
+	if (r.status !== "running" && r.status !== "suspended") throw Error("Workflow control target has an invalid resident status");
+	let i = n.dispatchAttempts + 1;
+	if (!Number.isSafeInteger(i)) throw Error("Workflow control attempt counter exhausted");
+	if (await e.update("_voltro_workflow_control_requests", n.id, { dispatchAttempts: i }) === null) throw Error("Workflow control request disappeared before dispatch");
+	return {
+		kind: "dispatch",
+		request: {
+			...n,
+			dispatchAttempts: i
+		}
+	};
+}, M = async (a, c) => {
+	let u = c.owner, d;
+	for (;;) {
+		let f = await a.query({
+			table: l,
+			predicate: i(o("runId", u.runId), o("workflowName", u.workflowName), o("executionId", u.executionId), o("generation", u.generation), ...d === void 0 ? [] : [s("id", d)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let i of f) {
+			if (typeof i.id != "string") throw Error("Workflow control request has an invalid identity");
+			let o = await D(a, i.id);
+			if (o === void 0) throw Error("Workflow control request disappeared during completion");
+			if (o.result !== null) continue;
+			let s = c.outcome;
+			await b(a, o, r.decodeUnknownSync(p)({
+				kind: s.status === "cancelled" && o.operation !== "resume" ? "confirmed" : "already-terminal",
+				status: s.status,
+				completedAt: c.now,
+				output: s.status === "succeeded" ? e(u.workflowName) ? n(s.output, `workflow '${u.workflowName}' result`) : s.output : null,
+				errorTag: s.status === "failed" ? s.errorTag : null,
+				errorMessage: s.status === "failed" ? t(u.workflowName, s.errorMessage) : null
+			}), c.now);
+		}
+		if (f.length < 100) return;
+		let m = f[f.length - 1];
+		if (typeof m.id != "string") throw Error("Workflow control cursor has an invalid identity");
+		d = m.id;
+	}
+}, N = async (e, t, n, a) => {
+	let c = r.decodeUnknownSync(f)({
+		kind: "confirmed",
+		status: "running",
+		generation: n,
+		enteredAt: a
+	}), u;
+	for (;;) {
+		let n = await e.query({
+			table: l,
+			predicate: i(o("runId", t.runId), o("workflowName", t.workflowName), o("executionId", t.executionId), o("generation", t.generation), o("operation", "resume"), ...u === void 0 ? [] : [s("id", u)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let t of n) {
+			if (typeof t.id != "string") throw Error("Workflow control request has an invalid identity");
+			let n = await D(e, t.id);
+			if (n === void 0) throw Error("Workflow control request disappeared during resume");
+			n.result === null && await b(e, n, c, a);
+		}
+		if (n.length < 100) return;
+		let r = n[n.length - 1];
+		if (typeof r.id != "string") throw Error("Workflow control cursor has an invalid identity");
+		u = r.id;
+	}
+};
+//#endregion
+export { l as CONTROL_REQUESTS_TABLE, w as FLOW_CONTROL_FINISH_TIMEOUT, k as acceptWorkflowControlInTransaction, j as beginWorkflowControlDispatchInTransaction, A as bindWorkflowResumeJournalInTransaction, E as finishTimeoutCause, C as hasPendingWorkflowCancellation, O as hasUnsettledParentClosureControls, S as readPendingWorkflowCancellation, x as readPendingWorkflowCancellations, D as readWorkflowControlInTransaction, M as settleWorkflowControlsInTransaction, N as settleWorkflowResumesInTransaction };

package/dist/executionRefusal.js

@@ -0,0 +1,162 @@
+import { isWorkflowEncrypted as e, loggableCause as t } from "./journalEncryption.js";
+import { CurrentWorkflowDelivery as n } from "./workflowDelivery.js";
+import { completeWorkflowRunGenerationInTransaction as r, enterWorkflowRunGenerationInTransaction as i } from "./runGeneration.js";
+import { serialiseWorkflowRowForWire as a } from "./runRecording.js";
+import { Cause as o, Effect as s, Schema as c } from "effect";
+import { SubjectIdentity as l, publishServerError as u } from "@voltro/protocol";
+import { randomUUID as d } from "node:crypto";
+import { WorkflowInstance as f } from "effect/workflow/WorkflowEngine";
+//#region src/executionRefusal.ts
+var p = (p, m) => s.gen(function* () {
+	let h = yield* s.sync(() => c.decodeUnknownSync(l)(p.subject));
+	if (h.tenantId !== p.failureContext.tenantId) return yield* s.die(/* @__PURE__ */ Error("Workflow refusal has inconsistent caller tenant"));
+	let g = `wfrg_${d()}`, _ = yield* s.serviceOption(n), v = Date.now(), y = o.findErrorOption(m.cause), b = y._tag === "Some" ? y.value : o.squash(m.cause), x = b && typeof b == "object" && "_tag" in b ? String(b._tag) : null, S = b && typeof b == "object" && "message" in b ? String(b.message) : String(b), C = yield* s.promise(() => p.transaction(async (e) => {
+		let t = await i(e, {
+			workflowName: p.name,
+			executionId: m.executionId,
+			generation: g,
+			now: v,
+			delivery: _._tag === "Some" ? _.value : null,
+			initialRow: {
+				id: p.makeId?.("wr") ?? `wr_${d()}`,
+				payload: p.encodePayload === void 0 ? m.payload : p.encodePayload(m.payload),
+				status: "running",
+				subject: p.subject,
+				source: p.source ?? null,
+				traceId: p.traceId ?? null,
+				workflowVersion: p.workflowVersion ?? null,
+				workflowPatches: p.workflowPatches ?? null,
+				output: null,
+				errorTag: null,
+				errorMessage: null,
+				cancelled: !1,
+				startedAt: new Date(v),
+				completedAt: null,
+				durationMs: null,
+				parentExecutionId: p.parentExecutionId ?? null,
+				parentGeneration: p.parentGeneration ?? null,
+				parentClosePolicy: p.parentClosePolicy ?? null
+			}
+		}), n = c.decodeUnknownSync(l)(t.row.subject);
+		if (n.type !== h.type || n.id !== h.id || n.tenantId !== h.tenantId || h.type === "service" && (n.type !== "service" || n.service !== h.service)) throw Error("Workflow refusal belongs to a different recorded caller");
+		if (t.kind === "cancelled" || t.kind === "already-cancelled") return t;
+		if (typeof t.row.id != "string") throw Error("Workflow refusal has no allocated run identity");
+		let a = await r(e, {
+			owner: {
+				runId: t.row.id,
+				workflowName: p.name,
+				executionId: m.executionId,
+				generation: g
+			},
+			now: v,
+			durationMs: 0,
+			outcome: {
+				status: "failed",
+				errorTag: x,
+				errorMessage: S,
+				...p.failureContext
+			}
+		});
+		if (a.kind !== "committed") throw Error("Workflow refusal lost its resident generation");
+		return {
+			...a,
+			created: t.kind === "created",
+			restartEvent: t.restartEvent
+		};
+	}));
+	if (C.kind === "already-cancelled") {
+		let e = yield* f;
+		return e.interrupted = !0, yield* s.interrupt;
+	}
+	let w = (e) => {
+		try {
+			p.log?.warn(e, {
+				workflow: p.name,
+				executionId: m.executionId
+			});
+		} catch {}
+	};
+	yield* s.sync(() => {
+		try {
+			p.emit?.("workflowRuns", {
+				op: C.kind === "committed" && C.created ? "insert" : "update",
+				row: a(C.row)
+			}), C.restartEvent !== void 0 && p.emit?.("workflowEvents", {
+				op: "insert",
+				row: a(C.restartEvent)
+			}), C.terminalEvent !== void 0 && p.emit?.("workflowEvents", {
+				op: "insert",
+				row: a(C.terminalEvent)
+			});
+		} catch {
+			w("workflow refusal observer failed after terminal commit");
+		}
+	});
+	let T = C.kind === "cancelled" ? "cancelled" : "failed", E = String(C.row.id);
+	if (yield* s.tryPromise({
+		try: async () => {
+			await p.wakeups?.cancel(E, h.tenantId ?? void 0);
+		},
+		catch: (e) => e
+	}).pipe(s.catch(() => s.sync(() => w("workflow refusal wakeup observer failed after terminal commit")))), yield* s.tryPromise({
+		try: async () => {
+			await p.onParentClose?.({
+				workflowName: p.name,
+				executionId: m.executionId,
+				runId: E,
+				status: T
+			});
+		},
+		catch: (e) => e
+	}).pipe(s.catch(() => s.sync(() => w("workflow refusal parent observer failed after terminal commit")))), yield* s.tryPromise({
+		try: async () => {
+			await p.onTerminal?.({
+				workflowName: p.name,
+				executionId: m.executionId,
+				runId: E,
+				status: T,
+				...T === "failed" ? {
+					payload: m.payload,
+					errorTag: x,
+					errorMessage: S
+				} : {}
+			});
+		},
+		catch: (e) => e
+	}).pipe(s.catch(() => s.sync(() => w("workflow refusal terminal observer failed after commit")))), yield* s.sync(() => {
+		try {
+			p.recordRun?.({
+				name: p.name,
+				status: T,
+				durationMs: 0
+			});
+		} catch {
+			w("workflow refusal metrics observer failed after terminal commit");
+		}
+	}), C.kind === "cancelled") {
+		let e = yield* f;
+		return e.interrupted = !0, yield* s.interrupt;
+	}
+	return yield* s.sync(() => {
+		try {
+			p.log?.warn("workflow execution refused before application body", {
+				workflow: p.name,
+				executionId: m.executionId,
+				cause: t(p.name, b)
+			});
+		} catch {}
+		u({
+			error: b,
+			source: "workflow",
+			name: p.name,
+			contentSensitive: e(p.name),
+			...p.traceId ? { traceId: p.traceId } : {},
+			fields: {
+				executionId: m.executionId,
+				runId: C.row.id
+			}
+		});
+	}), yield* s.failCause(m.cause);
+});
+//#endregion
+export { p as recordWorkflowExecutionRefusal };