alepha 0.14.2 → 0.14.4

package/src/cli/index.ts

@@ -2,16 +2,16 @@ export * from "./apps/AlephaCli.ts";
 export * from "./apps/AlephaPackageBuilderCli.ts";
 export * from "./atoms/changelogOptions.ts";
 export * from "./commands/build.ts";
-export * from "./commands/changelog.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";

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";
@@ -15,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";
 
 /**
@@ -32,6 +30,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 +141,73 @@ 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) =>
+        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.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> {
+    await this.removeFiles(root, ["package-lock.json"]);
+  }
+
+  public async removeBun(root: string): Promise<void> {
+    await this.removeFiles(root, ["bun.lockb", "bun.lock"]);
+  }
+
+  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 +223,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");
   }
 
   /**
@@ -272,7 +332,6 @@ export class AlephaCliUtils {
     opts: {
       packageJson?: boolean | DependencyModes;
       tsconfigJson?: boolean;
-      viteConfigTs?: boolean;
       indexHtml?: boolean;
       biomeJson?: boolean;
       editorconfig?: boolean;
@@ -291,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));
     }
@@ -318,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,
@@ -436,9 +475,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 +563,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";
     }
@@ -625,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);
@@ -659,6 +702,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 +741,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/changelog.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.end();
+
+    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.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;