alepha 0.14.3 → 0.14.4

package/src/cli/commands/build.ts

@@ -1,7 +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 { $logger } from "alepha/logger";
 import {
@@ -15,15 +14,17 @@ import {
   generateVercel,
   prerenderPages,
 } from "alepha/vite";
-import type * as Vite from "vite";
+import { buildOptions } from "../atoms/buildOptions.ts";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
 export class BuildCommand {
   protected readonly log = $logger();
   protected readonly utils = $inject(AlephaCliUtils);
+  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" }),
@@ -61,13 +62,11 @@ export class BuildCommand {
       process.env.NODE_ENV = "production";
 
       if (await this.utils.hasExpo(root)) {
-        // will coming soon
-        // 1. ensure "expo prebuild" is run
+        // will come soon
         return;
       }
 
       await this.utils.ensureConfig(root, {
-        viteConfigTs: true,
         tsconfigJson: true,
       });
 
@@ -77,25 +76,13 @@ export class BuildCommand {
       const distDir = "dist";
       const clientDir = "public";
 
-      await this.utils.ensureDependency(root, "vite", {
-        run,
-      });
-
-      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] || {};
+      await this.utils.ensureDependency(root, "vite", { run });
+      await run.rm("dist", { alias: "clean dist" });
 
+      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;
 
       let hasClient = false;
       try {
@@ -105,13 +92,7 @@ export class BuildCommand {
         // 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 +101,7 @@ export class BuildCommand {
               silent: true,
               dist: `${distDir}/${clientDir}`,
               stats,
-              precompress: clientOptions.precompress,
+              precompress: true,
             }),
         });
       }
@@ -129,7 +110,6 @@ 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");
@@ -147,7 +127,7 @@ export class BuildCommand {
           });
 
           // Server will handle index.html if both client & server are built
-          if (clientBuilt && hasServer) {
+          if (clientBuilt) {
             await unlink(`${distDir}/${clientDir}/index.html`);
           }
         },
@@ -163,9 +143,8 @@ 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 () => {
@@ -173,73 +152,57 @@ export class BuildCommand {
                 `${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

@@ -134,7 +134,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 +172,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 +198,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 +224,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",

package/src/cli/commands/dev.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { $inject, Alepha, t } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
-import { boot } from "alepha/vite";
+import { boot, devServer } from "alepha/vite";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
 export class DevCommand {
@@ -25,7 +25,6 @@ export class DevCommand {
       const expo = await this.utils.hasExpo(root);
 
       await this.utils.ensureConfig(root, {
-        viteConfigTs: !expo,
         tsconfigJson: true,
       });
 
@@ -40,7 +39,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";
@@ -54,10 +53,23 @@ export class DevCommand {
 
       // Ensure vite is installed before running
       await this.utils.ensureDependency(root, "vite");
-      await this.utils.exec("vite");
+
+      await devServer();
     },
   });
 
+  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"));

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();
     },

package/src/cli/commands/init.ts

@@ -43,7 +43,6 @@ export class InitCommand {
             tsconfigJson: true,
             packageJson: flags,
             biomeJson: true,
-            viteConfigTs: !isExpo,
             editorconfig: true,
             indexHtml: !!flags.react && !isExpo,
           });

package/src/cli/commands/test.ts

@@ -28,7 +28,6 @@ export class TestCommand {
     handler: async ({ root, flags, env }) => {
       await this.utils.ensureConfig(root, {
         tsconfigJson: true,
-        viteConfigTs: true,
       });
 
       // Ensure vitest is installed before running

package/src/cli/commands/verify.ts

@@ -34,7 +34,7 @@ export class VerifyCommand {
       }
 
       if (await this.utils.exists(root, "migrations")) {
-        await run("alepha db:check-migrations");
+        await run("alepha db check-migrations");
       }
 
       const isExpo = await this.utils.hasExpo(root);

package/src/cli/defineConfig.ts

@@ -1,19 +1,61 @@
 import type { Alepha } from "alepha";
 import type { CommandPrimitive } from "alepha/command";
+import { type BuildOptions, buildOptions } from "./atoms/buildOptions.ts";
 
-export type AlephaCliConfig = (alepha: Alepha) => {
+export interface AlephaCliConfig {
+  /**
+   * Add custom commands to the Alepha CLI.
+   *
+   * You can override 'deploy', 'build', 'dev', 'start' commands this way.
+   * But you can also add your own commands and run them via `alepha <command>`.
+   */
   commands?: Record<string, CommandPrimitive>;
+
+  /**
+   * Register more services to the Alepha CLI (enhancements, commands, etc.).
+   */
   services?: Array<any>;
-};
 
-export const defineConfig = (config: AlephaCliConfig) => {
+  /**
+   * Configure Alepha build command.
+   */
+  build?: BuildOptions;
+
+  /**
+   * Environment variables to set before running commands.
+   *
+   * Always use .env files by default, this is only for dynamic values.
+   */
+  env?: Record<string, unknown>;
+}
+
+export type AlephaCliConfigFn = (alepha: Alepha) => AlephaCliConfig;
+
+export const defineConfig = (
+  runConfig: AlephaCliConfig | AlephaCliConfigFn,
+) => {
   return (alepha: Alepha) => {
-    const { commands, services = [] } = config(alepha);
-    for (const it of services) {
-      alepha.with(it);
+    const config =
+      typeof runConfig === "function" ? runConfig(alepha) : runConfig;
+
+    if (config.services) {
+      for (const it of config.services) {
+        alepha.with(it);
+      }
     }
+
+    if (config.env) {
+      for (const [key, value] of Object.entries(config.env)) {
+        process.env[key] = String(value);
+      }
+    }
+
+    if (config.build) {
+      alepha.set(buildOptions, config.build);
+    }
+
     return {
-      ...commands,
+      ...config.commands,
     };
   };
 };

package/src/cli/index.ts

@@ -12,7 +12,6 @@ export * from "./commands/gen/openapi.ts";
 export * from "./commands/init.ts";
 export * from "./commands/lint.ts";
 export * from "./commands/root.ts";
-export * from "./commands/run.ts";
 export * from "./commands/test.ts";
 export * from "./commands/typecheck.ts";
 export * from "./commands/verify.ts";

package/src/cli/services/AlephaCliUtils.ts

@@ -14,7 +14,6 @@ import { indexHtml } from "../assets/indexHtml.ts";
 import { mainBrowserTs } from "../assets/mainBrowserTs.ts";
 import { mainTs } from "../assets/mainTs.ts";
 import { tsconfigJson } from "../assets/tsconfigJson.ts";
-import { viteConfigTs } from "../assets/viteConfigTs.ts";
 import { version } from "../version.ts";
 
 /**
@@ -142,6 +141,33 @@ export class AlephaCliUtils {
   // Package Manager & Project Setup
   // ===================================================================================================================
 
+  public async editFile(
+    root: string,
+    name: string,
+    editFn: (content: string) => string | Promise<string>,
+  ): Promise<void> {
+    const filePath = join(root, name);
+    try {
+      const content = await readFile(filePath, "utf8");
+      const newContent = await editFn(content);
+      await writeFile(filePath, newContent);
+    } catch (error) {
+      this.log.debug("Could not edit file", error);
+    }
+  }
+
+  public async editJsonFile(
+    root: string,
+    name: string,
+    editFn: (obj: any) => any | Promise<any>,
+  ): Promise<void> {
+    return await this.editFile(root, name, async (content) => {
+      const obj = JSON.parse(content);
+      const newObj = await editFn(obj);
+      return JSON.stringify(newObj, null, 2);
+    });
+  }
+
   public async removeFiles(root: string, files: string[]): Promise<void> {
     await Promise.all(
       files.map((file) =>
@@ -151,11 +177,17 @@ export class AlephaCliUtils {
   }
 
   public async removeYarn(root: string): Promise<void> {
-    await this.removeFiles(root, [".yarn", ".yarnrc.yml", ".yarn"]);
+    await this.removeFiles(root, [".yarn", ".yarnrc.yml", "yarn.lock"]);
+    await this.editJsonFile(root, "package.json", (pkg) => {
+      delete pkg.packageManager;
+    });
   }
 
   public async removePnpm(root: string): Promise<void> {
     await this.removeFiles(root, ["pnpm-lock.yaml", "pnpm-workspace.yaml"]);
+    await this.editJsonFile(root, "package.json", (pkg) => {
+      delete pkg.packageManager;
+    });
   }
 
   public async removeNpm(root: string): Promise<void> {
@@ -163,7 +195,7 @@ export class AlephaCliUtils {
   }
 
   public async removeBun(root: string): Promise<void> {
-    await this.removeFiles(root, ["bun.lockb"]);
+    await this.removeFiles(root, ["bun.lockb", "bun.lock"]);
   }
 
   public async removeAllPmFilesExcept(
@@ -300,7 +332,6 @@ export class AlephaCliUtils {
     opts: {
       packageJson?: boolean | DependencyModes;
       tsconfigJson?: boolean;
-      viteConfigTs?: boolean;
       indexHtml?: boolean;
       biomeJson?: boolean;
       editorconfig?: boolean;
@@ -319,9 +350,6 @@ export class AlephaCliUtils {
     if (opts.tsconfigJson) {
       tasks.push(this.ensureTsConfig(root));
     }
-    if (opts.viteConfigTs) {
-      tasks.push(this.ensureViteConfig(root));
-    }
     if (opts.indexHtml) {
       tasks.push(this.ensureIndexHtml(root));
     }
@@ -346,23 +374,6 @@ export class AlephaCliUtils {
     await this.ensureFileExists(root, "tsconfig.json", tsconfigJson, true);
   }
 
-  /**
-   * Ensure vite.config.ts exists in the project.
-   *
-   * Creates a standard Alepha vite.config.ts if none exists.
-   */
-  public async ensureViteConfig(
-    root: string,
-    serverEntry?: string,
-  ): Promise<void> {
-    await this.ensureFileExists(
-      root,
-      "vite.config.ts",
-      viteConfigTs(serverEntry),
-      false,
-    );
-  }
-
   protected async checkFileExists(
     root: string,
     name: string,
@@ -657,7 +668,7 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
   async readPackageJson(root: string): Promise<Record<string, any>> {
     const packageJson = await this.fs
       .createFile({
-        path: join(root, "package.json"),
+        path: this.fs.join(root, "package.json"),
       })
       .text();
     return JSON.parse(packageJson);

package/src/command/helpers/Runner.spec.ts

@@ -109,7 +109,7 @@ describe("Runner", () => {
     await runner.run(`echo "Task 1"`);
     await runner.run("A slightly longer task name", () => {});
 
-    runner.summary();
+    runner.end();
 
     const logs = mockLogger.logs
       .slice(4)
@@ -118,7 +118,7 @@ describe("Runner", () => {
   });
 
   test("summary() should not print a table if no tasks were run", () => {
-    runner.summary();
+    runner.end();
 
     const logs = mockLogger.logs.map((l) => l.message);
     expect(logs.length).toBe(0);

package/src/command/helpers/Runner.ts

@@ -179,7 +179,7 @@ export class Runner {
   /**
    * Prints a summary of all executed tasks and their durations.
    */
-  public summary(): void {
+  public end(): void {
     if (this.useDynamicLogger && this.firstTaskStarted) {
       this.prettyPrint.endCommand();
       return;

package/src/command/primitives/$command.ts

@@ -105,12 +105,6 @@ export interface CommandPrimitiveOptions<
    */
   args?: A;
 
-  /**
-   * If false, skip summary message at the end of the command execution.
-   * Summary will display only if ({ run }) method calls were made.
-   */
-  summary?: boolean;
-
   /**
    * Marks this command as the root command.
    * Equivalent to setting name to an empty string "".

package/src/command/providers/CliProvider.ts

@@ -237,9 +237,7 @@ export class CliProvider {
         await hook.options.handler(args as CommandHandlerArgs<TObject>);
       }
 
-      if (command.options.summary !== false) {
-        runner.summary();
-      }
+      runner.end();
 
       this.log.debug(`Command '${command.name}' executed successfully.`);
     });