create-ailk 0.21.0 → 0.23.0

package/templates/apps/web/app/[locale]/careers/__tests__/apply.actions.test.ts

@@ -0,0 +1,319 @@
+/**
+ * The job page's apply action (#8746 D4, D5; AC-5): a submission writes one
+ * lead through the site's lead writer with source `flow:job-application`,
+ * `name` = first + last, and the posting's slug as the hidden `job` value.
+ */
+
+import {
+  __resetRateLimit,
+  checkRateLimit,
+} from "../../../../src/lib/rate-limit";
+import { captureLeadAction } from "../[slug]/apply.actions";
+
+jest.mock("@working-theory/api-client", () => ({
+  leads: { submit: jest.fn() },
+  visitorForwardHeaders: jest.requireActual("@working-theory/api-client")
+    .visitorForwardHeaders,
+}));
+
+jest.mock("next/headers", () => ({
+  __esModule: true,
+  headers: jest.fn().mockResolvedValue({ get: () => null }),
+  cookies: jest.fn().mockResolvedValue({ get: () => undefined }),
+}));
+
+const mockGetLocale = jest.fn();
+const mockGetTranslations = jest.fn();
+jest.mock("next-intl/server", () => ({
+  getLocale: (...args: unknown[]) => mockGetLocale(...args),
+  getTranslations: (...args: unknown[]) => mockGetTranslations(...args),
+}));
+
+const mockInviteHref = jest.fn();
+// eslint-disable-next-line no-restricted-syntax -- accountInviteHref reads the generated topology (build output); this file asserts the action's own decision
+jest.mock("../../../../lib/account-invite", () => ({
+  accountInviteHref: (...args: unknown[]) => mockInviteHref(...args),
+}));
+
+import { leads } from "@working-theory/api-client";
+import { headers } from "next/headers";
+const mockSubmit = leads.submit as jest.Mock;
+const mockHeaders = headers as jest.Mock;
+
+const JOB = "content-strategist";
+
+function form(fields: Record<string, string>): FormData {
+  const fd = new FormData();
+  for (const [key, value] of Object.entries(fields)) fd.append(key, value);
+  return fd;
+}
+
+const VALID = {
+  first_name: "Ada",
+  last_name: "Lovelace",
+  email: "ada@example.com",
+  consent: "true",
+};
+
+type SubmitBody = {
+  source: string;
+  email: string;
+  consent?: boolean;
+  payload: Record<string, unknown>;
+};
+const submitted = (): SubmitBody => mockSubmit.mock.calls[0][0] as SubmitBody;
+
+beforeEach(() => {
+  mockSubmit.mockResolvedValue({ ok: true, status: 201, body: { ok: true } });
+  mockGetLocale.mockResolvedValue("en");
+  mockGetTranslations.mockResolvedValue((key: string) =>
+    key === "trackInAccount" ? "Track this in your account" : key,
+  );
+  mockInviteHref.mockReturnValue("/sign-in?next=%2Faccount&email=ada%40example.com");
+});
+
+afterEach(() => {
+  jest.clearAllMocks();
+  mockHeaders.mockResolvedValue({ get: () => null });
+  __resetRateLimit();
+  delete process.env.AILK_LEAD_SITE;
+});
+
+describe("captureLeadAction on a job page (#8746 AC-5)", () => {
+  it("writes one flow:job-application lead with name = first + last and the hidden job slug", async () => {
+    const result = await captureLeadAction(JOB, null, form(VALID));
+
+    expect(result).toEqual({ kind: "success" });
+    expect(mockSubmit).toHaveBeenCalledTimes(1);
+    const body = submitted();
+    expect(body.source).toBe("flow:job-application");
+    expect(body.email).toBe("ada@example.com");
+    expect(body.payload).toEqual({
+      name: "Ada Lovelace",
+      first_name: "Ada",
+      last_name: "Lovelace",
+      job: JOB,
+      page: "careers",
+    });
+    expect(body).not.toHaveProperty("siteId");
+  });
+
+  it("sends the accepted terms as the body's top-level consent: true, never inside payload (#9130)", async () => {
+    await captureLeadAction(JOB, null, form(VALID));
+
+    const body = submitted();
+    expect(body.consent).toBe(true);
+    expect(body.payload).not.toHaveProperty("consent");
+  });
+
+  it("carries phone and a LinkedIn URL, a bare domain gaining https://", async () => {
+    await captureLeadAction(
+      JOB,
+      null,
+      form({
+        ...VALID,
+        phone: "+1 555 0100",
+        linkedin_url: "linkedin.com/in/ada",
+      }),
+    );
+    expect(submitted().payload).toMatchObject({
+      phone: "+1 555 0100",
+      linkedin_url: "https://linkedin.com/in/ada",
+    });
+  });
+
+  it("keeps an extra field the owner added to the magnet, and no field overrides job, name or source", async () => {
+    await captureLeadAction(
+      JOB,
+      null,
+      form({
+        ...VALID,
+        cover_letter: "Hello",
+        job: "other-job",
+        name: "Mallory",
+        source: "web",
+      }),
+    );
+    const body = submitted();
+    expect(body.source).toBe("flow:job-application");
+    expect(body.payload).toMatchObject({
+      cover_letter: "Hello",
+      job: JOB,
+      name: "Ada Lovelace",
+    });
+  });
+
+  it.each([
+    ["first_name", { ...VALID, first_name: " " }],
+    ["last_name", { ...VALID, last_name: "" }],
+    ["email", { ...VALID, email: "not-an-email" }],
+    ["linkedin_url", { ...VALID, linkedin_url: "not a url" }],
+    ["linkedin_url", { ...VALID, linkedin_url: "javascript:alert(1)" }],
+    [
+      "linkedin_url",
+      { ...VALID, linkedin_url: "https://linkedin.com@evil.example/in/ada" },
+    ],
+    ["consent", { ...VALID, consent: "" }],
+  ])(
+    "refuses a bad %s with a field error and sends nothing",
+    async (field, fields) => {
+      const result = await captureLeadAction(JOB, null, form(fields));
+      expect(result).toMatchObject({
+        kind: "error",
+        fieldErrors: { [field]: expect.any(String) },
+      });
+      expect(mockSubmit).not.toHaveBeenCalled();
+    },
+  );
+
+  it("refuses a job value that is not a slug, sending nothing", async () => {
+    const result = await captureLeadAction("../../etc", null, form(VALID));
+    expect(result).toMatchObject({ kind: "error" });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it.each([[["eng-lead"]], [123]])(
+    "refuses a bound job of the wrong type (%p), sending nothing",
+    async (job) => {
+      // eslint-disable-next-line no-restricted-syntax -- a tampered bound argument is exactly a value of the wrong type
+      const tampered = job as unknown as string;
+      const result = await captureLeadAction(tampered, null, form(VALID));
+      expect(result).toMatchObject({ kind: "error" });
+      expect(mockSubmit).not.toHaveBeenCalled();
+    },
+  );
+
+  it("reads host:port without a scheme as a bare domain", async () => {
+    await captureLeadAction(
+      JOB,
+      null,
+      form({ ...VALID, linkedin_url: "www.linkedin.com:443/in/ada" }),
+    );
+    expect(submitted().payload).toMatchObject({
+      linkedin_url: "https://www.linkedin.com:443/in/ada",
+    });
+  });
+
+  it("shares /contact's per-visitor bucket", async () => {
+    mockHeaders.mockResolvedValue({
+      get: (name: string) =>
+        name === "x-forwarded-for" ? "203.0.113.7" : null,
+    });
+    for (let i = 0; i < 30; i += 1)
+      checkRateLimit("contact:203.0.113.7", 30, 10 * 60 * 1000);
+    expect(await captureLeadAction(JOB, null, form(VALID))).toMatchObject({
+      kind: "error",
+    });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it("answers a filled honeypot as success and sends nothing", async () => {
+    const result = await captureLeadAction(
+      JOB,
+      null,
+      form({ ...VALID, ailk_hp: "bot" }),
+    );
+    expect(result).toEqual({ kind: "success" });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it("maps lead_capture_not_configured and an unreachable API to unavailable", async () => {
+    mockSubmit.mockResolvedValueOnce({
+      ok: false,
+      status: 503,
+      body: { error: "lead_capture_not_configured" },
+    });
+    expect(await captureLeadAction(JOB, null, form(VALID))).toEqual({
+      kind: "unavailable",
+    });
+    mockSubmit.mockRejectedValueOnce(new Error("fetch failed"));
+    expect(await captureLeadAction(JOB, null, form(VALID))).toEqual({
+      kind: "unavailable",
+    });
+  });
+
+  it("answers any other refusal with the generic error", async () => {
+    mockSubmit.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      body: { error: "invalid" },
+    });
+    expect(await captureLeadAction(JOB, null, form(VALID))).toMatchObject({
+      kind: "error",
+      message: expect.any(String),
+    });
+  });
+
+  it("limits one visitor to 30 applications per 10 minutes", async () => {
+    mockHeaders.mockResolvedValue({
+      get: (name: string) =>
+        name === "x-forwarded-for" ? "203.0.113.9" : null,
+    });
+    for (let i = 0; i < 30; i += 1) {
+      expect(await captureLeadAction(JOB, null, form(VALID))).toEqual({
+        kind: "success",
+      });
+    }
+    expect(await captureLeadAction(JOB, null, form(VALID))).toMatchObject({
+      kind: "error",
+    });
+    expect(mockSubmit).toHaveBeenCalledTimes(30);
+  });
+});
+
+describe("the thank-you's account link (#8771 AC-6)", () => {
+  const invite = () =>
+    mockSubmit.mockResolvedValue({
+      ok: true,
+      status: 201,
+      body: { ok: true, next: { completion: "invite" } },
+    });
+
+  it("an invite answer returns the prefilled link and label", async () => {
+    invite();
+
+    const result = await captureLeadAction(JOB, null, form(VALID));
+
+    expect(result).toEqual({
+      kind: "success",
+      next: {
+        href: "/sign-in?next=%2Faccount&email=ada%40example.com",
+        label: "Track this in your account",
+      },
+    });
+    expect(mockInviteHref).toHaveBeenCalledWith("en", "ada@example.com");
+  });
+
+  it.each([
+    ["no next", { ok: true }],
+    ["a checkout next", { ok: true, next: { completion: "checkout", checkoutOffering: "retainer" } }],
+  ])("%s: exactly { kind: 'success' }", async (_name, body) => {
+    mockSubmit.mockResolvedValue({ ok: true, status: 201, body });
+
+    await expect(captureLeadAction(JOB, null, form(VALID))).resolves.toEqual({ kind: "success" });
+    expect(mockInviteHref).not.toHaveBeenCalled();
+  });
+
+  it("a site with no sign-in (href null) is exactly { kind: 'success' }", async () => {
+    invite();
+    mockInviteHref.mockReturnValue(null);
+    await expect(captureLeadAction(JOB, null, form(VALID))).resolves.toEqual({ kind: "success" });
+  });
+
+  it.each([
+    ["getLocale", () => mockGetLocale.mockRejectedValue(new Error("x"))],
+    ["accountInviteHref", () => mockInviteHref.mockImplementation(() => { throw new Error("x"); })],
+    ["getTranslations", () => mockGetTranslations.mockRejectedValue(new Error("x"))],
+  ])("a throw from %s after the write is still a success", async (_name, arm) => {
+    invite();
+    arm();
+    await expect(captureLeadAction(JOB, null, form(VALID))).resolves.toEqual({ kind: "success" });
+    expect(mockSubmit).toHaveBeenCalledTimes(1);
+  });
+
+  it("a filled honeypot is exactly { kind: 'success' } and writes nothing", async () => {
+    const result = await captureLeadAction(JOB, null, form({ ...VALID, ailk_hp: "http://x" }));
+    expect(result).toEqual({ kind: "success" });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+});

package/templates/apps/web/app/[locale]/careers/__tests__/careers-hub.test.tsx

@@ -0,0 +1,172 @@
+/**
+ * /careers in sections mode (#8849 D10, AC-4): one generated `items` section
+ * from the JobPosting records, first, searchable and filterable by employment
+ * type and location, the facets read from the postings' first-class
+ * frontmatter fields.
+ *
+ * `renderPage` is spied on, so each case reads the input the page hands it and
+ * resolves the sections through the page's own `getPageSections`.
+ */
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import * as pageRenderer from "@working-theory/page-renderer";
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: jest.fn(() => {
+    throw new Error("NEXT_NOT_FOUND");
+  }),
+}));
+
+jest.mock("next-mdx-remote/rsc", () => ({
+  __esModule: true,
+  MDXRemote: ({ source }: { source: string }) =>
+    React.createElement("div", { "data-testid": "mdx-rendered" }, source),
+}));
+
+import CareersPage from "../page";
+
+type Input = Parameters<typeof pageRenderer.renderPage>[0];
+type Section = Awaited<ReturnType<typeof pageRenderer.getPageSections>>[number];
+type GetMdxSource = typeof pageRenderer.getMdxSource;
+type Source = NonNullable<Awaited<ReturnType<GetMdxSource>>>;
+type Frontmatter = Source["frontmatter"];
+
+const SEED: Source = {
+  frontmatter: {
+    type: "CareersList",
+    slug: "careers",
+    title: "Careers",
+    description: "Open roles.",
+  },
+  body: "",
+};
+
+const HOW_WE_WORK: Section = {
+  type: "content-block",
+  id: "how-we-work",
+  data: { headline: "How we work", body: "Async." },
+};
+
+const POSTINGS: Record<string, Frontmatter> = {
+  writer: {
+    type: "JobPosting",
+    slug: "writer",
+    title: "Writer",
+    description: "Write for us.",
+    employmentType: "FULL_TIME",
+    remote: true,
+    location: "Remote (US)",
+    publishedAt: "2026-10-01",
+  },
+  editor: {
+    type: "JobPosting",
+    slug: "editor",
+    title: "Editor",
+    description: "Edit for us.",
+    employmentType: "PART_TIME",
+    location: "Austin, TX",
+    publishedAt: "2026-09-01",
+  },
+};
+
+function sourceFor(postings: Record<string, Frontmatter>) {
+  return jest.fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>(
+    async (type, slug) => {
+      if (type === "CareersList") return SEED;
+      const frontmatter = postings[slug];
+      return frontmatter ? { frontmatter, body: "" } : null;
+    },
+  );
+}
+
+/** Render /careers and return renderPage's input and its resolved sections. */
+async function renderHub(
+  slugs: string[],
+  postings: Record<string, Frontmatter> = POSTINGS,
+): Promise<{ input: Input; sections: Section[] }> {
+  const spy = jest.spyOn(pageRenderer, "renderPage");
+  await CareersPage({
+    params: Promise.resolve({ locale: "en" }),
+    getMdxSource: sourceFor(postings),
+    getMdxSlugs: jest.fn().mockResolvedValue(slugs),
+    getPageSections: jest.fn().mockResolvedValue([HOW_WE_WORK]),
+  });
+  const input = spy.mock.calls[0]![0];
+  spy.mockRestore();
+  const sections = await input.getPageSections!(SEED.frontmatter);
+  return { input, sections };
+}
+
+/** The generated section's data, narrowed to the `items` shape. */
+function generated(sections: Section[]) {
+  const first = sections[0]!;
+  if (first.type !== "items") throw new Error(`expected items, got ${first.type}`);
+  return first.data;
+}
+
+describe("/careers renders the generated, filterable grid (#8849 D10, AC-4)", () => {
+  it("renders in sections mode, the generated section first", async () => {
+    const { input, sections } = await renderHub(["editor", "writer"]);
+    expect(input.bodyMode).toBeUndefined();
+    expect(input.translationsNamespace).toBe("careers");
+    expect(sections.map((section) => section.id)).toEqual([
+      "open-positions",
+      "how-we-work",
+    ]);
+    expect(sections[0]!.type).toBe("items");
+  });
+
+  it("builds one card per posting, newest first, with the facets from the frontmatter", async () => {
+    const { sections } = await renderHub(["editor", "writer"]);
+    const data = generated(sections);
+    expect(data.items.map((item) => item.title)).toEqual(["Writer", "Editor"]);
+    expect(data.items.map((item) => item.eyebrow)).toEqual([
+      "Full-time · Remote (US)",
+      "Part-time · Austin, TX",
+    ]);
+    expect(data.items.map((item) => item.link?.href)).toEqual([
+      "/careers/writer",
+      "/careers/editor",
+    ]);
+    expect(data.items.map((item) => item.facets)).toEqual([
+      { type: "Full-time", location: "Remote (US)" },
+      { type: "Part-time", location: "Austin, TX" },
+    ]);
+    expect(data.filter?.facets?.map((facet) => facet.key)).toEqual([
+      "type",
+      "location",
+    ]);
+    expect(data.filter?.countText.other).toBe("{count} open positions");
+  });
+
+  it("reads no facet from schema.mainEntity", async () => {
+    const { sections } = await renderHub(["override"], {
+      override: {
+        type: "JobPosting",
+        slug: "override",
+        title: "Override",
+        description: "Typed only in the override.",
+        schema: { mainEntity: { employmentType: "FULL_TIME" } },
+      },
+    });
+    const item = generated(sections).items[0]!;
+    expect(item.facets).toBeUndefined();
+    expect(item.eyebrow).toBeUndefined();
+  });
+
+  it("with no postings, renders the declared sections alone", async () => {
+    const { sections } = await renderHub([]);
+    expect(sections.map((section) => section.id)).toEqual(["how-we-work"]);
+  });
+
+  it("with no seed, renders the careers empty state", async () => {
+    const element = await CareersPage({
+      params: Promise.resolve({ locale: "en" }),
+      getMdxSource: jest.fn().mockResolvedValue(null),
+      getMdxSlugs: jest.fn().mockResolvedValue(["writer"]),
+    });
+    render(element);
+    expect(screen.getByTestId("section-empty-state")).toBeTruthy();
+  });
+});

package/templates/apps/web/app/[locale]/careers/__tests__/careers-set.test.tsx

@@ -0,0 +1,149 @@
+/**
+ * The careers set end to end (#8849 D7, D8, D9, D10; AC-7): one `writer`
+ * posting, served by one shared content mock, through /careers, the posting
+ * page and the Free apply page. The `signal-collectors` walk over the same
+ * posting is apply-routes.test.tsx's (#8840 D11), which reads the moved
+ * `lib/posting-title.ts` through the same page-renderer loader.
+ */
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import * as pageRenderer from "@working-theory/page-renderer";
+import { jobApplicationFlowConfig } from "@working-theory/validation";
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: jest.fn(() => {
+    throw new Error("NEXT_NOT_FOUND");
+  }),
+}));
+
+jest.mock("next-mdx-remote/rsc", () => ({
+  __esModule: true,
+  MDXRemote: ({ source }: { source: string }) =>
+    React.createElement("div", { "data-testid": "mdx-rendered" }, source),
+}));
+
+jest.mock("@working-theory/api-client", () => ({
+  flows: { get: jest.fn() },
+  leads: { captureStatus: jest.fn(), submit: jest.fn() },
+  visitorForwardHeaders: () => undefined,
+}));
+
+jest.mock("next/headers", () => ({
+  __esModule: true,
+  headers: jest.fn().mockResolvedValue({ get: () => null }),
+  cookies: jest.fn().mockResolvedValue({ get: () => undefined }),
+}));
+
+// eslint-disable-next-line no-restricted-syntax -- test-seam mock: the real read is a node:fs frontmatter parse of content/_site.mdx; narrowest possible scope
+jest.mock("../../contact/site-contact-email", () => ({
+  readSiteContactEmail: jest.fn().mockReturnValue("jobs@example.com"),
+}));
+
+import { flows, leads } from "@working-theory/api-client";
+
+import CareersPage from "../page";
+import JobPage from "../[slug]/page";
+import ApplyPage from "../[slug]/[action]/page";
+
+const WRITER = {
+  type: "JobPosting" as const,
+  slug: "writer",
+  title: "Writer",
+  description: "Write for us.",
+  employmentType: "FULL_TIME" as const,
+  remote: true,
+  location: "Remote (US)",
+};
+
+type GetMdxSource = typeof pageRenderer.getMdxSource;
+
+const getMdxSource = jest.fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>(async (type, slug) => {
+  if (type === "CareersList")
+    return {
+      frontmatter: {
+        type: "CareersList" as const,
+        slug: "careers",
+        title: "Careers",
+        description: "Open roles.",
+      },
+      body: "",
+    };
+  if (type === "JobPosting" && slug === "writer")
+    return { frontmatter: WRITER, body: "The writer role." };
+  return null;
+});
+const getMdxSlugs = jest.fn().mockResolvedValue(["writer"]);
+
+beforeEach(() => {
+  // `lib/posting-title.ts` reads through the package loader, not a prop.
+  jest.spyOn(pageRenderer, "getMdxSource").mockImplementation(getMdxSource);
+  (flows.get as jest.Mock).mockResolvedValue({
+    ok: true,
+    status: 200,
+    body: jobApplicationFlowConfig,
+  });
+  (leads.captureStatus as jest.Mock).mockResolvedValue({
+    ok: true,
+    status: 200,
+    body: { ok: true, data: { contact: true, newsletter: true } },
+  });
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("a writer posting renders through the careers set (#8849 AC-7)", () => {
+  it("/careers' generated card links to /careers/writer", async () => {
+    render(
+      await CareersPage({
+        params: Promise.resolve({ locale: "en" }),
+        getMdxSource,
+        getMdxSlugs,
+      }),
+    );
+    const links = Array.from(document.querySelectorAll("a")).map((a) =>
+      a.getAttribute("href"),
+    );
+    expect(links).toContain("/careers/writer");
+    expect(screen.getByTestId("items-filter-search")).toBeTruthy();
+  });
+
+  it("/careers/writer renders the posting, its Apply button, and an ApplyAction to the same page", async () => {
+    const { container } = render(
+      await JobPage({
+        params: Promise.resolve({ locale: "en", slug: "writer" }),
+        getMdxSource,
+      }),
+    );
+    expect(screen.getByRole("heading", { level: 1, name: "Writer" })).toBeTruthy();
+    const cta = screen.getByTestId("job-apply-cta");
+    expect(cta.getAttribute("href")).toBe("/careers/writer/apply");
+
+    const jsonLd = JSON.parse(
+      container.querySelector("[data-testid='json-ld']")!.textContent!,
+    ) as { "@graph": { "@type": string; mainEntity?: Record<string, unknown> }[] };
+    const posting = jsonLd["@graph"].find((node) => node["@type"] === "WebPage")!
+      .mainEntity!;
+    expect(posting["potentialAction"]).toEqual({
+      "@type": "ApplyAction",
+      target: "http://localhost:3000/en/careers/writer/apply",
+    });
+    expect(posting["employmentType"]).toBe("FULL_TIME");
+    expect(posting["jobLocationType"]).toBe("TELECOMMUTE");
+  });
+
+  it("the Free page at /careers/writer/apply renders the form bound to writer", async () => {
+    render(
+      await ApplyPage({
+        params: Promise.resolve({ locale: "en", slug: "writer", action: "apply" }),
+      }),
+    );
+    expect(screen.getByRole("heading", { level: 1, name: "Writer" })).toBeTruthy();
+    expect(screen.getByTestId("lead-capture-form")).toBeTruthy();
+    expect(screen.getByTestId("nav-back-link").getAttribute("href")).toBe(
+      "/careers/writer",
+    );
+  });
+});