create-ailk 0.5.0 → 0.6.1

package/templates/apps/api/src/routes/content/__tests__/get-page.test.ts

@@ -9,6 +9,10 @@
 import type { FastifyInstance } from "fastify";
 
 import { setupContentFixture } from "../../../__tests__/factories/content-fixture";
+import {
+  getContentAdapter,
+  type MdxContentAdapter,
+} from "../../../lib/content-adapter.js";
 import { contentRoutes } from "../index";
 
 const fixture = setupContentFixture();
@@ -71,6 +75,30 @@ describe("GET /api/content/:type/:slug", () => {
     expect(res.statusCode).toBe(400);
   });
 
+  // #5927 — the read-path slug tightens from `z.string().min(1)` to
+  // SLUG_PATTERN, the same boundary create/update/delete already enforce on
+  // their own slug params. `paramsSchema.safeParse` runs before any adapter
+  // is resolved, so this 400 is unconditionally before any content query.
+  it("returns 400 on a traversal-shaped slug, before any adapter call", async () => {
+    // The slash is percent-encoded so it stays part of one path segment
+    // (`:slug`) rather than splitting into a second one — a literal `../`
+    // would fail routing entirely, and a bare `..` dot-segment-normalizes
+    // away before find-my-way ever sees it (WHATWG URL §4.7 recognises both
+    // "." and ".." — and their sole percent-encoded variants — as
+    // normalize-away segments, RFC 3986 §5.2's algorithm). This encoded form
+    // survives normalization intact and decodes to "../etc/passwd" only once
+    // find-my-way populates `request.params.slug`, which is what the
+    // paramsSchema regex actually sees.
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/..%2Fetc%2Fpasswd",
+    });
+
+    expect(res.statusCode).toBe(400);
+    const body = JSON.parse(res.body);
+    expect(body.error).toBe("Invalid type or slug");
+  });
+
   it("includes publishedAt in ContentPageInput when page has publishedAt", async () => {
     // Cover the `publishedAt !== undefined` branch.
     await fixture.writeFixturePage(
@@ -138,4 +166,530 @@ describe("GET /api/content/:type/:slug", () => {
     expect(body["@type"]).toBe("WebPage");
     expect(body.mainEntity["@type"]).toBe("SoftwareApplication");
   });
+
+  /**
+   * D3 — API↔MCP parity evidence for #6030's AC-1 ("both ends"). `apps/api`
+   * cannot import `apps/mcp` (the hard import boundary), so the shared seam
+   * is asserted instead: the route must resolve through the SAME
+   * `ContentAdapter.getPageSource(type, slug, locale)` call the MCP tool
+   * builds, for BlogPosting and DocsDetail — the two types this issue
+   * admits. `apps/mcp/__tests__/read_content.test.ts`'s "MDX leg" describe
+   * pins the other half, the same shape `search.test.ts`'s D6 section
+   * established for #5831. `get-page.ts` itself is unedited (N3) — it
+   * already accepted both types via `SCHEMA_ORG_TYPES` before this issue.
+   */
+  describe("parity with the adapter the MCP tool calls (D3)", () => {
+    it.each(["BlogPosting", "DocsDetail"] as const)(
+      "GET /v1/content/%s/:slug?include=body deep-equals adapter.getPageSource",
+      async (type) => {
+        const slug = "launch-post";
+        await fixture.writeFixturePage(
+          type,
+          slug,
+          {
+            type,
+            slug,
+            title: `${type} ${slug} title`,
+            description: `${type} ${slug} description`,
+          },
+          "# Written body\n\nWith a second paragraph.",
+        );
+
+        const res = await app.inject({
+          method: "GET",
+          url: `/v1/content/${type}/${slug}?include=body`,
+        });
+        expect(res.statusCode).toBe(200);
+
+        const adapter = getContentAdapter() as MdxContentAdapter;
+        const expected = await adapter.getPageSource(type, slug, "en");
+        expect(expected).not.toBeNull();
+
+        const body = JSON.parse(res.body);
+        expect(body.page).toMatchObject(expected!.frontmatter);
+        expect(body.body).toBe(expected!.body);
+      },
+    );
+  });
+});
+
+// ─── #5852 — the database path: which workspace a public read serves ────────
+//
+// Appended, so every MDX case above is untouched (AC-4). Database-free: the
+// module-level Prisma singleton is faked via the repo's manual-mock convention,
+// and `jest.mock` is hoisted above the imports by ts-jest regardless of where
+// it is written. The MDX cases never load `lib/prisma.js` — the resolver's
+// import is deferred behind the `CONTENT_ADAPTER=database` branch — so the mock
+// is inert for them.
+
+// eslint-disable-next-line no-restricted-syntax -- lib/prisma.ts wraps the external DB boundary (PrismaClient requires a live connection); __mocks__/prisma.ts is the repo-standard test double for this boundary.
+jest.mock("../../../lib/prisma.js");
+
+import {
+  DEFAULT_ORG_ID,
+  DEFAULT_WORKSPACE_ID,
+} from "@working-theory/database/tenancy";
+
+import { prisma } from "../../../lib/prisma.js";
+
+const PUBLISHED_VERSION_ID = "ver_published";
+
+/** The artifact row a resolved, published `probe` page reads from. */
+const PUBLISHED_ARTIFACT = {
+  id: "art_probe",
+  workspaceId: DEFAULT_WORKSPACE_ID,
+  contentType: "text/page",
+  locale: "en",
+  slug: "probe",
+  title: "Probe",
+  publishedVersionId: PUBLISHED_VERSION_ID,
+};
+
+/** The published version's `text/page` blob. */
+const PUBLISHED_VERSION = {
+  id: PUBLISHED_VERSION_ID,
+  artifactId: PUBLISHED_ARTIFACT.id,
+  workspaceId: DEFAULT_WORKSPACE_ID,
+  isCurrent: false,
+  content: {
+    type: "HomePage",
+    slug: "probe",
+    title: "Probe",
+    description: "The published revision of the probe page.",
+    body: "Published body.",
+  },
+};
+
+/** A one-workspace deployment seeded with the well-known default. */
+function seedOneWorkspaceDeployment(): void {
+  (prisma.workspace.count as jest.Mock).mockResolvedValue(1);
+  (prisma.workspace.findUnique as jest.Mock).mockResolvedValue({
+    id: DEFAULT_WORKSPACE_ID,
+    organizationId: DEFAULT_ORG_ID,
+  });
+}
+
+describe("GET /v1/content/:type/:slug under CONTENT_ADAPTER=database (#5852)", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    process.env.CONTENT_ADAPTER = "database";
+    app = require("fastify")();
+    await app.register(contentRoutes);
+  });
+
+  afterEach(async () => {
+    delete process.env.CONTENT_ADAPTER;
+    await app.close();
+  });
+
+  // AC-1 — the seeded default workspace's PUBLISHED revision, with no workspace
+  // id anywhere in the URL (AC-WCE-06, read half).
+  it("serves the default workspace's published revision, with no workspace id in the URL", async () => {
+    seedOneWorkspaceDeployment();
+    (prisma.artifact.findFirst as jest.Mock).mockResolvedValue(
+      PUBLISHED_ARTIFACT,
+    );
+    (prisma.artifactVersion.findFirst as jest.Mock).mockResolvedValue(
+      PUBLISHED_VERSION,
+    );
+
+    const url = "/v1/content/HomePage/probe";
+    const res = await app.inject({ method: "GET", url });
+
+    expect(res.statusCode).toBe(200);
+    expect(JSON.parse(res.body).page.slug).toBe("probe");
+    // The tenant is resolved server-side; it is never addressable from the wire.
+    expect(url).not.toMatch(/wksp_/);
+    expect(prisma.artifact.findFirst).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ workspaceId: DEFAULT_WORKSPACE_ID }),
+      }),
+    );
+  });
+
+  // AC-2 — a draft with no published pointer is not public (the read-side
+  // invariant of AC-WCE-09). The draft tip is never even fetched.
+  it("404s a page whose artifact has a draft but no publishedVersionId", async () => {
+    seedOneWorkspaceDeployment();
+    (prisma.artifact.findFirst as jest.Mock).mockResolvedValue({
+      ...PUBLISHED_ARTIFACT,
+      publishedVersionId: null,
+    });
+    // The draft tip EXISTS and would parse — the read must still not reach it.
+    (prisma.artifactVersion.findFirst as jest.Mock).mockResolvedValue({
+      ...PUBLISHED_VERSION,
+      id: "ver_draft",
+      isCurrent: true,
+      content: { ...PUBLISHED_VERSION.content, title: "Unpublished draft" },
+    });
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/probe",
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(prisma.artifactVersion.findFirst).not.toHaveBeenCalled();
+  });
+
+  // AC-3 — enumeration: a foreign workspace's slug, a slug published nowhere,
+  // and both ambiguity arms are the SAME 404 bytes for the same request
+  // (AC-WCE-05), and the ambiguity arms emit theirs before any content query.
+  it("answers a foreign slug, a missing slug and both ambiguity arms with identical 404 bodies", async () => {
+    // (a) resolved deployment; `probe` is published only in a FOREIGN
+    // workspace, so the workspace-bound query cannot see it.
+    seedOneWorkspaceDeployment();
+    (prisma.artifact.findFirst as jest.Mock).mockResolvedValue(null);
+    const foreign = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/probe",
+    });
+    expect(foreign.statusCode).toBe(404);
+    // What makes this a FOREIGN-workspace test rather than a mock returning
+    // null on request: the query is bound to the resolved workspace.
+    expect(prisma.artifact.findFirst).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ workspaceId: DEFAULT_WORKSPACE_ID }),
+      }),
+    );
+
+    // (b) resolved deployment; `probe` is published nowhere at all.
+    jest.clearAllMocks();
+    seedOneWorkspaceDeployment();
+    (prisma.artifact.findFirst as jest.Mock).mockResolvedValue(null);
+    const missing = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/probe",
+    });
+    expect(missing.statusCode).toBe(404);
+
+    // (c) two workspaces — ambiguous, so no site resolves.
+    jest.clearAllMocks();
+    (prisma.workspace.count as jest.Mock).mockResolvedValue(2);
+    const ambiguous = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/probe",
+    });
+    expect(ambiguous.statusCode).toBe(404);
+    expect(prisma.artifact.findFirst).not.toHaveBeenCalled();
+
+    // (d) no workspace at all — the same refusal.
+    jest.clearAllMocks();
+    (prisma.workspace.count as jest.Mock).mockResolvedValue(0);
+    const empty = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/probe",
+    });
+    expect(empty.statusCode).toBe(404);
+    expect(prisma.artifact.findFirst).not.toHaveBeenCalled();
+
+    // The four bodies are byte-identical: a resolution failure and a missing
+    // page are indistinguishable to an unauthenticated caller.
+    expect(missing.body).toBe(foreign.body);
+    expect(ambiguous.body).toBe(foreign.body);
+    expect(empty.body).toBe(foreign.body);
+  });
+});
+
+// ─── #5890 — the published body over HTTP: an opt-in `?include=body` ────────
+//
+// Appended again, so every case above — the MDX cases (#507) and the database
+// cases (#5852) — stays byte-identical. The inline snapshot below was recorded
+// against the PRE-change handler and must survive the change unmodified; that,
+// not a hand-copied literal, is the byte-identity evidence AC-1 asks for.
+//
+// The body-less-adapter cases use the real PROJECTION adapter rather than a
+// module spy: it satisfies `ContentAdapter` and has no `getPageSource`, so the
+// route's capability branch is exercised through the real resolver — the file
+// header's "no internal module mocks" (#507) holds for these cases too.
+
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import * as contentAdapterModule from "../../../lib/content-adapter.js";
+import { resetContentAdapter } from "../../../lib/content-adapter.js";
+
+/** A projection manifest carrying the one page these cases read. */
+function withProjectionAdapter(): void {
+  const manifestPath = join(
+    mkdtempSync(join(tmpdir(), "ailk-api-5890-")),
+    "manifest.json",
+  );
+  writeFileSync(
+    manifestPath,
+    JSON.stringify({
+      HomePage: [
+        {
+          type: "HomePage",
+          slug: "home",
+          title: "Projection home",
+          description: "Served by an adapter with no getPageSource.",
+        },
+      ],
+    }),
+  );
+  process.env.CONTENT_ADAPTER = "projection";
+  process.env.MANIFEST_PATH = manifestPath;
+  resetContentAdapter();
+}
+
+describe("GET /v1/content/:type/:slug?include=body (#5890)", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    app = require("fastify")();
+    await app.register(contentRoutes);
+  });
+
+  afterEach(async () => {
+    jest.restoreAllMocks();
+    delete process.env.CONTENT_ADAPTER;
+    delete process.env.MANIFEST_PATH;
+    resetContentAdapter();
+    await app.close();
+  });
+
+  // AC-1, the floor half — the unparameterised read is unchanged to the byte.
+  it("serves a response byte-identical to the pre-change handler when the parameter is absent", async () => {
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/home",
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchInlineSnapshot(
+      `"{"@context":"https://schema.org","@graph":[{"@context":"https://schema.org","@type":"WebPage","inLanguage":"en","name":"HomePage home title","description":"HomePage home description"},{"@context":"https://schema.org","@type":"Organization","name":"HomePage home title"},{"@context":"https://schema.org","@type":"WebSite","name":"HomePage home title","inLanguage":"en"}],"page":{"type":"HomePage","slug":"home","title":"HomePage home title","description":"HomePage home description"}}"`,
+    );
+    expect(JSON.parse(res.body)).not.toHaveProperty("body");
+  });
+
+  // AC-1, the additive half — the raw MDX body, beside `page`, on request.
+  it("adds the raw published MDX body beside `page` when asked", async () => {
+    await fixture.writeFixturePage(
+      "HomePage",
+      "home",
+      {
+        type: "HomePage",
+        slug: "home",
+        title: "HomePage home title",
+        description: "HomePage home description",
+      },
+      "# Written body\n\nWith a second paragraph.",
+    );
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/home?include=body",
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    // RAW, not trimmed: the body is handed to `next-mdx-remote` verbatim, so
+    // the route must not normalise whitespace the author wrote.
+    expect(body.body).toBe("\n# Written body\n\nWith a second paragraph.\n");
+    // Additive: everything the unparameterised read serves is still served.
+    expect(body.page).toMatchObject({ type: "HomePage", slug: "home" });
+    expect(body["@context"]).toBe("https://schema.org");
+  });
+
+  // The query idiom `list-pages.ts` uses: an unrecognised value is a 400 with
+  // the zod issues under `details`, never a silently-ignored parameter.
+  it("400s an unrecognised include value", async () => {
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/home?include=other",
+    });
+
+    expect(res.statusCode).toBe(400);
+    const body = JSON.parse(res.body);
+    expect(body.error).toBe("Invalid query parameters");
+    expect(JSON.stringify(body.details)).toContain("include");
+  });
+
+  // AC-2's refusal arm — a body-less adapter answers 400 naming the parameter,
+  // never a 500 from `getPageSource is not a function`, and never after having
+  // read content it then throws away.
+  it("400s naming `include` when the resolved adapter has no getPageSource, before any content read", async () => {
+    withProjectionAdapter();
+    // The adapter is REAL — a projection adapter genuinely has no
+    // `getPageSource`. The module spy only PINS the instance (the resolver
+    // hands out a fresh object per call), so the read spy below observes the
+    // object the route actually uses instead of a discarded twin. Nothing
+    // about the adapter's behaviour is faked.
+    const real = contentAdapterModule.getContentAdapter();
+    const read = jest.spyOn(real, "getPageBySlug");
+    jest
+      .spyOn(contentAdapterModule, "getContentAdapter")
+      .mockReturnValue(real);
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/home?include=body",
+    });
+
+    expect(res.statusCode).toBe(400);
+    const body = JSON.parse(res.body);
+    expect(body.error).toBe("Invalid query parameters");
+    expect(body.details).toEqual([
+      {
+        path: ["include"],
+        message: "body is not available from this content adapter",
+      },
+    ]);
+    // The refusal precedes the lookup: nothing was read to be discarded.
+    expect(read).not.toHaveBeenCalled();
+  });
+
+  // The same adapter still serves the unparameterised read unchanged — the
+  // capability gate is scoped to the parameter, not to the route.
+  it("leaves the unparameterised read working on a body-less adapter", async () => {
+    withProjectionAdapter();
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/home",
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(JSON.parse(res.body).page.title).toBe("Projection home");
+  });
+
+  // #5927 — the fix's whole point: `include=body` performs exactly ONE
+  // adapter read, so `page` and `body` can never straddle two revisions. A
+  // mocked adapter whose two methods disagree proves it: if the route still
+  // called `getPageBySlug` as well as `getPageSource`, `page` would read the
+  // revision `getPageBySlug` returns while `body` read the (different)
+  // revision `getPageSource` returns — the mixed response this test forbids.
+  it("performs a single adapter read for include=body, so page and body can never straddle two revisions", async () => {
+    const staleFrontmatter = {
+      type: "HomePage" as const,
+      slug: "probe",
+      title: "Stale — the revision a second, independent read would see",
+      description: "Would only be returned by a getPageBySlug call.",
+    };
+    const published = {
+      frontmatter: {
+        type: "HomePage" as const,
+        slug: "probe",
+        title: "Published — the revision the single read actually returns",
+        description: "Returned by the one getPageSource call.",
+      },
+      body: "Published body.",
+    };
+    const getPageBySlug = jest.fn().mockResolvedValue(staleFrontmatter);
+    const getPageSource = jest.fn().mockResolvedValue(published);
+    // Typed directly at the boundary (no `as unknown as` cast) — every
+    // `MdxContentAdapter` member is stubbed, so the object literal satisfies
+    // the interface on its own.
+    const fakeAdapter: MdxContentAdapter = {
+      getPageBySlug,
+      getPageSource,
+      listPages: jest.fn(),
+      getDetailBySlug: jest.fn(),
+      listDetail: jest.fn(),
+      searchPages: jest.fn(),
+      extractStructuredData: jest.fn(),
+      createPage: jest.fn(),
+      updatePage: jest.fn(),
+      deletePage: jest.fn(),
+      getPageVersion: jest.fn(),
+    };
+    jest
+      .spyOn(contentAdapterModule, "getContentAdapter")
+      .mockReturnValue(fakeAdapter);
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/probe?include=body",
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    // getPageBySlug is never called on this path — getPageSource alone
+    // supplies both halves, from the SAME read.
+    expect(getPageBySlug).not.toHaveBeenCalled();
+    expect(getPageSource).toHaveBeenCalledTimes(1);
+    expect(body.page.title).toBe(
+      "Published — the revision the single read actually returns",
+    );
+    expect(body.body).toBe("Published body.");
+  });
+});
+
+describe("GET /v1/content/:type/:slug?include=body under CONTENT_ADAPTER=database (#5890)", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    process.env.CONTENT_ADAPTER = "database";
+    app = require("fastify")();
+    await app.register(contentRoutes);
+  });
+
+  afterEach(async () => {
+    delete process.env.CONTENT_ADAPTER;
+    await app.close();
+  });
+
+  // AC-2 — #5874's `getPageSource` on the database adapter, reached over HTTP.
+  it("serves the published version's body", async () => {
+    seedOneWorkspaceDeployment();
+    (prisma.artifact.findFirst as jest.Mock).mockResolvedValue(
+      PUBLISHED_ARTIFACT,
+    );
+    (prisma.artifactVersion.findFirst as jest.Mock).mockResolvedValue(
+      PUBLISHED_VERSION,
+    );
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/probe?include=body",
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.body).toBe("Published body.");
+    expect(body.page.slug).toBe("probe");
+    // The body comes from the PUBLISHED pointer, not the draft tip.
+    expect(prisma.artifactVersion.findFirst).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ id: PUBLISHED_VERSION_ID }),
+      }),
+    );
+    // #5927 — ONE read of each table, not two: `page` and `body` come from
+    // the SAME `getPageSource` call, never a `getPageBySlug` call plus a
+    // second, independent `getPageSource` call.
+    expect(prisma.artifact.findFirst).toHaveBeenCalledTimes(1);
+    expect(prisma.artifactVersion.findFirst).toHaveBeenCalledTimes(1);
+  });
+
+  // AC-2 — the parameter buys no access a plain read does not have.
+  it("404s a draft-only page with the parameter, exactly as without it", async () => {
+    seedOneWorkspaceDeployment();
+    (prisma.artifact.findFirst as jest.Mock).mockResolvedValue({
+      ...PUBLISHED_ARTIFACT,
+      publishedVersionId: null,
+    });
+    (prisma.artifactVersion.findFirst as jest.Mock).mockResolvedValue({
+      ...PUBLISHED_VERSION,
+      id: "ver_draft",
+      isCurrent: true,
+    });
+
+    const withParam = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/probe?include=body",
+    });
+    const without = await app.inject({
+      method: "GET",
+      url: "/v1/content/HomePage/probe",
+    });
+
+    expect(withParam.statusCode).toBe(404);
+    expect(withParam.body).toBe(without.body);
+    expect(prisma.artifactVersion.findFirst).not.toHaveBeenCalled();
+  });
 });

package/templates/apps/api/src/routes/content/__tests__/list-pages.test.ts

@@ -120,3 +120,111 @@ describe("GET /api/content/:type", () => {
     expect(res.statusCode).toBe(400);
   });
 });
+
+// ─── #5852 — the database path: which workspace a public list serves ────────
+//
+// Appended, so every MDX case above is untouched (AC-4). Same database-free
+// convention as the sibling `get-page.test.ts` block.
+
+// eslint-disable-next-line no-restricted-syntax -- lib/prisma.ts wraps the external DB boundary (PrismaClient requires a live connection); __mocks__/prisma.ts is the repo-standard test double for this boundary.
+jest.mock("../../../lib/prisma.js");
+
+import {
+  DEFAULT_ORG_ID,
+  DEFAULT_WORKSPACE_ID,
+} from "@working-theory/database/tenancy";
+
+import { prisma } from "../../../lib/prisma.js";
+
+const LISTED_VERSION_ID = "ver_listed";
+
+/** A one-workspace deployment seeded with the well-known default. */
+function seedOneWorkspaceDeployment(): void {
+  (prisma.workspace.count as jest.Mock).mockResolvedValue(1);
+  (prisma.workspace.findUnique as jest.Mock).mockResolvedValue({
+    id: DEFAULT_WORKSPACE_ID,
+    organizationId: DEFAULT_ORG_ID,
+  });
+}
+
+describe("GET /v1/content/:type under CONTENT_ADAPTER=database (#5852)", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    process.env.CONTENT_ADAPTER = "database";
+    app = require("fastify")();
+    await app.register(contentRoutes);
+  });
+
+  afterEach(async () => {
+    delete process.env.CONTENT_ADAPTER;
+    await app.close();
+  });
+
+  // The resolved arm — the seeded workspace's PUBLISHED pages, and nothing else.
+  it("lists the default workspace's published pages", async () => {
+    seedOneWorkspaceDeployment();
+    (prisma.artifact.findMany as jest.Mock).mockResolvedValue([
+      {
+        id: "art_listed",
+        workspaceId: DEFAULT_WORKSPACE_ID,
+        contentType: "text/page",
+        locale: "en",
+        slug: "listed",
+        title: "Listed",
+        publishedVersionId: LISTED_VERSION_ID,
+      },
+      // A draft-only artifact: it has no published pointer, so it never reaches
+      // the version fetch and never reaches the list.
+      {
+        id: "art_draft_only",
+        workspaceId: DEFAULT_WORKSPACE_ID,
+        contentType: "text/page",
+        locale: "en",
+        slug: "draft-only",
+        title: "Draft only",
+        publishedVersionId: null,
+      },
+    ]);
+    (prisma.artifactVersion.findMany as jest.Mock).mockResolvedValue([
+      {
+        id: LISTED_VERSION_ID,
+        artifactId: "art_listed",
+        workspaceId: DEFAULT_WORKSPACE_ID,
+        isCurrent: false,
+        content: {
+          type: "HomePage",
+          slug: "listed",
+          title: "Listed",
+          description: "The published revision of the listed page.",
+          body: "Published body.",
+        },
+      },
+    ]);
+
+    const res = await app.inject({ method: "GET", url: "/v1/content/HomePage" });
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.items.map((item: { slug: string }) => item.slug)).toEqual([
+      "listed",
+    ]);
+    expect(prisma.artifact.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ workspaceId: DEFAULT_WORKSPACE_ID }),
+      }),
+    );
+  });
+
+  // The unresolved arm — 404 before any content query, never an empty 200
+  // `ItemList`, which would assert a site that did not resolve.
+  it("404s an ambiguous deployment before any content query", async () => {
+    (prisma.workspace.count as jest.Mock).mockResolvedValue(2);
+
+    const res = await app.inject({ method: "GET", url: "/v1/content/HomePage" });
+
+    expect(res.statusCode).toBe(404);
+    expect(prisma.artifact.findMany).not.toHaveBeenCalled();
+  });
+});