alepha 0.14.1 → 0.14.3

package/src/cli/commands/test.ts

@@ -0,0 +1,42 @@
+import { $inject, t } from "alepha";
+import { $command } from "alepha/command";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+
+export class TestCommand {
+  protected readonly utils = $inject(AlephaCliUtils);
+
+  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/typecheck.ts

@@ -0,0 +1,24 @@
+import { $inject } from "alepha";
+import { $command } from "alepha/command";
+import { $logger } from "alepha/logger";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+
+export class TypecheckCommand {
+  protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly log = $logger();
+
+  /**
+   * Run TypeScript type checking across the codebase with no emit.
+   */
+  public readonly typecheck = $command({
+    name: "typecheck",
+    aliases: ["tc"],
+    description: "Check TypeScript types across the codebase",
+    handler: async ({ root }) => {
+      this.log.info("Starting TypeScript type checking...");
+      await this.utils.ensureDependency(root, "typescript");
+      await this.utils.exec("tsc --noEmit");
+      this.log.info("TypeScript type checking completed successfully.");
+    },
+  });
+}

package/src/cli/commands/{VerifyCommands.ts → verify.ts}

@@ -2,7 +2,7 @@ import { $inject } from "alepha";
 import { $command } from "alepha/command";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
-export class VerifyCommands {
+export class VerifyCommand {
   protected readonly utils = $inject(AlephaCliUtils);
 
   /**
@@ -44,16 +44,4 @@ export class VerifyCommands {
       await run("alepha clean");
     },
   });
-
-  /**
-   * Run TypeScript type checking across the codebase with no emit.
-   */
-  public readonly typecheck = $command({
-    name: "typecheck",
-    description: "Check TypeScript types across the codebase",
-    handler: async ({ root }) => {
-      await this.utils.ensureDependency(root, "typescript");
-      await this.utils.exec("tsc --noEmit");
-    },
-  });
 }

package/src/cli/defineConfig.ts

@@ -3,13 +3,22 @@ import type { CommandPrimitive } from "alepha/command";
 
 export type AlephaCliConfig = (alepha: Alepha) => {
   commands?: Record<string, CommandPrimitive>;
+  services?: Array<any>;
 };
 
 export const defineConfig = (config: AlephaCliConfig) => {
   return (alepha: Alepha) => {
-    const { commands } = config(alepha);
+    const { commands, services = [] } = config(alepha);
+    for (const it of services) {
+      alepha.with(it);
+    }
     return {
       ...commands,
     };
   };
 };
+
+/**
+ * @alias defineConfig
+ */
+export const defineAlephaConfig = defineConfig;

package/src/cli/index.ts

@@ -1,12 +1,22 @@
 export * from "./apps/AlephaCli.ts";
 export * from "./apps/AlephaPackageBuilderCli.ts";
-export * from "./commands/BiomeCommands.ts";
-export * from "./commands/ChangelogCommands.ts";
-export * from "./commands/CoreCommands.ts";
-export * from "./commands/DeployCommands.ts";
-export * from "./commands/DrizzleCommands.ts";
-export * from "./commands/VerifyCommands.ts";
-export * from "./commands/ViteCommands.ts";
+export * from "./atoms/changelogOptions.ts";
+export * from "./commands/build.ts";
+export * from "./commands/clean.ts";
+export * from "./commands/db.ts";
+export * from "./commands/deploy.ts";
+export * from "./commands/dev.ts";
+export * from "./commands/format.ts";
+export * from "./commands/gen/changelog.ts";
+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";
 export * from "./defineConfig.ts";
 export * from "./services/AlephaCliUtils.ts";
+export * from "./services/GitMessageParser.ts";
 export * from "./version.ts";

package/src/cli/services/AlephaCliUtils.ts

@@ -6,7 +6,6 @@ import { EnvUtils, type RunnerMethod } from "alepha/command";
 import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
 import { boot } from "alepha/vite";
-import { tsImport } from "tsx/esm/api";
 import { appRouterTs } from "../assets/appRouterTs.ts";
 import { biomeJson } from "../assets/biomeJson.ts";
 import { dummySpecTs } from "../assets/dummySpecTs.ts";
@@ -32,6 +31,7 @@ export class AlephaCliUtils {
   protected readonly log = $logger();
   protected readonly fs = $inject(FileSystemProvider);
   protected readonly envUtils = $inject(EnvUtils);
+  protected readonly alepha = $inject(Alepha);
 
   /**
    * Execute a command using npx with inherited stdio.
@@ -142,6 +142,40 @@ export class AlephaCliUtils {
   // Package Manager & Project Setup
   // ===================================================================================================================
 
+  public async removeFiles(root: string, files: string[]): Promise<void> {
+    await Promise.all(
+      files.map((file) =>
+        this.fs.rm(join(root, file), { force: true, recursive: true }),
+      ),
+    );
+  }
+
+  public async removeYarn(root: string): Promise<void> {
+    await this.removeFiles(root, [".yarn", ".yarnrc.yml", ".yarn"]);
+  }
+
+  public async removePnpm(root: string): Promise<void> {
+    await this.removeFiles(root, ["pnpm-lock.yaml", "pnpm-workspace.yaml"]);
+  }
+
+  public async removeNpm(root: string): Promise<void> {
+    await this.removeFiles(root, ["package-lock.json"]);
+  }
+
+  public async removeBun(root: string): Promise<void> {
+    await this.removeFiles(root, ["bun.lockb"]);
+  }
+
+  public async removeAllPmFilesExcept(
+    root: string,
+    except: string,
+  ): Promise<void> {
+    if (except !== "yarn") await this.removeYarn(root);
+    if (except !== "pnpm") await this.removePnpm(root);
+    if (except !== "npm") await this.removeNpm(root);
+    if (except !== "bun") await this.removeBun(root);
+  }
+
   /**
    * Ensure Yarn is configured in the project directory.
    *
@@ -157,25 +191,19 @@ export class AlephaCliUtils {
       false,
     );
 
-    // remove lock files from other package managers
-    await this.fs.rm(join(root, "package-lock.json"), { force: true });
-    await this.fs.rm(join(root, "pnpm-lock.yaml"), { force: true });
+    await this.removeAllPmFilesExcept(root, "yarn");
+  }
+
+  public async ensureBun(root: string): Promise<void> {
+    await this.removeAllPmFilesExcept(root, "bun");
   }
 
   public async ensurePnpm(root: string): Promise<void> {
-    // remove lock files from other package managers
-    await this.fs.rm(join(root, "package-lock.json"), { force: true });
-    await this.fs.rm(join(root, "yarn.lock"), { force: true });
-    await this.fs.rm(join(root, ".yarn"), { force: true, recursive: true });
-    await this.fs.rm(join(root, ".yarnrc.yml"), { force: true });
+    await this.removeAllPmFilesExcept(root, "pnpm");
   }
 
   public async ensureNpm(root: string): Promise<void> {
-    // remove lock files from other package managers
-    await this.fs.rm(join(root, "pnpm-lock.yaml"), { force: true });
-    await this.fs.rm(join(root, "yarn.lock"), { force: true });
-    await this.fs.rm(join(root, ".yarn"), { force: true, recursive: true });
-    await this.fs.rm(join(root, ".yarnrc.yml"), { force: true });
+    await this.removeAllPmFilesExcept(root, "npm");
   }
 
   /**
@@ -436,9 +464,10 @@ export class AlephaCliUtils {
     process.env.ALEPHA_CLI_IMPORT = "true";
 
     const entry = await boot.getServerEntry(rootDir, explicitEntry);
-    const mod = await tsImport(entry, {
-      parentURL: import.meta.url,
-    });
+
+    delete (global as any).__alepha;
+
+    const mod = await import(entry);
 
     this.log.debug(`Load entry: ${entry}`);
 
@@ -523,6 +552,9 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
     if (flags?.bun) {
       return "bun";
     }
+    if (this.alepha.isBun()) {
+      return "bun";
+    }
     if (await this.checkFileExists(root, "yarn.lock", true)) {
       return "yarn";
     }
@@ -659,6 +691,27 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
     return this.hasDependency(root, "expo");
   }
 
+  async getInstallCommand(root: string, packageName: string, dev = true) {
+    const pm = await this.getPackageManager(root);
+    let cmd: string;
+
+    switch (pm) {
+      case "yarn":
+        cmd = `yarn add ${dev ? "-D" : ""} ${packageName}`;
+        break;
+      case "pnpm":
+        cmd = `pnpm add ${dev ? "-D" : ""} ${packageName}`;
+        break;
+      case "bun":
+        cmd = `bun add ${dev ? "-d" : ""} ${packageName}`;
+        break;
+      default:
+        cmd = `npm install ${dev ? "--save-dev" : ""} ${packageName}`;
+    }
+
+    return cmd.replace(/\s+/g, " ").trim();
+  }
+
   /**
    * Install a dependency if it's missing from the project.
    *
@@ -677,21 +730,7 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
       return;
     }
 
-    const pm = await this.getPackageManager(root);
-    let cmd: string;
-
-    switch (pm) {
-      case "yarn":
-        cmd = `yarn add ${dev ? "-D" : ""} ${packageName}`;
-        break;
-      case "pnpm":
-        cmd = `pnpm add ${dev ? "-D" : ""} ${packageName}`;
-        break;
-      default:
-        cmd = `npm install ${dev ? "--save-dev" : ""} ${packageName}`;
-    }
-
-    cmd = cmd.replace(/\s+/g, " ").trim();
+    const cmd = await this.getInstallCommand(root, packageName, dev);
 
     if (options.run) {
       // if it's during a Runner flow, just use the runner's run method

package/src/cli/services/GitMessageParser.ts

@@ -3,7 +3,7 @@ import {
   type ChangelogOptions,
   DEFAULT_IGNORE,
 } from "../atoms/changelogOptions.ts";
-import type { Commit } from "../commands/ChangelogCommands.ts";
+import type { Commit } from "../commands/gen/changelog.ts";
 
 /**
  * Service for parsing git commit messages into structured format.

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

@@ -0,0 +1,127 @@
+import { Alepha, AlephaError, t } from "alepha";
+import {
+  LogDestinationProvider,
+  MemoryDestinationProvider,
+} from "alepha/logger";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { Asker } from "../index.ts";
+
+describe("Asker", () => {
+  let alepha: Alepha;
+  let asker: Asker;
+  let mockLogger: MemoryDestinationProvider;
+
+  const mockPromptInterface = (answers: string[]) => {
+    const question = vi.fn();
+    for (const answer of answers) {
+      question.mockResolvedValueOnce(answer);
+    }
+    const close = vi.fn();
+
+    vi.spyOn(
+      asker as unknown as { createPromptInterface: () => any },
+      "createPromptInterface",
+    ).mockReturnValue({
+      question,
+      close,
+    });
+
+    return { question, close };
+  };
+
+  beforeEach(() => {
+    alepha = Alepha.create({
+      env: {
+        LOG_LEVEL: "info",
+      },
+    })
+      .with({
+        provide: LogDestinationProvider,
+        use: MemoryDestinationProvider,
+      })
+      .with(Asker);
+
+    asker = alepha.inject(Asker);
+    mockLogger = alepha.inject(MemoryDestinationProvider);
+    mockLogger.clear();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("returns trimmed string when no schema is provided", async () => {
+    const { question, close } = mockPromptInterface(["  hello world  "]);
+
+    const result = await asker.ask("What is your name?");
+
+    expect(result).toBe("hello world");
+    expect(question).toHaveBeenCalledTimes(1);
+    expect(question).toHaveBeenCalledWith("What is your name?\n> ");
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  test("retries until schema validation passes", async () => {
+    const { question, close } = mockPromptInterface(["abc", "41"]);
+
+    const result = await asker.ask("Enter a number", {
+      schema: t.number(),
+    });
+
+    expect(result).toBe(41);
+    expect(question).toHaveBeenCalledTimes(2);
+    expect(close).toHaveBeenCalledTimes(1);
+    expect(mockLogger.logs.some((log) => log.level === "ERROR")).toBe(true);
+  });
+
+  test("uses schema defaults when the user provides an empty answer", async () => {
+    const { question, close } = mockPromptInterface([""]);
+
+    const result = await asker.ask("What is your favorite color?", {
+      schema: t.text({ default: "blue" }),
+    });
+
+    expect(result).toBe("blue");
+    expect(question).toHaveBeenCalledTimes(1);
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  test("retries when custom validation throws an AlephaError", async () => {
+    const { question, close } = mockPromptInterface(["wrong", "right"]);
+
+    const result = await asker.ask("Provide the secret", {
+      schema: t.text(),
+      validate: (value) => {
+        if (value !== "right") {
+          throw new AlephaError("Invalid secret");
+        }
+      },
+    });
+
+    expect(result).toBe("right");
+    expect(question).toHaveBeenCalledTimes(2);
+    expect(close).toHaveBeenCalledTimes(1);
+
+    const errorLogs = mockLogger.logs.filter((log) => log.level === "ERROR");
+    expect(errorLogs).toHaveLength(1);
+    expect(errorLogs[0].message).toContain("Invalid secret");
+  });
+
+  test("propagates unexpected errors without logging", async () => {
+    const { question, close } = mockPromptInterface(["value"]);
+    const unexpectedError = new Error("boom");
+
+    await expect(
+      asker.ask("Trigger failure", {
+        schema: t.text(),
+        validate: () => {
+          throw unexpectedError;
+        },
+      }),
+    ).rejects.toBe(unexpectedError);
+
+    expect(question).toHaveBeenCalledTimes(1);
+    expect(close).toHaveBeenCalledTimes(1);
+    expect(mockLogger.logs.some((log) => log.level === "ERROR")).toBe(false);
+  });
+});

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

@@ -0,0 +1,126 @@
+import { Alepha } from "alepha";
+import {
+  LogDestinationProvider,
+  MemoryDestinationProvider,
+} from "alepha/logger";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { Runner } from "../index.ts";
+
+describe("Runner", () => {
+  let mockLogger: MemoryDestinationProvider;
+  let runner: Runner;
+
+  beforeEach(async () => {
+    const alepha = Alepha.create({
+      env: {
+        LOG_LEVEL: "info",
+      },
+    }).with({
+      provide: LogDestinationProvider,
+      use: MemoryDestinationProvider,
+    });
+    // Create a new MockLogger and Runner for each test to ensure isolation
+    runner = alepha.inject(Runner);
+    mockLogger = alepha.inject(MemoryDestinationProvider);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("should execute a single shell command via run.sh", async () => {
+    await runner.run(`echo "hello"`);
+
+    expect(mockLogger.logs).toHaveLength(2);
+    const startLog = mockLogger.logs[0];
+    const finishLog = mockLogger.logs[1];
+
+    expect(startLog.message).toBe("Starting 'echo \"hello\"' ...");
+    expect(startLog.level).toBe("INFO");
+
+    expect(finishLog.message).toMatch(
+      /^Finished 'echo "hello"' after \d+\.\ds$/,
+    );
+    expect(finishLog.level).toBe("INFO");
+
+    const timers = (runner as any).timers;
+    expect(timers).toHaveLength(1);
+    expect(timers[0].name).toBe('echo "hello"');
+    expect(timers[0].duration).toMatch(/^\d+\.\ds$/);
+  });
+
+  test("should execute a single shell command via run(sh`...`)", async () => {
+    await runner.run(`echo "world"`);
+    expect(mockLogger.logs[0].message).toBe("Starting 'echo \"world\"' ...");
+    expect(mockLogger.logs).toHaveLength(2);
+  });
+
+  test("should execute a single function task via run.fn", async () => {
+    const mockFn = vi.fn();
+    await runner.run("my-test-function", mockFn);
+
+    expect(mockFn).toHaveBeenCalledOnce();
+    expect(mockLogger.logs).toHaveLength(2);
+    expect(mockLogger.logs[0].message).toBe("Starting 'my-test-function' ...");
+    expect(mockLogger.logs[1].message).toMatch(
+      /^Finished 'my-test-function' after \d+\.\ds$/,
+    );
+  });
+
+  test("should execute a single function task via run(fn(...))", async () => {
+    const mockFn = vi.fn();
+    await runner.run("another-function", mockFn);
+    expect(mockFn).toHaveBeenCalledOnce();
+    expect(mockLogger.logs).toHaveLength(2);
+  });
+
+  test("should execute an array of tasks in parallel", async () => {
+    const fn1 = vi.fn(() => new Promise((res) => setTimeout(res, 20)));
+    const fn2 = vi.fn(() => new Promise((res) => setTimeout(res, 20)));
+
+    await runner.run([
+      `echo "parallel sh"`,
+      { name: "parallel fn 1", handler: fn1 },
+      { name: "parallel fn 2", handler: fn2 },
+    ]);
+
+    expect(fn1).toHaveBeenCalledOnce();
+    expect(fn2).toHaveBeenCalledOnce();
+    expect(mockLogger.logs).toHaveLength(6); // 3 start, 3 finish logs
+    expect((runner as any).timers).toHaveLength(3);
+  });
+
+  test("should throw and log an error for a failing shell command", async () => {
+    await expect(runner.run(`exit 1`)).rejects.toThrow("Task 'exit 1' failed");
+  });
+
+  test("should throw and log an error for a failing function task", async () => {
+    const error = new Error("Function failed!");
+    const failingFn = () => {
+      throw error;
+    };
+
+    await expect(runner.run("failing-task", failingFn)).rejects.toThrow(
+      "Task 'failing-task' failed",
+    );
+  });
+
+  test("summary() should print a formatted table of executed tasks", async () => {
+    await runner.run(`echo "Task 1"`);
+    await runner.run("A slightly longer task name", () => {});
+
+    runner.summary();
+
+    const logs = mockLogger.logs
+      .slice(4)
+      .map((l) => l.message)
+      .join("\n");
+  });
+
+  test("summary() should not print a table if no tasks were run", () => {
+    runner.summary();
+
+    const logs = mockLogger.logs.map((l) => l.message);
+    expect(logs.length).toBe(0);
+  });
+});