alepha 0.14.2 → 0.14.4

package/src/cli/commands/gen/changelog.spec.ts

@@ -0,0 +1,315 @@
+import { Alepha } from "alepha";
+import { cliOptions } from "alepha/command";
+import {
+  LogDestinationProvider,
+  MemoryDestinationProvider,
+} from "alepha/logger";
+import { describe, expect, test } from "vitest";
+import {
+  ChangelogCommand,
+  changelogOptions,
+  GitMessageParser,
+  GitProvider,
+} from "./changelog.ts";
+
+// =============================================================================
+// MOCK GIT PROVIDER
+// =============================================================================
+
+let currentMockResponses: Map<string, string> | null = null;
+
+class MockGitProvider extends GitProvider {
+  override async exec(cmd: string, _cwd: string): Promise<string> {
+    if (!currentMockResponses) {
+      throw new Error("No git mocks configured");
+    }
+    const response = currentMockResponses.get(cmd);
+    if (response === undefined) {
+      throw new Error(`Unmocked git command: ${cmd}`);
+    }
+    return response;
+  }
+}
+
+function setMockGitResponses(
+  mocks: Array<{ cmd: string; response: string }>,
+): void {
+  currentMockResponses = new Map<string, string>();
+  for (const { cmd, response } of mocks) {
+    currentMockResponses.set(cmd, response);
+  }
+}
+
+// =============================================================================
+// TESTS
+// =============================================================================
+
+describe("changelog", () => {
+  describe("GitMessageParser.parseCommit", () => {
+    const defaultConfig = { ignore: ["chore", "ci", "build", "test"] };
+
+    const getParser = () => {
+      const alepha = Alepha.create();
+      return alepha.inject(GitMessageParser);
+    };
+
+    test("should parse conventional commit with scope", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "abc12345 feat(ui): add button component",
+        defaultConfig,
+      );
+
+      expect(result).toEqual({
+        hash: "abc12345",
+        type: "feat",
+        scope: "ui",
+        description: "add button component",
+        breaking: false,
+      });
+    });
+
+    test("should ignore conventional commit without scope", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "def45678 fix: resolve memory leak",
+        defaultConfig,
+      );
+      expect(result).toBeNull();
+    });
+
+    test("should detect breaking change with ! marker", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "aaa78901 feat(api)!: remove deprecated endpoint",
+        defaultConfig,
+      );
+
+      expect(result).toEqual({
+        hash: "aaa78901",
+        type: "feat",
+        scope: "api",
+        description: "remove deprecated endpoint",
+        breaking: true,
+      });
+    });
+
+    test("should detect breaking change in description", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "bbb01234 feat(auth): breaking change to token format",
+        defaultConfig,
+      );
+
+      expect(result).toEqual({
+        hash: "bbb01234",
+        type: "feat",
+        scope: "auth",
+        description: "breaking change to token format",
+        breaking: true,
+      });
+    });
+
+    test("should ignore commits with ignored scope", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "ccc34567 feat(chore): update deps",
+        defaultConfig,
+      );
+      expect(result).toBeNull();
+    });
+
+    test("should ignore commits with nested ignored scope", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "ddd67890 feat(test/unit): add tests",
+        defaultConfig,
+      );
+      expect(result).toBeNull();
+    });
+
+    test("should ignore module-style commits (no type)", () => {
+      const parser = getParser();
+      const result = parser.parseCommit("eee90123 cli: add new command", {});
+      expect(result).toBeNull();
+    });
+
+    test("should return null for non-matching commits", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "fff78901 random commit message",
+        defaultConfig,
+      );
+      expect(result).toBeNull();
+    });
+
+    test("should truncate hash to 8 characters", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "abcdef1234567890 feat(core): something",
+        defaultConfig,
+      );
+      expect(result?.hash).toBe("abcdef12");
+    });
+
+    test("should parse all supported types", () => {
+      const parser = getParser();
+      const types = ["feat", "fix", "docs", "refactor", "perf", "revert"];
+
+      for (const type of types) {
+        const result = parser.parseCommit(
+          `abc12345 ${type}(core): test`,
+          defaultConfig,
+        );
+        expect(result?.type).toBe(type);
+      }
+    });
+
+    test("should handle nested scopes", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "abc12345 feat(api/users): add endpoint",
+        defaultConfig,
+      );
+
+      expect(result).toEqual({
+        hash: "abc12345",
+        type: "feat",
+        scope: "api/users",
+        description: "add endpoint",
+        breaking: false,
+      });
+    });
+  });
+
+  describe("changelogOptions atom", () => {
+    test("should have default ignore list", async () => {
+      const alepha = Alepha.create();
+      await alepha.start();
+
+      const config = alepha.store.get(changelogOptions);
+      expect(config.ignore).toContain("chore");
+      expect(config.ignore).toContain("ci");
+      expect(config.ignore).toContain("build");
+      expect(config.ignore).toContain("test");
+    });
+
+    test("should allow custom configuration", async () => {
+      const alepha = Alepha.create();
+      alepha.set(changelogOptions, {
+        ignore: ["custom", "internal"],
+      });
+      await alepha.start();
+
+      const config = alepha.store.get(changelogOptions);
+      expect(config.ignore).toEqual(["custom", "internal"]);
+    });
+  });
+
+  describe("changelog command", () => {
+    const setupCommand = async (
+      gitMocks: { cmd: string; response: string }[],
+      argv: string[] = ["changelog"],
+      options?: { ignore?: string[] },
+    ) => {
+      setMockGitResponses(gitMocks);
+
+      const alepha = Alepha.create()
+        .with({
+          provide: LogDestinationProvider,
+          use: MemoryDestinationProvider,
+        })
+        .with({ provide: GitProvider, use: MockGitProvider })
+        .with(ChangelogCommand);
+
+      alepha.store.mut(cliOptions, (old) => ({
+        ...old,
+        argv,
+      }));
+
+      if (options) {
+        alepha.set(changelogOptions, options);
+      }
+
+      await alepha.start();
+
+      return {
+        alepha,
+        logger: alepha.inject(MemoryDestinationProvider),
+      };
+    };
+
+    test("should show changes since latest tag", async () => {
+      await setupCommand([
+        { cmd: "tag --sort=-version:refname", response: "1.0.0\n0.9.0\n" },
+        {
+          cmd: "log 1.0.0..HEAD --oneline",
+          response: [
+            "abc12345 feat(ui): add dashboard",
+            "def56789 fix(core): resolve crash",
+          ].join("\n"),
+        },
+      ]);
+      // Outputs to stdout - test verifies no error
+    });
+
+    test("should show changes from specified version", async () => {
+      await setupCommand(
+        [
+          {
+            cmd: "log 0.5.0..HEAD --oneline",
+            response: "abc12345 feat(api): new feature",
+          },
+        ],
+        ["changelog", "--from=0.5.0"],
+      );
+      // Outputs to stdout - test verifies no error
+    });
+
+    test("should handle no tags found", async () => {
+      await setupCommand([
+        { cmd: "tag --sort=-version:refname", response: "" },
+      ]);
+      // Should output "No version tags found" - no error
+    });
+
+    test("should handle no changes since tag", async () => {
+      await setupCommand([
+        { cmd: "tag --sort=-version:refname", response: "1.0.0\n" },
+        { cmd: "log 1.0.0..HEAD --oneline", response: "" },
+      ]);
+      // Should output "No changes since 1.0.0" - no error
+    });
+
+    test("should filter commits by ignore list", async () => {
+      await setupCommand(
+        [
+          { cmd: "tag --sort=-version:refname", response: "1.0.0\n" },
+          {
+            cmd: "log 1.0.0..HEAD --oneline",
+            response: [
+              "abc12345 feat(ui): add dashboard",
+              "def56789 feat(internal): should be filtered",
+            ].join("\n"),
+          },
+        ],
+        ["changelog"],
+        { ignore: ["internal"] },
+      );
+      // "feat(internal)" is filtered out
+    });
+
+    test("should use -f alias for --from", async () => {
+      await setupCommand(
+        [
+          {
+            cmd: "log 0.8.0..HEAD --oneline",
+            response: "abc12345 feat(cli): new command",
+          },
+        ],
+        ["changelog", "-f=0.8.0"],
+      );
+      // Outputs to stdout - test verifies no error
+    });
+  });
+});

package/src/cli/commands/{changelog.ts → gen/changelog.ts}

@@ -3,15 +3,15 @@ import { promisify } from "node:util";
 import { $inject, $use, t } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
-import { changelogOptions } from "../atoms/changelogOptions.ts";
-import { GitMessageParser } from "../services/GitMessageParser.ts";
+import { changelogOptions } from "../../atoms/changelogOptions.ts";
+import { GitMessageParser } from "../../services/GitMessageParser.ts";
 
 export {
   type ChangelogOptions,
   changelogOptions,
   DEFAULT_IGNORE,
-} from "../atoms/changelogOptions.ts";
-export { GitMessageParser } from "../services/GitMessageParser.ts";
+} from "../../atoms/changelogOptions.ts";
+export { GitMessageParser } from "../../services/GitMessageParser.ts";
 
 const execAsync = promisify(exec);
 
@@ -55,10 +55,10 @@ interface ChangelogEntry {
  * Changelog command for generating release notes from git commits.
  *
  * Usage:
- * - `alepha changelog` - Show unreleased changes since latest tag to HEAD
- * - `alepha changelog --from=1.0.0` - Show changes from version to HEAD
- * - `alepha changelog --from=1.0.0 --to=1.1.0` - Show changes between two refs
- * - `alepha changelog | tee -a CHANGELOG.md` - Append to file
+ * - `alepha gen changelog` - Show unreleased changes since latest tag to HEAD
+ * - `alepha gen changelog --from=1.0.0` - Show changes from version to HEAD
+ * - `alepha gen changelog --from=1.0.0 --to=1.1.0` - Show changes between two refs
+ * - `alepha gen changelog | tee -a CHANGELOG.md` - Append to file
  */
 export class ChangelogCommand {
   protected readonly log = $logger();
@@ -166,7 +166,7 @@ export class ChangelogCommand {
   // COMMAND
   // ---------------------------------------------------------------------------
 
-  public readonly changelog = $command({
+  public readonly command = $command({
     name: "changelog",
     description:
       "Generate changelog from conventional commits (outputs to stdout)",

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

@@ -0,0 +1,71 @@
+import { $inject, t } from "alepha";
+import { $command } from "alepha/command";
+import { FileSystemProvider } from "alepha/file";
+import { $logger } from "alepha/logger";
+import { ServerSwaggerProvider } from "alepha/server/swagger";
+import { AlephaCliUtils } from "../../services/AlephaCliUtils.ts";
+
+export class OpenApiCommand {
+  protected readonly log = $logger();
+  protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly fs = $inject(FileSystemProvider);
+
+  public readonly command = $command({
+    name: "openapi",
+    description: "Generate OpenAPI specification from actions",
+    flags: t.object({
+      out: t.optional(
+        t.text({
+          aliases: ["o"],
+          description: "Output file path",
+        }),
+      ),
+    }),
+    handler: async ({ root, flags }) => {
+      const { alepha } = await this.utils.loadAlephaFromServerEntryFile(root);
+
+      try {
+        const openapiProvider = alepha.inject(
+          ServerSwaggerProvider,
+        ) as ServerSwaggerProvider;
+
+        await alepha.events.emit("configure", alepha);
+
+        let json: any = openapiProvider.json;
+
+        if (!json) {
+          json = openapiProvider.generateSwaggerDoc({
+            info: {
+              title: "API Documentation",
+              version: "1.0.0",
+            },
+          });
+        }
+
+        if (!json) {
+          this.log.error("No actions found to generate OpenAPI specification.");
+          return;
+        }
+
+        if (flags.out) {
+          await this.fs.writeFile(
+            this.fs.join(root, flags.out),
+            JSON.stringify(json, null, 2),
+          );
+        } else {
+          this.log.info(JSON.stringify(json, null, 2));
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("Service not found")) {
+          this.log.error(
+            "Missing $swagger() primitive in your server configuration.",
+          );
+          return;
+        }
+
+        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

@@ -0,0 +1,24 @@
+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,
+      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,
           });
@@ -61,6 +60,8 @@ export class InitCommand {
       if (pm === "yarn") {
         await this.utils.ensureYarn(root);
         await run("yarn set version stable");
+      } else if (pm === "bun") {
+        await this.utils.ensureBun(root);
       } else if (pm === "pnpm") {
         await this.utils.ensurePnpm(root);
       } else {

package/src/cli/commands/root.ts

@@ -1,11 +1,13 @@
-import { $inject, t } from "alepha";
+import { $inject, Alepha, t } from "alepha";
 import { $command, CliProvider } from "alepha/command";
-import { $logger } from "alepha/logger";
+import { $logger, ConsoleColorProvider } from "alepha/logger";
 import { version } from "../version.ts";
 
 export class RootCommand {
   protected readonly log = $logger();
   protected readonly cli = $inject(CliProvider);
+  protected readonly alepha = $inject(Alepha);
+  protected readonly color = $inject(ConsoleColorProvider);
 
   /**
    * Called when no command is provided
@@ -22,7 +24,14 @@ export class RootCommand {
     }),
     handler: async ({ flags }) => {
       if (flags.version) {
-        this.log.info(version);
+        this.log.info(this.color.set("WHITE_BOLD", `Alepha v${version}`));
+        if (this.alepha.isBun()) {
+          this.log.info(this.color.set("GREY_DARK", `└─ Bun v${Bun.version}`));
+        } else {
+          this.log.info(
+            this.color.set("GREY_DARK", `└─ Node ${process.version}`),
+          );
+        }
         return;
       }
 

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/typecheck.ts

@@ -1,19 +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/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,
     };
   };
 };