create-ailk 0.18.0 → 0.19.1

package/templates/apps/api/src/services/__tests__/request-confirm.test.ts

@@ -23,6 +23,7 @@ jest.mock("../../lib/prisma.js");
 
 import { prisma } from "../../lib/prisma.js";
 import { routeLead } from "../lead-routing.js";
+import * as personService from "../person.js";
 import {
   CONFIRM_TOKEN_TTL_MS,
   claimConfirmation,
@@ -218,6 +219,92 @@ describe("recordPaymentLink()", () => {
       data: { stripePaymentLinkId: "plink_abc" },
     });
   });
+
+  // ── #8435 D5 (AC-3) — the Person step, after the Payment Link exists ────
+  describe("links the confirmed callback to its Person", () => {
+    const WORKSPACE = "wksp_00000000-0000-7000-8000-0000000084e5";
+    const PERSON = "person_00000000-0000-7000-8000-0000000084e5";
+    const LINKED = {
+      ok: true as const,
+      value: { personId: PERSON as never, created: true, billing: "unchanged" as const },
+    };
+    const row = (overrides: Record<string, unknown> = {}) => ({
+      workspaceId: WORKSPACE,
+      buyerEmail: "Buyer@Example.com",
+      name: "Bea",
+      phone: "+1 415 555 0123",
+      personId: null,
+      ...overrides,
+    });
+    let find: jest.SpyInstance;
+
+    beforeEach(() => {
+      find = jest.spyOn(personService, "findOrCreatePerson").mockResolvedValue(LINKED);
+    });
+    afterEach(() => find.mockRestore());
+
+    it("writes the link id first, then finds the buyer email's Person in the row's own workspace and stamps it once, guarded on personId: null", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockResolvedValue(row());
+      await recordPaymentLink(CALLBACK_ID, "plink_abc");
+
+      expect(find).toHaveBeenCalledTimes(1);
+      expect(find).toHaveBeenCalledWith(WORKSPACE, {
+        email: "Buyer@Example.com",
+        name: "Bea",
+        contact: { telephone: "+14155550123" },
+      });
+      expect(prisma.callback.updateMany).toHaveBeenCalledTimes(1);
+      expect(prisma.callback.updateMany).toHaveBeenCalledWith({
+        where: { id: CALLBACK_ID, workspaceId: WORKSPACE, personId: null },
+        data: { personId: PERSON },
+      });
+      const order = (fn: jest.Mock) => fn.mock.invocationCallOrder[0]!;
+      expect(order(prisma.callback.update as jest.Mock)).toBeLessThan(order(prisma.callback.findFirst as jest.Mock));
+    });
+
+    it("makes no Person call for a callback a capture already linked", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockResolvedValue(row({ personId: PERSON }));
+      await recordPaymentLink(CALLBACK_ID, "plink_abc");
+      expect(find).not.toHaveBeenCalled();
+      expect(prisma.callback.updateMany).not.toHaveBeenCalled();
+    });
+
+    it("makes no Person call for a row with no buyer email", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockResolvedValue(row({ buyerEmail: null }));
+      await recordPaymentLink(CALLBACK_ID, "plink_abc");
+      expect(find).not.toHaveBeenCalled();
+    });
+
+    it("a Person step that throws still leaves the link id written and recordPaymentLink resolving", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockResolvedValue(row());
+      find.mockRejectedValue(new Error("down"));
+      await expect(recordPaymentLink(CALLBACK_ID, "plink_abc")).resolves.toBeUndefined();
+      expect(prisma.callback.update).toHaveBeenCalledWith({
+        where: { id: CALLBACK_ID },
+        data: { stripePaymentLinkId: "plink_abc" },
+      });
+      expect(prisma.callback.updateMany).not.toHaveBeenCalled();
+    });
+
+    it("a read that throws is swallowed the same way", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockRejectedValue(new Error("down"));
+      await expect(recordPaymentLink(CALLBACK_ID, "plink_abc")).resolves.toBeUndefined();
+    });
+
+    it("claimConfirmation makes no person delegate call at all — the token is spent before any Person work", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockResolvedValue(row());
+      await claimConfirmation({
+        id: CALLBACK_ID,
+        token: "a-token",
+        confirmedTime: "Friday 3pm",
+        buyerEmail: "buyer@example.com",
+      });
+      expect(find).not.toHaveBeenCalled();
+      expect(jest.mocked(prisma.person.findFirst)).not.toHaveBeenCalled();
+      expect(jest.mocked(prisma.person.createMany)).not.toHaveBeenCalled();
+      expect(jest.mocked(prisma.person.updateMany)).not.toHaveBeenCalled();
+    });
+  });
 });
 
 // ── Configuration ──────────────────────────────────────────────────────────

package/templates/apps/api/src/services/__tests__/revalidation.test.ts

@@ -12,6 +12,12 @@
  * The server binds 127.0.0.1, which `ssrfBlocked` rejects; D7's
  * `allowPrivate: true` is what makes this substrate runnable at all.
  *
+ * The backoff schedule is asserted through the injected `sleep` seam, never
+ * against wall-clock: the delays a case observes are the ones the service asked
+ * for, so a loaded runner cannot stretch or shrink them (#7904, #8418). And the
+ * server answers every request `connection: close`, so no attempt can land on
+ * a pooled socket the server has already dropped (#8418).
+ *
  * `CONTENT_REVALIDATE_*` are read through `config`, which snapshots
  * `process.env` at import time — so every case sets env first and then
  * `require`s the service through `jest.resetModules()`.
@@ -73,7 +79,6 @@ interface Recorded {
   eventHeader: string;
   timestampHeader: string;
   contentType: string;
-  receivedAt: number;
 }
 
 let server: Server;
@@ -81,6 +86,10 @@ let serverUrl: string;
 let recorded: Recorded[] = [];
 /** Status codes the server replies with, one per request, in order. */
 let responseStatuses: number[] = [];
+/** Every backoff the service asked to sleep for, in order. */
+let sleeps: number[] = [];
+/** The injected sleep seam: records the backoff and resolves at once. */
+const sleep = async (ms: number): Promise<void> => void sleeps.push(ms);
 
 beforeAll(async () => {
   server = createServer((req, res) => {
@@ -123,10 +132,16 @@ beforeAll(async () => {
         eventHeader,
         timestampHeader,
         contentType: String(req.headers["content-type"] ?? ""),
-        receivedAt: Date.now(),
       });
 
-      res.writeHead(responseStatuses[recorded.length - 1] ?? 200);
+      // `connection: close` — one TCP connection per request. With keep-alive,
+      // fetch reuses a pooled socket, and when the server's idle timeout drops
+      // that socket as the next request goes out, the attempt fails on the
+      // client (UND_ERR_SOCKET) and never reaches this handler: the lost
+      // attempt behind #8418's flake on the #8417 release PR.
+      res.writeHead(responseStatuses[recorded.length - 1] ?? 200, {
+        connection: "close",
+      });
       res.end();
     });
   });
@@ -151,7 +166,14 @@ beforeEach(() => {
   process.env.CONTENT_REVALIDATE_SECRET = TEST_SECRET;
   recorded = [];
   responseStatuses = [];
+  sleeps = [];
   mockLogLines.length = 0;
+  // Drop any connection a previous case left idle — the server-side
+  // keep-alive close that ate attempt 1 on the CI shard, made to happen at the
+  // start of every case. Under `connection: close` there is never one to drop;
+  // without the header, the next case's first attempt lands on the dropped
+  // socket and a counting case below fails on every run, not 1-in-N on CI.
+  server.closeIdleConnections();
 });
 
 afterEach(() => {
@@ -193,35 +215,35 @@ describe("notifyRevalidate", () => {
   it("retries a 5xx with D3 backoff and succeeds on the third attempt", async () => {
     responseStatuses = [500, 500, 200];
 
-    await loadService().notifyRevalidate(TARGET, { event: "unpublish" });
+    await loadService().notifyRevalidate(TARGET, {
+      event: "unpublish",
+      sleep,
+    });
 
     expect(recorded).toHaveLength(3);
-    // D3 — 500 ms before attempt 2, 2000 ms before attempt 3. Bounded on BOTH
-    // sides: a lower bound alone would pass an arbitrarily long backoff, and
-    // the whole point of D3's schedule is that it fits the 60 s publish budget.
-    // The upper slack absorbs loopback scheduling jitter, nothing more.
-    const gapA = recorded[1].receivedAt - recorded[0].receivedAt;
-    const gapB = recorded[2].receivedAt - recorded[1].receivedAt;
-    expect(gapA).toBeGreaterThanOrEqual(500);
-    expect(gapA).toBeLessThan(2000);
-    expect(gapB).toBeGreaterThanOrEqual(2000);
-    expect(gapB).toBeLessThan(4000);
+    // D3 — exactly 500 ms before attempt 2 and 2000 ms before attempt 3, the
+    // schedule that fits the 60 s publish budget. Asserted as the delays the
+    // service scheduled, not as measured gaps a loaded runner can stretch
+    // (#7904: a 2122 ms gapA failed the old `< 2000` bound).
+    expect(sleeps).toEqual([500, 2000]);
     expect(recorded.every((r) => r.signatureValid)).toBe(true);
 
     expect(
       mockLogLines.filter((l) => l.msg === "revalidate.sent"),
     ).toHaveLength(1);
     expect(mockLogLines.some((l) => l.level === "error")).toBe(false);
-  }, 20_000);
+  });
 
   it("stops at three attempts, logs the failure at error, and still resolves", async () => {
     responseStatuses = [500, 500, 500];
 
     await expect(
-      loadService().notifyRevalidate(TARGET, { event: "publish" }),
+      loadService().notifyRevalidate(TARGET, { event: "publish", sleep }),
     ).resolves.toBeUndefined();
 
     expect(recorded).toHaveLength(3);
+    // Two backoffs and no third: running out of the schedule IS the bound.
+    expect(sleeps).toEqual([500, 2000]);
 
     const perAttempt = mockLogLines.filter(
       (l) => l.level === "warn" && l.msg === "revalidate.failed",
@@ -238,7 +260,25 @@ describe("notifyRevalidate", () => {
       attempts: 3,
       lastStatus: 500,
     });
-  }, 20_000);
+  });
+
+  it("waits out the backoff on the real timer when no sleep is injected", async () => {
+    responseStatuses = [500, 200];
+    const setTimeoutSpy = jest.spyOn(global, "setTimeout");
+    let delays: unknown[];
+
+    try {
+      await loadService().notifyRevalidate(TARGET, { event: "publish" });
+      delays = setTimeoutSpy.mock.calls.map(([, ms]) => ms);
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    // The production default: the one backoff is a real 500 ms timer. Asserted
+    // as the delay scheduled, never as a measured gap.
+    expect(recorded).toHaveLength(2);
+    expect(delays).toContain(500);
+  });
 
   it("signs v0:{timestamp}:{event}:{body} and sends the timestamp header (#5902)", async () => {
     responseStatuses = [200];