batch-version-cas.test.ts

batch-version-cas.test.tsapps/api/src/modules/blocks/__tests__/batch-version-cas.test.tsraw ← __tests__8,618 B← Back to the app
1/**
2 * TASK-0092 slice 3 — the REST batch's `pages.version` CAS (backend-
3 * architecture §12: "the REST batch endpoint remains… uses a CAS on
4 * `pages.version` to serialize against a concurrent flush (flush wins;
5 * REST sees fresh state on retry — CONFLICT carries the new version)").
6 *
7 * The service is tested directly against a mock Prisma (the same
8 * `updateMany({where: {id, version}})` count-check the internal flush
9 * uses — the two writers now serialize on ONE column):
10 *  - a stale `baseVersion` → 409 CONFLICT carrying the CURRENT version
11 *    (nothing written, no transaction);
12 *  - the authoritative in-transaction CAS failure (a concurrent writer
13 *    advanced the version between the pre-check and the UPDATE) → 409
14 *    with the freshly re-read version (nothing written);
15 *  - success (fresh or legacy no-baseVersion) → the version is advanced
16 *    and carried in the response + the `page.updated` event + the audit
17 *    row.
18 */
19import { describe, expect, it, vi } from "vitest";
20import { BlockService } from "../block.service.js";
21 
22// Isolate the CAS logic under test from `assertCan` (the pre-existing
23// `effectiveLevel` in lib/authorize.ts has a TDZ bug — `teams` is read
24// inside its own `Promise.all` initializer — part of the 134-error
25// baseline, 11 failing `authorize.test.ts` tests, NOT this slice). The
26// permission gate is verified by the integration matrix, not here.
27vi.mock("../../../lib/authorize.js", () => ({
28  assertCan: vi.fn(async () => "EDIT" as const)
29}));
30 
31interface PageState {
32  id: string;
33  workspaceId: string;
34  version: number;
35  deletedAt: null;
36}
37 
38interface TxLog {
39  casBase: number | null;
40  created: number;
41  /** When set, the CAS `updateMany` returns this count (simulate the
42   *  concurrent writer racing the transaction). */
43  casCount: number;
44}
45 
46function makeMockPrisma(page: PageState, tx: TxLog, casCountOverride?: number) {
47  const log: TxLog = { ...tx, casCount: casCountOverride ?? 1 };
48  const prisma = {
49    page: {
50      // requirePageAccess (the pre-check) + the conflict-path re-read.
51      findUnique: vi.fn(async () => ({
52        id: page.id,
53        workspaceId: page.workspaceId,
54        deletedAt: null,
55        version: page.version
56      })),
57      // The CAS: only the transactional client (tx) is used by the batch;
58      // the top-level page has no updateMany (the service must not CAS
59      // outside the transaction).
60      updateMany: vi.fn()
61    },
62    // The authorize seam (MEMBER → EDIT, no teams, no grants).
63    workspaceMember: {
64      findUnique: vi.fn(async () => ({ role: "MEMBER" }))
65    },
66    teamMember: { findMany: vi.fn(async () => []) },
67    permission: { findMany: vi.fn(async () => []) },
68    block: {
69      create: vi.fn(async () => ({ id: "blk_new" }))
70    },
71    $transaction: vi.fn(async (fn: (tx: unknown) => Promise<number>) => {
72      const txClient = {
73        page: {
74          updateMany: vi.fn(async (args: { where: { id: string; version: number } }) => {
75            log.casBase = args.where.version;
76            return { count: log.casCount };
77          })
78        },
79        block: {
80          create: prisma.block.create
81        }
82      };
83      return fn(txClient);
84    })
85  };
86  return { prisma, log };
87}
88 
89// `prisma` is a hand-rolled mock (see makeMockPrisma) — typed as `never`
90// to bypass BlockService's constructor parameter types.
91function makeService(prisma: unknown) {
92  const audit = { audit: vi.fn(async () => undefined) };
93  const events = { publish: vi.fn(async () => undefined) };
94  // 4th arg: the TASK-0135 cache. batch() never reads it (only list() does),
95  // so an empty object suffices for this constructor.
96  const cache = {} as never;
97  const notifications = { notifyWatchersForPageUpdate: vi.fn(async () => 0) };
98  const service = new BlockService(prisma as never, audit as never, events as never, cache, notifications as never);
99  return { service, prisma, audit, events, notifications };
100}
101 
102// `type` is the DB/REST wire enum (UPPERCASE — dto.ts normalizes codec
103// case to DB case); `properties` is required on the upsert block.
104const UP = {
105  op: "upsert" as const,
106  block: { type: "PARAGRAPH" as const, content: { text: "hi" }, properties: {}, position: "a1" }
107};
108 
109describe("REST batch — pages.version CAS (slice 3)", () => {
110  it("stale baseVersion → 409 CONFLICT carrying the CURRENT version, nothing written", async () => {
111    const page: PageState = { id: "pg_1", workspaceId: "ws_1", version: 9, deletedAt: null };
112    const { prisma, log } = makeMockPrisma(page, { casBase: null, created: 0, casCount: 0 });
113    const { service } = makeService(prisma);
114 
115    await expect(
116      service.batch("pg_1", "u_1", { pageId: "pg_1", baseVersion: 5, ops: [UP] }, {} as never)
117    ).rejects.toMatchObject({ code: "CONFLICT", httpStatus: 409 });
118    // The error carries the new version (the "CONFLICT carries the new
119    // version" contract) + the reason.
120    // The catch() result unions the success shape with the cast error
121    // shape; the reject (asserted just above) guarantees the error form.
122    const err = (await service
123      .batch("pg_1", "u_1", { pageId: "pg_1", baseVersion: 5, ops: [UP] }, {} as never)
124      .catch((e: unknown) => e)) as { details?: Array<Record<string, unknown>> };
125    const flat = (err.details ?? []).flatMap((d) => Object.values(d));
126    expect(flat).toContain(9); // currentVersion
127    expect(err.details?.[0]).toMatchObject({ issue: "stale_base_version", received: 5 });
128    // No transaction was even started (the fast path rejected first).
129    expect((prisma.$transaction as unknown as ReturnType<typeof vi.fn>).mock.calls).toHaveLength(0);
130    expect(log.casBase).toBeNull();
131  });
132 
133  it("success: advances pages.version and carries it in response + event + audit", async () => {
134    const page: PageState = { id: "pg_1", workspaceId: "ws_1", version: 5, deletedAt: null };
135    const { prisma, log } = makeMockPrisma(page, { casBase: null, created: 0, casCount: 0 });
136    const { service, audit, events } = makeService(prisma);
137 
138    const res = await service.batch(
139      "pg_1",
140      "u_1",
141      { pageId: "pg_1", baseVersion: 5, ops: [UP] },
142      {} as never
143    );
144    expect(res).toMatchObject({ applied: 1, version: 6 });
145    // The CAS ran on the READ version (5) — the same column the flush's
146    // CAS checks, so the two writers now serialize.
147    expect(log.casBase).toBe(5);
148    expect((prisma.block.create as unknown as ReturnType<typeof vi.fn>).mock.calls).toHaveLength(1);
149    // The event + audit carry the new version (the shared PageUpdatedPayload
150    // shape — the realtime flush also populates it).
151    expect(events.publish).toHaveBeenCalledWith(
152      "page.updated",
153      expect.objectContaining({ pageId: "pg_1", version: 6, blockIds: ["blk_new"] })
154    );
155    expect(audit.audit).toHaveBeenCalledWith(
156      {},
157      undefined,
158      expect.objectContaining({
159        action: "block.batch",
160        metadata: expect.objectContaining({ version: 6 })
161      })
162    );
163  });
164 
165  it("legacy client (no baseVersion) → the write proceeds, the version still advances (a concurrent flush's CAS now fails and rebases)", async () => {
166    const page: PageState = { id: "pg_1", workspaceId: "ws_1", version: 7, deletedAt: null };
167    const { prisma, log } = makeMockPrisma(page, { casBase: null, created: 0, casCount: 0 });
168    const { service } = makeService(prisma);
169 
170    const res = await service.batch("pg_1", "u_1", { pageId: "pg_1", ops: [UP] }, {} as never);
171    expect(res).toMatchObject({ applied: 1, version: 8 });
172    expect(log.casBase).toBe(7); // base = the page's current version
173  });
174 
175  it("in-transaction CAS failure (a concurrent writer raced the tx) → 409 with the freshly re-read version, nothing written", async () => {
176    const page: PageState = { id: "pg_1", workspaceId: "ws_1", version: 5, deletedAt: null };
177    // casCount 0 → the CAS UPDATE matched zero rows (the concurrent
178    // writer advanced the version after our pre-check).
179    const { prisma, log } = makeMockPrisma(page, { casBase: null, created: 0, casCount: 0 }, 0);
180    const { service } = makeService(prisma);
181 
182    await expect(
183      service.batch("pg_1", "u_1", { pageId: "pg_1", baseVersion: 5, ops: [UP] }, {} as never)
184    ).rejects.toMatchObject({ code: "CONFLICT", httpStatus: 409 });
185    // The CAS was attempted at the read version…
186    expect(log.casBase).toBe(5);
187    // …and no block was written (the transaction aborted at the CAS).
188    expect((prisma.block.create as unknown as ReturnType<typeof vi.fn>).mock.calls).toHaveLength(0);
189  });
190});
191