alepha 0.14.1 → 0.14.3

package/src/cli/commands/{ViteCommands.ts → build.ts}

@@ -1,7 +1,7 @@
 import { access, readFile, unlink, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { join } from "node:path";
-import { $env, $inject, OPTIONS, t } from "alepha";
+import { $inject, OPTIONS, t } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
 import {
@@ -18,78 +18,10 @@ import {
 import type * as Vite from "vite";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
-export class ViteCommands {
+export class BuildCommand {
   protected readonly log = $logger();
   protected readonly utils = $inject(AlephaCliUtils);
 
-  protected readonly env = $env(
-    t.object({
-      VITEST_ARGS: t.string({ default: "" }),
-    }),
-  );
-
-  public readonly run = $command({
-    name: "run",
-    hide: true,
-    description: "Run a TypeScript file directly",
-    flags: t.object({
-      watch: t.optional(
-        t.boolean({ description: "Watch file for changes", alias: "w" }),
-      ),
-    }),
-    summary: false,
-    args: t.text({ title: "path", description: "Filepath to run" }),
-    handler: async ({ args, flags, root }) => {
-      await this.utils.ensureTsConfig(root);
-      await this.utils.exec(`tsx ${flags.watch ? "watch " : ""}${args}`);
-    },
-  });
-
-  /**
-   * 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.utils.hasExpo(root);
-
-      await this.utils.ensureConfig(root, {
-        viteConfigTs: !expo,
-        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 });
-
-      try {
-        await access(join(root, "index.html"));
-      } catch {
-        this.log.trace("No index.html found, running entry file with tsx");
-        let cmd = "tsx --watch";
-        if (await this.utils.exists(root, ".env")) {
-          cmd += ` --env-file=./.env`;
-        }
-        cmd += ` ${entry}`;
-        await this.utils.exec(cmd);
-        return;
-      }
-
-      // Ensure vite is installed before running
-      await this.utils.ensureDependency(root, "vite");
-      await this.utils.exec(`vite`);
-    },
-  });
-
   public readonly build = $command({
     name: "build",
     description: "Build the project for production",
@@ -313,39 +245,4 @@ export class ViteCommands {
       }
     },
   });
-
-  public readonly test = $command({
-    name: "test",
-    description: "Run tests using Vitest",
-    flags: t.object({
-      config: t.optional(
-        t.string({
-          description: "Path to Vitest config file",
-          alias: "c",
-        }),
-      ),
-    }),
-    env: t.object({
-      VITEST_ARGS: t.optional(
-        t.string({
-          default: "",
-          description:
-            "Additional arguments to pass to Vitest. E.g., --coverage",
-        }),
-      ),
-    }),
-    handler: async ({ root, flags, env }) => {
-      await this.utils.ensureConfig(root, {
-        tsconfigJson: true,
-        viteConfigTs: true,
-      });
-
-      // Ensure vitest is installed before running
-      await this.utils.ensureDependency(root, "vitest");
-
-      const config = flags.config ? `--config=${flags.config}` : "";
-
-      await this.utils.exec(`vitest run ${config} ${env.VITEST_ARGS}`);
-    },
-  });
 }

package/src/cli/commands/clean.ts

@@ -0,0 +1,14 @@
+import { $command } from "alepha/command";
+
+export class CleanCommand {
+  /**
+   * Clean the project, removing the "dist" directory
+   */
+  public readonly clean = $command({
+    name: "clean",
+    description: "Clean the project",
+    handler: async ({ run }) => {
+      await run.rm("./dist");
+    },
+  });
+}

package/src/cli/commands/{DrizzleCommands.ts → db.ts}

@@ -25,14 +25,14 @@ const drizzleCommandFlags = t.object({
   ),
 });
 
-export class DrizzleCommands {
-  log = $logger();
-  utils = $inject(AlephaCliUtils);
+export class DbCommand {
+  protected readonly log = $logger();
+  protected readonly utils = $inject(AlephaCliUtils);
 
   /**
    * Check if database migrations are up to date.
    */
-  check = $command({
+  protected readonly check = $command({
     name: "check-migrations",
     description: "Check if database migration files are up to date",
     args: t.optional(
@@ -74,7 +74,7 @@ export class DrizzleCommands {
         ).catch(() => null);
 
         if (!journalFile) {
-          this.log.info(`No migration journal found.`);
+          this.log.info("No migration journal found.");
           return;
         }
 
@@ -130,14 +130,8 @@ export class DrizzleCommands {
 
   /**
    * Generate database migration files
-   *
-   * - Loads the Alepha instance from the specified entry file.
-   * - Retrieves all repository primitives to gather database models.
-   * - Creates temporary entity definitions based on the current database schema.
-   * - Writes these definitions to a temporary schema file. (node_modules/.db/entities.ts)
-   * - Invokes Drizzle Kit's CLI to generate migration files based on the current schema.
    */
-  generate = $command({
+  protected readonly generate = $command({
     name: "generate",
     description: "Generate migration files based on current database schema",
     summary: false,
@@ -175,13 +169,8 @@ export class DrizzleCommands {
 
   /**
    * Push database schema changes directly to the database
-   *
-   * - Loads the Alepha instance from the specified entry file.
-   * - Retrieves all repository primitives to gather database models.
-   * - Creates temporary entity definitions and Drizzle config.
-   * - Invokes Drizzle Kit's push command to apply schema changes directly.
    */
-  push = $command({
+  protected readonly push = $command({
     name: "push",
     description: "Push database schema changes directly to the database",
     summary: false,
@@ -207,13 +196,8 @@ export class DrizzleCommands {
 
   /**
    * Apply pending database migrations
-   *
-   * - Loads the Alepha instance from the specified entry file.
-   * - Retrieves all repository primitives to gather database models.
-   * - Creates temporary entity definitions and Drizzle config.
-   * - Invokes Drizzle Kit's migrate command to apply pending migrations.
    */
-  migrate = $command({
+  protected readonly migrate = $command({
     name: "migrate",
     description: "Apply pending database migrations",
     summary: false,
@@ -239,13 +223,8 @@ export class DrizzleCommands {
 
   /**
    * Launch Drizzle Studio database browser
-   *
-   * - Loads the Alepha instance from the specified entry file.
-   * - Retrieves all repository primitives to gather database models.
-   * - Creates temporary entity definitions and Drizzle config.
-   * - Invokes Drizzle Kit's studio command to launch the web-based database browser.
    */
-  studio = $command({
+  protected readonly studio = $command({
     name: "studio",
     description: "Launch Drizzle Studio database browser",
     summary: false,
@@ -272,7 +251,7 @@ export class DrizzleCommands {
   /**
    * Parent command for database operations.
    */
-  db = $command({
+  public readonly db = $command({
     name: "db",
     description: "Database management commands",
     children: [this.check, this.generate, this.push, this.migrate, this.studio],
@@ -283,11 +262,6 @@ export class DrizzleCommands {
 
   /**
    * Run a drizzle-kit command for all database providers in an Alepha instance.
-   *
-   * Iterates through all repository providers, prepares Drizzle config for each,
-   * and executes the specified drizzle-kit command.
-   *
-   * @param options - Configuration including command to run, flags, and logging
    */
   public async runDrizzleKitCommand(options: {
     root: string;
@@ -365,12 +339,6 @@ export class DrizzleCommands {
 
   /**
    * Prepare Drizzle configuration files for a database provider.
-   *
-   * Creates temporary entities.js and drizzle.config.js files needed
-   * for Drizzle Kit commands to run properly.
-   *
-   * @param options - Configuration options including kit, provider info, and paths
-   * @returns Path to the generated drizzle.config.js file
    */
   public async prepareDrizzleConfig(options: {
     kit: any;
@@ -473,79 +441,4 @@ export class DrizzleCommands {
       options.rootDir,
     );
   }
-
-  // /**
-  //  * Drop database schema (development only)
-  //  *
-  //  * @experimental
-  //  */
-  // drop = $command({
-  //   name: "db:drop",
-  //   description: "Drop database schema (development only)",
-  //   summary: false,
-  //   args: t.optional(
-  //     t.text({
-  //       title: "path",
-  //       description: "Path to the Alepha server entry file",
-  //     }),
-  //   ),
-  //   flags: drizzleCommandFlags,
-  //   handler: async ({ flags }) => {
-  //     // TODO: Implement db:drop
-  //     this.log.warn("db:drop is not yet implemented");
-  //     if (flags.provider) {
-  //       this.log.info(`Provider filter: ${flags.provider}`);
-  //     }
-  //   },
-  // });
-  //
-  // /**
-  //  * Seed database with initial data
-  //  *
-  //  * @experimental
-  //  */
-  // seed = $command({
-  //   name: "db:seed",
-  //   description: "Seed database with initial data",
-  //   summary: false,
-  //   args: t.optional(
-  //     t.text({
-  //       title: "path",
-  //       description: "Path to the Alepha server entry file",
-  //     }),
-  //   ),
-  //   flags: drizzleCommandFlags,
-  //   handler: async ({ flags }) => {
-  //     // TODO: Implement db:seed
-  //     this.log.warn("db:seed is not yet implemented");
-  //     if (flags.provider) {
-  //       this.log.info(`Provider filter: ${flags.provider}`);
-  //     }
-  //   },
-  // });
-  //
-  // /**
-  //  * Show pending database migrations status
-  //  *
-  //  * @experimental
-  //  */
-  // status = $command({
-  //   name: "db:status",
-  //   description: "Show pending database migrations status",
-  //   summary: false,
-  //   args: t.optional(
-  //     t.text({
-  //       title: "path",
-  //       description: "Path to the Alepha server entry file",
-  //     }),
-  //   ),
-  //   flags: drizzleCommandFlags,
-  //   handler: async ({ flags }) => {
-  //     // TODO: Implement db:status
-  //     this.log.warn("db:status is not yet implemented");
-  //     if (flags.provider) {
-  //       this.log.info(`Provider filter: ${flags.provider}`);
-  //     }
-  //   },
-  // });
 }

package/src/cli/commands/{DeployCommands.ts → deploy.ts}

@@ -4,7 +4,7 @@ import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
-export class DeployCommands {
+export class DeployCommand {
   protected readonly log = $logger();
   protected readonly utils = $inject(AlephaCliUtils);
 

package/src/cli/commands/dev.ts

@@ -0,0 +1,69 @@
+import { access } from "node:fs/promises";
+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 { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+
+export class DevCommand {
+  protected readonly log = $logger();
+  protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly alepha = $inject(Alepha);
+
+  /**
+   * 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.utils.hasExpo(root);
+
+      await this.utils.ensureConfig(root, {
+        viteConfigTs: !expo,
+        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 = this.alepha.isBun() ? "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;
+      }
+
+      // Ensure vite is installed before running
+      await this.utils.ensureDependency(root, "vite");
+      await this.utils.exec("vite");
+    },
+  });
+
+  protected async isFullstackProject(root: string): Promise<boolean> {
+    try {
+      await access(join(root, "index.html"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/cli/commands/format.ts

@@ -0,0 +1,17 @@
+import { $inject } from "alepha";
+import { $command } from "alepha/command";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+
+export class FormatCommand {
+  protected readonly utils = $inject(AlephaCliUtils);
+
+  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.utils.exec("biome format --fix");
+    },
+  });
+}