@voltro/workflow 0.70.0 → 0.71.1

package/dist/clusterDiagnostics-jpkNVay6.js

@@ -0,0 +1,379 @@
+import { Context as e, Effect as t, Schema as n } from "effect";
+import { and as r, derivedRowId as i, eq as a, gt as o, or as s } from "@voltro/database";
+//#region src/controlRequest.ts
+var c = "_voltro_workflow_control_requests", l = n.String.pipe(n.minLength(1)), u = n.Struct({
+	kind: n.Literal("confirmed", "already-terminal"),
+	status: n.Literal("succeeded", "failed", "cancelled"),
+	completedAt: n.Number.pipe(n.finite()),
+	output: n.Unknown,
+	errorTag: n.NullOr(n.String),
+	errorMessage: n.NullOr(n.String)
+}), d = n.Struct({
+	kind: n.Literal("confirmed"),
+	status: n.Literal("running"),
+	enteredAt: n.Number.pipe(n.finite()),
+	generation: l
+}), f = n.Union(u, d), p = n.Struct({
+	reason: n.NonEmptyString,
+	detail: n.optional(n.Record({
+		key: n.String,
+		value: n.Unknown
+	}))
+}), m = n.Struct({ tenantId: n.NullOr(n.String) }), h = n.Struct({
+	requestId: n.String.pipe(n.pattern(/^[1-9]\d*$/)),
+	replyId: n.String.pipe(n.pattern(/^[1-9]\d*$/)),
+	restartToken: n.NullOr(n.NonEmptyString)
+}), g = n.Struct({
+	id: l,
+	runId: l,
+	workflowName: l,
+	executionId: l,
+	generation: l,
+	operation: n.Literal("cancel", "terminate", "resume"),
+	requestedAt: n.Number.pipe(n.finite()),
+	owner: n.NullOr(m),
+	cause: n.optional(n.NullOr(p)),
+	dispatchAttempts: n.Number.pipe(n.int(), n.nonNegative()),
+	resumeJournal: n.NullOr(h),
+	result: n.NullOr(f)
+}), _ = n.Struct({
+	...g.fields,
+	requestedAt: n.DateFromSelf
+}), v = (e) => {
+	let t = n.decodeUnknownSync(_)(e);
+	return n.decodeUnknownSync(g)({
+		...t,
+		requestedAt: t.requestedAt.getTime()
+	});
+}, y = 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: i("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 } : {}
+		}
+	});
+}, b = async (e, t) => {
+	let n;
+	for (;;) {
+		let i = await e({
+			table: c,
+			predicate: r(a("runId", t.runId), a("workflowName", t.workflowName), a("executionId", t.executionId), a("generation", t.generation), s(a("operation", "cancel"), a("operation", "terminate")), ...n === void 0 ? [] : [o("id", n)]),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let e of i) if (v(e).result === null) return !0;
+		if (i.length < 100) return !1;
+		n = v(i[i.length - 1]).id;
+	}
+}, x = (e, t) => b((t) => e.query({
+	...t,
+	lock: "update"
+}), t), S = async (e, t) => {
+	let [n] = await e.query({
+		table: c,
+		predicate: a("id", t),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (n !== void 0) return v(n);
+}, C = async (e, t) => {
+	let n;
+	for (;;) {
+		let i = await e.query({
+			table: c,
+			predicate: r(a("parentClosureId", t), ...n === void 0 ? [] : [o("id", n)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let e of i) {
+			let r = v(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 (i.length < 100) return !1;
+	}
+}, w = async (e, t) => {
+	let r = n.decodeUnknownSync(g)({
+		...t,
+		owner: null,
+		cause: t.cause ?? null,
+		dispatchAttempts: 0,
+		resumeJournal: null,
+		result: null
+	}), i = await S(e, r.id);
+	if (i !== void 0) {
+		if (i.runId !== r.runId || i.workflowName !== r.workflowName || i.executionId !== r.executionId || i.generation !== r.generation || i.operation !== r.operation) throw Error("Workflow control identity belongs to a different target or operation");
+		return i;
+	}
+	let o = new Date(r.requestedAt);
+	if (!Number.isFinite(o.getTime())) throw Error("Workflow control timestamp is outside the supported date range");
+	let [s] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: a("id", r.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (s !== void 0 && (s.tag !== r.workflowName || s.executionId !== r.executionId)) throw Error("Workflow control target does not match its resident run");
+	let l = n.decodeUnknownOption(m)(s?.runnerGeneration === r.generation ? s.subject : void 0), u = {
+		...r,
+		owner: l._tag === "Some" ? l.value : null
+	}, d = s !== void 0 && s.runnerGeneration === r.generation && (s.status === "succeeded" || s.status === "failed" || s.status === "cancelled") ? {
+		...u,
+		result: n.decodeUnknownSync(f)({
+			kind: "already-terminal",
+			status: s.status,
+			completedAt: n.decodeUnknownSync(n.DateFromSelf)(s.completedAt).getTime(),
+			output: s.output,
+			errorTag: s.errorTag,
+			errorMessage: s.errorMessage
+		})
+	} : u, p = d.cause?.reason === "parent-close" ? n.decodeUnknownSync(n.NonEmptyString)(d.cause.detail?.closureId) : null;
+	return await e.insert(c, {
+		...d,
+		requestedAt: o,
+		parentClosureId: p
+	}), d.result !== null && await y(e, d, d.result, r.requestedAt), d;
+}, T = async (e, t, r) => {
+	let i = await S(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 [o] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: a("id", i.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (o === void 0) return {
+		kind: "unknown",
+		request: i
+	};
+	if (o.tag !== i.workflowName || o.executionId !== i.executionId) throw Error("Workflow control target does not match its resident run");
+	if (o.runnerGeneration !== i.generation) return {
+		kind: "superseded",
+		request: i
+	};
+	if (o.status !== "suspended" || o.runnerEnteredAt !== null) return {
+		kind: "not-suspended",
+		request: i
+	};
+	let s = n.decodeUnknownSync(n.NullOr(n.Struct({
+		requestId: h.fields.requestId,
+		restartToken: h.fields.restartToken
+	})))(o.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 r({
+		workflowName: i.workflowName,
+		executionId: i.executionId,
+		...s
+	});
+	if (c === void 0) return {
+		kind: "waiting-journal",
+		request: i
+	};
+	let l = n.decodeUnknownSync(h)(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
+		}
+	};
+}, E = async (e, t) => {
+	let n = await S(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: a("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
+		}
+	};
+}, D = async (e, t) => {
+	let i = t.owner, s;
+	for (;;) {
+		let l = await e.query({
+			table: c,
+			predicate: r(a("runId", i.runId), a("workflowName", i.workflowName), a("executionId", i.executionId), a("generation", i.generation), ...s === void 0 ? [] : [o("id", s)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let r of l) {
+			if (typeof r.id != "string") throw Error("Workflow control request has an invalid identity");
+			let i = await S(e, r.id);
+			if (i === void 0) throw Error("Workflow control request disappeared during completion");
+			if (i.result !== null) continue;
+			let a = t.outcome;
+			await y(e, i, n.decodeUnknownSync(f)({
+				kind: a.status === "cancelled" && i.operation !== "resume" ? "confirmed" : "already-terminal",
+				status: a.status,
+				completedAt: t.now,
+				output: a.status === "succeeded" ? a.output : null,
+				errorTag: a.status === "failed" ? a.errorTag : null,
+				errorMessage: a.status === "failed" ? a.errorMessage : null
+			}), t.now);
+		}
+		if (l.length < 100) return;
+		let u = l[l.length - 1];
+		if (typeof u.id != "string") throw Error("Workflow control cursor has an invalid identity");
+		s = u.id;
+	}
+}, O = async (e, t, i, s) => {
+	let l = n.decodeUnknownSync(d)({
+		kind: "confirmed",
+		status: "running",
+		generation: i,
+		enteredAt: s
+	}), u;
+	for (;;) {
+		let n = await e.query({
+			table: c,
+			predicate: r(a("runId", t.runId), a("workflowName", t.workflowName), a("executionId", t.executionId), a("generation", t.generation), a("operation", "resume"), ...u === void 0 ? [] : [o("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 S(e, t.id);
+			if (n === void 0) throw Error("Workflow control request disappeared during resume");
+			n.result === null && await y(e, n, l, s);
+		}
+		if (n.length < 100) return;
+		let i = n[n.length - 1];
+		if (typeof i.id != "string") throw Error("Workflow control cursor has an invalid identity");
+		u = i.id;
+	}
+}, k = "voltro-workflow-restart", A = class extends e.Tag("voltro/CurrentWorkflowDelivery")() {}, j = (e) => ({
+	...e,
+	registerEntity: (n, r, i) => e.registerEntity(n, n.type.startsWith("Workflow/") ? r.pipe(t.map((e) => {
+		let n = e.run;
+		if (typeof n != "function") throw Error("Workflow entity is missing its run handler");
+		return {
+			...e,
+			run: (e) => {
+				let r = {
+					requestId: String(e.requestId),
+					restartToken: e.headers["voltro-workflow-restart"] ?? null
+				};
+				return t.suspend(() => {
+					let r = n(e);
+					return t.isEffect(r) ? r : t.die(/* @__PURE__ */ Error("Workflow run handler must return an Effect"));
+				}).pipe(t.provideService(A, r));
+			}
+		};
+	})) : r, i)
+}), M = 6e5, N = class extends e.Tag("@voltro/workflow/ClusterDiagnostics")() {}, P = (e, n, r = Date.now()) => t.flatMap(e.messagesFor(n), (n) => {
+	if (n.length === 0) return t.succeed(void 0);
+	let i = [...new Set(n.filter((e) => !e.processed).map((e) => e.shardId))], a = i.length === 0 ? t.succeed([]) : e.shardLockHolders(i);
+	return t.map(a, (t) => ({
+		runner: e.ownAddress,
+		shardLockMode: e.shardLockMode,
+		messages: n.map((e) => ({
+			tag: e.tag,
+			shardId: e.shardId,
+			processed: e.processed,
+			lastRead: e.lastRead === null ? null : e.lastRead.toISOString(),
+			unreadForMs: !e.processed && e.lastRead !== null ? Math.max(0, r - e.lastRead.getTime()) : null
+		})),
+		shardLocks: t
+	}));
+});
+//#endregion
+export { k as a, E as c, C as d, b as f, O as h, A as i, T as l, D as m, N as n, j as o, S as p, P as r, w as s, M as t, x as u };

package/dist/clusterTestSuite.js

@@ -1,6 +1,6 @@
-import { I as e, P as t, S as n, g as r, v as i } from "./primitives-CqHxfASq.js";
-import { o as a } from "./src-TRpoU54e.js";
-import { i as o, p as s } from "./cluster-CSycI4sz.js";
+import { F as e, L as t, S as n, g as r, v as i } from "./primitives-DsMsMr5S.js";
+import { r as a } from "./src-OEBqLBJl.js";
+import { i as o, p as s } from "./cluster-BRSoL1tb.js";
 import { Cron as c, Deferred as l, Effect as u, Fiber as d, Layer as f, Schema as p } from "effect";
 import { SqlClient as m } from "@effect/sql";
 import { beforeAll as h, describe as g, expect as _, test as v } from "vitest";
@@ -188,7 +188,7 @@ var y = async (e, t, n = 750) => {
 						l.push(a);
 					})
 				}), "done";
-			}).pipe(u.locally(t, c), u.provideService(e, g))), S = m.runnerPort + 2, T = (e) => {
+			}).pipe(u.locally(e, c), u.provideService(t, g))), S = m.runnerPort + 2, T = (e) => {
 				let t = v();
 				return {
 					wf: t,