@iterativeflow/conformance 2.2.0 → 2.4.0

package/README.md

@@ -30,6 +30,12 @@ level of a test file.
   behaviors built on the ports.
 - `engineConformance` — the composed engine (retry/dead-letter, signal resume,
   cancel cascade, fan-out, drift) end-to-end on your backend.
+- `claimFilterConformance`, `shardedClaimConformance` — flow-name-filtered claims,
+  and concurrent claims across a fleet. `shardedClaimConformance` is for backends
+  that support concurrent writers; single-writer backends (memory, sqlite,
+  durable-objects) skip it by design.
+- `pendingWorkConformance` — the autoscaling backlog reads (`Queue.depth`,
+  `Timer.dueCount`, `Store.dueCronCount`) that `engine.pendingWork` composes.
 
 Every suite takes `(label, makeBackend)` where `makeBackend` returns a fresh
 `Backend` (or a `Promise` of one) per case.

package/dist/index.mjs

@@ -219,6 +219,24 @@ const storeConformance = (label, makeStore) => {
 				attempts: 1
 			});
 		});
+		it("a step memo round-trips through JSON — a Date comes back as a string on every backend", async () => {
+			const s = await makeStore();
+			const { runId } = await s.startRun({
+				name: "f",
+				version: 1,
+				input: {}
+			});
+			const at = /* @__PURE__ */ new Date("2030-01-01T00:00:00.000Z");
+			await s.checkpointStep({
+				runId,
+				cursorKey: "a",
+				status: "ok",
+				result: { at },
+				attempts: 1
+			});
+			const memo = (await s.loadRun(runId))?.steps.get("a")?.result;
+			expect(memo.at).toBe("2030-01-01T00:00:00.000Z");
+		});
 		it("checkpointStep round-trips the shape tag (drift-guard evidence)", async () => {
 			const s = await makeStore();
 			const { runId } = await s.startRun({
@@ -615,6 +633,109 @@ const storeConformance = (label, makeStore) => {
 			const again = await s.retryRun(runId);
 			expect(again.retried).toBe(false);
 		});
+		it("retryRun clears the spent attempt budget, so a dead-lettered run gets dispatched again", async () => {
+			const s = await makeStore();
+			const { runId } = await s.startRun({
+				name: "f",
+				version: 1,
+				input: {}
+			});
+			await s.markRunning(runId);
+			await s.markRunning(runId);
+			expect(await s.markRunning(runId)).toBe(3);
+			await s.markTerminal(runId, {
+				status: "failed",
+				error: {
+					code: "X",
+					message: "boom"
+				}
+			});
+			await s.retryRun(runId);
+			expect((await s.loadRunRow(runId))?.attempts).toBe(0);
+			expect(await s.markRunning(runId)).toBe(1);
+		});
+		it("cancelRuns cancels the live matched set and never a terminal run", async () => {
+			const s = await makeStore();
+			const mk = async (name) => (await s.startRun({
+				name,
+				version: 1,
+				input: {}
+			})).runId;
+			const live1 = await mk("f");
+			const live2 = await mk("f");
+			const other = await mk("g");
+			const done = await mk("f");
+			await s.markTerminal(done, {
+				status: "done",
+				output: 1
+			});
+			expect(await s.cancelRuns({ name: "f" }, 100)).toBe(2);
+			expect((await s.loadRunRow(live1))?.status).toBe("canceled");
+			expect((await s.loadRunRow(live2))?.status).toBe("canceled");
+			expect((await s.loadRunRow(other))?.status).toBe("pending");
+			expect((await s.loadRunRow(done))?.status).toBe("done");
+			expect(await s.cancelRuns({ name: "f" }, 100)).toBe(0);
+			await expect(s.cancelRuns({}, 100)).rejects.toThrow();
+		});
+		it("retryRuns re-drives the failed matched set, clearing the spent attempt budget", async () => {
+			const s = await makeStore();
+			const mk = async (name) => (await s.startRun({
+				name,
+				version: 1,
+				input: {}
+			})).runId;
+			const a = await mk("f");
+			const b = await mk("f");
+			const live = await mk("f");
+			await s.markRunning(a);
+			await s.markTerminal(a, {
+				status: "failed",
+				error: {
+					code: "X",
+					message: "x"
+				}
+			});
+			await s.markTerminal(b, {
+				status: "failed",
+				error: {
+					code: "X",
+					message: "x"
+				}
+			});
+			expect(await s.retryRuns({ name: "f" }, 100)).toBe(2);
+			for (const id of [a, b]) {
+				const row = await s.loadRunRow(id);
+				expect(row?.status).toBe("pending");
+				expect(row?.error).toBeUndefined();
+				expect(row?.attempts).toBe(0);
+			}
+			expect((await s.loadRunRow(live))?.status).toBe("pending");
+			expect(await s.retryRuns({ name: "f" }, 100)).toBe(0);
+			await expect(s.retryRuns({}, 100)).rejects.toThrow();
+		});
+		it("listRuns filters by version, not just name", async () => {
+			const s = await makeStore();
+			const v1 = (await s.startRun({
+				name: "f",
+				version: 1,
+				input: {}
+			})).runId;
+			const v2 = (await s.startRun({
+				name: "f",
+				version: 2,
+				input: {}
+			})).runId;
+			const only1 = await s.listRuns({
+				name: "f",
+				version: 1
+			}, { limit: 10 });
+			expect(only1.runs.map((r) => r.id)).toEqual([v1]);
+			const only2 = await s.listRuns({
+				name: "f",
+				version: 2
+			}, { limit: 10 });
+			expect(only2.runs.map((r) => r.id)).toEqual([v2]);
+		});
 		it("runStats counts runs per status", async () => {
 			const s = await makeStore();
 			const a = await s.startRun({
@@ -1325,6 +1446,26 @@ const signalConformance = (label, makeBackend) => {
 			expect(b.delivered).toBe(false);
 			expect((await store.loadRun(runId))?.signals).toHaveLength(1);
 		});
+		it("postSignal stays idempotent AFTER the signal is consumed — a late redelivery lands once", async () => {
+			const { store } = await makeBackend();
+			const { runId } = await store.startRun({
+				name: "f",
+				version: 1,
+				input: {}
+			});
+			await store.postSignal(runId, "approve", 1, { idempotencyKey: "evt-1" });
+			const delivered = (await store.loadRun(runId))?.signals ?? [];
+			await store.checkpointStep({
+				runId,
+				cursorKey: "wait",
+				status: "ok",
+				result: 1,
+				attempts: 1
+			}, { consumeSignals: [delivered[0].id] });
+			const again = await store.postSignal(runId, "approve", 1, { idempotencyKey: "evt-1" });
+			expect(again.delivered).toBe(false);
+			expect((await store.loadRun(runId))?.signals).toHaveLength(0);
+		});
 		it("consumeSignals drains exactly the referenced signal, atomically with the checkpoint", async () => {
 			const { store } = await makeBackend();
 			const { runId } = await store.startRun({
@@ -1540,6 +1681,37 @@ const reconcileConformance = (label, makeBackend) => {
 			});
 			expect(await store.orphanedRuns(10)).not.toContain(runId);
 		});
+		it("retryRuns re-enqueues, and cancelRuns clears the timer — not just a status flip", async () => {
+			const { store, queue, timer } = await makeBackend();
+			const now = /* @__PURE__ */ new Date("2030-01-01T00:00:00Z");
+			const failed = (await store.startRun({
+				name: "f",
+				version: 1,
+				input: {}
+			})).runId;
+			await store.markTerminal(failed, {
+				status: "failed",
+				error: {
+					code: "X",
+					message: "x"
+				}
+			});
+			const live = (await store.startRun({
+				name: "g",
+				version: 1,
+				input: {}
+			})).runId;
+			await timer.schedule(live, now);
+			expect(await store.retryRuns({ name: "f" }, 10)).toBe(1);
+			const leases = await queue.claim({
+				limit: 10,
+				leaseMs: 1e3,
+				now
+			});
+			expect(leases.map((l) => l.runId)).toContain(failed);
+			expect(await store.cancelRuns({ name: "g" }, 10)).toBe(1);
+			expect(await timer.dueCount(now)).toBe(0);
+		});
 	});
 };
 //#endregion
@@ -1584,6 +1756,39 @@ const cronConformance = (label, makeStore) => {
 			expect(due.map((c) => c.name)).toEqual(["nightly"]);
 			expect(due[0].input).toEqual({ kind: "changed" });
 		});
+		it("a CHANGED schedule takes its new nextRunAt (the old one would outlive the deploy)", async () => {
+			const s = await makeStore();
+			await s.upsertCron({
+				...spec,
+				schedule: "0 3 * * *",
+				nextRunAt: at(999999)
+			});
+			await s.upsertCron({
+				...spec,
+				schedule: "*/5 * * * *",
+				nextRunAt: at(5e3)
+			});
+			const due = await s.dueCrons(at(5e3), 10);
+			expect(due.map((c) => c.name)).toEqual(["nightly"]);
+			expect(due[0].schedule).toBe("*/5 * * * *");
+		});
+		it("listCrons returns every registered cron; removeCron stops one firing", async () => {
+			const s = await makeStore();
+			await s.upsertCron({
+				...spec,
+				nextRunAt: at(1e3)
+			});
+			await s.upsertCron({
+				...spec,
+				name: "weekly",
+				nextRunAt: at(2e3)
+			});
+			expect((await s.listCrons()).map((c) => c.name).sort()).toEqual(["nightly", "weekly"]);
+			expect(await s.removeCron("weekly")).toBe(true);
+			expect(await s.removeCron("weekly")).toBe(false);
+			expect((await s.listCrons()).map((c) => c.name)).toEqual(["nightly"]);
+			expect((await s.dueCrons(at(2e3), 10)).map((c) => c.name)).toEqual(["nightly"]);
+		});
 		it("advanceCron is a CAS — only the worker matching the expected time wins", async () => {
 			const s = await makeStore();
 			await s.upsertCron({

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@iterativeflow/conformance",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ahmedrowaihi/iterativeflow.git",
-    "directory": "v2/packages/conformance"
+    "directory": "packages/conformance"
   },
   "files": [
     "dist",
@@ -25,11 +25,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@iterativeflow/core": "2.2.0"
+    "@iterativeflow/core": "2.4.0"
   },
   "peerDependencies": {
     "vitest": ">=3"
   },
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
     "build": "tsdown"
   }