create-ailk 0.11.4 → 0.12.0

package/templates/apps/web/lib/listings.tsx

@@ -0,0 +1,472 @@
+/**
+ * The listicle directory, mounted on whichever page a live listicle names
+ * (#7521 D6).
+ *
+ * A listicle is a magnet whose accepted applications are listed. Its owner
+ * picks a landing page in the wizard (`landingPage: "/partners"`); this module
+ * puts that listicle's accepted entries on that page as shelves, below the
+ * page's own sections, and gives each entry a page at `/<landingPage>/<slug>`.
+ * Nothing here knows `/projects` — `/partners`, `/tools` and `/projects` all
+ * work with no per-site route.
+ *
+ * It is a page-renderer EXTENSION (`setPageExtension`, D5), registered at
+ * module load exactly as `./site-identity.ts` registers the site identity:
+ * `app/[locale]/layout.tsx` imports this module, so every `renderPage` call
+ * sees it with no per-route prop. `appendix` renders the shelves on a found
+ * page; `detailFallback` turns a detail route's 404 into an entry page;
+ * `detailMetadata` titles it. `[slug]/[detail]/page.tsx` calls `entryAt`
+ * directly, because that route 404s before it reaches `renderPage`.
+ *
+ * BASE TREE, and inert without two things (D7). It ships in every scaffold,
+ * Free included, and is never slice-owned — the layout imports it, so owning
+ * it would strip every page from a keyless scaffold. Each member answers
+ * `null` with NO read when `AILK_LISTING_PUBLIC_KEY` is unset or the paid
+ * `@working-theory/ui-signal-collectors` package is absent. The package is
+ * reached the way `src/lib/commerce-sections.ts` reaches its own: through
+ * `loadUiSignalCollectors()` in the generated paid-sections registry (#7536),
+ * a bundled `import()` where the site carries the package and a stub that
+ * answers `null` where it does not, so a keyless build resolves no paid
+ * package.
+ *
+ * BOTH TENANCY SHAPES, no branch: the API resolves the public key through a
+ * `SiteListingConfig` row (multi-tenant) or its own env key (single-tenant).
+ *
+ * FAIL-SOFT: a read that fails, answers non-2xx, fails its schema or takes
+ * longer than 2000 ms renders the page as today, with one warning that never
+ * carries the key. Reads are bounded twice: React `cache()` shares one read
+ * between a request's metadata and its page, and a 30 s process memo keeps
+ * the API at one read per landing page per server process (SEC-7521-D1).
+ *
+ * PATH TRUST (SEC-7521-C1): `x-pathname` is the middleware's, except on a
+ * dotted path it does not match — the one shape a client could forge. So
+ * every segment must be `^[a-z0-9][a-z0-9-]*$` (no dots) and the last must
+ * equal the slug the route rendered, or the member answers `null`.
+ */
+import { projectListings } from "@working-theory/api-client";
+import {
+  JsonLdScript,
+  setPageExtension,
+  type PageExtension,
+  type PageExtensionContext,
+} from "@working-theory/page-renderer";
+import { localeHref } from "@working-theory/ui";
+import {
+  listingDirectoryResponseSchema,
+  type ListingDirectory,
+  type ListingEntryPublic,
+} from "@working-theory/validation";
+import { readLocales } from "@working-theory/web-i18n";
+import type { Metadata } from "next";
+import { headers } from "next/headers";
+import { unstable_rethrow } from "next/navigation";
+import { getTranslations } from "next-intl/server";
+import { cache, type ComponentType, type ReactElement, type ReactNode } from "react";
+
+import { resolveBaseUrl } from "../src/lib/routes";
+
+import { loadUiSignalCollectors } from "./paid-sections.generated";
+
+// ── The paid sections, through the generated registry ──────────────────────
+
+/** The props this module passes `ListingShelves` — a structural copy, never an `import type`. */
+export interface ListingShelvesSlotProps {
+  entries: ListingEntryPublic[];
+  hrefFor: (entry: ListingEntryPublic) => string;
+  activeCopy: { title: string; empty: string };
+  closedCopy: { title: string; empty: string };
+  featuredLabel: string;
+  waitlistCountLabel: (n: number) => string;
+}
+
+/** The props this module passes `ListingDetail`. */
+export interface ListingDetailSlotProps {
+  entry: ListingEntryPublic;
+  websiteLabel: string;
+  profileHeading: string;
+}
+
+/** The two exports this module needs from the paid package. */
+export interface ListingUiModule {
+  ListingShelves: ComponentType<ListingShelvesSlotProps>;
+  ListingDetail: ComponentType<ListingDetailSlotProps>;
+}
+
+let uiModule: Promise<ListingUiModule | null> | undefined;
+
+/**
+ * The paid sections, or `null` when this site does not carry the package.
+ * Once per process. An older package without the directory surfaces also
+ * answers `null`, never an undefined component that would fail the render
+ * past the extension's try/catch.
+ */
+function loadListingUi(): Promise<ListingUiModule | null> {
+  uiModule ??= loadUiSignalCollectors().then((mod) => {
+    const ui = mod as Partial<ListingUiModule> | null;
+    return typeof ui?.ListingShelves === "function" && typeof ui.ListingDetail === "function"
+      ? (ui as ListingUiModule)
+      : null;
+  });
+  return uiModule;
+}
+
+// ── Dependencies ────────────────────────────────────────────────────────────
+
+/** The `listings.*` message keys this module reads (`messages/en.json`). */
+type ListingMessageKey =
+  | "activeTitle"
+  | "activeEmpty"
+  | "closedTitle"
+  | "closedEmpty"
+  | "featured"
+  | "waitlistCount"
+  | "website"
+  | "profileHeading";
+
+/** A `listings.*` message lookup for one locale. */
+export type ListingTranslator = (key: ListingMessageKey, values?: Record<string, number>) => string;
+
+/** What a directory read answers — the api-client's result envelope, structurally. */
+export type DirectoryReadResult = { ok: true; body: unknown } | { ok: false; status: number };
+
+/** Every outside input, injectable so the suite runs with no network and no request. */
+export interface ListingExtensionDeps {
+  siteKey?: () => string | undefined;
+  pathname?: () => Promise<string | null>;
+  locales?: () => readonly string[];
+  fetchDirectory?: (
+    siteKey: string,
+    landingPage: string,
+    locale: string,
+  ) => Promise<DirectoryReadResult>;
+  loadUi?: () => Promise<ListingUiModule | null>;
+  translate?: (locale: string) => Promise<ListingTranslator>;
+  baseUrl?: () => string;
+  /** The memo's clock, in ms. */
+  now?: () => number;
+}
+
+/**
+ * Whether the landing page an explicit path names is itself a page. The
+ * `[slug]/[detail]` route's first segment is the visitor's to choose, so the
+ * route proves `/<slug>` exists before any directory read (SEC-7521-D1).
+ */
+export type HubExists = () => Promise<boolean>;
+
+/** The registered extension, plus the explicit-path entry the `[slug]/[detail]` route calls. */
+export interface ListingExtension extends PageExtension {
+  entryAt(
+    path: string,
+    slug: string,
+    locale: string,
+    hubExists: HubExists,
+  ): Promise<ReactElement | null>;
+  entryMetadataAt(
+    path: string,
+    slug: string,
+    locale: string,
+    hubExists: HubExists,
+  ): Promise<Metadata | null>;
+}
+
+const READ_TIMEOUT_MS = 2000;
+const MEMO_TTL_MS = 30_000;
+/** A failed read is retried sooner, so one transient error never hides a directory for the full TTL. */
+const MEMO_FAILURE_TTL_MS = 5_000;
+const MEMO_MAX_KEYS = 500;
+const SEGMENT = /^[a-z0-9][a-z0-9-]*$/;
+
+// ── Pure helpers ────────────────────────────────────────────────────────────
+
+/** A trusted path: its landing page, its segments after the locale, and whether it was prefixed. */
+interface ListingPath {
+  landingPage: string;
+  segments: string[];
+  prefixed: boolean;
+}
+
+/**
+ * Parse a request path into `segmentCount` trusted segments after an
+ * enabled-locale prefix (`auth-routes.ts`'s prefix rule), the last equal to
+ * `slug`. Any other shape is `null`.
+ */
+function parseListingPath(
+  pathname: string | null,
+  locales: readonly string[],
+  segmentCount: 1 | 2,
+  slug: string,
+): ListingPath | null {
+  if (!pathname) return null;
+  const raw = (pathname.split(/[?#]/)[0] ?? "").split("/").slice(1);
+  const prefixed = raw.length > 0 && locales.includes(raw[0]!);
+  const segments = prefixed ? raw.slice(1) : raw;
+  if (segments.length !== segmentCount) return null;
+  if (!segments.every((segment) => SEGMENT.test(segment))) return null;
+  if (segments[segments.length - 1] !== slug) return null;
+  return { landingPage: `/${segments[0]}`, segments, prefixed };
+}
+
+/**
+ * An entry's site-relative URL. `localeHref`'s as-needed rule, except that a
+ * request that arrived prefixed keeps its prefix — a page's links point
+ * where the page itself was served.
+ */
+function entryHref(locale: string, path: ListingPath, slug: string): string {
+  const target = `${path.landingPage}/${slug}`;
+  return path.prefixed ? `/${locale}${target}` : localeHref(locale, target);
+}
+
+function absolute(baseUrl: string, path: string): string {
+  return `${baseUrl.replace(/\/+$/, "")}${path}`;
+}
+
+/** The landing page's `ItemList` — one `ListItem` per entry, in the directory's order. */
+export function directoryItemListJsonLd(
+  entries: readonly ListingEntryPublic[],
+  urlFor: (entry: ListingEntryPublic) => string,
+) {
+  return {
+    "@context": "https://schema.org" as const,
+    "@type": "ItemList",
+    itemListElement: entries.map((entry, i) => ({
+      "@type": "ListItem",
+      position: i + 1,
+      url: urlFor(entry),
+      name: entry.name,
+    })),
+  };
+}
+
+/** An entry page's own node, typed by its listicle's `entryType`. */
+export function entryJsonLd(entry: ListingEntryPublic, entryType: string, url: string) {
+  return {
+    "@context": "https://schema.org" as const,
+    "@type": entryType,
+    "@id": url,
+    name: entry.name,
+    ...(entry.summary !== null && { description: entry.summary }),
+    ...(entry.url !== null && { url: entry.url }),
+    ...(entry.logoMarkUrl !== null && { image: entry.logoMarkUrl }),
+  };
+}
+
+// ── The extension ───────────────────────────────────────────────────────────
+
+export function createListingExtension(deps: ListingExtensionDeps = {}): ListingExtension {
+  const siteKey = deps.siteKey ?? (() => process.env["AILK_LISTING_PUBLIC_KEY"]);
+  const pathname =
+    deps.pathname ?? (async () => (await headers()).get("x-pathname"));
+  const locales = deps.locales ?? (() => readLocales());
+  // Resolved per call, never at module load: the layout imports this module,
+  // so it must load even where the api-client is partially stubbed.
+  const fetchDirectory =
+    deps.fetchDirectory ??
+    ((key: string, landingPage: string, locale: string) =>
+      projectListings.directory(key, landingPage, locale));
+  const loadUi = deps.loadUi ?? loadListingUi;
+  const translate =
+    deps.translate ??
+    (async (locale: string): Promise<ListingTranslator> => {
+      const t = await getTranslations({ namespace: "listings", locale });
+      return (key, values) => t(key, values);
+    });
+  const baseUrl = deps.baseUrl ?? resolveBaseUrl;
+  const now = deps.now ?? Date.now;
+
+  type ReadOutcome = { directory: ListingDirectory | null; failed: boolean };
+  const memo = new Map<string, { at: number; value: Promise<ReadOutcome> }>();
+
+  async function readOnce(key: string, landingPage: string, locale: string): Promise<ReadOutcome> {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeout = new Promise<"timeout">((resolve) => {
+      timer = setTimeout(() => resolve("timeout"), READ_TIMEOUT_MS);
+    });
+    const fail = (reason: string): ReadOutcome => {
+      console.warn("[listings] directory read failed; rendering the page without it", {
+        landingPage,
+        reason,
+      });
+      return { directory: null, failed: true };
+    };
+    try {
+      const res = await Promise.race([fetchDirectory(key, landingPage, locale), timeout]);
+      if (res === "timeout") return fail("timeout");
+      if (!res.ok) return fail(`status ${res.status}`);
+      const parsed = listingDirectoryResponseSchema.safeParse(res.body);
+      if (!parsed.success) return fail("schema");
+      return { directory: parsed.data, failed: false };
+    } catch (err) {
+      unstable_rethrow(err);
+      return fail("error");
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  /**
+   * At most one read per (key, landing page, locale) per 30 s in this
+   * process — 5 s after a failed read.
+   */
+  async function memoRead(key: string, landingPage: string, locale: string) {
+    const memoKey = `${key}\u0000${landingPage}\u0000${locale}`;
+    const hit = memo.get(memoKey);
+    if (hit) {
+      const outcome = await hit.value;
+      const ttl = outcome.failed ? MEMO_FAILURE_TTL_MS : MEMO_TTL_MS;
+      if (now() - hit.at < ttl) return outcome.directory;
+      // A concurrent caller may already have replaced the stale entry.
+      if (memo.get(memoKey) === hit) memo.delete(memoKey);
+      else return memoRead(key, landingPage, locale);
+    }
+    if (memo.size >= MEMO_MAX_KEYS) memo.delete(memo.keys().next().value!);
+    const value = readOnce(key, landingPage, locale);
+    memo.set(memoKey, { at: now(), value });
+    return (await value).directory;
+  }
+  /** One read per request, shared by `generateMetadata` and the page. */
+  const read = cache(memoRead);
+
+  /**
+   * The directory for a path — `null` with NO read without a key, for an
+   * untrusted path, for a hub that is not a page, or without the paid
+   * package. The key is checked first, so a keyless site reads no header, no
+   * locale list and no hub either.
+   */
+  async function directoryFor(
+    pathValue: () => Promise<string | null>,
+    segmentCount: 1 | 2,
+    slug: string,
+    locale: string,
+    hubExists?: HubExists,
+  ): Promise<{ directory: ListingDirectory; ui: ListingUiModule; path: ListingPath } | null> {
+    const key = siteKey();
+    if (!key) return null;
+    // A dotted path skips the middleware, so its `x-pathname` is the client's;
+    // its dot can only sit in the locale segment, since any other dotted
+    // segment fails `SEGMENT` or the slug match. So a locale this site does
+    // not enable answers null, never a read (SEC-7521-C1).
+    if (!locales().includes(locale)) return null;
+    let path: ListingPath | null;
+    try {
+      path = parseListingPath(await pathValue(), locales(), segmentCount, slug);
+    } catch (err) {
+      // `headers()` signals dynamic rendering by throwing; that is Next's to see.
+      unstable_rethrow(err);
+      return null;
+    }
+    if (path === null) return null;
+    if (hubExists !== undefined && !(await hubExists())) return null;
+    const ui = await loadUi();
+    if (ui === null) return null;
+    const directory = await read(key, path.landingPage, locale);
+    return directory === null ? null : { directory, ui, path };
+  }
+
+  async function entryFor(
+    pathValue: () => Promise<string | null>,
+    slug: string,
+    locale: string,
+    hubExists?: HubExists,
+  ) {
+    const found = await directoryFor(pathValue, 2, slug, locale, hubExists);
+    const entry = found?.directory.entries.find((e) => e.slug === slug);
+    return found && entry ? { ...found, entry } : null;
+  }
+
+  type FoundEntry = Awaited<ReturnType<typeof entryFor>>;
+
+  async function renderEntry(
+    found: FoundEntry,
+    slug: string,
+    locale: string,
+  ): Promise<ReactElement | null> {
+    if (found === null) return null;
+    const { ui, directory, entry, path } = found;
+    const t = await translate(locale);
+    const url = absolute(baseUrl(), entryHref(locale, path, slug));
+    return (
+      <>
+        <JsonLdScript data={entryJsonLd(entry, directory.entryType, url)} />
+        <main id="main">
+          <ui.ListingDetail
+            entry={entry}
+            websiteLabel={t("website")}
+            profileHeading={t("profileHeading")}
+          />
+        </main>
+      </>
+    );
+  }
+
+  function entryMetadata(found: FoundEntry): Metadata | null {
+    if (found === null) return null;
+    return {
+      title: found.entry.name,
+      ...(found.entry.summary !== null && { description: found.entry.summary }),
+    };
+  }
+
+  /**
+   * Called by the route directly, not through `consultPageExtension`, so it
+   * carries that wrapper's fail-soft itself: Next's signals propagate, any
+   * other failure answers `null` and the route 404s as it would without it.
+   */
+  async function failSoft<T>(work: () => Promise<T | null>): Promise<T | null> {
+    try {
+      return await work();
+    } catch (err) {
+      unstable_rethrow(err);
+      console.warn("[listings] entry render failed; answering as if absent");
+      return null;
+    }
+  }
+
+  function entryAt(path: string, slug: string, locale: string, hubExists: HubExists) {
+    return failSoft(async () =>
+      renderEntry(await entryFor(async () => path, slug, locale, hubExists), slug, locale),
+    );
+  }
+
+  function entryMetadataAt(path: string, slug: string, locale: string, hubExists: HubExists) {
+    return failSoft(async () =>
+      entryMetadata(await entryFor(async () => path, slug, locale, hubExists)),
+    );
+  }
+
+  return {
+    async appendix({ slug, locale }: PageExtensionContext): Promise<ReactNode | null> {
+      const found = await directoryFor(pathname, 1, slug, locale);
+      if (found === null || found.directory.entries.length === 0) return null;
+      const { ui, directory, path } = found;
+      const t = await translate(locale);
+      const hrefFor = (entry: ListingEntryPublic) => entryHref(locale, path, entry.slug);
+      const origin = baseUrl();
+      return (
+        <>
+          <ui.ListingShelves
+            entries={directory.entries}
+            hrefFor={hrefFor}
+            activeCopy={{ title: t("activeTitle"), empty: t("activeEmpty") }}
+            closedCopy={{ title: t("closedTitle"), empty: t("closedEmpty") }}
+            featuredLabel={t("featured")}
+            waitlistCountLabel={(count) => t("waitlistCount", { count })}
+          />
+          <JsonLdScript
+            data={directoryItemListJsonLd(directory.entries, (e) => absolute(origin, hrefFor(e)))}
+          />
+        </>
+      );
+    },
+    async detailFallback({ slug, locale }: PageExtensionContext) {
+      return renderEntry(await entryFor(pathname, slug, locale), slug, locale);
+    },
+    async detailMetadata({ slug, locale }: PageExtensionContext) {
+      return entryMetadata(await entryFor(pathname, slug, locale));
+    },
+    entryAt,
+    entryMetadataAt,
+  };
+}
+
+/** The app's one extension, registered for every `renderPage` under the locale layout. */
+export const listingExtension = createListingExtension();
+setPageExtension(listingExtension);

package/templates/apps/web/lib/paid-section-contracts.ts

@@ -0,0 +1,22 @@
+/**
+ * The structural contracts base code loads paid section packages through
+ * (#7536) — what `apps/web/lib/paid-sections.generated.ts` types each loader
+ * with, so a keyless scaffold can stub a package it does not carry.
+ *
+ * Hand-authored and in the base tree: it names ONLY the members base code
+ * uses and imports no paid package. In the monorepo, `tsc` checks each present
+ * `import()` against its contract, so a contract that drifts from the real
+ * package is a type error here.
+ */
+
+/** `@working-theory/ui-commerce`: the one export `commerce-sections.ts` calls. */
+export interface UiCommerceContract {
+  registerCommerceSections(): void;
+}
+
+/**
+ * `@working-theory/ui-signal-collectors`: no member is consumed yet — the
+ * directory surface (#7521) widens this to name `ListingShelves` and
+ * `ListingDetail`.
+ */
+export type UiSignalCollectorsContract = Record<never, never>;

package/templates/apps/web/lib/paid-sections.generated.ts

@@ -0,0 +1,16 @@
+// paid-sections.generated.ts — the paid section packages this site carries.
+//
+// GENERATED by create-ailk from MODULE_SLICES (`paidSectionsPackage`) and
+// this app's package.json dependencies (#7536). Do not edit: every scaffold
+// and `create-ailk add-module` rewrites it. A carried package is a bundled
+// dynamic import; one this site does not carry is a stub that answers null.
+import type {
+  UiCommerceContract,
+  UiSignalCollectorsContract,
+} from "./paid-section-contracts";
+
+export const loadUiSignalCollectors =
+  async (): Promise<UiSignalCollectorsContract | null> => null;
+
+export const loadUiCommerce = async (): Promise<UiCommerceContract | null> =>
+  null;

package/templates/apps/web/messages/en.json

@@ -262,6 +262,16 @@
     "heading": "Projects",
     "emptyState": "Projects listing coming soon."
   },
+  "listings": {
+    "activeTitle": "Open now",
+    "activeEmpty": "Nothing listed yet.",
+    "closedTitle": "Past entries",
+    "closedEmpty": "Nothing here yet.",
+    "featured": "Featured",
+    "waitlistCount": "{count, plural, one {# person waiting} other {# people waiting}}",
+    "website": "Visit website",
+    "profileHeading": "Details"
+  },
   "purchase": {
     "success": {
       "title": "Payment successful",
@@ -768,39 +778,63 @@
     "notFoundHeadline": "Page not found",
     "notFoundDescription": "There is no page at this address. It may have been renamed or removed.",
     "editor": {
-      "tabForm": "Details",
-      "tabBody": "Body",
       "tabPreview": "Preview",
-      "tabCode": "Code",
+      "toolChanges": "Show unsaved changes",
+      "backLabel": "Pages",
       "statusDraft": "Draft",
       "statusNotYetLive": "Not yet live",
       "statusPublished": "Published",
-      "frontmatterHeading": "Page details",
+      "publishedSwitch": "Published",
+      "publishBlockedHint": "Fix the items under For you before publishing.",
+      "unsaved": "Unsaved",
+      "unsavedChanges": "Unsaved changes",
+      "discardButton": "Discard",
+      "loading": "Loading…",
+      "loadError": "Could not load this page. Try again.",
+      "retryButton": "Try again",
       "frontmatterTitle": "Title",
       "frontmatterSlug": "Slug",
       "frontmatterDescription": "Description",
-      "issuesHeading": "Fix these before publishing",
-      "saveButton": "Save draft",
+      "titlePlaceholder": "Page title",
+      "fieldPageType": "Page type",
+      "toolbarLabel": "Formatting",
+      "formatMenu": "Page actions",
+      "closeSheet": "Close",
+      "toolH1": "Heading 1",
+      "toolH2": "Heading 2",
+      "toolH3": "Heading 3",
+      "toolBold": "Bold",
+      "toolItalic": "Italic",
+      "toolBulletList": "Bulleted list",
+      "toolNumberedList": "Numbered list",
+      "toolLink": "Link",
+      "toolImage": "Insert image",
+      "issueRequired": "{field} is required.",
+      "issueInvalid": "{field} isn't a valid choice.",
+      "forYou": {
+        "typeFix": "Blocks publish",
+        "typeSuggestion": "Suggestion",
+        "fixWhy": "The page can't go live until this is fixed.",
+        "fixOutcome": "Once it is fixed, the Published switch turns on.",
+        "descriptionTitle": "Add a search description",
+        "descriptionWhy": "Search engines and AI answers show this line under the page's title. Without it they write their own.",
+        "descriptionOutcome": "A sentence you chose appears wherever this page is listed.",
+        "altTitle": "{count, plural, one {Describe # image} other {Describe # images}}",
+        "altWhy": "Screen readers and search engines can't see an image without alt text.",
+        "altOutcome": "Every reader gets the image's meaning, and the page is easier to find."
+      },
+      "saveButton": "Save",
       "saving": "Saving…",
       "saved": "Saved",
       "saveError": "Could not save. Try again.",
-      "publishButton": "Publish",
-      "publishing": "Publishing…",
-      "published": "Published",
       "publishError": "Could not publish. Try again.",
-      "unpublishButton": "Unpublish",
-      "unpublishing": "Unpublishing…",
-      "unpublished": "Unpublished",
       "unpublishError": "Could not unpublish. Try again.",
       "conflictHeading": "Someone else saved this page",
       "conflictMessage": "This page changed since you opened it. Reload to take their version, or overwrite it with yours.",
       "conflictReload": "Reload their version",
       "conflictOverwrite": "Overwrite with mine",
-      "imageInsertLabel": "Insert an image",
-      "imageInsertHint": "The image is uploaded and its markdown inserted at the cursor.",
       "imageAlt": "Image",
       "imageInsertError": "Could not upload that image. Try again.",
-      "codeHeading": "Composed MDX",
       "diffLegendAdded": "Added",
       "diffLegendRemoved": "Removed",
       "diffLegendUnchanged": "Unchanged"

package/templates/apps/web/src/lib/__tests__/commerce-sections.test.ts

@@ -0,0 +1,57 @@
+// oss: false
+/**
+ * #7536 AC-4 — `ensureCommerceSectionsRegistered()` loads the paid package
+ * through the generated registry and fails loud: absence (a stub's `null`)
+ * answers `false`, a present package whose import rejects propagates, and one
+ * process registers at most once. Each case isolates the module so its
+ * memoised `registration` starts fresh.
+ */
+const REGISTRY = "../../../lib/paid-sections.generated";
+
+type Ensure = () => Promise<boolean>;
+
+function load(loadUiCommerce: jest.Mock): Ensure {
+  let ensure: Ensure | undefined;
+  jest.isolateModules(() => {
+    jest.doMock(REGISTRY, () => ({ loadUiCommerce }));
+    ensure = (
+      require("../commerce-sections") as { ensureCommerceSectionsRegistered: Ensure }
+    ).ensureCommerceSectionsRegistered;
+  });
+  if (!ensure) throw new Error("commerce-sections did not load");
+  return ensure;
+}
+
+afterEach(() => {
+  jest.dontMock(REGISTRY);
+});
+
+describe("ensureCommerceSectionsRegistered", () => {
+  it("registers once and answers true when the registry loads the package", async () => {
+    const spy = jest.fn();
+    const loader = jest.fn().mockResolvedValue({ registerCommerceSections: spy });
+    const ensure = load(loader);
+
+    await expect(ensure()).resolves.toBe(true);
+    await expect(ensure()).resolves.toBe(true);
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(loader).toHaveBeenCalledTimes(1);
+  });
+
+  it("answers false and registers nothing when the registry answers null (package not carried)", async () => {
+    const loader = jest.fn().mockResolvedValue(null);
+    const ensure = load(loader);
+
+    await expect(ensure()).resolves.toBe(false);
+    expect(loader).toHaveBeenCalledTimes(1);
+  });
+
+  it("lets a rejected import reject — never degrades to false — and stays memoised", async () => {
+    const loader = jest.fn().mockRejectedValue(new Error("chunk"));
+    const ensure = load(loader);
+
+    await expect(ensure()).rejects.toThrow("chunk");
+    await expect(ensure()).rejects.toThrow("chunk");
+    expect(loader).toHaveBeenCalledTimes(1);
+  });
+});