@cplieger/actions 1.0.1 → 1.0.2

package/src/cross-action-coordination.test.ts

@@ -1,176 +0,0 @@
-// @vitest-environment happy-dom
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-vi.mock("./notifier.js", () => ({
-  configure: vi.fn(),
-  notifySuccess: vi.fn(),
-  notifyError: vi.fn(),
-  _resetNotifierForTest: vi.fn(),
-}));
-import { defineAction, _resetForTest as resetDefine } from "./define.js";
-import { _resetForTest as resetRegistry, recentLog } from "./registry.js";
-import { _resetForTest as resetCleanup } from "./cleanup.js";
-import { ActionError, retryNetwork } from "./error.js";
-
-beforeEach(() => {
-  resetDefine();
-  resetRegistry();
-  resetCleanup();
-  vi.clearAllMocks();
-});
-
-describe("two retry-configured actions in the same scope", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("second action waits for first action's retries to complete before starting", async () => {
-    let attemptA = 0;
-    let attemptB = 0;
-    const actionA = defineAction<void, string>({
-      name: "test.scope_retry_A",
-      scope: "shared",
-      retryable: retryNetwork,
-      retry: { count: 2, delay: 100 },
-      error: false,
-      run: () => {
-        attemptA++;
-        if (attemptA < 3) {
-          throw new ActionError("net", { code: "network" });
-        }
-        return Promise.resolve("A-done");
-      },
-    });
-    const actionB = defineAction<void, string>({
-      name: "test.scope_retry_B",
-      scope: "shared",
-      retryable: retryNetwork,
-      retry: { count: 1, delay: 50 },
-      error: false,
-      run: () => {
-        attemptB++;
-        return Promise.resolve("B-done");
-      },
-    });
-    const pA = actionA.dispatch();
-    await Promise.resolve();
-    const pB = actionB.dispatch();
-    await Promise.resolve();
-    expect(attemptA).toBe(1);
-    expect(attemptB).toBe(0);
-    await vi.advanceTimersByTimeAsync(100);
-    expect(attemptA).toBe(2);
-    expect(attemptB).toBe(0);
-    await vi.advanceTimersByTimeAsync(200);
-    const rA = await pA;
-    expect(rA).toBe("A-done");
-    await Promise.resolve();
-    const rB = await pB;
-    expect(rB).toBe("B-done");
-    expect(attemptB).toBe(1);
-  });
-});
-
-describe("onSuccess → dispatch chain with same scope", () => {
-  it("chained dispatch via onSuccess runs after the triggering action completes", async () => {
-    const order: string[] = [];
-    const actionA = defineAction<void, string>({
-      name: "test.chain_A",
-      scope: "chain",
-      run: () => {
-        order.push("A-run");
-        return Promise.resolve("A-result");
-      },
-    });
-    const actionB = defineAction<void, string>({
-      name: "test.chain_B",
-      scope: "chain",
-      run: () => {
-        order.push("B-run");
-        return Promise.resolve("B-result");
-      },
-    });
-    let chainedPromise: Promise<string | null> | null = null;
-    const pA = actionA.dispatch(undefined, {
-      onSuccess: () => {
-        order.push("A-onSuccess");
-        chainedPromise = actionB.dispatch();
-      },
-    });
-    const rA = await pA;
-    expect(rA).toBe("A-result");
-    const rB = await chainedPromise!;
-    expect(rB).toBe("B-result");
-    expect(order).toEqual(["A-run", "A-onSuccess", "B-run"]);
-  });
-});
-
-describe("cancellation during retry unblocks queued action", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("cancelling a retrying action lets the queued action proceed", async () => {
-    let attemptA = 0;
-    let attemptB = 0;
-    const actionA = defineAction<void, string>({
-      name: "test.cancel_retry_A",
-      scope: "cancel-scope",
-      retryable: (err) => err.code !== "cancelled",
-      retry: { count: 5, delay: 100 },
-      error: false,
-      run: () => {
-        attemptA++;
-        throw new ActionError("fail", { status: 500 });
-      },
-    });
-    const actionB = defineAction<void, string>({
-      name: "test.cancel_retry_B",
-      scope: "cancel-scope",
-      error: false,
-      run: () => {
-        attemptB++;
-        return Promise.resolve("B-done");
-      },
-    });
-    const pA = actionA.dispatch();
-    await Promise.resolve();
-    const pB = actionB.dispatch();
-    await Promise.resolve();
-    expect(attemptA).toBe(1);
-    expect(attemptB).toBe(0);
-    actionA.cancel();
-    const rA = await pA;
-    expect(rA).toBeNull();
-    await Promise.resolve();
-    const rB = await pB;
-    expect(rB).toBe("B-done");
-    expect(attemptB).toBe(1);
-  });
-});
-
-describe("throwing callbacks don't break scope chain", () => {
-  it("onSuccess throwing does not re-record action as error", async () => {
-    const action = defineAction<void, string>({
-      name: "test.cb_throw_success",
-      scope: "cb-scope",
-      run: () => Promise.resolve("ok"),
-    });
-    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    const result = await action.dispatch(undefined, {
-      onSuccess: () => {
-        throw new Error("callback boom");
-      },
-    });
-    consoleSpy.mockRestore();
-    expect(result).toBe("ok");
-    const log = recentLog();
-    const entry = log.find((e) => e.name === "test.cb_throw_success");
-    expect(entry?.status).toBe("success");
-  });
-});

package/src/cross-action-races-extra.test.ts

@@ -1,231 +0,0 @@
-// @vitest-environment happy-dom
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-vi.mock("./notifier.js", () => ({
-  configure: vi.fn(),
-  notifySuccess: vi.fn(),
-  notifyError: vi.fn(),
-  _resetNotifierForTest: vi.fn(),
-}));
-import { defineAction, _resetForTest as resetDefine, _internalsForTest } from "./define.js";
-import { _resetForTest as resetRegistry } from "./registry.js";
-import { _resetForTest as resetCleanup } from "./cleanup.js";
-import { ActionError, retryNetwork } from "./error.js";
-
-beforeEach(() => {
-  resetDefine();
-  resetRegistry();
-  resetCleanup();
-  vi.clearAllMocks();
-});
-
-describe("dedupe + scope combined behavior", () => {
-  it("deduped dispatch shares the scope-queued promise without double-queuing", async () => {
-    let runCount = 0;
-    let resolveRun: ((v: string) => void) | null = null;
-    const action = defineAction<string, string>({
-      name: "test.dedupe_scope",
-      dedupe: true,
-      scope: "ds",
-      run: () => {
-        runCount++;
-        return new Promise<string>((r) => {
-          resolveRun = r;
-        });
-      },
-    });
-    const p1 = action.dispatch("x");
-    const p2 = action.dispatch("x");
-    await Promise.resolve();
-    expect(runCount).toBe(1);
-    resolveRun!("done");
-    const [r1, r2] = await Promise.all([p1, p2]);
-    expect(r1).toBe("done");
-    expect(r2).toBe("done");
-  });
-});
-
-describe("optimistic persistence across retries", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("rollback fires exactly once after all retries exhaust", async () => {
-    const rollbackCalls: string[] = [];
-    let attempt = 0;
-    const action = defineAction<string, string, string>({
-      name: "test.opt_retry_rollback",
-      retryable: (err) => err.code !== "cancelled",
-      retry: { count: 2, delay: 50 },
-      error: false,
-      optimistic: (args) => `snap-${args}`,
-      rollback: (_args, op) => {
-        rollbackCalls.push(op ?? "none");
-      },
-      run: () => {
-        attempt++;
-        throw new ActionError("fail", { status: 500 });
-      },
-    });
-    const p = action.dispatch("x");
-    await vi.advanceTimersByTimeAsync(50);
-    await vi.advanceTimersByTimeAsync(100);
-    await p;
-    expect(attempt).toBe(3);
-    expect(rollbackCalls).toEqual(["snap-x"]);
-  });
-
-  it("rollback does NOT fire when retries eventually succeed", async () => {
-    const rollbackCalls: string[] = [];
-    let attempt = 0;
-    const action = defineAction<string, string, string>({
-      name: "test.opt_retry_success",
-      retryable: retryNetwork,
-      retry: { count: 2, delay: 30 },
-      optimistic: (args) => `snap-${args}`,
-      rollback: (_args, op) => {
-        rollbackCalls.push(op ?? "none");
-      },
-      run: () => {
-        attempt++;
-        if (attempt < 3) {
-          throw new ActionError("net", { code: "network" });
-        }
-        return Promise.resolve("recovered");
-      },
-    });
-    const p = action.dispatch("y");
-    await vi.advanceTimersByTimeAsync(30);
-    await vi.advanceTimersByTimeAsync(60);
-    const result = await p;
-    expect(result).toBe("recovered");
-    expect(rollbackCalls).toEqual([]);
-  });
-});
-
-describe("onSettled re-dispatch with dedupe", () => {
-  it("dispatch from onSettled with same dedupe key starts a fresh run", async () => {
-    let runCount = 0;
-    const action = defineAction<string, string>({
-      name: "test.settled_redispatch",
-      dedupe: true,
-      run: () => {
-        runCount++;
-        return Promise.resolve(`run-${String(runCount)}`);
-      },
-    });
-    let chainedPromise: Promise<string | null> | null = null;
-    await action.dispatch("k", {
-      onSettled: () => {
-        chainedPromise = action.dispatch("k");
-      },
-    });
-    const result = await chainedPromise!;
-    expect(runCount).toBe(2);
-    expect(result).toBe("run-2");
-  });
-});
-
-describe("scope chain after optimistic throw", () => {
-  it("next action in scope runs after optimistic throw", async () => {
-    const order: string[] = [];
-    const broken = defineAction<void, string>({
-      name: "test.opt_throw",
-      scope: "opt-throw",
-      error: false,
-      optimistic: () => {
-        throw new Error("optimistic boom");
-      },
-      run: () => Promise.resolve("never"),
-    });
-    const follower = defineAction<void, string>({
-      name: "test.opt_throw_follower",
-      scope: "opt-throw",
-      run: () => {
-        order.push("follower-run");
-        return Promise.resolve("ok");
-      },
-    });
-    const pBroken = broken.dispatch();
-    const pFollower = follower.dispatch();
-    const rBroken = await pBroken;
-    expect(rBroken).toBeNull();
-    const rFollower = await pFollower;
-    expect(rFollower).toBe("ok");
-    expect(order).toEqual(["follower-run"]);
-  });
-});
-
-describe("rapid cancel + re-dispatch", () => {
-  it("re-dispatch after cancel uses a fresh AbortController", async () => {
-    const signalAborted: boolean[] = [];
-    const action = defineAction<void, string>({
-      name: "test.rapid_cancel",
-      error: false,
-      run: (_args, signal) => {
-        signalAborted.push(signal.aborted);
-        if (signal.aborted) {
-          throw new DOMException("aborted", "AbortError");
-        }
-        return Promise.resolve("ok");
-      },
-    });
-    const p1 = action.dispatch();
-    action.cancel();
-    await p1;
-    const p2 = action.dispatch();
-    const r2 = await p2;
-    expect(r2).toBe("ok");
-    expect(signalAborted[1]).toBe(false);
-  });
-});
-
-describe("idempotency key stability across retries", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("same idempotency key is passed to all retry attempts", async () => {
-    const keys: (string | undefined)[] = [];
-    const action = defineAction<void, string>({
-      name: "test.idem_retry",
-      idempotencyKey: true,
-      retryable: (err) => err.code !== "cancelled",
-      retry: { count: 2, delay: 20 },
-      error: false,
-      run: (_args, _signal, ctx) => {
-        keys.push(ctx?.idempotencyKey);
-        throw new ActionError("fail", { status: 500 });
-      },
-    });
-    const p = action.dispatch();
-    await vi.advanceTimersByTimeAsync(20);
-    await vi.advanceTimersByTimeAsync(40);
-    await p;
-    expect(keys.length).toBe(3);
-    expect(keys[0]).toBeDefined();
-    expect(keys[0]).toBe(keys[1]);
-    expect(keys[1]).toBe(keys[2]);
-  });
-
-  it("different dispatches get different idempotency keys", async () => {
-    const keys: (string | undefined)[] = [];
-    const action = defineAction<void, string>({
-      name: "test.idem_unique",
-      idempotencyKey: true,
-      run: (_args, _signal, ctx) => {
-        keys.push(ctx?.idempotencyKey);
-        return Promise.resolve("ok");
-      },
-    });
-    await action.dispatch();
-    await action.dispatch();
-    expect(keys.length).toBe(2);
-    expect(keys[0]).not.toBe(keys[1]);
-  });
-});

package/src/cross-action-races.test.ts

@@ -1,213 +0,0 @@
-// @vitest-environment happy-dom
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-vi.mock("./notifier.js", () => ({
-  configure: vi.fn(),
-  notifySuccess: vi.fn(),
-  notifyError: vi.fn(),
-  _resetNotifierForTest: vi.fn(),
-}));
-import { defineAction, _resetForTest as resetDefine, _internalsForTest } from "./define.js";
-import { _resetForTest as resetRegistry } from "./registry.js";
-import { _resetForTest as resetCleanup } from "./cleanup.js";
-import { ActionError } from "./error.js";
-
-beforeEach(() => {
-  resetDefine();
-  resetRegistry();
-  resetCleanup();
-  vi.clearAllMocks();
-});
-
-describe("dedupe + retry interaction", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("deduped caller's onError fires with the real error after retries exhaust", async () => {
-    let attempt = 0;
-    const action = defineAction<string, string>({
-      name: "test.dedupe_retry",
-      dedupe: true,
-      retryable: (err) => err.code !== "cancelled",
-      retry: { count: 2, delay: 50 },
-      error: false,
-      run: () => {
-        attempt++;
-        throw new ActionError("server down", { status: 503 });
-      },
-    });
-    const onError1 = vi.fn();
-    const onError2 = vi.fn();
-    const p1 = action.dispatch("x", { onError: onError1 });
-    const p2 = action.dispatch("x", { onError: onError2 });
-    await vi.advanceTimersByTimeAsync(50);
-    await vi.advanceTimersByTimeAsync(100);
-    const [r1, r2] = await Promise.all([p1, p2]);
-    expect(r1).toBeNull();
-    expect(r2).toBeNull();
-    expect(attempt).toBe(3);
-    expect(onError1).toHaveBeenCalledWith(
-      expect.objectContaining({ message: "server down", status: 503 }),
-      "x",
-    );
-    expect(onError2).toHaveBeenCalledWith(
-      expect.objectContaining({ message: "server down", status: 503 }),
-      "x",
-    );
-  });
-
-  it("dedupe map is cleaned up after retry exhaustion", async () => {
-    const action = defineAction<string, string>({
-      name: "test.dedupe_cleanup",
-      dedupe: true,
-      retryable: (err) => err.code !== "cancelled",
-      retry: { count: 1, delay: 20 },
-      error: false,
-      run: () => {
-        throw new ActionError("fail", { status: 500 });
-      },
-    });
-    const p = action.dispatch("z");
-    await vi.advanceTimersByTimeAsync(20);
-    await p;
-    const { activeDedupes } = _internalsForTest();
-    expect(activeDedupes).toBe(0);
-  });
-});
-
-describe("cancel during scope-queued wait", () => {
-  it("cancelling a queued action that hasn't started lets subsequent actions proceed", async () => {
-    let resolveOccupant: (() => void) | null = null;
-    const order: string[] = [];
-    const occupant = defineAction<void, string>({
-      name: "test.queue_cancel_occ",
-      scope: "q-cancel",
-      run: () =>
-        new Promise<string>((r) => {
-          resolveOccupant = () => {
-            r("occ");
-          };
-        }),
-    });
-    const victim = defineAction<void, string>({
-      name: "test.queue_cancel_victim",
-      scope: "q-cancel",
-      error: false,
-      run: () => {
-        order.push("victim-run");
-        return Promise.resolve("victim");
-      },
-    });
-    const follower = defineAction<void, string>({
-      name: "test.queue_cancel_follower",
-      scope: "q-cancel",
-      run: () => {
-        order.push("follower-run");
-        return Promise.resolve("follower");
-      },
-    });
-    const pOcc = occupant.dispatch();
-    await Promise.resolve();
-    const pVictim = victim.dispatch();
-    const pFollower = follower.dispatch();
-    await Promise.resolve();
-    victim.cancel();
-    resolveOccupant!();
-    await pOcc;
-    const rVictim = await pVictim;
-    expect(rVictim).toBeNull();
-    expect(order).not.toContain("victim-run");
-    const rFollower = await pFollower;
-    expect(rFollower).toBe("follower");
-    expect(order).toContain("follower-run");
-  });
-});
-
-describe("dedupe + cancel interaction", () => {
-  it("cancelling the original dispatch propagates cancellation to deduped caller", async () => {
-    const action = defineAction<string, string>({
-      name: "test.dedupe_cancel",
-      dedupe: true,
-      error: false,
-      run: (_args, signal) =>
-        new Promise<string>((_, reject) => {
-          signal.addEventListener("abort", () => {
-            reject(new DOMException("aborted", "AbortError"));
-          });
-        }),
-    });
-    const onSettled1 = vi.fn();
-    const onSettled2 = vi.fn();
-    const p1 = action.dispatch("a", { onSettled: onSettled1 });
-    const p2 = action.dispatch("a", { onSettled: onSettled2 });
-    action.cancel();
-    const [r1, r2] = await Promise.all([p1, p2]);
-    expect(r1).toBeNull();
-    expect(r2).toBeNull();
-    expect(onSettled1).toHaveBeenCalledTimes(1);
-    expect(onSettled2).toHaveBeenCalledTimes(1);
-  });
-
-  it("dedupe map is cleaned up after cancellation", async () => {
-    const action = defineAction<string, string>({
-      name: "test.dedupe_cancel_cleanup",
-      dedupe: true,
-      error: false,
-      run: (_args, signal) =>
-        new Promise<string>((_, reject) => {
-          signal.addEventListener("abort", () => {
-            reject(new DOMException("aborted", "AbortError"));
-          });
-        }),
-    });
-    const p = action.dispatch("b");
-    action.cancel();
-    await p;
-    const { activeDedupes } = _internalsForTest();
-    expect(activeDedupes).toBe(0);
-  });
-});
-
-describe("interleaved cross-action scope chain ordering", () => {
-  it("A-B-A-B dispatches serialize in dispatch order", async () => {
-    const order: string[] = [];
-    const actionA = defineAction<number, string>({
-      name: "test.interleave_A",
-      scope: "interleave",
-      run: (n) => {
-        order.push(`A-${String(n)}`);
-        return Promise.resolve(`A-${String(n)}`);
-      },
-    });
-    const actionB = defineAction<number, string>({
-      name: "test.interleave_B",
-      scope: "interleave",
-      run: (n) => {
-        order.push(`B-${String(n)}`);
-        return Promise.resolve(`B-${String(n)}`);
-      },
-    });
-    const p1 = actionA.dispatch(1);
-    const p2 = actionB.dispatch(1);
-    const p3 = actionA.dispatch(2);
-    const p4 = actionB.dispatch(2);
-    await Promise.all([p1, p2, p3, p4]);
-    expect(order).toEqual(["A-1", "B-1", "A-2", "B-2"]);
-  });
-
-  it("scope chain drains completely — no leaked promises", async () => {
-    const action = defineAction<number, number>({
-      name: "test.drain",
-      scope: "drain",
-      run: (n) => Promise.resolve(n),
-    });
-    await action.dispatch(1);
-    await action.dispatch(2);
-    await action.dispatch(3);
-    const { scopeChains } = _internalsForTest();
-    expect(scopeChains).toBe(0);
-  });
-});