src/lib/db/perf.integration.test.ts

Linked repository file from this build.

import { queryReport } from "./report-store";
import { mkdir, writeFile } from "node:fs/promises";
import { expect, test } from "bun:test";
import { demoActor } from "@/lib/auth/roster";
import { queryCatalog } from "./catalog-store";
import { queryInbox } from "./inbox-store";
import { queryReviewVersions, reviewStore } from "./review-store";
import { fixtureReviewKey } from "@/programs/snap-negative/fixture-key";
import { budgets } from "@/lib/perf/budgets";
import { gzipBytes, jsonBytes, medianAsyncMs } from "@/lib/perf/measure";

const integration = process.env.QC_DB_INTEGRATION === "1" ? test : test.skip;

/** Live sizes and query times against the seeded database. Isolated tests do not cover this load. */
integration(
  "database list, inbox, catalog, and one-review load stay within blaze ceilings",
  async () => {
    const examiner = demoActor("examiner");

    const reportMs = await medianAsyncMs(async () => {
      await queryReport(demoActor("statistics"));
    });
    const report = await queryReport(demoActor("statistics"));
    const versions = await queryReviewVersions(demoActor("statistics"));
    const inbox = await queryInbox(examiner, { pageSize: 20 });
    const inboxMs = await medianAsyncMs(async () => {
      await queryInbox(examiner, { pageSize: 20 });
    });
    const catalog = await queryCatalog(examiner, {
      queue: "false",
      category: "",
      sort: "newest",
      page: 0,
      pageSize: 10,
    });
    const catalogMs = await medianAsyncMs(async () => {
      await queryCatalog(examiner, {
        queue: "false",
        category: "",
        sort: "newest",
        page: 0,
        pageSize: 10,
      });
    });
    const loadMs = await medianAsyncMs(async () => {
      await reviewStore.load(fixtureReviewKey("60001"));
    });
    const history = await reviewStore.load(fixtureReviewKey("60001"));
    // The e2e suite intentionally accumulates activity on 60001; gate a stable seed baseline.
    const baseline = await reviewStore.load(fixtureReviewKey("60003"));

    const measurements = {
      timestamp: new Date().toISOString(),
      records: versions.length,
      note: "Live DB, warm median of 3 runs after 1 warmup. gzip is a local estimate, not measured HTTP transfer.",
      payloadBaseline: {
        reviewNumber: "60003",
        jsonBytes: jsonBytes(baseline),
        gzipEstimateBytes: gzipBytes(baseline),
      },
      queries: [
        {
          component: "reports",
          medianMs: reportMs,
          jsonBytes: jsonBytes(report),
          gzipEstimateBytes: gzipBytes(report),
        },
        {
          component: "inbox",
          medianMs: inboxMs,
          jsonBytes: jsonBytes(inbox),
          gzipEstimateBytes: gzipBytes(inbox),
        },
        {
          component: "catalog",
          medianMs: catalogMs,
          jsonBytes: jsonBytes(catalog),
          gzipEstimateBytes: gzipBytes(catalog),
        },
        {
          component: "workspace",
          medianMs: loadMs,
          jsonBytes: jsonBytes(history),
          gzipEstimateBytes: gzipBytes(history),
        },
      ],
    };
    await mkdir("test-results/performance-db", { recursive: true });
    await writeFile(
      "test-results/performance-db/results.json",
      JSON.stringify(measurements, null, 2),
    );
    console.table(measurements.queries);
    console.log(`Live dataset: ${versions.length} reviews`);

    expect(reportMs).toBeLessThan(budgets.dbReportMs);
    expect(inboxMs).toBeLessThan(budgets.dbInboxMs);
    expect(catalogMs).toBeLessThan(budgets.dbCatalogMs);
    expect(loadMs).toBeLessThan(budgets.dbLoadMs);
    expect(
      [...inbox.newReviews, ...inbox.lastTouched, ...inbox.awaitingReview].every(
        (row) => !("report" in row),
      ),
    ).toBe(true);
    expect(jsonBytes(inbox)).toBeLessThan(budgets.inboxApi);
    expect(gzipBytes(inbox)).toBeLessThan(budgets.inboxApi);
    expect(jsonBytes(catalog)).toBeLessThan(budgets.catalogApi);
    expect(history).toBeDefined();
    expect(baseline).toBeDefined();
    expect(jsonBytes(baseline)).toBeLessThan(budgets.oneReviewWithReceivedCopiesApi);
    const { receivedSnapshots, ...currentReview } = baseline!.review;
    // Keep the original ceiling for the current review independently of retained received copies.
    expect(jsonBytes({ ...baseline, review: currentReview })).toBeLessThan(budgets.oneReviewApi);
    expect(Object.keys(receivedSnapshots ?? {}).length).toBeLessThanOrEqual(3);

    expect(versions.length).toBeGreaterThan(0);
  },
);

integration("GET /api/reports stays under the reports payload target", async () => {
  expect(jsonBytes(await queryReport(demoActor("statistics")))).toBeLessThan(budgets.reportsApi);
});