alepha 0.15.0 → 0.15.2

package/src/cli/apps/AlephaPackageBuilderCli.ts

@@ -3,7 +3,7 @@ import * as os from "node:os";
 import { join } from "node:path";
 import { $inject, AlephaError } from "alepha";
 import { $command } from "alepha/command";
-import { FileSystemProvider } from "alepha/file";
+import { FileSystemProvider } from "alepha/system";
 import type { InlineConfig } from "tsdown";
 
 interface Module {
@@ -110,6 +110,7 @@ export class AlephaPackageBuilderCli {
           sourcemap: true,
           fixedExtension: false,
           platform: "node", // TODO: node must be enabled only if index.node.ts exists
+          inlineOnly: false,
           external,
           dts: {
             sourcemap: true,
@@ -123,6 +124,7 @@ export class AlephaPackageBuilderCli {
             platform: "neutral",
             sourcemap: true,
             dts: false,
+            inlineOnly: false,
             external,
           });
         }
@@ -134,6 +136,7 @@ export class AlephaPackageBuilderCli {
             platform: "browser",
             sourcemap: true,
             dts: false,
+            inlineOnly: false,
             external,
           });
         }
@@ -146,6 +149,7 @@ export class AlephaPackageBuilderCli {
             sourcemap: true,
             fixedExtension: false,
             dts: false,
+            inlineOnly: false,
             external,
           });
         }
@@ -158,8 +162,10 @@ export class AlephaPackageBuilderCli {
           config,
           `export default ${JSON.stringify(entries, null, 2)};`,
         );
+
+        // /!\ Warning /!\
+        // avoid to call tsdown programmatically, when we spawn 8 processes at once it 'JavaScript heap out of memory' :---)
         await run(`npx tsdown -c=${config}`);
-        //await this.fs.rm(config);
       };
 
       const concurrency = Math.ceil(os.cpus().length / 2);
@@ -183,6 +189,8 @@ export class AlephaPackageBuilderCli {
   });
 }
 
+export default AlephaPackageBuilderCli;
+
 async function getAllFiles(dir: string): Promise<string[]> {
   const files: string[] = [];
 

package/src/cli/atoms/appEntryOptions.ts

@@ -0,0 +1,13 @@
+import { $atom, type Static, t } from "alepha";
+
+export const appEntryOptions = $atom({
+  name: "alepha.cli.appEntry.options",
+  schema: t.object({
+    server: t.optional(t.text()),
+    browser: t.optional(t.text()),
+    style: t.optional(t.text()),
+  }),
+  default: {},
+});
+
+export type AppEntryOptions = Static<typeof appEntryOptions.schema>;

package/src/cli/atoms/buildOptions.ts

@@ -8,7 +8,7 @@ import { $atom } from "../../core/primitives/$atom.ts";
  * Options can be overridden via vite.config.ts or CLI flags.
  */
 export const buildOptions = $atom({
-  name: "alepha.build.options",
+  name: "alepha.cli.build.options",
   description: "Build configuration options",
   schema: t.object({
     /**

package/src/cli/atoms/changelogOptions.ts

@@ -29,7 +29,7 @@ export const DEFAULT_IGNORE = [
  * ```
  */
 export const changelogOptions = $atom({
-  name: "alepha.changelog",
+  name: "alepha.cli.changelog.options",
   schema: t.object({
     /**
      * Scopes to ignore (e.g., "project", "release", "chore").

package/src/cli/commands/build.ts

@@ -1,9 +1,8 @@
-import { $inject, $use, t } from "alepha";
+import { $inject, $use, type Alepha, AlephaError, t } from "alepha";
 import { $command } from "alepha/command";
-import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
+import { FileSystemProvider } from "alepha/system";
 import {
-  boot,
   buildClient,
   buildServer,
   copyAssets,
@@ -14,6 +13,8 @@ import {
   prerenderPages,
 } from "alepha/vite";
 import { buildOptions } from "../atoms/buildOptions.ts";
+import { AppEntryProvider } from "../providers/AppEntryProvider.ts";
+import { ViteBuildProvider } from "../providers/ViteBuildProvider.ts";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
 import { ProjectScaffolder } from "../services/ProjectScaffolder.ts";
@@ -24,15 +25,14 @@ export class BuildCommand {
   protected readonly utils = $inject(AlephaCliUtils);
   protected readonly pm = $inject(PackageManagerUtils);
   protected readonly scaffolder = $inject(ProjectScaffolder);
+  protected readonly boot = $inject(AppEntryProvider);
+  protected readonly viteBuildProvider = $inject(ViteBuildProvider);
   protected readonly options = $use(buildOptions);
 
   public readonly build = $command({
     name: "build",
     mode: "production",
     description: "Build the project for production",
-    args: t.optional(
-      t.text({ title: "path", description: "Filepath to build" }),
-    ),
     flags: t.object({
       stats: t.optional(
         t.boolean({
@@ -65,9 +65,7 @@ export class BuildCommand {
         }),
       ),
     }),
-    handler: async ({ flags, args, run, root }) => {
-      // Tell viteAlephaBuild plugin to skip - CLI handles all tasks
-      process.env.ALEPHA_BUILD_MODE = "cli";
+    handler: async ({ flags, run, root }) => {
       process.env.NODE_ENV = "production";
 
       if (await this.pm.hasExpo(root)) {
@@ -79,43 +77,67 @@ export class BuildCommand {
         tsconfigJson: true,
       });
 
-      const entry = await boot.getServerEntry(root, args);
+      const entry = await this.boot.getAppEntry(root);
       this.log.trace("Entry file found", { entry });
 
       const distDir = "dist";
-      const clientDir = "public";
+      const publicDir = "public";
 
-      await this.pm.ensureDependency(root, "vite", {
-        run,
-        exec: (cmd, opts) => this.utils.exec(cmd, opts),
-      });
       await run.rm("dist", { alias: "clean dist" });
 
       const options = this.options;
       await this.utils.loadEnv(root, [".env", ".env.production"]);
 
       const stats = flags.stats ?? options.stats ?? false;
-      const hasClient = await this.fs.exists(this.fs.join(root, "index.html"));
+      let template = "";
+      let hasClient = false;
+      let alepha: Alepha | undefined;
+
+      await run({
+        name: "analyze app",
+        handler: async () => {
+          alepha = await this.viteBuildProvider.init({ entry });
+          hasClient = this.viteBuildProvider.hasClient();
+          if (hasClient) {
+            template = this.viteBuildProvider.generateIndexHtml();
+          }
+        },
+      });
+
+      if (!alepha) {
+        throw new AlephaError("Alepha instance not found");
+      }
 
       // Build client (precompress always enabled)
       if (hasClient) {
-        await run({
-          name: "vite build client",
-          handler: () =>
-            buildClient({
-              silent: true,
-              dist: `${distDir}/${clientDir}`,
-              stats,
-              precompress: true,
-            }),
-        });
+        // TODO: find a way to avoid writing index.html to disk
+        const indexHtmlPath = this.fs.join(root, "index.html");
+        await this.fs.writeFile(indexHtmlPath, template);
+        try {
+          await run({
+            name: "vite build client",
+            handler: () =>
+              buildClient({
+                silent: true,
+                dist: `${distDir}/${publicDir}`,
+                stats,
+                precompress: true,
+              }),
+          });
+        } finally {
+          await this.fs.rm(indexHtmlPath);
+        }
       }
 
       // Build server
       await run({
         name: "vite build server",
         handler: async () => {
-          const clientIndexPath = `${distDir}/${clientDir}/index.html`;
+          if (!alepha) {
+            throw new AlephaError("Alepha instance not found");
+          }
+
+          const clientIndexPath = `${distDir}/${publicDir}/index.html`;
           const clientBuilt = await this.fs.exists(clientIndexPath);
 
           const conditions: string[] = [];
@@ -131,19 +153,18 @@ export class BuildCommand {
           // workerd:
           // - react-dom
           // - postgres
-
-          // TODO: investigate if we have more conditions like 'edge' to add here
           if (options.cloudflare) {
             conditions.push("workerd");
           }
 
           await buildServer({
             silent: true,
-            entry,
+            entry: entry.server,
             distDir,
-            clientDir: clientBuilt ? clientDir : undefined,
+            clientDir: clientBuilt ? publicDir : undefined,
             stats,
             conditions,
+            alepha,
           });
 
           // Server will handle index.html if both client & server are built
@@ -155,6 +176,7 @@ export class BuildCommand {
 
       // Copy assets
       await copyAssets({
+        alepha,
         root,
         entry: `${distDir}/index.js`,
         distDir,
@@ -165,30 +187,20 @@ export class BuildCommand {
         // Generate sitemap
         const sitemapHostname = flags.sitemap ?? options.sitemap?.hostname;
         if (sitemapHostname) {
-          await run({
-            name: "add sitemap",
-            handler: async () => {
-              await this.fs.writeFile(
-                `${distDir}/${clientDir}/sitemap.xml`,
-                await generateSitemap({
-                  entry: `${distDir}/index.js`,
-                  baseUrl: sitemapHostname,
-                }),
-              );
-            },
+          await generateSitemap({
+            alepha,
+            baseUrl: sitemapHostname,
+            output: `${distDir}/${publicDir}/sitemap.xml`,
+            run,
           });
         }
 
         // Pre-render static pages (always enabled)
-        await run({
-          name: "pre-render pages",
-          handler: async () => {
-            await prerenderPages({
-              dist: `${distDir}/${clientDir}`,
-              entry: `${distDir}/index.js`,
-              compress: true,
-            });
-          },
+        await prerenderPages({
+          alepha,
+          dist: `${distDir}/${publicDir}`,
+          compress: true,
+          run,
         });
       }
 
@@ -199,7 +211,7 @@ export class BuildCommand {
           handler: () =>
             generateVercel({
               distDir,
-              clientDir,
+              clientDir: publicDir,
               config: options.vercel,
             }),
         });

package/src/cli/commands/db.ts

@@ -1,12 +1,13 @@
 import { $inject, AlephaError, t } from "alepha";
 import { $command } from "alepha/command";
-import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
 import type {
   DatabaseProvider,
   DrizzleKitProvider,
   RepositoryProvider,
 } from "alepha/orm";
+import { FileSystemProvider } from "alepha/system";
+import { AppEntryProvider } from "../providers/AppEntryProvider.ts";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
 const drizzleCommandFlags = t.object({
@@ -28,6 +29,7 @@ export class DbCommand {
   protected readonly log = $logger();
   protected readonly fs = $inject(FileSystemProvider);
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly entryProvider = $inject(AppEntryProvider);
 
   /**
    * Check if database migrations are up to date.
@@ -46,10 +48,11 @@ export class DbCommand {
       const rootDir = root;
       this.log.debug(`Using project root: ${rootDir}`);
 
-      const { alepha } = await this.utils.loadAlephaFromServerEntryFile(
-        rootDir,
-        args,
-      );
+      const entry = await this.entryProvider.getAppEntry(root);
+      const alepha = await this.utils.loadAlephaFromServerEntryFile({
+        mode: "development",
+        entry,
+      });
 
       const repositoryProvider =
         alepha.inject<RepositoryProvider>("RepositoryProvider");
@@ -276,10 +279,11 @@ export class DbCommand {
 
     this.log.debug(`Using project root: ${rootDir}`);
 
-    const { alepha, entry } = await this.utils.loadAlephaFromServerEntryFile(
-      rootDir,
-      options.args,
-    );
+    const entry = await this.entryProvider.getAppEntry(rootDir);
+    const alepha = await this.utils.loadAlephaFromServerEntryFile({
+      mode: "development",
+      entry,
+    });
 
     const drizzleKitProvider =
       alepha.inject<DrizzleKitProvider>("DrizzleKitProvider");
@@ -319,7 +323,7 @@ export class DbCommand {
         providerUrl: provider.url,
         providerDriver: provider.driver,
         dialect,
-        entry,
+        entry: this.fs.join(rootDir, entry.server),
         rootDir,
       });
 
@@ -328,7 +332,9 @@ export class DbCommand {
         `drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`,
         {
           env: {
-            NODE_OPTIONS: "--import tsx",
+            NODE_OPTIONS: [process.env.NODE_OPTIONS, "--import tsx"]
+              .filter(Boolean)
+              .join(" "),
           },
         },
       );

package/src/cli/commands/deploy.ts

@@ -1,7 +1,7 @@
 import { $inject, AlephaError, t } from "alepha";
 import { $command } from "alepha/command";
-import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
+import { FileSystemProvider } from "alepha/system";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
 

package/src/cli/commands/dev.ts

@@ -1,8 +1,9 @@
-import { $inject, Alepha, t } from "alepha";
+import { $inject, Alepha } from "alepha";
 import { $command } from "alepha/command";
-import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
-import { boot, devServer } from "alepha/vite";
+import { FileSystemProvider } from "alepha/system";
+import { AppEntryProvider } from "../providers/AppEntryProvider.ts";
+import { ViteDevServerProvider } from "../providers/ViteDevServerProvider.ts";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
 import { ProjectScaffolder } from "../services/ProjectScaffolder.ts";
@@ -14,64 +15,27 @@ export class DevCommand {
   protected readonly pm = $inject(PackageManagerUtils);
   protected readonly scaffolder = $inject(ProjectScaffolder);
   protected readonly alepha = $inject(Alepha);
+  protected readonly viteDevServer = $inject(ViteDevServerProvider);
+  protected readonly boot = $inject(AppEntryProvider);
 
   /**
    * Will run the project in watch mode.
-   *
-   * - If an index.html file is found in the project root, it will run Vite in dev mode.
-   * - Otherwise, it will look for a server entry file and run it with tsx in watch mode.
    */
   public readonly dev = $command({
     name: "dev",
     description: "Run the project in development mode",
-    args: t.optional(t.text({ title: "path", description: "Filepath to run" })),
-    handler: async ({ args, root }) => {
-      const expo = await this.pm.hasExpo(root);
-
+    handler: async ({ root }) => {
       await this.scaffolder.ensureConfig(root, {
         tsconfigJson: true,
       });
 
-      if (expo) {
-        await this.utils.exec("expo start");
-        return;
-      }
-
-      const entry = await boot.getServerEntry(root, args);
-      this.log.trace("Entry file found", { entry });
-
-      const isFullstack = await this.isFullstackProject(root);
-
-      if (!isFullstack) {
-        const exe = (await this.isBunProject(root)) ? "bun" : "tsx";
-        let cmd = `${exe} --watch`;
-        if (await this.utils.exists(root, ".env")) {
-          cmd += " --env-file=./.env";
-        }
-        cmd += ` ${entry}`;
-        await this.utils.exec(cmd, {
-          global: exe === "bun",
-        });
-        return;
-      }
+      const entry = await this.boot.getAppEntry(root);
+      this.log.debug("Entry file found", { entry });
 
-      // Ensure vite is installed before running
-      await this.pm.ensureDependency(root, "vite", {
-        exec: (cmd, opts) => this.utils.exec(cmd, opts),
-      });
-
-      await devServer();
+      // -> here, we assume we use Vite as runner (api or fullstack)
+      // but it's planned to support Bun runner in the future as well
+      await this.viteDevServer.init({ root, entry });
+      await this.viteDevServer.start();
     },
   });
-
-  protected async isBunProject(root: string): Promise<boolean> {
-    if (this.alepha.isBun()) {
-      return true;
-    }
-    return this.fs.exists(this.fs.join(root, "bun.lock"));
-  }
-
-  protected async isFullstackProject(root: string): Promise<boolean> {
-    return this.fs.exists(this.fs.join(root, "index.html"));
-  }
 }

package/src/cli/commands/gen/env.ts

@@ -1,7 +1,7 @@
 import { $inject, t } from "alepha";
 import { $command } from "alepha/command";
-import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
+import { FileSystemProvider } from "alepha/system";
 import { AlephaCliUtils } from "../../services/AlephaCliUtils.ts";
 
 export class GenEnvCommand {
@@ -21,7 +21,10 @@ export class GenEnvCommand {
       ),
     }),
     handler: async ({ root, flags }) => {
-      const { alepha } = await this.utils.loadAlephaFromServerEntryFile(root);
+      const alepha = await this.utils.loadAlephaFromServerEntryFile({
+        root,
+        mode: "development",
+      });
 
       try {
         const { env } = alepha.dump();
@@ -37,7 +40,7 @@ export class GenEnvCommand {
           if (value.enum) {
             dotEnvFile += `# Possible values: ${value.enum.join(", ")}\n`;
           }
-          dotEnvFile += `${key}=${value.default || ""}\n\n`;
+          dotEnvFile += `#${key}=${value.default || ""}\n\n`;
         }
 
         if (flags.out) {

package/src/cli/commands/gen/openapi.ts

@@ -1,8 +1,8 @@
 import { $inject, t } from "alepha";
 import { $command } from "alepha/command";
-import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
 import { ServerSwaggerProvider } from "alepha/server/swagger";
+import { FileSystemProvider } from "alepha/system";
 import { AlephaCliUtils } from "../../services/AlephaCliUtils.ts";
 
 export class OpenApiCommand {
@@ -22,7 +22,10 @@ export class OpenApiCommand {
       ),
     }),
     handler: async ({ root, flags }) => {
-      const { alepha } = await this.utils.loadAlephaFromServerEntryFile(root);
+      const alepha = await this.utils.loadAlephaFromServerEntryFile({
+        root,
+        mode: "development",
+      });
 
       try {
         const openapiProvider = alepha.inject(