@cplieger/actions 1.0.1 → 1.1.0

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/actions",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "exports": {
     ".": "./src/index.ts"
   },

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@cplieger/actions",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "type": "module",
   "sideEffects": false,
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./src/*": "./src/*"
   },
   "scripts": {
     "typecheck": "tsgo -project tsconfig.json",
@@ -34,6 +35,9 @@
   },
   "files": [
     "src/",
+    "!src/**/*.test.ts",
+    "!src/**/__test-helpers__",
+    "!src/**/fc-strict-setup.ts",
     "jsr.json"
   ]
 }

package/src/__test-helpers__/action-test-setup.ts

@@ -1,34 +0,0 @@
-/**
- * Shared action-test setup. Provides resetActionFramework() and mock factories.
- */
-import { vi } from "vitest";
-
-import { _resetForTest as resetDefine } from "../define.js";
-import { _resetForTest as resetRegistry } from "../registry.js";
-import { _resetForTest as resetCleanup } from "../cleanup.js";
-import { _resetNotifierForTest as resetNotifier } from "../notifier.js";
-import { _resetTransportForTest as resetTransport } from "../transport.js";
-
-/** Resets define, registry, cleanup, notifier, and transport modules. Call in beforeEach(). */
-export function resetActionFramework(): void {
-  resetDefine();
-  resetRegistry();
-  resetCleanup();
-  resetNotifier();
-  resetTransport();
-}
-
-/** Canonical notifier mock factory for vi.mock("../notifier.js", mockNotifier) */
-export const mockNotifier = () => ({
-  configure: vi.fn(),
-  notifySuccess: vi.fn(),
-  notifyError: vi.fn(),
-  _resetNotifierForTest: vi.fn(),
-});
-
-/** Canonical transport mock factory for vi.mock("../transport.js", mockTransport) */
-export const mockTransport = () => ({
-  configureTransport: vi.fn(),
-  transportAction: vi.fn(),
-  _resetTransportForTest: vi.fn(),
-});

package/src/api-idempotency.test.ts

@@ -1,163 +0,0 @@
-// @vitest-environment happy-dom
-// Tests for apiAction idempotency key and edge-case response handling.
-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 { apiAction } from "./api.js";
-import { IDEMPOTENCY_HEADER, _resetForTest as resetDefine } from "./define.js";
-import { _resetForTest as resetRegistry, recentLog } from "./registry.js";
-import { _resetForTest as resetCleanup } from "./cleanup.js";
-
-const mockFetch = vi.fn();
-
-beforeEach(() => {
-  resetDefine();
-  resetRegistry();
-  resetCleanup();
-  mockFetch.mockReset();
-  vi.stubGlobal("fetch", mockFetch);
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe("apiAction — idempotency key", () => {
-  it("sends Idempotency-Key header when idempotencyKey: true", async () => {
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }));
-    const action = apiAction<{ id: string }>({
-      name: "test.idem",
-      request: ({ id }) => ({ method: "POST", path: `/api/${id}`, body: { x: 1 } }),
-      idempotencyKey: true,
-      error: "Failed",
-    });
-    await action.dispatch({ id: "abc" });
-    const [, opts] = mockFetch.mock.calls[0]!;
-    const hdrKey = IDEMPOTENCY_HEADER.toLowerCase();
-    expect(opts.headers[hdrKey]).toEqual(expect.any(String));
-    expect(opts.headers[hdrKey].length).toBeGreaterThan(5);
-  });
-
-  it("does NOT send Idempotency-Key when not configured", async () => {
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }));
-    const action = apiAction<undefined>({
-      name: "test.no_idem",
-      request: () => ({ method: "POST", path: "/api/x", body: {} }),
-      error: "Failed",
-    });
-    await action.dispatch(undefined);
-    const [, opts] = mockFetch.mock.calls[0]!;
-    expect(opts.headers?.[IDEMPOTENCY_HEADER.toLowerCase()]).toBeUndefined();
-  });
-
-  it("idempotencyKey function receives args", async () => {
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    const action = apiAction<{ id: string }>({
-      name: "test.idem_fn",
-      request: ({ id }) => ({ method: "POST", path: `/api/${id}`, body: {} }),
-      idempotencyKey: (args) => `custom-${args.id}`,
-      error: "Failed",
-    });
-    await action.dispatch({ id: "xyz" });
-    const [, opts] = mockFetch.mock.calls[0]!;
-    expect(opts.headers[IDEMPOTENCY_HEADER.toLowerCase()]).toBe("custom-xyz");
-  });
-});
-
-describe("apiAction — response edge cases", () => {
-  it("handles empty body on DELETE gracefully", async () => {
-    mockFetch.mockResolvedValue(new Response("", { status: 200 }));
-    const action = apiAction<undefined>({
-      name: "test.empty_delete",
-      request: () => ({ method: "DELETE", path: "/api/item/1" }),
-      error: "Failed",
-    });
-    const result = await action.dispatch(undefined);
-    expect(result).toBeUndefined();
-    expect(recentLog()[0]?.status).toBe("success");
-  });
-
-  it("throws ActionError on non-JSON response body", async () => {
-    mockFetch.mockResolvedValue(
-      new Response("<html>error</html>", {
-        status: 200,
-        headers: { "Content-Type": "text/html" },
-      }),
-    );
-    const action = apiAction<undefined>({
-      name: "test.bad_json",
-      request: () => ({ method: "GET", path: "/api/broken" }),
-      error: "Parse failed",
-    });
-    const result = await action.dispatch(undefined);
-    expect(result).toBeNull();
-    expect(recentLog()[0]?.status).toBe("error");
-    expect(recentLog()[0]?.error?.message).toContain("response not JSON");
-  });
-
-  it("falls back to HTTP status string when error body is not JSON", async () => {
-    mockFetch.mockResolvedValue(new Response("plain text error", { status: 502 }));
-    const action = apiAction<undefined>({
-      name: "test.non_json_err",
-      request: () => ({ method: "GET", path: "/api/down" }),
-      error: "Server error",
-    });
-    const result = await action.dispatch(undefined);
-    expect(result).toBeNull();
-    expect(recentLog()[0]?.error?.message).toBe("HTTP 502");
-    expect(recentLog()[0]?.error?.status).toBe(502);
-  });
-
-  it("GET request does not send Content-Type or body", async () => {
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({ v: 1 }), { status: 200 }));
-    const action = apiAction<undefined>({
-      name: "test.get_clean",
-      request: () => ({ method: "GET", path: "/api/data" }),
-      error: "Failed",
-    });
-    await action.dispatch(undefined);
-    const [, opts] = mockFetch.mock.calls[0]!;
-    expect(opts.body).toBeUndefined();
-    expect(opts.headers?.["Content-Type"]).toBeUndefined();
-  });
-});
-
-describe("apiAction — error code propagation", () => {
-  it("propagates code from JSON error body to ActionError", async () => {
-    mockFetch.mockResolvedValue(
-      new Response(JSON.stringify({ error: "rate limited", code: "rate_limit" }), { status: 429 }),
-    );
-    const action = apiAction<undefined>({
-      name: "test.code_prop",
-      request: () => ({ method: "POST", path: "/api/limited", body: {} }),
-      error: false,
-    });
-    await action.dispatch(undefined);
-    const entry = recentLog()[0]!;
-    expect(entry.status).toBe("error");
-    expect(entry.error?.message).toBe("rate limited");
-    expect(entry.error?.status).toBe(429);
-    expect(entry.error?.code).toBe("rate_limit");
-  });
-
-  it("omits code when error body has no code field", async () => {
-    mockFetch.mockResolvedValue(
-      new Response(JSON.stringify({ error: "not found" }), { status: 404 }),
-    );
-    const action = apiAction<undefined>({
-      name: "test.no_code",
-      request: () => ({ method: "GET", path: "/api/missing" }),
-      error: false,
-    });
-    await action.dispatch(undefined);
-    const entry = recentLog()[0]!;
-    expect(entry.error?.message).toBe("not found");
-    expect(entry.error?.code).toBeUndefined();
-  });
-});

package/src/api.test.ts

@@ -1,96 +0,0 @@
-// @vitest-environment happy-dom
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { resetActionFramework } from "./__test-helpers__/action-test-setup.js";
-vi.mock("./notifier.js", () => ({
-  configure: vi.fn(),
-  notifySuccess: vi.fn(),
-  notifyError: vi.fn(),
-  _resetNotifierForTest: vi.fn(),
-}));
-import { apiAction } from "./api.js";
-import { recentLog } from "./registry.js";
-
-const mockFetch = vi.fn();
-
-beforeEach(() => {
-  resetActionFramework();
-  mockFetch.mockReset();
-  vi.stubGlobal("fetch", mockFetch);
-});
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-const testAction = () =>
-  apiAction<{ id: string }, { name: string }>({
-    name: "test.api",
-    request: ({ id }) => ({ method: "GET", path: `/api/items/${id}` }),
-    error: "Test failed",
-  });
-
-describe("apiAction", () => {
-  it("returns parsed JSON on 200", async () => {
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({ name: "foo" }), { status: 200 }));
-    const action = testAction();
-    const result = await action.dispatch({ id: "1" });
-    expect(result).toEqual({ name: "foo" });
-    expect(recentLog()[0]?.status).toBe("success");
-  });
-
-  it("returns undefined on 204 (no JSON parse)", async () => {
-    mockFetch.mockResolvedValue(new Response(null, { status: 204 }));
-    const action = testAction();
-    const result = await action.dispatch({ id: "1" });
-    expect(result).toBeUndefined();
-  });
-
-  it("throws ActionError with code 'timeout' on TimeoutError DOMException", async () => {
-    mockFetch.mockRejectedValue(new DOMException("The operation timed out", "TimeoutError"));
-    const action = testAction();
-    const result = await action.dispatch({ id: "1" });
-    expect(result).toBeNull();
-    expect(recentLog()[0]?.error?.code).toBe("timeout");
-  });
-
-  it("throws ActionError with code 'cancelled' on AbortError when signal.aborted", async () => {
-    mockFetch.mockRejectedValue(new DOMException("The operation was aborted", "AbortError"));
-    const action = testAction();
-    const promise = action.dispatch({ id: "1" });
-    action.cancel();
-    await promise;
-    expect(recentLog()[0]?.status).toBe("cancelled");
-  });
-
-  it("throws ActionError with code 'network' on TypeError (Failed to fetch)", async () => {
-    mockFetch.mockRejectedValue(new TypeError("Failed to fetch"));
-    const action = testAction();
-    await action.dispatch({ id: "1" });
-    expect(recentLog()[0]?.error?.code).toBe("network");
-  });
-
-  it("throws ActionError with status + body.error message on non-OK response", async () => {
-    mockFetch.mockResolvedValue(
-      new Response(JSON.stringify({ error: "Not found" }), { status: 404 }),
-    );
-    const action = testAction();
-    await action.dispatch({ id: "1" });
-    const log = recentLog()[0];
-    expect(log?.error?.status).toBe(404);
-    expect(log?.error?.message).toBe("Not found");
-  });
-
-  it("POST sends JSON body with Content-Type header", async () => {
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }));
-    const action = apiAction<{ name: string }>({
-      name: "test.post",
-      request: ({ name }) => ({ method: "POST", path: "/api/items", body: { name } }),
-      error: "Failed",
-    });
-    await action.dispatch({ name: "foo" });
-    const [url, opts] = mockFetch.mock.calls[0]!;
-    expect(url).toBe("/api/items");
-    expect(opts.method).toBe("POST");
-    expect(opts.headers).toEqual({ "content-type": "application/json" });
-    expect(opts.body).toBe(JSON.stringify({ name: "foo" }));
-  });
-});

package/src/cleanup.test.ts

@@ -1,102 +0,0 @@
-// @vitest-environment happy-dom
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { resetActionFramework } from "./__test-helpers__/action-test-setup.js";
-vi.mock("./notifier.js", () => ({
-  configure: vi.fn(),
-  notifySuccess: vi.fn(),
-  notifyError: vi.fn(),
-  _resetNotifierForTest: vi.fn(),
-}));
-import { defineAction } from "./define.js";
-import { registerCleanup, _cancelAllForTest as cancelAllPending } from "./cleanup.js";
-
-beforeEach(() => {
-  resetActionFramework();
-  vi.clearAllMocks();
-});
-
-describe("cancelAllPending + registered cleanup", () => {
-  it("aborts in-flight action via action.cancel() on global cleanup", async () => {
-    let aborted = false;
-    const action = defineAction({
-      name: "test.cleanup1",
-      run: (_args, signal) =>
-        new Promise<void>((_, reject) => {
-          signal.addEventListener("abort", () => {
-            aborted = true;
-            reject(new Error("aborted"));
-          });
-        }),
-    });
-    const p = action.dispatch({});
-    cancelAllPending();
-    await p;
-    expect(aborted).toBe(true);
-  });
-
-  it("invokes registered cleanup hooks", () => {
-    const fn1 = vi.fn();
-    const fn2 = vi.fn();
-    registerCleanup(fn1);
-    registerCleanup(fn2);
-    cancelAllPending();
-    expect(fn1).toHaveBeenCalledOnce();
-    expect(fn2).toHaveBeenCalledOnce();
-  });
-
-  it("returns an unregister function for cleanup hooks", () => {
-    const fn = vi.fn();
-    const unreg = registerCleanup(fn);
-    unreg();
-    cancelAllPending();
-    expect(fn).not.toHaveBeenCalled();
-  });
-
-  it("a throwing cleanup hook does not stop other hooks", () => {
-    const fn1 = vi.fn(() => {
-      throw new Error("bad");
-    });
-    const fn2 = vi.fn();
-    const consoleErr = vi.spyOn(console, "error").mockImplementation(() => undefined);
-    registerCleanup(fn1);
-    registerCleanup(fn2);
-    cancelAllPending();
-    expect(fn1).toHaveBeenCalledOnce();
-    expect(fn2).toHaveBeenCalledOnce();
-    consoleErr.mockRestore();
-  });
-
-  it("cancels multiple actions and runs hooks in one cancelAllPending call", async () => {
-    let abort1 = false;
-    let abort2 = false;
-    const a1 = defineAction({
-      name: "test.cleanup-multi-1",
-      run: (_args, signal) =>
-        new Promise<void>((_, reject) => {
-          signal.addEventListener("abort", () => {
-            abort1 = true;
-            reject(new Error("aborted"));
-          });
-        }),
-    });
-    const a2 = defineAction({
-      name: "test.cleanup-multi-2",
-      run: (_args, signal) =>
-        new Promise<void>((_, reject) => {
-          signal.addEventListener("abort", () => {
-            abort2 = true;
-            reject(new Error("aborted"));
-          });
-        }),
-    });
-    const hook = vi.fn();
-    registerCleanup(hook);
-    const p1 = a1.dispatch({});
-    const p2 = a2.dispatch({});
-    cancelAllPending();
-    await Promise.all([p1, p2]);
-    expect(abort1).toBe(true);
-    expect(abort2).toBe(true);
-    expect(hook).toHaveBeenCalledOnce();
-  });
-});

package/src/configure-api.test.ts

@@ -1,219 +0,0 @@
-// @vitest-environment happy-dom
-// Tests for the configureApi HTTP-customization seam.
-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 { apiAction, configureApi, _resetApiConfigForTest } from "./api.js";
-import { _resetForTest as resetDefine } from "./define.js";
-import { _resetForTest as resetRegistry } from "./registry.js";
-import { _resetForTest as resetCleanup } from "./cleanup.js";
-
-const mockFetch = vi.fn();
-
-beforeEach(() => {
-  resetDefine();
-  resetRegistry();
-  resetCleanup();
-  _resetApiConfigForTest();
-  mockFetch.mockReset();
-  vi.stubGlobal("fetch", mockFetch);
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe("configureApi — baseUrl", () => {
-  it("prepends baseUrl to request path", async () => {
-    configureApi({ baseUrl: "https://api.example.com/v1" });
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }));
-    const action = apiAction<string>({
-      name: "base.url",
-      request: (id) => ({ method: "GET", path: `/items/${id}` }),
-    });
-    await action.dispatch("42");
-    expect(mockFetch.mock.calls[0]![0]).toBe("https://api.example.com/v1/items/42");
-  });
-
-  it("works without baseUrl (relative path)", async () => {
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }));
-    const action = apiAction<string>({
-      name: "no.base",
-      request: (id) => ({ method: "GET", path: `/items/${id}` }),
-    });
-    await action.dispatch("1");
-    expect(mockFetch.mock.calls[0]![0]).toBe("/items/1");
-  });
-});
-
-describe("configureApi — prepareHeaders", () => {
-  it("injects auth headers on every request", async () => {
-    configureApi({
-      prepareHeaders: (headers) => {
-        headers.set("Authorization", "Bearer test-token");
-      },
-    });
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    const action = apiAction<string>({
-      name: "auth.header",
-      request: () => ({ method: "GET", path: "/me" }),
-    });
-    await action.dispatch("x");
-    const headers = mockFetch.mock.calls[0]![1].headers as Record<string, string>;
-    expect(headers["authorization"]).toBe("Bearer test-token");
-  });
-
-  it("supports async prepareHeaders", async () => {
-    configureApi({
-      prepareHeaders: async (headers) => {
-        await Promise.resolve();
-        headers.set("X-CSRF", "async-token");
-      },
-    });
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    const action = apiAction<string>({
-      name: "async.header",
-      request: () => ({ method: "GET", path: "/x" }),
-    });
-    await action.dispatch("x");
-    const headers = mockFetch.mock.calls[0]![1].headers as Record<string, string>;
-    expect(headers["x-csrf"]).toBe("async-token");
-  });
-
-  it("receives the request spec as context", async () => {
-    const spy = vi.fn();
-    configureApi({
-      prepareHeaders: (headers, ctx) => {
-        spy(ctx.spec);
-      },
-    });
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    const action = apiAction<string>({
-      name: "ctx.spec",
-      request: (id) => ({ method: "POST", path: `/items/${id}`, body: { id } }),
-    });
-    await action.dispatch("5");
-    expect(spy).toHaveBeenCalledWith(expect.objectContaining({ method: "POST", path: "/items/5" }));
-  });
-
-  it("does not override per-request headers set in RequestSpec", async () => {
-    configureApi({
-      prepareHeaders: (headers) => {
-        headers.set("X-Global", "global");
-        headers.set("X-Override", "from-global");
-      },
-    });
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    // Per-request headers are set before prepareHeaders, so prepareHeaders wins
-    // This matches RTK behavior where prepareHeaders runs last
-    const action = apiAction<string>({
-      name: "override.test",
-      request: () => ({ method: "GET", path: "/x", headers: { "X-Override": "from-spec" } }),
-    });
-    await action.dispatch("x");
-    const headers = mockFetch.mock.calls[0]![1].headers as Record<string, string>;
-    expect(headers["x-global"]).toBe("global");
-    // prepareHeaders runs after spec headers, so it overrides
-    expect(headers["x-override"]).toBe("from-global");
-  });
-});
-
-describe("configureApi — credentials", () => {
-  it("sets credentials on every request", async () => {
-    configureApi({ credentials: "include" });
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    const action = apiAction<string>({
-      name: "creds",
-      request: () => ({ method: "GET", path: "/x" }),
-    });
-    await action.dispatch("x");
-    expect(mockFetch.mock.calls[0]![1].credentials).toBe("include");
-  });
-
-  it("omits credentials when not configured", async () => {
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    const action = apiAction<string>({
-      name: "no.creds",
-      request: () => ({ method: "GET", path: "/x" }),
-    });
-    await action.dispatch("x");
-    expect(mockFetch.mock.calls[0]![1].credentials).toBeUndefined();
-  });
-});
-
-describe("configureApi — fetchFn", () => {
-  it("uses custom fetch implementation", async () => {
-    const customFetch = vi
-      .fn()
-      .mockResolvedValue(new Response(JSON.stringify({ custom: true }), { status: 200 }));
-    configureApi({ fetchFn: customFetch });
-    const action = apiAction<string>({
-      name: "custom.fetch",
-      request: () => ({ method: "GET", path: "/x" }),
-    });
-    const result = await action.dispatch("x");
-    expect(customFetch).toHaveBeenCalled();
-    expect(mockFetch).not.toHaveBeenCalled();
-    expect(result).toEqual({ custom: true });
-  });
-});
-
-describe("configureApi — combined", () => {
-  it("baseUrl + prepareHeaders + credentials work together", async () => {
-    configureApi({
-      baseUrl: "https://api.test.io",
-      credentials: "include",
-      prepareHeaders: (headers) => {
-        headers.set("Authorization", "Bearer combo");
-      },
-    });
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }));
-    const action = apiAction<{ name: string }>({
-      name: "combo",
-      request: ({ name }) => ({ method: "POST", path: "/items", body: { name } }),
-    });
-    await action.dispatch({ name: "test" });
-    const [url, opts] = mockFetch.mock.calls[0]!;
-    expect(url).toBe("https://api.test.io/items");
-    expect(opts.credentials).toBe("include");
-    const headers = opts.headers as Record<string, string>;
-    expect(headers["authorization"]).toBe("Bearer combo");
-    expect(headers["content-type"]).toBe("application/json");
-  });
-});
-
-describe("RequestSpec.headers — per-request headers", () => {
-  it("sends per-request headers on GET", async () => {
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    const action = apiAction<string>({
-      name: "per.req.get",
-      request: () => ({ method: "GET", path: "/x", headers: { "X-Custom": "val" } }),
-    });
-    await action.dispatch("x");
-    const headers = mockFetch.mock.calls[0]![1].headers as Record<string, string>;
-    expect(headers["x-custom"]).toBe("val");
-  });
-
-  it("sends per-request headers on POST alongside Content-Type", async () => {
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    const action = apiAction<string>({
-      name: "per.req.post",
-      request: () => ({
-        method: "POST",
-        path: "/x",
-        body: { a: 1 },
-        headers: { "X-Request-Id": "abc" },
-      }),
-    });
-    await action.dispatch("x");
-    const headers = mockFetch.mock.calls[0]![1].headers as Record<string, string>;
-    expect(headers["content-type"]).toBe("application/json");
-    expect(headers["x-request-id"]).toBe("abc");
-  });
-});