alepha 0.14.4 → 0.15.1

package/src/cli/commands/build.ts

@@ -1,10 +1,8 @@
-import { access, readFile, unlink, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-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 {
-  boot,
   buildClient,
   buildServer,
   copyAssets,
@@ -15,20 +13,26 @@ 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";
 
 export class BuildCommand {
   protected readonly log = $logger();
+  protected readonly fs = $inject(FileSystemProvider);
   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({
@@ -55,86 +59,128 @@ export class BuildCommand {
           description: "Generate sitemap.xml with base URL",
         }),
       ),
+      bun: t.optional(
+        t.boolean({
+          description: "Prioritize .bun.ts entry files for Bun runtime",
+        }),
+      ),
     }),
-    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.utils.hasExpo(root)) {
+      if (await this.pm.hasExpo(root)) {
         // will come soon
         return;
       }
 
-      await this.utils.ensureConfig(root, {
+      await this.scaffolder.ensureConfig(root, {
         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.utils.ensureDependency(root, "vite", { run });
+      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;
-
+      let template = "";
       let hasClient = false;
-      try {
-        await access(join(root, "index.html"));
-        hasClient = true;
-      } catch {
-        // No index.html
+      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 () => {
-          let clientBuilt = false;
-          try {
-            await readFile(`${distDir}/${clientDir}/index.html`, "utf-8");
-            clientBuilt = true;
-          } catch {
-            // No client build
+          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[] = [];
+
+          // bun:
+          // - alepha
+          // - react-dom
+
+          if (flags.bun) {
+            conditions.push("bun");
+          }
+
+          // workerd:
+          // - react-dom
+          // - postgres
+          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
           if (clientBuilt) {
-            await unlink(`${distDir}/${clientDir}/index.html`);
+            await this.fs.rm(clientIndexPath);
           }
         },
       });
 
       // Copy assets
       await copyAssets({
+        alepha,
         root,
         entry: `${distDir}/index.js`,
         distDir,
@@ -145,30 +191,20 @@ export class BuildCommand {
         // Generate sitemap
         const sitemapHostname = flags.sitemap ?? options.sitemap?.hostname;
         if (sitemapHostname) {
-          await run({
-            name: "add sitemap",
-            handler: async () => {
-              await 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,
         });
       }
 
@@ -179,7 +215,7 @@ export class BuildCommand {
           handler: () =>
             generateVercel({
               distDir,
-              clientDir,
+              clientDir: publicDir,
               config: options.vercel,
             }),
         });

package/src/cli/commands/db.ts

@@ -1,7 +1,6 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
 import { $inject, AlephaError, t } from "alepha";
 import { $command } from "alepha/command";
+import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
 import type {
   DatabaseProvider,
@@ -27,6 +26,7 @@ const drizzleCommandFlags = t.object({
 
 export class DbCommand {
   protected readonly log = $logger();
+  protected readonly fs = $inject(FileSystemProvider);
   protected readonly utils = $inject(AlephaCliUtils);
 
   /**
@@ -66,26 +66,23 @@ export class DbCommand {
 
         accepted.add(providerName);
 
-        const migrationDir = join(rootDir, "migrations", providerName);
+        const migrationDir = this.fs.join(rootDir, "migrations", providerName);
 
-        const journalFile = await readFile(
-          `${migrationDir}/meta/_journal.json`,
-          "utf-8",
-        ).catch(() => null);
+        const journalBuffer = await this.fs
+          .readFile(`${migrationDir}/meta/_journal.json`)
+          .catch(() => null);
 
-        if (!journalFile) {
+        if (!journalBuffer) {
           this.log.info("No migration journal found.");
           return;
         }
 
-        const journal = JSON.parse(journalFile);
+        const journal = JSON.parse(journalBuffer.toString("utf-8"));
         const lastMigration = journal.entries[journal.entries.length - 1];
-        const lastSnapshot = JSON.parse(
-          await readFile(
-            `${migrationDir}/meta/${String(lastMigration.idx).padStart(4, "0")}_snapshot.json`,
-            "utf-8",
-          ),
+        const snapshotBuffer = await this.fs.readFile(
+          `${migrationDir}/meta/${String(lastMigration.idx).padStart(4, "0")}_snapshot.json`,
         );
+        const lastSnapshot = JSON.parse(snapshotBuffer.toString("utf-8"));
 
         const models = drizzleKitProvider.getModels(provider);
         const kit = drizzleKitProvider.importDrizzleKit();
@@ -295,6 +292,10 @@ export class DbCommand {
       const providerName = provider.name;
       const dialect = provider.dialect;
 
+      if (providerName === "") {
+        continue;
+      }
+
       if (accepted.has(providerName)) {
         continue;
       }
@@ -316,6 +317,7 @@ export class DbCommand {
         provider,
         providerName,
         providerUrl: provider.url,
+        providerDriver: provider.driver,
         dialect,
         entry,
         rootDir,
@@ -341,6 +343,7 @@ export class DbCommand {
     provider: DatabaseProvider;
     providerName: string;
     providerUrl: string;
+    providerDriver: string;
     dialect: string;
     entry: string;
     rootDir: string;
@@ -371,16 +374,16 @@ export class DbCommand {
       config.schemaFilter = options.provider.schema;
     }
 
-    if (options.providerName === "d1") {
+    if (options.providerDriver === "d1") {
       config.driver = "d1-http";
     }
 
-    if (options.providerName === "pglite") {
+    if (options.providerDriver === "pglite") {
       config.driver = "pglite";
     }
 
     if (options.dialect === "sqlite") {
-      if (options.providerName === "d1") {
+      if (options.providerDriver === "d1") {
         const token = process.env.CLOUDFLARE_API_TOKEN;
         if (!token) {
           throw new AlephaError(
@@ -421,7 +424,7 @@ export class DbCommand {
       } else {
         let url = options.providerUrl;
         url = url.replace("sqlite://", "").replace("file://", "");
-        url = join(options.rootDir, url);
+        url = this.fs.join(options.rootDir, url);
 
         config.dbCredentials = {
           url,

package/src/cli/commands/deploy.ts

@@ -1,12 +1,15 @@
-import { join } from "node:path";
 import { $inject, AlephaError, t } from "alepha";
 import { $command } from "alepha/command";
+import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
 
 export class DeployCommand {
   protected readonly log = $logger();
+  protected readonly fs = $inject(FileSystemProvider);
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly pm = $inject(PackageManagerUtils);
 
   /**
    * Deploy the project to a hosting platform (e.g., Vercel, Cloudflare, Surge)
@@ -79,7 +82,10 @@ export class DeployCommand {
           this.log.debug("Running database migrations before deployment...");
           await this.utils.exec(`alepha db migrate --mode=${mode}`);
         }
-        await this.utils.ensureDependency(root, "vercel", { dev: true });
+        await this.pm.ensureDependency(root, "vercel", {
+          dev: true,
+          exec: (cmd, opts) => this.utils.exec(cmd, opts),
+        });
         const command =
           `vercel . --cwd=dist ${mode === "production" ? "--prod" : ""}`.trim();
         this.log.debug(`Deploying to Vercel with command: ${command}`);
@@ -93,7 +99,10 @@ export class DeployCommand {
           this.log.debug("Running database migrations before deployment...");
           await this.utils.exec(`alepha db migrate --mode=${mode}`);
         }
-        await this.utils.ensureDependency(root, "wrangler", { dev: true });
+        await this.pm.ensureDependency(root, "wrangler", {
+          dev: true,
+          exec: (cmd, opts) => this.utils.exec(cmd, opts),
+        });
         const command =
           `wrangler deploy ${mode === "production" ? "" : "--env preview"} --config=dist/wrangler.jsonc`.trim();
         this.log.info(`Deploying to Cloudflare with command: ${command}`);
@@ -103,8 +112,11 @@ export class DeployCommand {
 
       // Surge deployment
       if (await this.utils.exists(root, "dist/public/404.html")) {
-        await this.utils.ensureDependency(root, "surge", { dev: true });
-        const distPath = join(root, "dist/public");
+        await this.pm.ensureDependency(root, "surge", {
+          dev: true,
+          exec: (cmd, opts) => this.utils.exec(cmd, opts),
+        });
+        const distPath = this.fs.join(root, "dist/public");
         this.log.debug(`Deploying to Surge from directory: ${distPath}`);
         await this.utils.exec(`surge ${distPath}`);
         return;

package/src/cli/commands/dev.ts

@@ -1,15 +1,22 @@
-import { access } from "node:fs/promises";
-import { join } from "node:path";
-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 { 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";
 
 export class DevCommand {
   protected readonly log = $logger();
+  protected readonly fs = $inject(FileSystemProvider);
   protected readonly utils = $inject(AlephaCliUtils);
+  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.
@@ -20,11 +27,13 @@ export class DevCommand {
   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.utils.hasExpo(root);
+    handler: async ({ root }) => {
+      const [expo, react] = await Promise.all([
+        this.pm.hasExpo(root),
+        this.pm.hasReact(root),
+      ]);
 
-      await this.utils.ensureConfig(root, {
+      await this.scaffolder.ensureConfig(root, {
         tsconfigJson: true,
       });
 
@@ -33,49 +42,19 @@ export class DevCommand {
         return;
       }
 
-      const entry = await boot.getServerEntry(root, args);
-      this.log.trace("Entry file found", { entry });
+      const entry = await this.boot.getAppEntry(root);
+      this.log.debug("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;
-      }
+      // -> here, we assume we use Vite as runner (api or fullstack)
+      // but it's planned to support Bun runner in the future as well
 
       // Ensure vite is installed before running
-      await this.utils.ensureDependency(root, "vite");
+      await this.pm.ensureDependency(root, "vite", {
+        exec: (cmd, opts) => this.utils.exec(cmd, opts),
+      });
 
-      await devServer();
+      await this.viteDevServer.init({ root, entry });
+      await this.viteDevServer.start();
     },
   });
-
-  protected async isBunProject(root: string): Promise<boolean> {
-    if (this.alepha.isBun()) {
-      return true;
-    }
-    try {
-      await access(join(root, "bun.lock"));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  protected async isFullstackProject(root: string): Promise<boolean> {
-    try {
-      await access(join(root, "index.html"));
-      return true;
-    } catch {
-      return false;
-    }
-  }
 }

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

@@ -37,7 +37,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) {