@voltro/workflow 0.84.0 → 0.86.0

package/dist/runGeneration.js

@@ -0,0 +1,345 @@
+import { isWorkflowEncrypted as e, sealErrorText as t, sealJournalValue as n } from "./journalEncryption.js";
+import { recordWorkflowFailureInTransaction as r } from "./failureReportStore.js";
+import { handoffWorkflowFailureInTransaction as i, isFailureDeliveryExecution as a } from "./failureHandoff.js";
+import { dispatchedExecutionSubmissions as o } from "./admissionSubmission.js";
+import { ADMISSIONS_TABLE as s, releaseLease as c } from "./admissionStore.js";
+import { finishTimeoutCause as l, hasPendingWorkflowCancellation as u, readPendingWorkflowCancellations as d, settleWorkflowControlsInTransaction as f, settleWorkflowResumesInTransaction as p } from "./controlRequest.js";
+import { stageParentClosureAtChildEntry as m } from "./parentClosure.js";
+import { consumeWorkflowRestartInTransaction as h } from "./workflowRestartReservation.js";
+import { stageQueuedCancellationsAtRunEntry as g } from "./queuedCancellationRequest.js";
+import { Schema as _ } from "effect";
+import { derivedRowId as v, eq as y } from "@voltro/database";
+import { createHash as b } from "node:crypto";
+//#region src/runGeneration.ts
+var x = "_voltro_workflow_runs", S = _.NullOr(_.Struct({
+	requestId: _.NonEmptyString,
+	restartToken: _.NullOr(_.NonEmptyString)
+})), C = async (e, t, n, r) => {
+	if (typeof t.id != "string") throw Error("Child entry has no allocated run identity");
+	let i = {
+		runId: t.id,
+		workflowName: n.workflowName,
+		executionId: n.executionId,
+		generation: n.generation
+	}, a = await g(e, i), o = await m(e, t);
+	if (!a && !o) return;
+	let s = await k(e, {
+		owner: i,
+		now: n.now,
+		durationMs: 0,
+		outcome: { status: "cancelled" }
+	}, "running");
+	if (s.kind !== "committed") throw Error("Child entry cancellation lost its resident owner");
+	return {
+		kind: "cancelled",
+		row: s.row,
+		previous: r,
+		terminalEvent: s.terminalEvent
+	};
+}, w = async (e, t) => {
+	let n = await h(e, t);
+	return {
+		...await C(e, n.row, t, n.previous) ?? {
+			kind: "entered",
+			row: n.row,
+			previous: n.previous
+		},
+		restartEvent: n.event
+	};
+}, T = async (e, t) => {
+	if ([
+		t.workflowName,
+		t.executionId,
+		t.generation
+	].some((e) => e.length === 0) || typeof t.initialRow.id != "string" || t.initialRow.id.length === 0 || !Number.isFinite(t.now)) throw Error("Workflow entry requires allocated identities and a finite timestamp");
+	let n = (await e.query({
+		table: x,
+		predicate: y("executionId", t.executionId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0], r = _.decodeUnknownSync(S)(t.delivery ?? null), i = (r) => C(e, r, t, n);
+	if (n === void 0) {
+		if (r !== null && r.restartToken !== null) throw Error("Workflow restart delivery has no resident authorization");
+		if ((await e.query({
+			table: "_voltro_workflow_parent_closures",
+			predicate: y("executionId", t.executionId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: ["id"]
+		})).length !== 0) throw Error("Workflow execution is already terminal; restore its engine journal instead of re-entering the body");
+		let n = await e.insert(x, {
+			...t.initialRow,
+			tag: t.workflowName,
+			executionId: t.executionId,
+			runnerGeneration: t.generation,
+			engineDelivery: r,
+			status: "running",
+			runnerEnteredAt: new Date(t.now),
+			reclaimCount: 0
+		});
+		return await i(n) ?? {
+			kind: "created",
+			row: n,
+			previous: void 0
+		};
+	}
+	if (n.tag !== t.workflowName || typeof n.id != "string") throw Error("Workflow entry execution belongs to a different resident run");
+	let a = _.decodeUnknownSync(S)(n.engineDelivery ?? null);
+	if (a?.requestId !== r?.requestId || a?.restartToken !== r?.restartToken) {
+		if (n.status === "failed" && r !== null && r.restartToken !== null && a?.requestId === r.requestId) return w(e, {
+			runId: n.id,
+			workflowName: t.workflowName,
+			executionId: t.executionId,
+			generation: t.generation,
+			delivery: r,
+			now: t.now
+		});
+		throw Error("Workflow delivery does not match its resident owner");
+	}
+	if (n.status === "cancelled") return {
+		kind: "already-cancelled",
+		row: n,
+		previous: n
+	};
+	if (n.status === "succeeded" || n.status === "failed") throw Error("Workflow execution is already terminal; restore its engine journal instead of re-entering the body");
+	if (n.status === "suspended" && n.runnerEnteredAt === null && typeof n.runnerGeneration == "string") {
+		let r = {
+			runId: n.id,
+			workflowName: t.workflowName,
+			executionId: t.executionId,
+			generation: n.runnerGeneration
+		};
+		if (await u(e, r)) {
+			let i = await k(e, {
+				owner: r,
+				now: t.now,
+				durationMs: 0,
+				outcome: { status: "cancelled" }
+			}, "suspended");
+			if (i.kind !== "committed") throw Error("Suspended cancellation lost its resident owner");
+			return {
+				kind: "cancelled",
+				row: i.row,
+				previous: n,
+				terminalEvent: i.terminalEvent
+			};
+		}
+	}
+	if (n.runnerGeneration === t.generation) return {
+		kind: "replayed",
+		row: n,
+		previous: void 0
+	};
+	let o = n.runnerEnteredAt !== null && n.runnerEnteredAt !== void 0, s = n.reclaimCount;
+	if (typeof s != "number" || !Number.isSafeInteger(s) || s < 0) throw Error("Workflow entry has an invalid resident reclaim counter");
+	let c = o ? s + 1 : 0;
+	if (!Number.isSafeInteger(c)) throw Error("Workflow reclaim counter exhausted");
+	let l = await e.update(x, n.id, {
+		runnerGeneration: t.generation,
+		runnerEnteredAt: new Date(t.now),
+		reclaimCount: c,
+		status: "running",
+		errorTag: null,
+		errorMessage: null,
+		output: null,
+		completedAt: null
+	});
+	if (l === null) throw Error("Workflow run disappeared while entering its new generation");
+	let d = await i(l);
+	return d === void 0 ? (n.status === "suspended" && n.runnerEnteredAt === null && typeof n.runnerGeneration == "string" && await p(e, {
+		runId: n.id,
+		workflowName: t.workflowName,
+		executionId: t.executionId,
+		generation: n.runnerGeneration
+	}, t.generation, t.now), {
+		kind: "entered",
+		row: l,
+		previous: n
+	}) : d;
+}, E = async (e, t) => {
+	if ([
+		t.runId,
+		t.workflowName,
+		t.executionId,
+		t.generation
+	].some((e) => e.length === 0)) throw Error("Workflow runner ownership requires non-empty identities");
+	let n = (await e.query({
+		table: x,
+		predicate: y("id", t.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0];
+	if (n === void 0 || n.tag !== t.workflowName || n.executionId !== t.executionId) throw Error("Workflow runner ownership does not match its resident run");
+	return n;
+}, D = async (e, t, n) => {
+	let r = await E(e, t);
+	if (r.runnerGeneration !== t.generation || r.status !== "suspended" || r.runnerEnteredAt !== null || !await u(e, t)) return !1;
+	if ((await k(e, {
+		owner: t,
+		now: n,
+		durationMs: 0,
+		outcome: { status: "cancelled" }
+	}, "suspended")).kind !== "committed") throw Error("Suspended cancellation lost its resident owner");
+	return !0;
+}, O = async (e, t, n) => {
+	let r = await E(e, t);
+	if (r.runnerGeneration !== t.generation) return { kind: "superseded" };
+	if (r.status !== "running") return { kind: "not-running" };
+	let i = await e.update(x, t.runId, {
+		status: "suspended",
+		runnerEnteredAt: null,
+		errorTag: n.errorTag,
+		errorMessage: n.errorMessage
+	});
+	if (i === null) throw Error("Workflow run disappeared during suspension recording");
+	return {
+		kind: "committed",
+		row: i
+	};
+}, k = async (u, p, m) => {
+	let h = await E(u, p.owner);
+	if (h.runnerGeneration !== p.owner.generation) return { kind: "superseded" };
+	if (h.status !== m) return { kind: "not-running" };
+	if (!Number.isFinite(p.now) || !Number.isFinite(p.durationMs) || p.durationMs < 0) throw Error("Workflow completion requires finite time and non-negative duration");
+	let g = p.outcome, S = null;
+	if (g.status === "failed" && (S = `wffr_${b("sha256").update(JSON.stringify([
+		"run",
+		p.owner.workflowName,
+		p.owner.runId,
+		p.owner.generation
+	])).digest("hex").slice(0, 40)}`, await r(u, {
+		id: S,
+		sourceKind: "run",
+		sourceId: p.owner.runId,
+		workflowName: p.owner.workflowName,
+		tenantId: g.tenantId,
+		handler: await a(u, p.owner.executionId, p.owner.workflowName, g.tenantId) ? null : g.handler,
+		callerContext: g.callerContext,
+		report: {
+			workflow: p.owner.workflowName,
+			payload: h.payload,
+			errorTag: g.errorTag,
+			errorMessage: g.errorMessage,
+			runId: p.owner.runId,
+			executionId: p.owner.executionId,
+			reason: "the run failed",
+			failedAt: p.now
+		}
+	}), await i(u, S, p.now)), g.status === "cancelled") {
+		let e = (await d((e) => u.query({
+			...e,
+			lock: "update"
+		}), p.owner)).map((e) => ({
+			request: e,
+			cause: l(e)
+		})).find((e) => e.cause !== void 0);
+		if (e !== void 0 && e.cause !== void 0) {
+			let t = _.decodeUnknownOption(_.Struct({ tenantId: _.NullOr(_.String) }))(h.subject), n = e.request.owner?.tenantId ?? (t._tag === "Some" ? t.value.tenantId : null);
+			S = `wffr_${b("sha256").update(JSON.stringify([
+				"finish-timeout",
+				p.owner.workflowName,
+				p.owner.runId,
+				p.owner.generation
+			])).digest("hex").slice(0, 40)}`, await r(u, {
+				id: S,
+				sourceKind: "run",
+				sourceId: p.owner.runId,
+				workflowName: p.owner.workflowName,
+				tenantId: n,
+				handler: await a(u, p.owner.executionId, p.owner.workflowName, n) ? null : e.cause.detail.onFailure,
+				callerContext: {
+					subject: h.subject ?? null,
+					traceId: h.traceId ?? null,
+					source: h.source ?? null,
+					parentExecutionId: h.parentExecutionId ?? null,
+					parentGeneration: h.parentGeneration ?? null,
+					parentClosePolicy: h.parentClosePolicy ?? null
+				},
+				report: {
+					workflow: p.owner.workflowName,
+					payload: h.payload,
+					errorTag: null,
+					errorMessage: null,
+					runId: p.owner.runId,
+					executionId: p.owner.executionId,
+					reason: e.cause.reason,
+					failedAt: p.now
+				}
+			}), await i(u, S, p.now);
+		}
+	}
+	let C = await u.update(x, p.owner.runId, {
+		status: g.status,
+		completedAt: new Date(p.now),
+		durationMs: p.durationMs,
+		cancelled: g.status === "cancelled",
+		runnerEnteredAt: null,
+		output: g.status === "succeeded" ? e(p.owner.workflowName) ? n(g.output, `workflow '${p.owner.workflowName}' result`) : g.output : null,
+		errorTag: g.status === "failed" ? g.errorTag : null,
+		errorMessage: g.status === "failed" ? t(p.owner.workflowName, g.errorMessage) : null
+	});
+	if (C === null) throw Error("Workflow run disappeared during terminal recording");
+	await u.insert("_voltro_workflow_parent_closures", {
+		id: v("wfpc", JSON.stringify([p.owner.runId, p.owner.generation])),
+		runId: p.owner.runId,
+		workflowName: p.owner.workflowName,
+		executionId: p.owner.executionId,
+		generation: p.owner.generation,
+		parentStatus: g.status,
+		closedAt: new Date(p.now),
+		afterChildId: null,
+		scanHasOpenChildren: !1,
+		completedAt: null
+	});
+	let w = await u.insert("_voltro_workflow_run_events", {
+		id: v("wfev", JSON.stringify([
+			"terminal",
+			p.owner.runId,
+			p.owner.generation
+		])),
+		runId: p.owner.runId,
+		eventType: `run-${g.status}`,
+		occurredAt: new Date(p.now),
+		stepName: null,
+		attempt: null,
+		payload: {
+			executionId: p.owner.executionId,
+			generation: p.owner.generation,
+			durationMs: p.durationMs,
+			...g.status === "failed" ? {
+				errorTag: g.errorTag,
+				errorMessage: t(p.owner.workflowName, g.errorMessage)
+			} : {}
+		}
+	});
+	await f(u, p), await c(u, p.owner.executionId, p.now);
+	for await (let e of o(u, p.owner.executionId, p.owner.workflowName)) {
+		let [t] = await u.query({
+			table: s,
+			predicate: y("id", e.ledgerId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (t === void 0 || t.workflowName !== e.workflowName || t.tenantId !== e.tenantId || t.outcome !== "admitted" || t.executionId !== null && t.executionId !== p.owner.executionId) throw Error("Workflow terminal reservation does not match its resident submission");
+		if (t.releasedAt === null && await u.update("_voltro_workflow_admissions", e.ledgerId, { releasedAt: new Date(p.now) }) === null) throw Error("Workflow terminal reservation disappeared during release");
+	}
+	return {
+		kind: "committed",
+		row: C,
+		failureId: S,
+		terminalEvent: w
+	};
+}, A = (e, t) => k(e, t, "running");
+//#endregion
+export { D as cancelSuspendedWorkflowRunInTransaction, A as completeWorkflowRunGenerationInTransaction, w as enterWorkflowRestartGenerationInTransaction, T as enterWorkflowRunGenerationInTransaction, O as suspendWorkflowRunGenerationInTransaction };