@voltro/workflow 0.86.0 → 0.87.0

package/dist/journalRoutingState.js

@@ -0,0 +1,93 @@
+import { makeJournalRoutingGuard as e } from "./journalRoutingGuard.js";
+import { workflowJournalRoutingRowId as t, workflowJournalRoutingTable as n } from "./journalRoutingTable.js";
+import { journalRoutingLayout as r, journalRoutingTransitions as i } from "./journalRoutingLayout.js";
+import { withJournalRoutingTransaction as a } from "./journalRoutingTransaction.js";
+import { resolvePostgresJournalLocation as o, resolvePostgresJournalNamespace as s } from "./journalRoutingNamespace.js";
+import { acquireJournalRoutingLock as c } from "./journalRoutingLock.js";
+import { JournalRoutingMaintenance as l, relocateWorkflowJournal as u } from "./workflowShardRelocationSql.js";
+import { makePostgresJournalRoutingMaintenance as d } from "./journalRoutingMaintenance.js";
+import { Effect as f, Option as p } from "effect";
+import { SqlClient as m } from "effect/sql";
+//#region src/journalRoutingState.ts
+var h = (e, t) => f.gen(function* () {
+	let r = yield* e`SELECT c.relkind AS kind
+    FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE n.nspname = ${t} AND c.relname = ${n.tableName}`;
+	return r.length === 0 ? !1 : r.length !== 1 || r[0]?.kind !== "r" ? yield* f.fail(/* @__PURE__ */ Error("Journal routing metadata must be a table in the journal schema")) : !0;
+}), g = (e) => {
+	if (!Number.isSafeInteger(e.generation) || e.generation < 0 || e.generation >= 2 ** 53 - 1 || !/^[a-z][a-z0-9._-]{0,63}$/.test(e.layout)) throw Error("Invalid journal routing state");
+	return r(e.layout), Object.freeze({
+		generation: e.generation,
+		layout: e.layout
+	});
+}, _ = (e) => f.gen(function* () {
+	let n = yield* f.sync(() => g(e.expected)), r = yield* f.sync(() => g({
+		generation: n.generation + 1,
+		layout: e.nextLayout
+	})), a = yield* f.sync(() => i(n.layout, r.layout)), c = yield* m.SqlClient, p = c.withoutTransforms(), _ = yield* s, v = yield* d(_), y = l.of({ exclusive: (e) => v.exclusive(f.gen(function* () {
+		let i = yield* o;
+		if (i.namespace !== _) return yield* f.fail(/* @__PURE__ */ Error("Journal namespace changed during maintenance acquisition"));
+		if (yield* p`SELECT pg_advisory_xact_lock(6322741009312602::bigint)`, !(yield* h(p, i.schema))) return yield* f.fail(/* @__PURE__ */ Error("Workflow journal routing table is missing; apply the app schema first"));
+		yield* p`INSERT INTO ${i.routingTable} (id, namespace, generation, layout, relocation)
+      VALUES (${t(_)}, ${_}, 0, 'default', '[]') ON CONFLICT (namespace) DO NOTHING`;
+		let [s] = yield* p`
+      SELECT generation, layout FROM ${i.routingTable} WHERE namespace = ${_} FOR UPDATE`;
+		if (!s || String(s.generation) !== String(n.generation) || s.layout !== n.layout) return yield* f.fail(/* @__PURE__ */ Error("Journal routing generation changed; transition refused"));
+		let c = yield* e;
+		return yield* p`UPDATE ${i.routingTable} SET generation = ${r.generation}, layout = ${r.layout},
+      relocation = ${JSON.stringify(a)} WHERE namespace = ${_}`, c;
+	}).pipe(f.provideService(m.SqlClient, c))) });
+	return {
+		...yield* u(a).pipe(f.provideService(l, y)),
+		state: r
+	};
+}), v = () => f.gen(function* () {
+	let e = yield* m.SqlClient;
+	if (p.isSome(yield* f.serviceOption(e.transactionService))) return yield* f.fail(/* @__PURE__ */ Error("Journal routing admission cannot enter an ambient transaction"));
+	if (!e.onDialectOrElse({
+		pg: () => !0,
+		orElse: () => !1
+	})) return yield* f.fail(/* @__PURE__ */ Error("Journal routing generation admission currently requires PostgreSQL"));
+	let t = yield* s, n = yield* c({
+		namespace: t,
+		mode: "shared"
+	}), r = yield* a(e, n.connection, f.gen(function* () {
+		let n = yield* o;
+		if (n.namespace !== t) return yield* f.fail(/* @__PURE__ */ Error("Journal namespace changed during runtime admission"));
+		if (!(yield* h(e, n.schema))) return {
+			generation: 0,
+			layout: "default"
+		};
+		let r = yield* e`
+        SELECT generation, layout FROM ${n.routingTable} WHERE namespace = ${t}`;
+		return r.length === 0 ? {
+			generation: 0,
+			layout: "default"
+		} : r.length === 1 ? yield* f.sync(() => g({
+			generation: Number(r[0]?.generation),
+			layout: String(r[0]?.layout)
+		})) : yield* f.fail(/* @__PURE__ */ Error("Journal routing metadata has duplicate namespace rows"));
+	}));
+	return {
+		...n,
+		state: r,
+		namespace: t
+	};
+}), y = f.gen(function* () {
+	let e = yield* v();
+	return {
+		namespace: e.namespace,
+		state: e.state
+	};
+}), b = (e) => f.gen(function* () {
+	let t = yield* f.sync(() => g(e)), n = yield* v();
+	return n.state.generation !== t.generation || n.state.layout !== t.layout ? yield* f.fail(/* @__PURE__ */ Error("Journal routing generation does not match this runtime")) : n;
+}), x = (t) => f.gen(function* () {
+	let n = yield* b(t), r = yield* e({ verify: n.verify });
+	return {
+		...n,
+		...r
+	};
+});
+//#endregion
+export { x as acquireGuardedPostgresJournalRoutingAdmission, b as acquirePostgresJournalRoutingAdmission, g as captureJournalRoutingState, y as readPostgresJournalRoutingState, _ as transitionPostgresJournalRouting };

package/dist/journalRoutingTable.js

@@ -0,0 +1,11 @@
+import { bigint as e, derivedRowId as t, id as n, table as r, text as i } from "@voltro/database";
+//#region src/journalRoutingTable.ts
+var a = r("_voltro_workflow_journal_routing", {
+	id: n({ prefix: "wfjr" }),
+	namespace: i(),
+	generation: e(),
+	layout: i(),
+	relocation: i()
+}).unique(["namespace"]).nonReactive(), o = (e) => t("wfjr", e);
+//#endregion
+export { o as workflowJournalRoutingRowId, a as workflowJournalRoutingTable };

package/dist/journalRoutingTransaction.js

@@ -0,0 +1,16 @@
+import { Effect as e } from "effect";
+import { SqlClient as t } from "effect/sql";
+//#region src/journalRoutingTransaction.ts
+var n = (n, r, i) => t.makeWithTransaction({
+	transactionService: n.transactionService,
+	spanAttributes: [],
+	acquireConnection: e.succeed([void 0, r]),
+	begin: (t) => t.executeUnprepared("BEGIN", [], void 0).pipe(e.asVoid),
+	commit: (t) => t.executeUnprepared("COMMIT", [], void 0).pipe(e.asVoid),
+	rollback: (t) => t.executeUnprepared("ROLLBACK", [], void 0).pipe(e.asVoid),
+	savepoint: (t, n) => t.executeUnprepared(`SAVEPOINT voltro_routing_${n}`, [], void 0).pipe(e.asVoid),
+	rollbackSavepoint: (t, n) => t.executeUnprepared(`ROLLBACK TO SAVEPOINT voltro_routing_${n}`, [], void 0).pipe(e.asVoid),
+	releaseSavepoint: (t, n) => t.executeUnprepared(`RELEASE SAVEPOINT voltro_routing_${n}`, [], void 0).pipe(e.asVoid)
+})(i);
+//#endregion
+export { n as withJournalRoutingTransaction };

package/dist/workflowExecutorRouting.js

@@ -0,0 +1,33 @@
+import { journalExecutorGroups as e } from "./journalRoutingLayout.js";
+import { WorkflowEngine as t } from "effect/workflow";
+import { Context as n, Effect as r, Layer as i, Option as a } from "effect";
+//#region src/workflowExecutorRouting.ts
+var o = n.Service("@voltro/workflow/WorkflowExecutorRouting"), s = (e, t, r, i, a) => n.add(e, o, Object.freeze({
+	engine: t,
+	mode: r,
+	state: i,
+	groups: a ?? Object.freeze({
+		available: Object.freeze(["default"]),
+		assigned: Object.freeze(r === "client" ? [] : ["default"])
+	})
+})), c = (n, s) => {
+	let c = Object.freeze({
+		workflows: s.workflows,
+		schedules: s.schedules,
+		webhooks: s.webhooks
+	});
+	if (Object.values(c).some((e) => typeof e != "boolean")) throw Error("Explicit executor selection is required");
+	let l = Object.values(c).every(Boolean), u = Object.values(c).some(Boolean), d = r.gen(function* () {
+		let n = yield* r.serviceOption(t.WorkflowEngine);
+		if (a.isNone(n)) return yield* r.die(/* @__PURE__ */ Error("Executor registration requires a workflow engine"));
+		let i = yield* r.serviceOption(o);
+		if (a.isNone(i)) return l ? void 0 : yield* r.die(/* @__PURE__ */ Error("Selected executor roles require an engine routing contract"));
+		let s = i.value;
+		if (s.engine !== n.value || s.mode !== (u ? "worker" : "client")) return yield* r.die(/* @__PURE__ */ Error("Executor roles do not match the provided workflow engine"));
+		let d = yield* r.sync(() => e(s.state?.layout ?? "default", c)), f = (e, t) => e.length === t.length && e.every((e) => t.includes(e));
+		if (!f(s.groups.available, d.available) || !f(s.groups.assigned, d.assigned)) return yield* r.die(/* @__PURE__ */ Error("Executor roles do not match the engine shard ownership"));
+	});
+	return i.effectDiscard(d).pipe(i.provideMerge(n));
+};
+//#endregion
+export { s as recordWorkflowExecutorRouting, c as withWorkflowExecutorSelection };

package/dist/workflowRestartDispatch.js

@@ -1,29 +1,35 @@
-import { resetReservedWorkflowJournal as e } from "./workflowRestartReservation.js";
-import { prepareWorkflowRestartCommand as t } from "./workflowRestartPreparation.js";
-import { observeWorkflowRestartReplies as n } from "./workflowRestartObservation.js";
-import { Context as r, Effect as i } from "effect";
-import { SqlClient as a } from "effect/sql";
-import { MessageStorage as o, Sharding as s } from "effect/cluster";
+import { JournalRoutingGuard as e, protectJournalRoutingEffect as t, tryOwnedJournalRoutingPromise as n } from "./journalRoutingGuard.js";
+import { resetReservedWorkflowJournal as r } from "./workflowRestartReservation.js";
+import { JournalRoutingLayout as i, routeJournalWorkflow as a } from "./journalRoutingRuntime.js";
+import { prepareWorkflowRestartCommand as o } from "./workflowRestartPreparation.js";
+import { observeWorkflowRestartReplies as s } from "./workflowRestartObservation.js";
+import { Context as c, Effect as l, Option as u } from "effect";
+import { SqlClient as d } from "effect/sql";
+import { MessageStorage as f, Sharding as p } from "effect/cluster";
 //#region src/workflowRestartDispatch.ts
-var c = (t) => i.gen(function* () {
-	let n = yield* e(t);
-	return n.kind === "waiting-capacity" ? n : (yield* (yield* s.Sharding).pollStorage, {
+var m = (e) => l.gen(function* () {
+	let t = yield* r(e);
+	return t.kind === "waiting-capacity" ? t : (yield* (yield* p.Sharding).pollStorage, {
 		kind: "attempted",
-		journal: n
+		journal: t
 	});
-}), l = class extends r.Service()("@voltro/workflow/WorkflowRestartDispatcher") {}, u = i.gen(function* () {
-	let e = yield* a.SqlClient, r = yield* s.Sharding, u = yield* o.MessageStorage, d = (t) => n(t).pipe(i.provideService(a.SqlClient, e), i.provideService(s.Sharding, r), i.provideService(o.MessageStorage, u));
-	return l.of({
-		prepare: (e) => i.tryPromise({
-			try: (n) => t({
-				...e,
-				observe: (e) => i.runPromise(d(e), { signal: n })
-			}),
-			catch: (e) => e
-		}),
-		observe: d,
-		dispatch: (t) => c(t).pipe(i.provideService(a.SqlClient, e), i.provideService(s.Sharding, r))
+}), h = class extends c.Service()("@voltro/workflow/WorkflowRestartDispatcher") {}, g = l.gen(function* () {
+	let r = u.getOrUndefined(yield* l.serviceOption(e)), c = u.getOrUndefined(yield* l.serviceOption(i)), g = yield* d.SqlClient, _ = yield* p.Sharding, v = yield* f.MessageStorage, y = (e) => t(r, s(c === void 0 ? e : {
+		...e,
+		workflow: a(e.workflow, c)
+	})).pipe(l.provideService(d.SqlClient, g), l.provideService(p.Sharding, _), l.provideService(f.MessageStorage, v));
+	return h.of({
+		prepare: (e) => t(r, n((t) => o({
+			...e,
+			transaction: (n) => {
+				if (t.throwIfAborted(), r?.isClosed()) throw Error("Journal routing admission is closed");
+				return e.transaction(n);
+			},
+			observe: (e) => l.runPromise(y(e), { signal: t })
+		}))),
+		observe: y,
+		dispatch: (e) => t(r, m(e)).pipe(l.provideService(d.SqlClient, g), l.provideService(p.Sharding, _))
 	});
 });
 //#endregion
-export { l as WorkflowRestartDispatcher, c as dispatchWorkflowRestart, u as makeWorkflowRestartDispatcher };
+export { h as WorkflowRestartDispatcher, m as dispatchWorkflowRestart, g as makeWorkflowRestartDispatcher };