@forgecart/cli 2.202610280649.0 → 2.202610280926.0

package/templates/storefront-shadcn-blank/src/components/ui/button.tsx

@@ -0,0 +1,64 @@
+import { Slot } from '@radix-ui/react-slot';
+import { cva, type VariantProps } from 'class-variance-authority';
+import type { ComponentProps } from 'react';
+
+import { cn } from './utils';
+
+/**
+ * The shadcn/ui button. `buttonVariants` is exported on its own so a link
+ * styled as a button keeps its own element — `<LocaleLink className={
+ * buttonVariants()}>` stays one crawlable `<a>` — and `asChild` hands the
+ * classes to whatever single child it wraps instead.
+ *
+ * Every colour is a token of the `:root` block in `src/app/globals.css`; the
+ * template has no destructive action, so the variant shadcn/ui paints with a
+ * raw `text-white` is not vendored.
+ */
+const buttonVariants = cva(
+  "inline-flex shrink-0 items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      variant: {
+        default: 'bg-primary text-primary-foreground shadow-xs hover:bg-primary/90',
+        secondary: 'bg-secondary text-secondary-foreground shadow-xs hover:bg-secondary/80',
+        outline:
+          'border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground',
+        ghost: 'hover:bg-accent hover:text-accent-foreground',
+        link: 'text-primary underline-offset-4 hover:underline',
+      },
+      size: {
+        default: 'h-9 px-4 py-2 has-[>svg]:px-3',
+        sm: 'h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5',
+        lg: 'h-10 rounded-md px-6 has-[>svg]:px-4',
+        icon: 'size-9',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+      size: 'default',
+    },
+  },
+);
+
+function Button({
+  className,
+  variant,
+  size,
+  asChild = false,
+  ...props
+}: ComponentProps<'button'> &
+  VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+  }) {
+  const Comp = asChild ? Slot : 'button';
+
+  return (
+    <Comp
+      data-slot="button"
+      className={cn(buttonVariants({ variant, size, className }))}
+      {...props}
+    />
+  );
+}
+
+export { Button, buttonVariants };

package/templates/storefront-shadcn-blank/src/components/ui/card.tsx

@@ -0,0 +1,28 @@
+import type { ComponentProps } from 'react';
+
+import { cn } from './utils';
+
+/**
+ * The shadcn/ui card: a raised `bg-card` surface with its border and radius.
+ * The template's cards carry their own headings — a product tile's `<h3>`, a
+ * cart panel's `<h2>` — so the heading level stays the page's decision, and
+ * `CardContent` pads whatever sits inside.
+ */
+function Card({ className, ...props }: ComponentProps<'div'>) {
+  return (
+    <div
+      data-slot="card"
+      className={cn(
+        'flex flex-col gap-6 rounded-xl border bg-card py-6 text-card-foreground shadow-sm',
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function CardContent({ className, ...props }: ComponentProps<'div'>) {
+  return <div data-slot="card-content" className={cn('px-6', className)} {...props} />;
+}
+
+export { Card, CardContent };

package/templates/storefront-shadcn-blank/src/components/ui/input.tsx

@@ -0,0 +1,26 @@
+import type { ComponentProps } from 'react';
+
+import { cn } from './utils';
+
+/**
+ * The shadcn/ui text input. An invalid field is marked by `aria-invalid` —
+ * the attribute a screen reader announces is the one that paints the
+ * destructive border, so the two can never disagree.
+ */
+function Input({ className, type, ...props }: ComponentProps<'input'>) {
+  return (
+    <input
+      type={type}
+      data-slot="input"
+      className={cn(
+        'flex h-9 w-full min-w-0 rounded-md border border-input bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none selection:bg-primary selection:text-primary-foreground file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm',
+        'focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50',
+        'aria-invalid:border-destructive aria-invalid:ring-destructive/20',
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Input };

package/templates/storefront-shadcn-blank/src/components/ui/label.tsx

@@ -0,0 +1,22 @@
+'use client';
+
+import * as LabelPrimitive from '@radix-ui/react-label';
+import type { ComponentProps } from 'react';
+
+import { cn } from './utils';
+
+/** The shadcn/ui form label, on Radix's label primitive. */
+function Label({ className, ...props }: ComponentProps<typeof LabelPrimitive.Root>) {
+  return (
+    <LabelPrimitive.Root
+      data-slot="label"
+      className={cn(
+        'flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50',
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Label };

package/templates/storefront-shadcn-blank/src/components/ui/native-select.tsx

@@ -0,0 +1,27 @@
+import type { ComponentProps } from 'react';
+
+import { cn } from './utils';
+
+/**
+ * A native `<select>` dressed as a shadcn/ui field. The checkout's country
+ * select stays the browser's own control — it takes part in the form's
+ * `required` validation and in the platform's address autofill, which a
+ * custom listbox would have to rebuild — and only borrows the input's
+ * border, focus ring and `aria-invalid` treatment.
+ */
+function NativeSelect({ className, ...props }: ComponentProps<'select'>) {
+  return (
+    <select
+      data-slot="native-select"
+      className={cn(
+        'flex h-9 w-full min-w-0 rounded-md border border-input bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm',
+        'focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50',
+        'aria-invalid:border-destructive aria-invalid:ring-destructive/20',
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { NativeSelect };

package/templates/storefront-shadcn-blank/src/components/ui/skeleton.tsx

@@ -0,0 +1,21 @@
+import type { ComponentProps } from 'react';
+
+import { cn } from './utils';
+
+/**
+ * The shadcn/ui loading placeholder. It pulses on `bg-muted`, the quiet
+ * surface, rather than on `bg-accent`: this variant's accent carries the
+ * daisyUI baseline's strong highlight, which would turn every loading block
+ * near-black.
+ */
+function Skeleton({ className, ...props }: ComponentProps<'div'>) {
+  return (
+    <div
+      data-slot="skeleton"
+      className={cn('animate-pulse rounded-md bg-muted', className)}
+      {...props}
+    />
+  );
+}
+
+export { Skeleton };

package/templates/storefront-shadcn-blank/src/components/ui/utils.ts

@@ -0,0 +1,16 @@
+import { clsx, type ClassValue } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+/**
+ * shadcn/ui's class helper: joins conditional classes (`clsx`) and lets a
+ * later utility win over an earlier one of the same group (`tailwind-merge`),
+ * so a component's own classes can be overridden from its `className`.
+ *
+ * It lives beside the vendored components rather than under `src/lib/`: the
+ * library holds the storefront's logic, which every row of the template set
+ * shares byte for byte, and this helper belongs to the shadcn/ui components
+ * alone. `components.json` points the shadcn/ui CLI's `utils` alias here.
+ */
+export function cn(...inputs: ClassValue[]): string {
+  return twMerge(clsx(inputs));
+}

package/templates/storefront-shadcn-blank/src/instrumentation.ts

@@ -0,0 +1,109 @@
+/**
+ * DEV-ONLY server-error beacon via Next's `onRequestError` instrumentation hook.
+ *
+ * This is the PRIMARY server-side crash-detection surface for the in-pod dev-server:
+ * when a Server Component, a server action, or a route handler THROWS while rendering
+ * a request under `next dev`, Next invokes `onRequestError` with the structured error
+ * + request + routing context. The hook POSTs that detail SERVER-side, straight to the
+ * in-pod workspace-manager loopback receiver at
+ * `http://127.0.0.1:<FORGE_BEACON_PORT>/__forge_beacon`, which folds it into the
+ * supervisor's runtime state so the shop's recovery brain can originate a fix for a
+ * crash the `/ping` liveness probe cannot see (the dev-server process stays up and
+ * `/ping` stays 200, but `/` 500s per request).
+ *
+ * This complements the browser beacon (`ForgeErrorBeacon`): that one catches
+ * CLIENT-component / hydration throws that surface only in the browser; this one
+ * catches SERVER render throws that surface only in the dev-server. Both POST the
+ * same `/__forge_beacon` shape — the only difference is `source` (`'browser'` vs
+ * `'server'`).
+ *
+ * Gated entirely on `NODE_ENV === 'development'`: a deployed `next start` storefront
+ * registers no beacon (the literal check is inlined by the bundler, so the body is
+ * dead-code-eliminated from a production build) and the loopback receiver does not
+ * exist outside the pod. Next compiles `instrumentation.ts` for BOTH the Node and Edge
+ * runtimes; the loopback POST is a Node-only concern, so the hook also gates on the
+ * Node runtime — the Edge bundle then carries an inert no-op.
+ *
+ * The hook NEVER throws out of itself: a failed delivery is swallowed (the beacon is a
+ * best-effort backstop, never a hard dependency of the request), so a flapping receiver
+ * can never mask or replace the underlying request error Next is already reporting.
+ *
+ * The error's own `code` rides along verbatim — a fact, never a verdict: a request
+ * that races a recompile evaluates Turbopack's stub for a module that no longer parses
+ * and throws `code: 'MODULE_UNPARSABLE'`, and the receiver reads that code to leave a
+ * BUILD failure to the build detectors instead of folding it as a render crash.
+ */
+
+const BEACON_PORT = process.env.FORGE_BEACON_PORT ?? '3002';
+
+/**
+ * Server-start hook: warm-boot the embedded NestJS backend (`src/server/`)
+ * so the first `sdk.backend` invocation doesn't pay the context creation.
+ *
+ * Warm-up ONLY — correctness never depends on it: the dispatch path's lazy
+ * `getBackend()` is what re-boots the context after dev-mode (HMR) edits,
+ * and a boot failure here is deliberately swallowed so a drifted api-map
+ * can never crash the server start — the first invocation (and the dev
+ * methods route) reports the same error as a typed envelope instead. The
+ * dynamic import keeps the Edge bundle inert (Nest is Node-only), and a
+ * no-env boot (image pre-warm) succeeds because clients are only built at
+ * invocation time.
+ */
+export async function register(): Promise<void> {
+  // POSITIVE if-block, never an early return: webpack's parser dead-code-
+  // eliminates a statically-false `if` BODY (NEXT_RUNTIME is DefinePlugin-
+  // substituted per bundle), but it does NOT track reachability past a
+  // `return` — with the guard inverted, the EDGE instrumentation bundle
+  // (compiled because middleware.ts exists) chases this import into
+  // @nestjs/*'s node-builtin requires and `next build --webpack` dies with
+  // five Module-not-found errors ('stream', 'os', 'perf_hooks'; every
+  // publish-button CI run since this import landed). Turbopack prunes the
+  // dead branch either way — only the webpack publish build sees the
+  // difference.
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    try {
+      const { getBackend } = await import('./server/bootstrap');
+      await getBackend();
+    } catch {
+      // Surfaced by the first sdk.backend invocation and /api/__backend/methods.
+    }
+  }
+}
+
+interface OnRequestErrorRequest {
+  path: string;
+  method: string;
+  headers: { [key: string]: string | string[] | undefined };
+}
+
+interface OnRequestErrorContext {
+  routerKind: string;
+  routePath: string;
+  routeType: string;
+}
+
+export async function onRequestError(
+  error: unknown,
+  request: OnRequestErrorRequest,
+  context: OnRequestErrorContext,
+): Promise<void> {
+  if (process.env.NODE_ENV !== 'development' || process.env.NEXT_RUNTIME !== 'nodejs') {
+    return;
+  }
+
+  const err = error as { message?: string; digest?: string; code?: unknown } | undefined;
+  const body = JSON.stringify({
+    message: typeof err?.message === 'string' ? err.message : String(error),
+    digest: typeof err?.digest === 'string' ? err.digest : undefined,
+    code: typeof err?.code === 'string' ? err.code : undefined,
+    route: request.path,
+    routeType: context.routeType,
+    source: 'server',
+  });
+
+  await fetch(`http://127.0.0.1:${BEACON_PORT}/__forge_beacon`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body,
+  }).catch(() => undefined);
+}

package/templates/storefront-shadcn-blank/src/lib/account/account-link.ts

@@ -0,0 +1,76 @@
+import type { RouteSearchParams } from '../seo/noindex';
+
+/**
+ * The anatomy of a ONE-SHOT account link (#1472).
+ *
+ * The platform mails a shopper two kinds of link and both have the same shape:
+ * this storefront's own origin, a fixed route, and a single-use token in the
+ * query — `<origin>/verify?token=…` and `<origin>/reset-password?token=…`. The
+ * `?token=` spelling is the CONTRACT between the mail templates and these
+ * pages (a merchant may have customized the mail body, so the parameter name
+ * cannot be changed on one side alone); the platform supplies the origin, this
+ * module reads what arrives.
+ *
+ * PURE BY CONTRACT: no Next imports, no `process.env`, no fetch, no I/O — the
+ * same constraint `lib/locale/grammar.ts` and `lib/seo/noindex.ts` carry, for
+ * the same reason. `tool/storefront-template-spec` imports this file directly
+ * by relative path from OUTSIDE the scaffold, so anything reachable from here
+ * must resolve without the template's Next toolchain. A rule that decides what
+ * a shopper sees after clicking a one-shot credential has to be a table of
+ * vectors rather than something only a running server can exercise. The
+ * `RouteSearchParams` import is type-only and names another pure module, so it
+ * erases and drags nothing in.
+ */
+
+/**
+ * The query parameter every account link carries.
+ *
+ * Named once so the two pages and their vectors cannot disagree about the
+ * spelling the platform's mail templates emit.
+ */
+export const ACCOUNT_TOKEN_PARAM = 'token';
+
+/** What the shop API answered when a token was actually presented to it. */
+export type AccountCallOutcome = { kind: 'ok' } | { kind: 'error'; code: string };
+
+/**
+ * Everything a link render has to account for: the API's answer, or the fact
+ * that there was no usable token to ask about in the first place.
+ *
+ * `no-token` is not an error the API returned — it is a property of the URL —
+ * and keeping it in the same union is what lets ONE total function decide the
+ * whole page, instead of a page-level branch plus a function that covers only
+ * the half of the cases that reached the network.
+ */
+export type AccountLinkOutcome = AccountCallOutcome | { kind: 'no-token' };
+
+/**
+ * The single usable token in this URL, or null.
+ *
+ * Three ways to get null, each deliberate:
+ *
+ *  - ABSENT — the page was opened without a link (a typed URL, or a mail
+ *    client that dropped the query).
+ *  - BLANK — `?token=` or `?token=%20`. Surrounding whitespace is trimmed
+ *    because a mail client wrapping a long URL can deliver it padded and the
+ *    platform's tokens never contain whitespace; a value that is nothing but
+ *    padding is not a token.
+ *  - REPEATED — `?token=a&token=b` arrives as an array, and is REFUSED rather
+ *    than resolved to the first value. This is a one-shot credential: picking
+ *    one of two candidates would SPEND a real token on a guess about which one
+ *    the shopper meant, and the one that loses the guess is unrecoverable.
+ *    Nothing legitimate produces a repeat, so the honest answer is that this
+ *    URL carries no token the page may act on.
+ */
+export function readLinkToken(searchParams: RouteSearchParams): string | null {
+  const raw = searchParams[ACCOUNT_TOKEN_PARAM];
+  if (typeof raw === 'string') return trimmedOrNull(raw);
+  if (!Array.isArray(raw)) return null;
+  if (raw.length !== 1) return null;
+  return trimmedOrNull(raw[0]);
+}
+
+function trimmedOrNull(value: string): string | null {
+  const trimmed = value.trim();
+  return trimmed === '' ? null : trimmed;
+}

package/templates/storefront-shadcn-blank/src/lib/account/account-state.ts

@@ -0,0 +1,152 @@
+import type { AccountCallOutcome } from './account-link';
+
+/**
+ * What `/account` renders, as a value (#1093).
+ *
+ * PURE BY CONTRACT, for the reasons `account-link.ts` states. The panel owns the
+ * COPY; this module owns which view a given answer of the shop API IS, so every
+ * decision the sign-in surface makes is a table of vectors and the panel is a
+ * render.
+ *
+ * The page is a static shell and the session lives on the shopper's own socket,
+ * so nothing here is known at render time: the server paints `loading`, and the
+ * panel asks the socket who is signed in once the cart provider has armed it.
+ */
+
+/** The shopper a signed-in session belongs to, as the account page greets them. */
+export interface SignedInCustomer {
+  readonly firstName: string;
+  readonly lastName: string;
+  readonly emailAddress: string;
+}
+
+/**
+ * What the shop API answered when asked who this socket's session belongs to.
+ *
+ * `customer: null` is an ordinary answer, not an error: a socket carrying no
+ * session, and an anonymous cart session, both belong to nobody.
+ */
+export type ActiveCustomerOutcome =
+  | { kind: 'ok'; customer: SignedInCustomer | null }
+  | { kind: 'error'; code: string };
+
+/** The call a refusal answered — what the panel says went wrong. */
+export type AccountStep = 'greeting' | 'sign-in' | 'sign-out';
+
+/** A refusal the panel renders, with the call it answered. */
+export interface AccountRefusal {
+  readonly step: AccountStep;
+  readonly code: string;
+}
+
+/**
+ * The views of the account page — each `state` is the `data-fc-account-state`
+ * the panel stamps.
+ *
+ *  - `loading`    — the server render, and every client render until the
+ *                   socket has been asked. A skeleton, never the form: a
+ *                   returning customer must land on their greeting without a
+ *                   flash of the sign-in form first.
+ *  - `signed-out` — the sign-in form, with the refusal that put it there, if
+ *                   any.
+ *  - `signed-in`  — the greeting and the way out.
+ */
+export type AccountView =
+  | { readonly state: 'loading' }
+  | { readonly state: 'signed-out'; readonly refusal: AccountRefusal | null }
+  | { readonly state: 'signed-in'; readonly customer: SignedInCustomer };
+
+/** The view the server renders. */
+export const LOADING_VIEW: AccountView = { state: 'loading' };
+
+/**
+ * The codes that mean the session the socket presented is OVER: the API holds
+ * no session for the token (`SESSION_NOT_FOUND`), or the request carried none
+ * it could use (`UNAUTHORIZED` — the guard's answer for a token that resolves
+ * to no session).
+ *
+ * A session that is over is a shopper who is signed out, not a fault: the
+ * greeting renders the form without a message, and a sign-out that finds the
+ * session already gone has done what it was asked.
+ */
+const SESSION_GONE_CODES: ReadonlySet<string> = new Set(['UNAUTHORIZED', 'SESSION_NOT_FOUND']);
+
+/**
+ * The refusal of a sign-in whose session greets nobody: the credentials were
+ * accepted, but the session belongs to no customer of THIS store — the code
+ * `/verify`'s `wrong-store` state reads for the same situation.
+ */
+const NO_CUSTOMER_CODE = 'CUSTOMER_NOT_FOUND';
+
+/** The refusal that a confirmation mail answers. */
+const NOT_VERIFIED_CODE = 'NOT_VERIFIED';
+
+/** Whether a refusal says the session it was asked about no longer exists. */
+export function isSessionGone(code: string): boolean {
+  return SESSION_GONE_CODES.has(code);
+}
+
+/**
+ * The view the page lands in when it asks who is signed in on arrival.
+ *
+ * A session that greets nobody — none on the socket, an anonymous cart session,
+ * or one that is over — is the sign-in form with nothing to apologise for. Any
+ * other refusal is shown: the form still renders, because a shopper who cannot
+ * be greeted can still try to sign in.
+ */
+export function greetingView(outcome: ActiveCustomerOutcome): AccountView {
+  if (outcome.kind === 'ok' && outcome.customer !== null) {
+    return { state: 'signed-in', customer: outcome.customer };
+  }
+  if (outcome.kind === 'ok' || isSessionGone(outcome.code)) {
+    return { state: 'signed-out', refusal: null };
+  }
+  return { state: 'signed-out', refusal: { step: 'greeting', code: outcome.code } };
+}
+
+/**
+ * The view an ACCEPTED sign-in lands in, from the greeting asked right after it.
+ *
+ * Unlike {@link greetingView}, "nobody is signed in" is never a silent answer
+ * here: the shopper has just been told yes, so a session that greets nobody is
+ * a failed sign-in and is rendered as one. A session that is gone the moment it
+ * was minted is the #1089 signature — a socket still speaking for the session
+ * it opened with — and is shown with its code rather than folded away.
+ */
+export function signInView(outcome: ActiveCustomerOutcome): AccountView {
+  if (outcome.kind === 'error') {
+    return { state: 'signed-out', refusal: { step: 'sign-in', code: outcome.code } };
+  }
+  if (outcome.customer === null) {
+    return { state: 'signed-out', refusal: { step: 'sign-in', code: NO_CUSTOMER_CODE } };
+  }
+  return { state: 'signed-in', customer: outcome.customer };
+}
+
+/** The view a REFUSED sign-in lands in. */
+export function signInRefusedView(code: string): AccountView {
+  return { state: 'signed-out', refusal: { step: 'sign-in', code } };
+}
+
+/**
+ * The view a sign-out lands in. Always `signed-out` — the session helper has
+ * left this tab without a session whatever the API answered — and a refusal is
+ * shown only when the API could not confirm the session ended.
+ */
+export function signedOutView(outcome: AccountCallOutcome): AccountView {
+  if (outcome.kind === 'ok') return { state: 'signed-out', refusal: null };
+  return { state: 'signed-out', refusal: { step: 'sign-out', code: outcome.code } };
+}
+
+/**
+ * Whether the view offers to send the confirmation mail again: only after a
+ * sign-in the API refused because the account was never confirmed. Without it
+ * that shopper has nowhere to go — the mail they lost is the only key.
+ */
+export function offersVerificationResend(view: AccountView): boolean {
+  return (
+    view.state === 'signed-out' &&
+    view.refusal?.step === 'sign-in' &&
+    view.refusal.code === NOT_VERIFIED_CODE
+  );
+}