record-open-query-shape.test.ts

record-open-query-shape.test.tsapps/api/src/modules/databases/__tests__/record-open-query-shape.test.tsraw ← __tests__10,305 B← Back to the app
1/**
2 * TASK-0135 (Phase 15, hot path #5 — record open): the Prisma query-shape
3 * test.
4 *
5 * Spec (docs/tasks/phase-15-production.md): "a lint rule + the query-shape
6 * test asserts the record-open path issues ≤ 4 queries for a 50-block
7 * record page, down from the profiled baseline".
8 *
9 * Profiled baseline (pre-fix): the record row was read TWICE (a wide
10 * `findUnique` before the permission check + an `include` fetch after) and
11 * the property list was read live — 7 PG queries per record open (5 with
12 * a permission-cache hit), plus N+1 per relation link.
13 *
14 * After the fix the record-open path (permission decision served from the
15 * 60 s permission cache — the production steady state — and the column
16 * metadata from the shared 60 s metadata cache) issues EXACTLY:
17 *   1. databaseRecord.findUnique   (the row, NARROW select — the page title
18 *                                   + property rows in the same round-trip)
19 *   2. databaseProperty.findMany   (the column metadata, cache-miss loader)
20 *   3. relationLink.findMany       (the record's links)
21 *   4. database.findMany           (target database titles — only when links)
22 *   5. databaseRecord.findMany     (target record titles — only when links)
23 * i.e. 3 for a record with no relation links, ≤ 5 with them — and the row
24 * itself is fetched ONCE (the profiled double-fetch is gone), independent
25 * of the record page's block count (50 blocks → no block queries at all;
26 * the k6 `record-open` scenario's second hop is the cached tree load).
27 *
28 * The count is measured on a counting prisma mock (the shape probe); the
29 * 50-block page is represented by the record's `pageId` (its block count
30 * never enters the record-open query plan — that is the point).
31 */
32import { afterEach, describe, expect, it } from "vitest";
33import { z } from "zod";
34import { ActorContext } from "../../../common/actor-context.js";
35import type { AuthContext } from "../../../common/types.js";
36import { CacheService } from "../../../common/cache.js";
37import { setPermissionCache } from "../../../lib/authorize.js";
38import { PrismaClient } from "@prisma/client";
39import type { PrismaService } from "../../../common/prisma.service.js";
40import { DatabaseQueryService } from "../query.service.js";
41 
42const WORKSPACE_ID = "ws_reco";
43const USER_ID = "user_reco";
44const DB_ID = "db_reco";
45const RECORD_ID = "rec_reco";
46const PAGE_ID = "pg_reco"; // the record's page (a 50-block record page)
47 
48/** A prisma mock that COUNTS every statement and answers the record-open
49 *  read path (membership/teams/grants for the un-cached permission
50 *  control, the property list, the row, the relation links). */
51function countingPrisma(opts: { withLinks: boolean }) {
52  const calls: string[] = [];
53  const targetDb = { id: "db_target", title: "Linked DB" };
54  const targetRecord = { id: "rec_target", page: { title: "Linked Record" } };
55  const prisma = {
56    // `read()` / `write()` — the replica-routing helpers. `PrismaService.read()`
57    // returns a (possibly separate) PrismaClient; in the counting mock both
58    // route to this same object (dev/test has no replica — read() is the
59    // primary). The record-open path resolves its reads via `prisma.read()`.
60    // Typed as `PrismaClient` (not `typeof prisma` / `this`) to avoid a
61    // circular self-reference (TS7022) and the object-literal `this` ban
62    // (TS2526); the mock casts itself — the service only needs the
63    // delegate surface below.
64    read(): PrismaClient {
65      return prisma as unknown as PrismaClient;
66    },
67    write(): PrismaClient {
68      return prisma as unknown as PrismaClient;
69    },
70    // The `relation` delegate — probed by `buildRelationLinkRecords` (which
71    // synthesizes `properties[relPropId].recordIds` from the `RelationLink`
72    // junction, mirroring the production read path). The fixture has no
73    // RELATION property, so the helper short-circuits BEFORE any statement —
74    // zero extra counted queries (the bounds below are unchanged).
75    relation: {
76      async findMany(): Promise<unknown[]> {
77        calls.push("relation.findMany");
78        return [];
79      }
80    },
81    workspaceMember: {
82      async findUnique(): Promise<unknown> {
83        calls.push("workspaceMember.findUnique");
84        return { workspaceId: WORKSPACE_ID, userId: USER_ID, role: "MEMBER" };
85      }
86    },
87    teamMember: {
88      async findMany(): Promise<unknown[]> {
89        calls.push("teamMember.findMany");
90        return [];
91      }
92    },
93    permission: {
94      async findMany(): Promise<unknown[]> {
95        calls.push("permission.findMany");
96        return [];
97      }
98    },
99    databaseProperty: {
100      async findMany(): Promise<unknown[]> {
101        calls.push("databaseProperty.findMany");
102        return [
103          { id: "prop_title", databaseId: DB_ID, name: "Name", type: "TITLE", position: "a0", isTitle: true, isVisible: true, required: false, config: {}, default: null, deletedAt: null, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString() },
104          { id: "prop_text", databaseId: DB_ID, name: "Notes", type: "TEXT", position: "a1", isTitle: false, isVisible: true, required: false, config: {}, default: null, deletedAt: null, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString() }
105        ];
106      }
107    },
108    databaseRecord: {
109      async findUnique(): Promise<unknown> {
110        calls.push("databaseRecord.findUnique");
111        // The narrow row (the 50-block page hangs off `pageId` — never
112        // fetched here; the tree hop is a separate, cached call).
113        return {
114          id: RECORD_ID,
115          workspaceId: WORKSPACE_ID,
116          databaseId: DB_ID,
117          pageId: PAGE_ID,
118          icon: null,
119          coverUrl: null,
120          archivedAt: null,
121          version: 3,
122          position: "a5",
123          createdTime: new Date(),
124          lastEditedTime: new Date(),
125          createdBy: USER_ID,
126          lastEditedBy: USER_ID,
127          createdAt: new Date(),
128          page: { title: "A 50-block record", icon: null },
129          properties: [{ propertyId: "prop_text", value: { text: "body", marks: [] } }]
130        };
131      },
132      async findMany(): Promise<unknown[]> {
133        calls.push("databaseRecord.findMany");
134        return [targetRecord];
135      }
136    },
137    relationLink: {
138      async findMany(): Promise<unknown[]> {
139        calls.push("relationLink.findMany");
140        return opts.withLinks
141          ? [{ recordId: RECORD_ID, targetRecordId: targetRecord.id, targetDatabaseId: targetDb.id }]
142          : [];
143      }
144    },
145    database: {
146      async findMany(): Promise<unknown[]> {
147        calls.push("database.findMany");
148        return [targetDb];
149      }
150    }
151  };
152  return { prisma, calls };
153}
154 
155/** A `CacheService` with no Redis (dev/test default) — the metadata
156 *  loader runs live (PG), which is exactly what the query plan measures. */
157function makeOffCache(): CacheService {
158  return new CacheService(undefined, undefined);
159}
160 
161function makeService(prisma: unknown, cache: CacheService) {
162  return new DatabaseQueryService(
163    prisma as unknown as PrismaService,
164    { write: async (): Promise<void> => {}, audit: async (): Promise<void> => {} } as never,
165    { publish: async (): Promise<void> => {} } as never,
166    cache,
167    {} as never
168  );
169}
170 
171const actor: AuthContext = { kind: "user", userId: USER_ID };
172 
173afterEach(() => {
174  setPermissionCache(null);
175});
176 
177describe("record-open query shape (TASK-0135, hot path #5)", () => {
178  it("issues ≤ 4 PG queries for a 50-block record page (no links, caches live)", async () => {
179    // The production steady state: the permission decision is served from
180    // the 60 s permission cache (a cache hit — zero PG permission queries).
181    setPermissionCache(async () => ({ level: "EDIT", cached: true }));
182    const { prisma, calls } = countingPrisma({ withLinks: false });
183    const service = makeService(prisma, makeOffCache());
184 
185    const dto = await ActorContext.run(actor, () => service.getRecord(RECORD_ID, USER_ID));
186    expect(dto.id).toBe(RECORD_ID);
187    expect(dto.title).toBe("A 50-block record");
188 
189    expect(calls).toEqual([
190      "databaseRecord.findUnique", // the row — NARROW select, ONE fetch
191      "databaseProperty.findMany", // the column metadata (the shared cache miss)
192      "relationLink.findMany" // no links → the target lookups are skipped
193    ]);
194    // The spec bound: ≤ 4 for a 50-block record page.
195    expect(calls.length).toBeLessThanOrEqual(4);
196    // The profiled double-fetch is gone: exactly ONE record-row read.
197    expect(calls.filter((c) => c === "databaseRecord.findUnique").length).toBe(1);
198  });
199 
200  it("stays ≤ 5 with relation links (the target lookups are batched, not per-link)", async () => {
201    setPermissionCache(async () => ({ level: "EDIT", cached: true }));
202    const { prisma, calls } = countingPrisma({ withLinks: true });
203    const service = makeService(prisma, makeOffCache());
204 
205    const dto = await ActorContext.run(actor, () => service.getRecord(RECORD_ID, USER_ID));
206    expect((dto as { relations?: Record<string, string[]> }).relations?.["Linked DB"]).toEqual(["Linked Record"]);
207 
208    expect(calls.length).toBeLessThanOrEqual(5);
209    expect(calls.filter((c) => c === "relationLink.findMany").length).toBe(1);
210    expect(calls.filter((c) => c === "database.findMany").length).toBe(1);
211    expect(calls.filter((c) => c === "databaseRecord.findMany").length).toBe(1);
212  });
213 
214  it("the un-cached permission path is the control (6 queries) — the cache is what bounds it", async () => {
215    // Control: no permission-cache binding → the live resolution (3 PG
216    // queries: membership + teams + grants). The shape fix alone (single
217    // narrow row read) already drops the baseline 7 → 6; the production
218    // bound (≤ 4) additionally assumes the steady-state permission hit
219    // (the TTL/event contract tested in cache-invalidation.integration.test.ts).
220    const { prisma, calls } = countingPrisma({ withLinks: false });
221    const service = makeService(prisma, makeOffCache());
222    await ActorContext.run(actor, () => service.getRecord(RECORD_ID, USER_ID));
223    expect(calls).toHaveLength(6);
224    expect(calls.filter((c) => c === "databaseRecord.findUnique").length).toBe(1);
225  });
226});
227