alepha 0.14.3 → 0.15.0

package/src/cli/commands/build.ts

@@ -1,8 +1,6 @@
-import { access, readFile, unlink, writeFile } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { join } from "node:path";
-import { $inject, OPTIONS, t } from "alepha";
+import { $inject, $use, t } from "alepha";
 import { $command } from "alepha/command";
+import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
 import {
   boot,
@@ -15,15 +13,22 @@ import {
   generateVercel,
   prerenderPages,
 } from "alepha/vite";
-import type * as Vite from "vite";
+import { buildOptions } from "../atoms/buildOptions.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 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" }),
@@ -54,20 +59,23 @@ 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";
       process.env.NODE_ENV = "production";
 
-      if (await this.utils.hasExpo(root)) {
-        // will coming soon
-        // 1. ensure "expo prebuild" is run
+      if (await this.pm.hasExpo(root)) {
+        // will come soon
         return;
       }
 
-      await this.utils.ensureConfig(root, {
-        viteConfigTs: true,
+      await this.scaffolder.ensureConfig(root, {
         tsconfigJson: true,
       });
 
@@ -77,41 +85,19 @@ export class BuildCommand {
       const distDir = "dist";
       const clientDir = "public";
 
-      await this.utils.ensureDependency(root, "vite", {
+      await this.pm.ensureDependency(root, "vite", {
         run,
+        exec: (cmd, opts) => this.utils.exec(cmd, opts),
       });
+      await run.rm("dist", { alias: "clean dist" });
 
-      await run.rm("dist", {
-        alias: "clean dist",
-      });
-
-      const vite: typeof Vite = createRequire(import.meta.url)("vite");
-      const config = await vite.resolveConfig({}, "build", "production");
-      const alephaPlugin: any = config.plugins.find(
-        (it) => it.name === "alepha:build",
-      );
-      const viteAlephaBuildOptions = alephaPlugin?.[OPTIONS] || {};
-
+      const options = this.options;
       await this.utils.loadEnv(root, [".env", ".env.production"]);
 
-      const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
-      const hasServer = viteAlephaBuildOptions.serverEntry !== false;
+      const stats = flags.stats ?? options.stats ?? false;
+      const hasClient = await this.fs.exists(this.fs.join(root, "index.html"));
 
-      let hasClient = false;
-      try {
-        await access(join(root, "index.html"));
-        hasClient = true;
-      } catch {
-        // No index.html
-      }
-
-      // Extract client options
-      const clientOptions =
-        typeof viteAlephaBuildOptions.client === "object"
-          ? viteAlephaBuildOptions.client
-          : {};
-
-      // Build client
+      // Build client (precompress always enabled)
       if (hasClient) {
         await run({
           name: "vite build client",
@@ -120,7 +106,7 @@ export class BuildCommand {
               silent: true,
               dist: `${distDir}/${clientDir}`,
               stats,
-              precompress: clientOptions.precompress,
+              precompress: true,
             }),
         });
       }
@@ -129,13 +115,26 @@ export class BuildCommand {
       await run({
         name: "vite build server",
         handler: async () => {
-          // Check if client template exists
-          let clientBuilt = false;
-          try {
-            await readFile(`${distDir}/${clientDir}/index.html`, "utf-8");
-            clientBuilt = true;
-          } catch {
-            // No client build
+          const clientIndexPath = `${distDir}/${clientDir}/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
+
+          // TODO: investigate if we have more conditions like 'edge' to add here
+          if (options.cloudflare) {
+            conditions.push("workerd");
           }
 
           await buildServer({
@@ -144,11 +143,12 @@ export class BuildCommand {
             distDir,
             clientDir: clientBuilt ? clientDir : undefined,
             stats,
+            conditions,
           });
 
           // Server will handle index.html if both client & server are built
-          if (clientBuilt && hasServer) {
-            await unlink(`${distDir}/${clientDir}/index.html`);
+          if (clientBuilt) {
+            await this.fs.rm(clientIndexPath);
           }
         },
       });
@@ -163,83 +163,66 @@ export class BuildCommand {
 
       if (hasClient) {
         // Generate sitemap
-        const sitemapBaseUrl = flags.sitemap ?? clientOptions.sitemap?.hostname;
-
-        if (sitemapBaseUrl) {
+        const sitemapHostname = flags.sitemap ?? options.sitemap?.hostname;
+        if (sitemapHostname) {
           await run({
             name: "add sitemap",
             handler: async () => {
-              await writeFile(
+              await this.fs.writeFile(
                 `${distDir}/${clientDir}/sitemap.xml`,
                 await generateSitemap({
                   entry: `${distDir}/index.js`,
-                  baseUrl: sitemapBaseUrl,
+                  baseUrl: sitemapHostname,
                 }),
               );
             },
           });
         }
 
-        // Pre-render static pages
-        const shouldPrerender = clientOptions.prerender;
-
-        if (shouldPrerender) {
-          await run({
-            name: "pre-render pages",
-            handler: async () => {
-              await prerenderPages({
-                dist: `${distDir}/${clientDir}`,
-                entry: `${distDir}/index.js`,
-                compress: clientOptions.precompress,
-              });
-            },
-          });
-        }
+        // 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,
+            });
+          },
+        });
       }
 
       // Generate deployment configurations
-      if (flags.vercel || viteAlephaBuildOptions.vercel) {
-        const config =
-          typeof viteAlephaBuildOptions.vercel === "object"
-            ? viteAlephaBuildOptions.vercel
-            : {};
+      if (flags.vercel || options.vercel) {
         await run({
           name: "add Vercel config",
           handler: () =>
             generateVercel({
               distDir,
               clientDir,
-              config,
+              config: options.vercel,
             }),
         });
       }
 
-      if (flags.cloudflare || viteAlephaBuildOptions.cloudflare) {
-        const config =
-          typeof viteAlephaBuildOptions.cloudflare === "boolean"
-            ? {}
-            : viteAlephaBuildOptions.cloudflare;
+      if (flags.cloudflare || options.cloudflare) {
         await run({
           name: "add Cloudflare config",
           handler: () =>
             generateCloudflare({
               distDir,
-              config,
+              config: options.cloudflare?.config,
             }),
         });
       }
 
-      if (flags.docker || viteAlephaBuildOptions.docker) {
-        const dockerConfig =
-          typeof viteAlephaBuildOptions.docker === "object"
-            ? viteAlephaBuildOptions.docker
-            : {};
+      if (flags.docker || options.docker) {
         await run({
           name: "add Docker config",
           handler: () =>
             generateDocker({
               distDir,
-              ...dockerConfig,
+              ...options.docker,
             }),
         });
       }

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();
@@ -134,7 +131,6 @@ export class DbCommand {
   protected readonly generate = $command({
     name: "generate",
     description: "Generate migration files based on current database schema",
-    summary: false,
     args: t.optional(
       t.text({
         title: "path",
@@ -173,7 +169,6 @@ export class DbCommand {
   protected readonly push = $command({
     name: "push",
     description: "Push database schema changes directly to the database",
-    summary: false,
     args: t.optional(
       t.text({
         title: "path",
@@ -200,7 +195,6 @@ export class DbCommand {
   protected readonly migrate = $command({
     name: "migrate",
     description: "Apply pending database migrations",
-    summary: false,
     args: t.optional(
       t.text({
         title: "path",
@@ -227,7 +221,6 @@ export class DbCommand {
   protected readonly studio = $command({
     name: "studio",
     description: "Launch Drizzle Studio database browser",
-    summary: false,
     args: t.optional(
       t.text({
         title: "path",
@@ -299,6 +292,10 @@ export class DbCommand {
       const providerName = provider.name;
       const dialect = provider.dialect;
 
+      if (providerName === "") {
+        continue;
+      }
+
       if (accepted.has(providerName)) {
         continue;
       }
@@ -320,6 +317,7 @@ export class DbCommand {
         provider,
         providerName,
         providerUrl: provider.url,
+        providerDriver: provider.driver,
         dialect,
         entry,
         rootDir,
@@ -345,6 +343,7 @@ export class DbCommand {
     provider: DatabaseProvider;
     providerName: string;
     providerUrl: string;
+    providerDriver: string;
     dialect: string;
     entry: string;
     rootDir: string;
@@ -375,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(
@@ -425,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,14 +1,18 @@
-import { access } from "node:fs/promises";
-import { join } from "node:path";
 import { $inject, Alepha, t } from "alepha";
 import { $command } from "alepha/command";
+import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
-import { boot } from "alepha/vite";
+import { boot, devServer } from "alepha/vite";
 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);
 
   /**
@@ -22,10 +26,9 @@ export class DevCommand {
     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);
+      const expo = await this.pm.hasExpo(root);
 
-      await this.utils.ensureConfig(root, {
-        viteConfigTs: !expo,
+      await this.scaffolder.ensureConfig(root, {
         tsconfigJson: true,
       });
 
@@ -40,7 +43,7 @@ export class DevCommand {
       const isFullstack = await this.isFullstackProject(root);
 
       if (!isFullstack) {
-        const exe = this.alepha.isBun() ? "bun" : "tsx";
+        const exe = (await this.isBunProject(root)) ? "bun" : "tsx";
         let cmd = `${exe} --watch`;
         if (await this.utils.exists(root, ".env")) {
           cmd += " --env-file=./.env";
@@ -53,17 +56,22 @@ export class DevCommand {
       }
 
       // Ensure vite is installed before running
-      await this.utils.ensureDependency(root, "vite");
-      await this.utils.exec("vite");
+      await this.pm.ensureDependency(root, "vite", {
+        exec: (cmd, opts) => this.utils.exec(cmd, opts),
+      });
+
+      await devServer();
     },
   });
 
-  protected async isFullstackProject(root: string): Promise<boolean> {
-    try {
-      await access(join(root, "index.html"));
+  protected async isBunProject(root: string): Promise<boolean> {
+    if (this.alepha.isBun()) {
       return true;
-    } catch {
-      return false;
     }
+    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/format.ts

@@ -1,16 +1,22 @@
 import { $inject } from "alepha";
 import { $command } from "alepha/command";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
+import { ProjectScaffolder } from "../services/ProjectScaffolder.ts";
 
 export class FormatCommand {
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly pm = $inject(PackageManagerUtils);
+  protected readonly scaffolder = $inject(ProjectScaffolder);
 
   public readonly format = $command({
     name: "format",
     description: "Format the codebase using Biome",
     handler: async ({ root }) => {
-      await this.utils.ensureConfig(root, { biomeJson: true });
-      await this.utils.ensureDependency(root, "@biomejs/biome");
+      await this.scaffolder.ensureConfig(root, { biomeJson: true });
+      await this.pm.ensureDependency(root, "@biomejs/biome", {
+        exec: (cmd, opts) => this.utils.exec(cmd, opts),
+      });
       await this.utils.exec("biome format --fix");
     },
   });

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

@@ -0,0 +1,53 @@
+import { $inject, t } from "alepha";
+import { $command } from "alepha/command";
+import { FileSystemProvider } from "alepha/file";
+import { $logger } from "alepha/logger";
+import { AlephaCliUtils } from "../../services/AlephaCliUtils.ts";
+
+export class GenEnvCommand {
+  protected readonly log = $logger();
+  protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly fs = $inject(FileSystemProvider);
+
+  public readonly command = $command({
+    name: "env",
+    description: "Extract environment variables from server entry file",
+    flags: t.object({
+      out: t.optional(
+        t.text({
+          aliases: ["o"],
+          description: "Output file path (e.g., .env)",
+        }),
+      ),
+    }),
+    handler: async ({ root, flags }) => {
+      const { alepha } = await this.utils.loadAlephaFromServerEntryFile(root);
+
+      try {
+        const { env } = alepha.dump();
+
+        let dotEnvFile = "";
+        for (const [key, value] of Object.entries(env)) {
+          if (value.description) {
+            dotEnvFile += `# ${value.description.split("\n").join("\n# ")}\n`;
+          }
+          if (value.required && !value.default) {
+            dotEnvFile += `# (required)\n`;
+          }
+          if (value.enum) {
+            dotEnvFile += `# Possible values: ${value.enum.join(", ")}\n`;
+          }
+          dotEnvFile += `${key}=${value.default || ""}\n\n`;
+        }
+
+        if (flags.out) {
+          await this.fs.writeFile(this.fs.join(root, flags.out), dotEnvFile);
+        } else {
+          this.log.info(dotEnvFile);
+        }
+      } catch (err) {
+        this.log.error("Failed to extract environment variables", err);
+      }
+    },
+  });
+}

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

@@ -64,7 +64,7 @@ export class OpenApiCommand {
           return;
         }
 
-        this.log.error(`OpenAPI generation failed - ${message}`, { err });
+        this.log.error(`OpenAPI generation failed - ${message}`, err);
       }
     },
   });

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

@@ -0,0 +1,15 @@
+/**
+ * TODO:
+ *
+ * alepha gen resource <name>
+ *
+ * will generate:
+ *
+ * src/api/controllers/<name>Controller.ts
+ * src/api/entity/<name>Entity.ts
+ * (maybe) src/api/services/<name>Service.ts
+ * (maybe) src/api/repositories/<name>Repository.ts
+ *
+ * Each file will contain a basic scaffold for the respective component.
+ *
+ */

package/src/cli/commands/gen.ts

@@ -1,16 +1,22 @@
 import { $inject } from "alepha";
 import { $command } from "alepha/command";
 import { ChangelogCommand } from "./gen/changelog.ts";
+import { GenEnvCommand } from "./gen/env.ts";
 import { OpenApiCommand } from "./gen/openapi.ts";
 
 export class GenCommand {
   protected readonly changelog = $inject(ChangelogCommand);
   protected readonly openapi = $inject(OpenApiCommand);
+  protected readonly genEnv = $inject(GenEnvCommand);
 
   public readonly gen = $command({
     name: "gen",
     description: "Generate code, documentation, ...",
-    children: [this.changelog.command, this.openapi.command],
+    children: [
+      this.changelog.command,
+      this.openapi.command,
+      this.genEnv.command,
+    ],
     handler: async ({ help }) => {
       help();
     },