create-ailk 0.4.0 → 0.6.0

package/templates/apps/web/app/[locale]/[slug]/__tests__/page.test.tsx

@@ -0,0 +1,111 @@
+/**
+ * Tests for the generic `[slug]` content route (#5469 D2).
+ *
+ * - Populated: getMdxSource returns a LandingPage source → renderPage
+ *   sections mode composes the page (JSON-LD + SectionRenderer), no
+ *   notFound() call, and the frontmatter `schema` override reaches the
+ *   emitted JSON-LD (the escape hatch, proven with a `HowTo` fixture).
+ * - Unknown slug: getMdxSource returns null → renderPage's own detail-route
+ *   branch (no translationsNamespace passed) calls notFound().
+ * - Resolution: the route asks the adapter for exactly `LandingPage` — the
+ *   one content type it serves.
+ */
+import React from "react";
+import { render } from "@testing-library/react";
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: jest.fn(() => {
+    throw new Error("NEXT_NOT_FOUND");
+  }),
+}));
+
+jest.mock("@working-theory/ui", () => ({
+  Heading: ({
+    children,
+    level,
+  }: {
+    children: React.ReactNode;
+    level: number;
+  }): React.ReactElement =>
+    React.createElement(`h${level}`, null, children),
+  SectionRenderer: ({ sections }: { sections: unknown[] }) =>
+    React.createElement("div", {
+      "data-testid": "section-renderer",
+      "data-section-count": String(sections.length),
+    }),
+}));
+
+import { notFound } from "next/navigation";
+import SlugPage from "../page";
+
+const mockNotFound = notFound as jest.MockedFunction<typeof notFound>;
+
+function makeSource(slug: string, schema?: Record<string, unknown>) {
+  return {
+    frontmatter: {
+      type: "LandingPage" as const,
+      slug,
+      title: `Title for ${slug}`,
+      description: `Description for ${slug}`,
+      ...(schema !== undefined && { schema }),
+      sections: [
+        {
+          id: "hero",
+          type: "hero" as const,
+          data: { headline: `Title for ${slug}` },
+        },
+      ],
+    },
+    body: "",
+  };
+}
+
+describe("[slug] — the generic LandingPage content route", () => {
+  beforeEach(() => {
+    mockNotFound.mockClear();
+  });
+
+  it("resolves the slug against LandingPage and renders through renderPage sections mode", async () => {
+    const getMdxSource = jest.fn().mockResolvedValue(makeSource("how-it-works"));
+
+    const element = await SlugPage({
+      params: Promise.resolve({ locale: "en", slug: "how-it-works" }),
+      getMdxSource,
+    });
+    const { container } = render(element);
+
+    expect(getMdxSource).toHaveBeenCalledWith("LandingPage", "how-it-works", "en");
+    expect(container.querySelector("[data-testid='section-renderer']")).not.toBeNull();
+    expect(container.querySelector("script[type='application/ld+json']")).not.toBeNull();
+    expect(mockNotFound).not.toHaveBeenCalled();
+  });
+
+  it("emits the frontmatter `schema` override in the JSON-LD (the HowTo escape hatch)", async () => {
+    const getMdxSource = jest
+      .fn()
+      .mockResolvedValue(makeSource("how-it-works", { "@type": "HowTo" }));
+
+    const element = await SlugPage({
+      params: Promise.resolve({ locale: "en", slug: "how-it-works" }),
+      getMdxSource,
+    });
+    const { container } = render(element);
+
+    const script = container.querySelector("script[type='application/ld+json']");
+    expect(script).not.toBeNull();
+    expect(script?.textContent ?? "").toContain('"HowTo"');
+  });
+
+  it("calls notFound() for a slug with no LandingPage source", async () => {
+    const getMdxSource = jest.fn().mockResolvedValue(null);
+
+    await expect(
+      SlugPage({
+        params: Promise.resolve({ locale: "en", slug: "not-a-page" }),
+        getMdxSource,
+      }),
+    ).rejects.toThrow("NEXT_NOT_FOUND");
+    expect(mockNotFound).toHaveBeenCalledTimes(1);
+  });
+});

package/templates/apps/web/app/[locale]/[slug]/page.tsx

@@ -0,0 +1,65 @@
+// The one generic content route (#5469 D2). Serves the Free marketing-site
+// template's /how-it-works, /features and /blog teaser — and any other
+// `content/<locale>/LandingPage/<slug>.mdx` a site adds — through exactly the
+// render path the static routes use (`renderPage`, sections mode, JSON-LD
+// from frontmatter — a page's `schema:` override rides the escape hatch,
+// though the structured-data gate only accepts a `WebPage` primary block
+// for a LandingPage, so the Free template's pages set none).
+//
+// Precedence, not gating: Next.js resolves a static segment before a dynamic
+// one, so this route never shadows a scaffolded route directory. That is what
+// lets /blog degrade — keyless there is no `blog/` directory and the teaser
+// renders here; with the docs-blog module its `blog/[[...slug]]` directory
+// wins and the teaser file is inert (#5469 D3).
+//
+// One content type, not two: `WebPage` is a schema.org @type the registry
+// emits, not a `SchemaOrgType` content key the adapter accepts, so the three
+// pages are `LandingPage` files (the coined slug-keyed landing surface whose
+// builder emits a `WebPage` envelope) — the lesson recorded with #5469
+// (site-template content composition) has the proving lines.
+//
+// Unknown slug → `notFound()` (renderPage's own detail-route branch: no
+// `translationsNamespace` is passed, so a null source 404s rather than
+// rendering an empty-state placeholder).
+//
+// Deliberately NO `generateStaticParams`: the locale layout reads cookies()
+// and headers() (theme, session), so every route under it renders on
+// request. A static-params export would make Next try to prerender this
+// segment and fail any slug outside the build-time list with
+// DYNAMIC_SERVER_USAGE (a 500, not the 404 an unknown slug must get).
+import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
+import { renderPage, renderPageMetadata } from "@working-theory/page-renderer";
+import type { Metadata } from "next";
+import type { ReactElement } from "react";
+
+// The content type is written as a literal in both renderPage calls below
+// (not a shared constant): `lib/__tests__/structured-data.test.tsx` and
+// tools/lint-check-content-renders.ts read `renderPage({ type: "…" })` off
+// the source to know which content this route emits JSON-LD for.
+
+interface Props {
+  params: Promise<{ locale: string; slug: string }>;
+  /** Test-only DI override for getMdxSource. Production callers leave undefined. */
+  getMdxSource?: typeof defaultGetMdxSource;
+}
+
+export async function generateMetadata({
+  params,
+}: Pick<Props, "params">): Promise<Metadata> {
+  const { locale, slug } = await params;
+  return renderPageMetadata({ type: "LandingPage", slug, locale });
+}
+
+export default async function Page({
+  params,
+  getMdxSource,
+}: Props): Promise<ReactElement> {
+  const { locale, slug } = await params;
+  return renderPage({
+    type: "LandingPage",
+    slug,
+    locale,
+    populatedDescriptionTestId: `${slug}-description`,
+    ...(getMdxSource !== undefined && { getMdxSource }),
+  });
+}

package/templates/apps/web/app/[locale]/cancellation/page.tsx

@@ -0,0 +1,44 @@
+// CancellationPolicyPage route (#5947). Reads the CancellationPolicyPage MDX frontmatter, renders sections via
+// SectionRenderer, and emits a JSON-LD <script>.
+import type {
+  getMdxSource as defaultGetMdxSource,
+  getPageSections as defaultGetPageSections} from "@working-theory/page-renderer";
+import {
+  renderPage,
+  renderPageMetadata
+} from "@working-theory/page-renderer";
+import type { Metadata } from "next";
+import type { ReactElement } from "react";
+
+interface Props {
+  params: Promise<{ locale: string }>;
+  getMdxSource?: typeof defaultGetMdxSource;
+  getPageSections?: typeof defaultGetPageSections;
+}
+
+export async function generateMetadata({
+  params,
+}: Pick<Props, "params">): Promise<Metadata> {
+  const { locale } = await params;
+  return renderPageMetadata({ type: "CancellationPolicyPage", slug: "cancellation", locale });
+}
+
+export default async function Page({
+  params,
+  getMdxSource,
+  getPageSections,
+}: Props): Promise<ReactElement> {
+  const { locale } = await params;
+  return renderPage({
+    type: "CancellationPolicyPage",
+    slug: "cancellation",
+    locale,
+    // Without a namespace `renderPage` 404s on a missing seed — and a scaffold
+    // IS a missing-seed environment, since `build-templates.mjs` snapshots
+    // `apps/` but deliberately not `content/`. The namespace makes this route
+    // render the #4154 authoring empty state at 200, exactly as /terms does.
+    translationsNamespace: "cancellation",
+    ...(getMdxSource !== undefined && { getMdxSource }),
+    ...(getPageSections !== undefined && { getPageSections }),
+  });
+}

package/templates/apps/web/app/[locale]/flows/[slug]/FlowStepperClient.tsx

@@ -54,7 +54,7 @@ import {
   type FlowStepperMessages,
   type FlowStepSubmitPayload,
   type FlowStepSubmitResult,
-} from "@working-theory/ui/slices/signal-collectors";
+} from "@working-theory/ui-signal-collectors";
 import type { AeoScoreResult, FlowConfig, FlowState } from "@working-theory/validation";
 import {
   deriveFlags,

package/templates/apps/web/app/[locale]/flows/[slug]/__tests__/FlowStepperClient.permalink.test.tsx

@@ -65,7 +65,7 @@ interface MockFlowStepperProps {
 
 let captured: MockFlowStepperProps | undefined;
 
-jest.mock("@working-theory/ui/slices/signal-collectors", () => ({
+jest.mock("@working-theory/ui-signal-collectors", () => ({
   FlowStepper: (props: MockFlowStepperProps) => {
     captured = props;
     return require("react").createElement("div", {

package/templates/apps/web/app/[locale]/flows/[slug]/__tests__/FlowStepperClient.test.tsx

@@ -14,10 +14,11 @@
  *       navigates (no `onCompleted` reaches FlowStepper at all); no
  *       `segment` on a `thankYou`-bearing flow resolves to `default`.
  *
- * `@working-theory/ui`'s FlowStepper is mocked as a minimal stub that calls
- * the real `onSubmitStep`/`onCompleted` props it receives — FlowStepper's
- * OWN submission/onCompleted-firing behavior is already covered by its own
- * package test (packages/ui/src/sections/__tests__/FlowStepper.test.tsx);
+ * `@working-theory/ui-signal-collectors`'s FlowStepper is mocked as a minimal
+ * stub that calls the real `onSubmitStep`/`onCompleted` props it receives —
+ * FlowStepper's OWN submission/onCompleted-firing behavior is already covered
+ * by its own package test
+ * (packages-paid/ui-signal-collectors/src/sections/__tests__/FlowStepper.test.tsx);
  * this file is scoped to FlowStepperClient's own responsibility — the
  * Server Action binding and the onCompleted → router.push wiring.
  */
@@ -69,7 +70,7 @@ const PII_PAYLOAD = {
 
 let capturedOnCompleted: MockFlowStepperProps["onCompleted"];
 
-jest.mock("@working-theory/ui/slices/signal-collectors", () => ({
+jest.mock("@working-theory/ui-signal-collectors", () => ({
   FlowStepper: (props: MockFlowStepperProps) => {
     capturedOnCompleted = props.onCompleted;
     async function handleSubmit(): Promise<void> {

package/templates/apps/web/app/[locale]/flows/[slug]/flow.actions.ts

@@ -30,7 +30,7 @@
  */
 
 import { flows } from "@working-theory/api-client";
-import type { FlowStepSubmitResult } from "@working-theory/ui/slices/signal-collectors";
+import type { FlowStepSubmitResult } from "@working-theory/ui-signal-collectors";
 import {
   flowSlugSchema,
   submitFlowStepInputSchema,