@voltro/workflow 0.85.0 → 0.87.0

package/dist/queuedCancellationRequest.js

@@ -0,0 +1,364 @@
+import { dispatchedExecutionSubmissions as e, readAdmissionSubmission as t } from "./admissionSubmission.js";
+import { readProvenSubmissionRejection as n } from "./submissionRejection.js";
+import { decodeWorkflowStartReceipt as r, readWorkflowStartReceipt as i } from "./startReceipt.js";
+import { cancelPendingWorkflowStartInTransaction as a } from "./cancelPendingStart.js";
+import { acceptWorkflowControlInTransaction as o, readWorkflowControlInTransaction as s } from "./controlRequest.js";
+import { cancelSuspendedWorkflowRunInTransaction as c } from "./runGeneration.js";
+import { Schema as l } from "effect";
+import { WorkflowQueuedCancellationResultSchema as u } from "@voltro/protocol";
+import { and as d, derivedRowId as f, eq as p, gt as m, id as h, json as g, table as _, text as v, timestamp as y } from "@voltro/database";
+//#region src/queuedCancellationRequest.ts
+var b = _("_voltro_workflow_queued_cancellations", {
+	id: h({ prefix: "wfqc" }),
+	receiptId: v(),
+	workflowName: v(),
+	tenantId: v().nullable(),
+	requestedAt: y(),
+	cause: g().nullable(),
+	target: g(),
+	controlBinding: g().nullable()
+}).index(["receiptId"]).index(["workflowName", "id"]).nonReactive(), x = l.NullOr(l.Struct({
+	reason: l.NonEmptyString,
+	detail: l.optional(l.Record(l.String, l.Unknown))
+})), S = l.Struct({
+	id: l.NonEmptyString,
+	receiptId: l.NonEmptyString,
+	workflowName: l.NonEmptyString,
+	tenantId: l.NullOr(l.String),
+	requestedAt: l.Date,
+	cause: x,
+	controlBinding: l.NullOr(l.Struct({
+		controlId: l.NonEmptyString,
+		runId: l.NonEmptyString,
+		executionId: l.NonEmptyString,
+		generation: l.NonEmptyString
+	})),
+	target: l.Union([l.Struct({
+		kind: l.Literal("submission"),
+		submissionId: l.NonEmptyString
+	}), l.Struct({
+		kind: l.Literal("terminal"),
+		receipt: l.Unknown
+	})])
+}), C = (e) => {
+	let t = l.decodeUnknownSync(S)(e);
+	if (!Number.isFinite(t.requestedAt.getTime())) throw Error("Queued cancellation request has an invalid timestamp");
+	if (t.target.kind === "submission") return {
+		...t,
+		target: t.target
+	};
+	let n = r(t.target.receipt);
+	if (t.controlBinding !== null) throw Error("A non-executed start cannot have a run control binding");
+	if (n.id !== t.receiptId || n.workflowName !== t.workflowName || n.tenantId !== t.tenantId || n.terminal === null) throw Error("Queued cancellation terminal evidence belongs to another start or is not terminal");
+	return {
+		...t,
+		target: {
+			kind: "terminal",
+			receipt: n
+		}
+	};
+}, w = async (e, t) => {
+	let [n] = await e.query({
+		table: b.tableName,
+		predicate: p("id", t),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n === void 0 ? void 0 : C(n);
+}, T = async (e, t) => {
+	let n = t.controlBinding;
+	if (n === null) throw Error("Queued cancellation has no control binding");
+	let r = await s(e, n.controlId);
+	if (r === void 0 || r.operation !== "cancel" || r.workflowName !== t.workflowName || r.runId !== n.runId || r.executionId !== n.executionId || r.generation !== n.generation || r.owner?.tenantId !== t.tenantId || r.result?.status === "running") throw Error("Queued cancellation lost its original resident control owner");
+	return r;
+}, E = async (e, t, n) => {
+	if (t.controlBinding === null) return;
+	let r = await T(e, t);
+	if (r.result !== null) return;
+	let [i] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: p("id", r.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	i !== void 0 && await c(e, {
+		runId: r.runId,
+		workflowName: r.workflowName,
+		executionId: r.executionId,
+		generation: r.generation
+	}, n);
+}, D = async (e, r) => {
+	let i = await w(e, r.requestId);
+	if (i === void 0) return {
+		kind: "unknown",
+		reason: "missing-request"
+	};
+	if (i.workflowName !== r.workflowName || i.tenantId !== r.tenantId) throw Error("Queued cancellation request belongs to another workflow or tenant");
+	if (i.target.kind === "terminal") {
+		let e = i.target.receipt.terminal;
+		if (e === null) throw Error("Queued cancellation has no terminal evidence");
+		return {
+			kind: e.kind === "cancelled" ? "confirmed" : "already-terminal",
+			request: i,
+			outcome: e
+		};
+	}
+	if (i.controlBinding !== null) {
+		let t = await T(e, i);
+		if (t.result !== null) return {
+			kind: t.result.kind,
+			request: i,
+			control: t
+		};
+		let [n] = await e.query({
+			table: "_voltro_workflow_runs",
+			predicate: p("id", t.runId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (n === void 0) return {
+			kind: "unknown",
+			reason: "missing-run",
+			request: i,
+			control: t
+		};
+		if (n.tag !== t.workflowName || n.executionId !== t.executionId) throw Error("Queued cancellation control belongs to another resident execution");
+		return n.runnerGeneration !== t.generation || n.status !== "running" && n.status !== "suspended" ? {
+			kind: "unknown",
+			reason: "unconfirmed-generation",
+			request: i,
+			control: t
+		} : {
+			kind: "accepted",
+			request: i,
+			control: t,
+			run: n
+		};
+	}
+	let a = await t(e, i.target.submissionId);
+	if (a === void 0 || !a.receiptsBound || a.workflowName !== i.workflowName || a.tenantId !== i.tenantId) throw Error("Queued cancellation has no matching submission evidence");
+	return a.failureId === null ? a.retry.stoppedAt !== null || a.runId !== null ? {
+		kind: "unknown",
+		reason: "unbound-submission",
+		request: i
+	} : {
+		kind: "accepted",
+		request: i
+	} : {
+		kind: "already-terminal",
+		request: i,
+		outcome: {
+			kind: "rejected",
+			failureId: await n(e, a)
+		}
+	};
+}, O = (e, t) => {
+	let n = "request" in t ? t.request : void 0;
+	if (n !== void 0 && (n.id !== e.requestId || n.receiptId !== e.receiptId || n.workflowName !== e.workflowName)) throw Error("Queued control result belongs to another request or receipt");
+	let r = {
+		operation: "cancel",
+		workflowName: e.workflowName,
+		receiptId: e.receiptId,
+		requestId: n?.id ?? null,
+		kind: t.kind
+	}, i = l.decodeUnknownSync(u);
+	if (t.kind === "unknown") return i({
+		...r,
+		observation: {
+			kind: "unavailable",
+			reason: t.reason
+		}
+	});
+	if ("outcome" in t && t.outcome !== void 0) return i({
+		...r,
+		observation: {
+			kind: "admission",
+			outcome: t.outcome
+		}
+	});
+	if ("control" in t && t.control !== void 0) {
+		let e = t.control, n = e.result;
+		return i({
+			...r,
+			observation: {
+				kind: "execution",
+				snapshot: {
+					id: e.runId,
+					workflowName: e.workflowName,
+					executionId: e.executionId,
+					status: n?.status ?? ("run" in t ? t.run?.status : void 0),
+					...n !== null && n.status === "succeeded" ? { output: n.output } : {},
+					...n !== null && n.status === "failed" && n.errorMessage !== null ? { error: {
+						tag: n.errorTag,
+						message: n.errorMessage
+					} } : {}
+				}
+			}
+		});
+	}
+	return i({
+		...r,
+		observation: { kind: "pending" }
+	});
+}, k = async (e, n) => {
+	let r = l.decodeUnknownSync(l.Struct({
+		id: l.NonEmptyString,
+		receiptId: l.NonEmptyString,
+		workflowName: l.NonEmptyString,
+		tenantId: l.NullOr(l.String),
+		requestedAt: l.Date,
+		cause: x
+	}))({
+		id: n.requestId,
+		receiptId: n.receiptId,
+		workflowName: n.workflowName,
+		tenantId: n.tenantId,
+		requestedAt: new Date(n.now),
+		cause: n.cause ?? null
+	});
+	if (!Number.isFinite(r.requestedAt.getTime())) throw Error("Queued cancellation request requires a valid timestamp");
+	let o = await w(e, r.id);
+	if (o !== void 0) {
+		if (o.receiptId !== r.receiptId || o.workflowName !== r.workflowName || o.tenantId !== r.tenantId) throw Error("Queued cancellation identity belongs to a different start or owner");
+		return await E(e, o, n.now), o;
+	}
+	let s = await a(e, n), c;
+	if (s.kind === "submitted") c = {
+		kind: "submission",
+		submissionId: s.submissionId
+	};
+	else {
+		let t = await i(e, n.receiptId);
+		if (t === void 0) throw Error("Cancelled start receipt disappeared during request acceptance");
+		c = {
+			kind: "terminal",
+			receipt: t
+		};
+	}
+	let u = C({
+		...r,
+		target: c,
+		controlBinding: null
+	});
+	if (await e.insert(b.tableName, u), c.kind === "submission") {
+		let r = await t(e, c.submissionId);
+		if (r === void 0) throw Error("Queued cancellation submission disappeared during acceptance");
+		if (r.preparedExecutionId !== null && r.dispatchAttempts > 0) {
+			let [t] = await e.query({
+				table: "_voltro_workflow_runs",
+				predicate: p("executionId", r.preparedExecutionId),
+				lock: "update",
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			});
+			if (t !== void 0) {
+				let r = l.decodeUnknownSync(l.Struct({
+					id: l.NonEmptyString,
+					tag: l.NonEmptyString,
+					executionId: l.NonEmptyString,
+					runnerGeneration: l.NonEmptyString
+				}))(t), i = {
+					runId: r.id,
+					workflowName: r.tag,
+					executionId: r.executionId,
+					generation: r.runnerGeneration
+				}, a = await A(e, u.id, i);
+				return await E(e, a.request, n.now), a.request;
+			}
+		}
+	}
+	return u;
+}, A = async (e, n, r) => {
+	let i = await w(e, n);
+	if (i === void 0) throw Error("Queued cancellation request is missing");
+	if (i.target.kind === "terminal") return {
+		kind: "terminal",
+		request: i
+	};
+	if (i.controlBinding !== null) return {
+		kind: "bound",
+		request: i,
+		control: await T(e, i)
+	};
+	let a = await t(e, i.target.submissionId);
+	if (a === void 0 || a.workflowName !== i.workflowName || a.tenantId !== i.tenantId || !a.receiptsBound || a.failureId !== null || a.dispatchAttempts === 0 || a.preparedExecutionId !== r.executionId || a.executionId !== null && a.executionId !== r.executionId || a.runId !== null && a.runId !== r.runId || r.workflowName !== i.workflowName) throw Error("Queued cancellation has no dispatched submission for this resident execution");
+	let [s] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: p("id", r.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), c = l.decodeUnknownOption(l.Struct({ tenantId: l.NullOr(l.String) }))(s?.subject);
+	if (s === void 0 || s.tag !== r.workflowName || s.executionId !== r.executionId || s.runnerGeneration !== r.generation || c._tag === "None" || c.value.tenantId !== i.tenantId || ![
+		"running",
+		"suspended",
+		"succeeded",
+		"failed",
+		"cancelled"
+	].includes(String(s.status))) throw Error("Queued cancellation generation or tenant does not match the resident run");
+	let u = {
+		controlId: f("wfctl", JSON.stringify(["queued-cancel", i.id])),
+		runId: r.runId,
+		executionId: r.executionId,
+		generation: r.generation
+	}, d = await o(e, {
+		id: u.controlId,
+		...r,
+		operation: "cancel",
+		requestedAt: i.requestedAt.getTime(),
+		cause: i.cause
+	});
+	if (await e.update(b.tableName, i.id, { controlBinding: u }) === null) throw Error("Queued cancellation request disappeared during run binding");
+	return {
+		kind: "bound",
+		request: {
+			...i,
+			controlBinding: u
+		},
+		control: d
+	};
+}, j = async (t, n) => {
+	let r = /* @__PURE__ */ new Set();
+	for await (let i of e(t, n.executionId, n.workflowName)) r.add(i.id);
+	if (r.size === 0) return !1;
+	let i, a = !1;
+	for (;;) {
+		let e = await t.query({
+			table: b.tableName,
+			predicate: d(p("workflowName", n.workflowName), ...i === void 0 ? [] : [m("id", i)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let o of e) {
+			let e = C(o);
+			if (i = e.id, e.target.kind !== "submission" || !r.has(e.target.submissionId)) continue;
+			let s = await A(t, e.id, n);
+			if (s.kind === "bound") {
+				if (s.control.runId !== n.runId || s.control.executionId !== n.executionId || s.control.workflowName !== n.workflowName) throw Error("Queued cancellation entry does not match its original resident execution");
+				s.control.result === null && (a = !0);
+			}
+		}
+		if (e.length < 100) return a;
+	}
+};
+//#endregion
+export { k as acceptQueuedCancellationInTransaction, A as bindQueuedCancellationRunInTransaction, D as observeQueuedCancellationInTransaction, b as queuedCancellationRequestsTable, O as queuedCancellationResult, w as readQueuedCancellationRequestInTransaction, j as stageQueuedCancellationsAtRunEntry };

package/dist/queuedControl.js

@@ -0,0 +1,21 @@
+import { acceptQueuedCancellationInTransaction as e, observeQueuedCancellationInTransaction as t, queuedCancellationResult as n } from "./queuedCancellationRequest.js";
+import { Schema as r } from "effect";
+//#region src/queuedControl.ts
+var i = r.Struct({
+	requestId: r.NonEmptyString,
+	receiptId: r.NonEmptyString,
+	workflowName: r.NonEmptyString,
+	tenantId: r.NullOr(r.String)
+}), a = async (t, n) => {
+	let a = r.decodeUnknownSync(i)(n);
+	return await e(t, {
+		...a,
+		now: n.now,
+		...n.cause === void 0 ? {} : { cause: n.cause }
+	}), o(t, a);
+}, o = async (e, a) => {
+	let o = r.decodeUnknownSync(i)(a);
+	return n(o, await t(e, o));
+};
+//#endregion
+export { a as cancelQueuedWorkflowStartInTransaction, o as readQueuedWorkflowCancellationInTransaction };

package/dist/recorder.js

@@ -0,0 +1,11 @@
+import { Context as e, Effect as t } from "effect";
+//#region src/recorder.ts
+var n = class extends e.Service()("@voltro/WorkflowRunRecorder") {}, r = e.Reference("@voltro/workflow/CurrentWorkflowRunId", { defaultValue: () => void 0 }), i = e.Reference("@voltro/workflow/CurrentWorkflowExecutionId", { defaultValue: () => void 0 }), a = e.Reference("@voltro/workflow/CurrentWorkflowStep", { defaultValue: () => void 0 }), o = t.gen(function* () {
+	let e = yield* i, t = yield* a;
+	return e === void 0 || t === void 0 ? void 0 : {
+		executionId: e,
+		step: t
+	};
+}), s = e.Reference("@voltro/workflow/CurrentWorkflowGeneration", { defaultValue: () => void 0 }), c = e.Reference("@voltro/workflow/CurrentWorkflowWakeTenant", { defaultValue: () => void 0 }), l = e.Reference("@voltro/workflow/CurrentWorkflowPatches", { defaultValue: () => [] }), u = () => r, d = () => i, f = class extends e.Service()("@voltro/WorkflowStepInterceptor") {};
+//#endregion
+export { i as CurrentWorkflowExecutionId, s as CurrentWorkflowGeneration, l as CurrentWorkflowPatches, r as CurrentWorkflowRunId, a as CurrentWorkflowStep, c as CurrentWorkflowWakeTenant, n as WorkflowRunRecorder, f as WorkflowStepInterceptorTag, o as currentWorkflowStep, d as getCurrentWorkflowExecutionId, u as getCurrentWorkflowRunId };

package/dist/residentExecutionEvidence.js

@@ -0,0 +1,64 @@
+import { Schema as e } from "effect";
+import { eq as t } from "@voltro/database";
+//#region src/residentExecutionEvidence.ts
+var n = e.Struct({
+	runId: e.NonEmptyString,
+	workflowName: e.NonEmptyString,
+	executionId: e.NonEmptyString,
+	generation: e.NonEmptyString,
+	parentStatus: e.Literals([
+		"succeeded",
+		"failed",
+		"cancelled"
+	]),
+	closedAt: e.Date
+}), r = async (r, i, a) => {
+	let [o] = await r.query({
+		table: "_voltro_workflow_runs",
+		predicate: t("executionId", a),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (o !== void 0) {
+		if (o.tag !== i) throw Error("Admission acknowledgement belongs to a different resident workflow");
+		if (typeof o.id != "string" || o.id.length === 0) throw Error("Resident execution has no run identity");
+		if (o.status === "running" || o.status === "suspended") return {
+			runId: o.id,
+			completedAt: null
+		};
+		if (o.status !== "succeeded" && o.status !== "failed" && o.status !== "cancelled") throw Error("Resident execution has an unrecognized status");
+		if (!(o.completedAt instanceof Date) || !Number.isFinite(o.completedAt.getTime())) throw Error("Terminal workflow has no valid completion timestamp for lease release");
+		return {
+			runId: o.id,
+			completedAt: o.completedAt
+		};
+	}
+	let [s] = await r.query({
+		table: "_voltro_workflow_parent_closures",
+		predicate: t("executionId", a),
+		lock: "update",
+		order: [{
+			column: "closedAt",
+			direction: "desc"
+		}, {
+			column: "id",
+			direction: "desc"
+		}],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (s === void 0) return;
+	let c = e.decodeUnknownSync(n)(s);
+	if (c.workflowName !== i || c.executionId !== a) throw Error("Admission acknowledgement belongs to a different resident workflow");
+	if (!Number.isFinite(c.closedAt.getTime())) throw Error("Workflow closure has no valid completion timestamp");
+	return {
+		runId: c.runId,
+		completedAt: c.closedAt
+	};
+};
+//#endregion
+export { r as readResidentExecutionEvidence };

package/dist/retryPolicy.js

@@ -0,0 +1,57 @@
+import { Cause as e, Duration as t, Effect as n, Exit as r, Option as i, Schedule as a } from "effect";
+//#region src/retryPolicy.ts
+var o = (e) => {
+	if (typeof e != "object" || !e) return;
+	let n = e.retryAfterMillis;
+	if (typeof n == "number" && Number.isFinite(n) && n >= 0) return t.millis(n);
+	let r = e.retryAfter;
+	if (typeof r == "number" && Number.isFinite(r) && r >= 0) return t.seconds(r);
+}, s = (e) => t.fromInputUnsafe(e), c = (e) => typeof e == "object" && e && "_tag" in e ? String(e._tag) : void 0, l = (e) => e !== void 0 && (e.maxAttempts ?? 3) > 1, u = (e) => {
+	if (e.retryable) return e.retryable;
+	if (e.retryableErrors && e.retryableErrors.length > 0) {
+		let t = new Set(e.retryableErrors);
+		return (e) => {
+			let n = c(e);
+			return n !== void 0 && t.has(n);
+		};
+	}
+	return () => !0;
+}, d = (e) => {
+	let r = e.baseDelay ?? "200 millis", i = e.strategy ?? "exponential", o = e.maxAttempts ?? 3, c = i === "linear" ? a.modifyDelay(a.spaced(s(e.step ?? r)), (i) => n.succeed(t.times(s(e.step ?? r), i.attempt))) : i === "fixed" ? a.spaced(s(r)) : a.exponential(s(r), e.factor ?? 2);
+	if (e.maxDelay !== void 0) {
+		let r = s(e.maxDelay);
+		c = a.modifyDelay(c, (e) => n.succeed(t.min(e.duration, r)));
+	}
+	(e.jitter ?? !0) === !0 && (c = a.jittered(c));
+	let l = a.max([c, a.recurs(Math.max(0, o - 1))]);
+	return e.maxElapsed !== void 0 && (l = a.upTo({ duration: s(e.maxElapsed) })(l)), l;
+}, f = (e, n) => {
+	let r = t.toMillis(s(e.baseDelay ?? "200 millis")), i = e.strategy ?? "exponential", a = i === "fixed" ? r : i === "linear" ? r + t.toMillis(s(e.step ?? e.baseDelay ?? "200 millis")) * (n - 1) : r * (e.factor ?? 2) ** (n - 1);
+	return e.maxDelay !== void 0 && (a = Math.min(a, t.toMillis(s(e.maxDelay)))), (e.jitter ?? !0) === !0 && (a *= Math.random()), a;
+}, p = (a, c, l, u) => n.gen(function* () {
+	let d = c.maxAttempts ?? 3, p = c.maxElapsed === void 0 ? Infinity : t.toMillis(s(c.maxElapsed)), m = yield* n.sync(() => Date.now()), h = 0;
+	for (;;) {
+		let s = yield* n.exit(a);
+		if (r.isSuccess(s)) return s.value;
+		let g = s.cause, _ = e.findErrorOption(g), v = i.isSome(_) ? _.value : e.squash(g);
+		h += 1;
+		let y = (yield* n.sync(() => Date.now())) - m;
+		if (h >= d || !l(v) || y >= p) return yield* n.failCause(g);
+		u?.(v);
+		let b = o(v), x = b === void 0 ? f(c, h) : t.toMillis(b);
+		yield* n.sleep(t.millis(x));
+	}
+}), m = (e, t, r) => {
+	if (!l(t)) return e;
+	let i = u(t);
+	if (t.respectRetryAfter === !0) return p(e, t, i, r);
+	let a = d(t), o = r ? n.tapError(e, (e) => n.sync(() => {
+		i(e) && r(e);
+	})) : e;
+	return n.retry(o, {
+		schedule: a,
+		while: i
+	});
+};
+//#endregion
+export { m as applyRetryPolicy, l as retryPolicyIsActive };

package/dist/runEventsTable.js

@@ -0,0 +1,17 @@
+import { _voltroWorkflowRunsTable as e } from "./runsTable.js";
+import { id as t, integer as n, json as r, reference as i, table as a, text as o, timestamp as s } from "@voltro/database";
+//#region src/runEventsTable.ts
+var c = a("_voltro_workflow_run_events", {
+	id: t({ prefix: "wfev" }),
+	runId: i(() => e, {
+		index: !1,
+		onDelete: "cascade"
+	}),
+	eventType: o(),
+	payload: r().nullable(),
+	occurredAt: s().default("now"),
+	stepName: o().nullable(),
+	attempt: n().nullable()
+}).index(["runId", "occurredAt"]).index(["eventType"]);
+//#endregion
+export { c as _voltroWorkflowRunEventsTable };