alepha 0.21.2 → 0.23.0

package/src/cli/core/tasks/BuildPrerenderTask.ts

@@ -4,11 +4,18 @@ import { FileSystemProvider } from "alepha/system";
 import { BuildTask, type BuildTaskContext } from "./BuildTask.ts";
 
 /**
- * Pre-render static pages defined in the Alepha application.
+ * Pre-render static pages and routes defined in the Alepha application.
  *
- * Queries all page primitives with `static: true` and generates
- * static HTML files for each page. Supports pages with parameterized
- * routes via `static.entries` configuration.
+ * Two passes, both writing into `dist/public`:
+ * - **pages** — every `$page` with `static: true` is rendered to an HTML file
+ *   (supports parameterized routes via `static.entries`).
+ * - **routes** — every `static` route primitive (a `$route({ static: true })`
+ *   or a `$sitemap`) is invoked in-process and its body written verbatim to
+ *   `{path}` (e.g. `sitemap.xml`, `robots.txt`).
+ *
+ * Both passes read the primitive registry and call a method on the already
+ * created primitive instances — no provider is re-injected, so this works in
+ * the build's configured-but-not-started container.
  */
 export class BuildPrerenderTask extends BuildTask {
   protected readonly fs = $inject(FileSystemProvider);
@@ -22,7 +29,8 @@ export class BuildPrerenderTask extends BuildTask {
     }
 
     const pages = this.getStaticPages(ctx);
-    if (pages.length === 0) {
+    const routes = this.getStaticRoutePrimitives(ctx);
+    if (pages.length === 0 && routes.length === 0) {
       return;
     }
 
@@ -31,13 +39,18 @@ export class BuildPrerenderTask extends BuildTask {
     const dist = this.fs.join(ctx.root, distDir, publicDir);
 
     await ctx.run({
-      name: "pre-render pages",
+      name: "pre-render",
       handler: async () => {
         // TODO: running configure here is a temporary workaround
         if (!ctx.alepha.isConfigured()) {
           await ctx.alepha.events.emit("configure", ctx.alepha);
         }
-        await this.prerenderFromAlepha(pages, dist);
+        if (pages.length > 0) {
+          await this.prerenderFromAlepha(pages, dist);
+        }
+        if (routes.length > 0) {
+          await this.prerenderRoutes(routes, dist);
+        }
       },
     });
   }
@@ -50,6 +63,18 @@ export class BuildPrerenderTask extends BuildTask {
     });
   }
 
+  /**
+   * Static route primitives to snapshot: `$route({ static: true })` and every
+   * `$sitemap`. Both expose an async `prerender(): { path, body }`.
+   */
+  protected getStaticRoutePrimitives(ctx: BuildTaskContext): any[] {
+    const routes = (ctx.alepha.primitives("route") as any[]).filter(
+      (route) => route.options?.static === true,
+    );
+    const sitemaps = ctx.alepha.primitives("sitemap") as any[];
+    return [...routes, ...sitemaps];
+  }
+
   protected async prerenderFromAlepha(
     pages: any[],
     dist: string,
@@ -77,6 +102,18 @@ export class BuildPrerenderTask extends BuildTask {
     return count;
   }
 
+  protected async prerenderRoutes(
+    primitives: any[],
+    dist: string,
+  ): Promise<void> {
+    for (const primitive of primitives) {
+      const { path, body } = await primitive.prerender();
+      const filepath = this.fs.join(dist, path);
+      await this.fs.mkdir(dirname(filepath));
+      await this.fs.writeFile(filepath, body);
+    }
+  }
+
   protected async renderFile(
     page: any,
     options: any,

package/src/cli/core/tasks/BuildTask.ts

@@ -2,6 +2,7 @@ import type { Alepha } from "alepha";
 import type { RunnerMethod } from "alepha/command";
 import type { BuildOptions } from "../atoms/buildOptions.ts";
 import type { AppEntry } from "../providers/AppEntryProvider.ts";
+import type { BuildManifest } from "./BuildCloudflareTask.ts";
 
 export interface BuildTaskContext {
   /**
@@ -43,6 +44,39 @@ export interface BuildTaskContext {
    * Raw CLI flags passed through from the command.
    * Tasks can read flags relevant to their domain.
    */
+  /**
+   * Build-time snapshot of primitive data, read from
+   * `dist/manifest.json`. Populated only in `--prebuilt` mode when a
+   * previous build's manifest is present — lets BuildCloudflareTask
+   * regenerate `wrangler.jsonc` without re-booting the workspace.
+   * `null` when introspection (`ctx.alepha`) is the source of truth.
+   */
+  manifest: BuildManifest | null;
+
+  /**
+   * Resolved `platform({ default, environments, ... })` options from
+   * the workspace's `alepha.config.ts`. Populated by `BuildCommand`
+   * from the CLI's Alepha instance (where alepha.config.ts ran) —
+   * BuildCloudflareTask uses these to write the corresponding fields
+   * into `dist/manifest.json` so the deploy side doesn't need to
+   * re-load `alepha.config.ts`. `null` when no platform options were
+   * declared.
+   */
+  platformOptions: {
+    default?: string;
+    tenancy?: "none" | "optional" | "required";
+    environments?: Record<
+      string,
+      {
+        adapter: "cloudflare" | "vercel";
+        domain?: string;
+        zone?: string;
+        jurisdiction?: "eu" | "fedramp";
+        accountId?: string;
+      }
+    >;
+  } | null;
+
   flags?: {
     image?: boolean | string;
     /**

package/src/cli/core/templates/apiIndexTs.ts

@@ -1,30 +1,9 @@
 export interface ApiIndexTsOptions {
   appName?: string;
-  /**
-   * Include `AlephaApiUsers` (realms, sessions, registration, identities,
-   * password reset, email verification, admin endpoints) plus the local
-   * `RealmProvider` that declares `$realm({ ... })`.
-   */
-  saas?: boolean;
 }
 
 export const apiIndexTs = (options: ApiIndexTsOptions = {}) => {
-  const { appName = "app", saas = false } = options;
-
-  if (saas) {
-    return `
-import { $module } from "alepha";
-import { AlephaApiUsers } from "alepha/api/users";
-import { HelloController } from "./controllers/HelloController.ts";
-import { RealmProvider } from "./providers/RealmProvider.ts";
-
-export const ApiModule = $module({
-  name: "${appName}.api",
-  services: [HelloController, RealmProvider],
-  imports: [AlephaApiUsers],
-});
-`.trim();
-  }
+  const { appName = "app" } = options;
 
   return `
 import { $module } from "alepha";

package/src/cli/core/templates/mainCss.ts

@@ -11,7 +11,6 @@ export const mainCss = (opts: { tailwind?: boolean } = {}) => {
  *
  * Options:
  * - Tailwind CSS: Use \`alepha init --tailwind\` to add Tailwind CSS
- * - shadcn/ui: Use \`alepha init --shadcn\` to add shadcn/ui setup
  * - Raw CSS: Write your own styles below
  */
 

package/src/cli/core/templates/webAppRouterTs.ts

@@ -1,16 +1,8 @@
 export interface WebAppRouterOptions {
   api?: boolean;
-  saas?: boolean;
 }
 
 export const webAppRouterTs = (options: WebAppRouterOptions) => {
-  if (options.saas) {
-    return saasAppRouterTs();
-  }
-  return basicAppRouterTs(options);
-};
-
-const basicAppRouterTs = (options: WebAppRouterOptions) => {
   const imports: string[] = ['import { $page } from "alepha/react/router";'];
   const classMembers: string[] = [];
 
@@ -39,94 +31,3 @@ export class AppRouter {
 ${classMembers.join("\n\n")}
 }`;
 };
-
-/**
- * SaaS router wires three trees onto the app:
- *   /            → Home
- *   /auth/*      → AuthLayout + login / register / reset / verify
- *   /admin/*     → AdminLayout + users / sessions / api-keys / parameters / audits
- *
- * Each auth page resolves the realm config from its loader, so the registry
- * components render with everything they need on first paint.
- */
-const saasAppRouterTs =
-  () => `import type { RealmController } from "alepha/api/users";
-import { $page, NotFound } from "alepha/react/router";
-import { $secure } from "alepha/security";
-import { $client } from "alepha/server/links";
-import type { HelloController } from "../api/controllers/HelloController.ts";
-
-export class AppRouter {
-  protected readonly api = $client<HelloController>();
-  protected readonly realmApi = $client<RealmController>();
-
-  home = $page({
-    path: "/",
-    lazy: () => import("./components/Home.tsx"),
-    loader: () => this.api.hello(),
-  });
-
-  // ── /auth — login, register, reset, verify ─────────────────────────────
-  authLayout = $page({
-    path: "/auth",
-    lazy: () => import("./components/auth/AuthLayout.tsx"),
-  });
-
-  login = $page({
-    parent: this.authLayout,
-    path: "/login",
-    name: "login",
-    head: { title: "Sign in" },
-    lazy: () => import("./components/auth/Login.tsx"),
-    loader: async () => ({ realmConfig: await this.realmApi.getRealmConfig() }),
-  });
-
-  register = $page({
-    parent: this.authLayout,
-    path: "/register",
-    name: "register",
-    head: { title: "Sign up" },
-    lazy: () => import("./components/auth/Register.tsx"),
-    loader: async () => ({ realmConfig: await this.realmApi.getRealmConfig() }),
-  });
-
-  resetPassword = $page({
-    parent: this.authLayout,
-    path: "/reset-password",
-    head: { title: "Reset password" },
-    lazy: () => import("./components/auth/ResetPassword.tsx"),
-    loader: async () => ({ realmConfig: await this.realmApi.getRealmConfig() }),
-  });
-
-  verifyEmail = $page({
-    parent: this.authLayout,
-    path: "/verify-email",
-    head: { title: "Verify email" },
-    lazy: () => import("./components/auth/VerifyEmail.tsx"),
-  });
-
-  // ── /admin — gated by 'admin:ui' permission, declared in RealmProvider.
-  // Children inherit the gate via the parent chain.
-  adminLayout = $page({
-    path: "/admin",
-    use: [$secure({ permissions: ["admin:ui"] })],
-    lazy: () => import("./components/admin/AdminLayout.tsx"),
-  });
-
-  adminUsers = $page({
-    parent: this.adminLayout,
-    path: "/users",
-    head: { title: "Users" },
-    lazy: () => import("./components/admin/Users.tsx"),
-  });
-
-  adminSessions = $page({
-    parent: this.adminLayout,
-    path: "/sessions",
-    head: { title: "Sessions" },
-    lazy: () => import("./components/admin/Sessions.tsx"),
-  });
-
-  notFound = $page({ path: "/*", component: NotFound });
-}
-`;

package/src/cli/core/templates/webIndexTs.ts

@@ -1,30 +1,9 @@
 export interface WebIndexTsOptions {
   appName?: string;
-  /**
-   * SaaS bundle: auth pages need `useAuth()` (ReactAuth) which lives in the
-   * `alepha.react.auth` module. Importing it here registers ReactAuth in the
-   * container so the auth-* registry components can inject it.
-   */
-  saas?: boolean;
 }
 
 export const webIndexTs = (options: WebIndexTsOptions = {}) => {
-  const { appName = "app", saas = false } = options;
-
-  if (saas) {
-    return `
-import { $module } from "alepha";
-import { AlephaReactAuth } from "alepha/react/auth";
-import { AlephaReactI18n } from "alepha/react/i18n";
-import { AppRouter } from "./AppRouter.ts";
-
-export const WebModule = $module({
-  name: "${appName}.web",
-  services: [AppRouter],
-  imports: [AlephaReactAuth, AlephaReactI18n],
-});
-`.trim();
-  }
+  const { appName = "app" } = options;
 
   return `
 import { $module } from "alepha";

package/src/cli/i18n/__tests__/I18nCheckService.spec.ts

@@ -109,6 +109,54 @@ ${body}
     expect(result.unused).toEqual(["home.title"]);
   });
 
+  it("extracts keys from lazily-imported per-language files", async () => {
+    await env.fs.mkdir(`${ROOT}/src/web/i18n`, { recursive: true });
+    // Marker file declares `$dictionary` but the keys live in split,
+    // markerless per-language files referenced via `lazy: () => import(...)`.
+    // A sibling `$page` lazy import must NOT be mistaken for a key file.
+    await env.fs.writeFile(
+      `${ROOT}/src/web/Router.ts`,
+      `import { $dictionary } from "alepha/react/i18n";
+export class Router {
+  fr = $dictionary({ lazy: () => import("./i18n/fr.ts"), lang: "fr" });
+  en = $dictionary({ lazy: () => import("./i18n/en.ts"), lang: "en" });
+  page = $page({ lazy: () => import("./Home.tsx") });
+}
+`,
+    );
+    await env.fs.writeFile(
+      `${ROOT}/src/web/i18n/fr.ts`,
+      `export default { "home.title": "Accueil", "home.unused": "Rien" };`,
+    );
+    await env.fs.writeFile(
+      `${ROOT}/src/web/i18n/en.ts`,
+      `export default { "home.title": "Home", "home.unused": "Nothing" };`,
+    );
+    // The only reference — `home.unused` is dead in both languages. The
+    // `"home.title": "…"` lines in the sibling language file must not count
+    // as references (key files are excluded from the usage corpus).
+    await env.fs.writeFile(
+      `${ROOT}/src/web/Home.tsx`,
+      `export const Home = () => tr("home.title");`,
+    );
+
+    const result = await env.service.check({
+      root: ROOT,
+      scan: ["src"],
+      dynamicPrefixes: [],
+      exclude: [],
+    });
+
+    expect(result.totalKeys).toBe(2);
+    expect(result.unused).toEqual(["home.unused"]);
+    // The resolved language file is treated as a dictionary; the sibling
+    // `$page` lazy import is not (it contributed no keys and stays in the
+    // usage corpus). `en.ts` is also a dictionary file but adds no *new*
+    // keys, so only the first contributor is listed.
+    expect(result.dictionaryFiles).toContain(`${ROOT}/src/web/i18n/fr.ts`);
+    expect(result.dictionaryFiles).not.toContain(`${ROOT}/src/web/Home.tsx`);
+  });
+
   it("returns totalKeys=0 when no dictionary is found", async () => {
     await env.fs.mkdir(`${ROOT}/src`, { recursive: true });
     await env.fs.writeFile(

package/src/cli/i18n/services/I18nCheckService.ts

@@ -35,6 +35,22 @@ const KEY_DECLARATION_RE = /"([\w-]+(?:\.[\w-]+)+)"\s*:/g;
  */
 const DICTIONARY_MARKER = "$dictionary";
 
+/**
+ * Captures the module specifier of a lazily-imported dictionary, i.e. the
+ * `"./fr.ts"` in `$dictionary({ lazy: () => import("./fr.ts") })`. Apps
+ * commonly split each language into its own file so a session only ships the
+ * active locale — those key files carry no `$dictionary` marker, so without
+ * this the keys would be invisible to the check.
+ *
+ * `[^{}]*?` keeps the match inside the `$dictionary` call's own object literal
+ * (it stops at the first brace), so unrelated lazy imports in the same file —
+ * e.g. a sibling `$page({ lazy: () => import("./Page.tsx") })` or a
+ * `$dictionary` whose `lazy` returns an inline `({ default: {…} })` object —
+ * are never mistaken for dictionary key files.
+ */
+const DICTIONARY_LAZY_IMPORT_RE =
+  /\$dictionary\s*\(\s*\{[^{}]*?import\s*\(\s*["']([^"']+)["']/g;
+
 export interface I18nCheckOptions {
   root: string;
   scan: string[];
@@ -62,11 +78,11 @@ export class I18nCheckService {
    * Find unused translation keys.
    *
    * Discovery is fully static: we walk `scan` dirs, identify files
-   * that import `$dictionary` (matched via the literal substring),
-   * extract every `"a.b.c": ...` property key declared in them, then
-   * grep the remaining source files for a quoted-literal occurrence
-   * of each key. Anything matching a `dynamicPrefixes` entry is
-   * exempted.
+   * that import `$dictionary` (matched via the literal substring) plus
+   * any per-language files they lazily `import(...)`, extract every
+   * `"a.b.c": ...` property key declared across them, then grep the
+   * remaining source files for a quoted-literal occurrence of each key.
+   * Anything matching a `dynamicPrefixes` entry is exempted.
    */
   async check(options: I18nCheckOptions): Promise<I18nCheckResult> {
     const { root, scan, dynamicPrefixes, exclude } = options;
@@ -91,14 +107,31 @@ export class I18nCheckService {
       }
     }
 
-    const dictionaryFiles: string[] = [];
-    const allKeys = new Set<string>();
     const fileContents = new Map<string, string>();
-
     for (const file of allFiles) {
-      const text = (await this.fs.readFile(file)).toString("utf8");
-      fileContents.set(file, text);
+      fileContents.set(file, (await this.fs.readFile(file)).toString("utf8"));
+    }
+
+    // A file is a dictionary if it declares `$dictionary` OR it is the target
+    // of a `$dictionary({ lazy: () => import("…") })` (the split per-language
+    // key files, which carry no marker of their own). Resolving the lazy
+    // targets first lets their keys be extracted below and keeps them out of
+    // the usage corpus (their `"key": "value"` lines aren't references).
+    const dictionarySet = new Set<string>();
+    for (const [file, text] of fileContents) {
       if (!text.includes(DICTIONARY_MARKER)) continue;
+      dictionarySet.add(file);
+      for (const m of text.matchAll(DICTIONARY_LAZY_IMPORT_RE)) {
+        const target = this.resolveImport(file, m[1], fileContents);
+        if (target) dictionarySet.add(target);
+      }
+    }
+
+    const dictionaryFiles: string[] = [];
+    const allKeys = new Set<string>();
+    for (const file of dictionarySet) {
+      const text = fileContents.get(file);
+      if (!text) continue;
       const before = allKeys.size;
       for (const m of text.matchAll(KEY_DECLARATION_RE)) {
         allKeys.add(m[1]);
@@ -108,7 +141,6 @@ export class I18nCheckService {
 
     // Concatenate every non-dictionary file into one corpus so each
     // key is tested with a single regex run rather than O(files × keys).
-    const dictionarySet = new Set(dictionaryFiles);
     const corpusParts: string[] = [];
     let scannedFiles = 0;
     for (const [file, text] of fileContents) {
@@ -141,4 +173,26 @@ export class I18nCheckService {
       unused: unused.sort(),
     };
   }
+
+  /**
+   * Resolve a relative `import("…")` specifier from `fromFile` to an absolute
+   * path that was actually scanned. Returns `undefined` for bare/package
+   * specifiers or targets outside the scan set. Extensionless specifiers are
+   * probed against each supported source extension.
+   */
+  protected resolveImport(
+    fromFile: string,
+    spec: string,
+    files: Map<string, string>,
+  ): string | undefined {
+    if (!spec.startsWith(".")) return undefined;
+    // `join(file, "..", spec)` drops the filename then applies the relative
+    // specifier — i.e. resolves against `fromFile`'s directory.
+    const base = this.fs.join(fromFile, "..", spec);
+    if (files.has(base)) return base;
+    for (const ext of SCAN_EXTS) {
+      if (files.has(base + ext)) return base + ext;
+    }
+    return undefined;
+  }
 }

package/src/cli/platform/__tests__/SecretsCommand.spec.ts

@@ -1,11 +1,13 @@
 import { Alepha } from "alepha";
+import {
+  MemorySecretStore,
+  platformOptions,
+  type SecretStoreProvider,
+} from "alepha/cli/platform-lib";
 import { CliProvider } from "alepha/command";
 import { FileSystemProvider, MemoryFileSystemProvider } from "alepha/system";
 import { describe, test } from "vitest";
-import { platformOptions } from "../atoms/platformOptions.ts";
 import { SecretsCommand } from "../commands/SecretsCommand.ts";
-import { MemorySecretStore } from "../providers/MemorySecretStore.ts";
-import type { SecretStoreProvider } from "../providers/SecretStoreProvider.ts";
 
 class TestSecretsCommand extends SecretsCommand {
   public readonly testList = this.list;

package/src/cli/platform/commands/SecretsCommand.ts

@@ -1,12 +1,14 @@
 import { $inject, $state, AlephaError, t } from "alepha";
+import {
+  GitHubSecretStore,
+  NamingService,
+  PlatformInspector,
+  platformOptions,
+  SecretFilterService,
+  type SecretStoreProvider,
+} from "alepha/cli/platform-lib";
 import { $command, EnvUtils } from "alepha/command";
 import { $logger, ConsoleColorProvider } from "alepha/logger";
-import { platformOptions } from "../atoms/platformOptions.ts";
-import { GitHubSecretStore } from "../providers/GitHubSecretStore.ts";
-import type { SecretStoreProvider } from "../providers/SecretStoreProvider.ts";
-import { NamingService } from "../services/NamingService.ts";
-import { PlatformInspector } from "../services/PlatformInspector.ts";
-import { SecretFilterService } from "../services/SecretFilterService.ts";
 
 export class SecretsCommand {
   protected readonly log = $logger();