alepha 0.14.0 → 0.14.2

package/src/redis/providers/RedisSubscriberProvider.ts

@@ -1,56 +1,65 @@
-import { $hook, $inject, Alepha } from "alepha";
-import { $logger } from "alepha/logger";
-import type { RedisClient } from "./RedisProvider.ts";
-import { RedisProvider } from "./RedisProvider.ts";
-
-export class RedisSubscriberProvider {
-  protected readonly log = $logger();
-  protected readonly alepha = $inject(Alepha);
-  protected readonly redisProvider: RedisProvider = $inject(RedisProvider);
-  protected readonly client: RedisClient = this.createClient();
-
-  public get subscriber(): RedisClient {
-    if (!this.client.isReady) {
-      throw new Error("Redis client is not ready");
-    }
-
-    return this.client;
-  }
-
-  protected readonly start = $hook({
-    on: "start",
-    handler: () => this.connect(),
-  });
-
-  protected readonly stop = $hook({
-    on: "stop",
-    handler: () => this.close(),
-  });
-
-  public async connect(): Promise<void> {
-    this.log.debug("Connecting...");
-    await this.client.connect();
-    this.log.info("Connection OK");
-  }
+/**
+ * Abstract Redis subscriber provider interface.
+ *
+ * This abstract class defines the common interface for Redis pub/sub subscriptions.
+ * Implementations include:
+ * - {@link NodeRedisSubscriberProvider} - Uses `@redis/client` for Node.js runtime
+ * - {@link BunRedisSubscriberProvider} - Uses Bun's native `RedisClient` for Bun runtime
+ *
+ * Redis requires separate connections for pub/sub operations, so this provider
+ * creates a dedicated connection for subscriptions.
+ *
+ * @example
+ * ```ts
+ * // Inject the abstract provider - runtime selects the implementation
+ * const subscriber = alepha.inject(RedisSubscriberProvider);
+ *
+ * // Subscribe to a channel
+ * await subscriber.subscribe("my-channel", (message, channel) => {
+ *   console.log(`Received: ${message} on ${channel}`);
+ * });
+ * ```
+ */
+export abstract class RedisSubscriberProvider {
+  /**
+   * Whether the Redis subscriber client is ready to accept commands.
+   */
+  public abstract readonly isReady: boolean;
 
-  public async close(): Promise<void> {
-    this.log.debug("Closing connection...");
-    this.subscriber.close();
-    this.log.info("Connection closed");
-  }
+  /**
+   * Connect to the Redis server for subscriptions.
+   */
+  public abstract connect(): Promise<void>;
 
   /**
-   * Redis subscriber client factory method.
+   * Close the subscriber connection.
    */
-  protected createClient(): RedisClient {
-    const client = this.redisProvider.duplicate();
+  public abstract close(): Promise<void>;
 
-    client.on("error", (error) => {
-      if (this.alepha.isStarted()) {
-        this.log.error(error);
-      }
-    });
+  /**
+   * Subscribe to a channel.
+   *
+   * @param channel The channel name.
+   * @param callback The callback to invoke when a message is received.
+   */
+  public abstract subscribe(
+    channel: string,
+    callback: SubscribeCallback,
+  ): Promise<void>;
 
-    return client;
-  }
+  /**
+   * Unsubscribe from a channel.
+   *
+   * @param channel The channel name.
+   * @param callback Optional specific callback to remove.
+   */
+  public abstract unsubscribe(
+    channel: string,
+    callback?: SubscribeCallback,
+  ): Promise<void>;
 }
+
+/**
+ * Callback for subscription messages.
+ */
+export type SubscribeCallback = (message: string, channel: string) => void;

package/src/server/core/providers/BunHttpServerProvider.ts

@@ -21,9 +21,6 @@ declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
 
-// Type declaration for Bun global (only when running in Bun runtime)
-declare const Bun: any;
-
 export class BunHttpServerProvider extends ServerProvider {
   protected readonly alepha = $inject(Alepha);
   protected readonly dateTimeProvider = $inject(DateTimeProvider);

package/src/server/core/providers/ServerBodyParserProvider.ts

@@ -36,7 +36,9 @@ export class ServerBodyParserProvider {
       } else if (request.raw.node?.req) {
         // convert Node.js IncomingMessage to Web ReadableStream
         // TODO: check performance impact, it's better to directly read from Node stream!
-        stream = WebStream.from(request.raw.node.req) as ReadableStream;
+        stream = WebStream.from(
+          request.raw.node.req,
+        ) as unknown as ReadableStream;
       }
 
       if (!stream) {

package/src/server/core/providers/ServerProvider.ts

@@ -212,10 +212,13 @@ export class ServerProvider {
 
     // if response.body is node stream
     if (response.body instanceof Readable) {
-      ev.res = new Response(Readable.toWeb(response.body) as ReadableStream, {
-        status: response.status,
-        headers: response.headers,
-      });
+      ev.res = new Response(
+        Readable.toWeb(response.body) as unknown as ReadableStream,
+        {
+          status: response.status,
+          headers: response.headers,
+        },
+      );
       return;
     }
 

package/src/server/multipart/providers/ServerMultipartProvider.ts

@@ -59,7 +59,9 @@ export class ServerMultipartProvider {
         webRequest = new Request(request.url, {
           method: request.method,
           headers: request.headers,
-          body: WebStream.from(request.raw.node.req) as ReadableStream,
+          body: WebStream.from(
+            request.raw.node.req,
+          ) as unknown as ReadableStream,
           duplex: "half",
         } as RequestInit & { duplex: "half" });
       }

package/src/server/proxy/providers/ServerProxyProvider.ts

@@ -116,7 +116,7 @@ export class ServerProxyProvider {
 
     if (req.raw?.node?.req) {
       const nodeReq = req.raw.node.req;
-      return WebStream.from(nodeReq) as ReadableStream;
+      return WebStream.from(nodeReq) as unknown as ReadableStream;
     }
   }
 }

package/src/topic/redis/providers/RedisTopicProvider.ts

@@ -42,7 +42,7 @@ export class RedisTopicProvider extends TopicProvider {
    * Publish a message to a topic.
    */
   public async publish(topic: string, message: string): Promise<void> {
-    await this.redisProvider.publisher.publish(this.prefix(topic), message);
+    await this.redisProvider.publish(this.prefix(topic), message);
   }
 
   /**
@@ -53,7 +53,7 @@ export class RedisTopicProvider extends TopicProvider {
     callback: SubscribeCallback,
   ): Promise<UnSubscribeFn> {
     const topic = this.prefix(name);
-    await this.redisSubscriberProvider.subscriber.subscribe(topic, callback);
+    await this.redisSubscriberProvider.subscribe(topic, callback);
 
     return () => this.unsubscribe(name, callback);
   }
@@ -67,6 +67,6 @@ export class RedisTopicProvider extends TopicProvider {
   ): Promise<void> {
     const topic = this.prefix(name);
 
-    await this.redisSubscriberProvider.subscriber.unsubscribe(topic, callback);
+    await this.redisSubscriberProvider.unsubscribe(topic, callback);
   }
 }

package/src/vite/tasks/buildServer.ts

@@ -91,6 +91,7 @@ export async function buildServer(
       minify: true,
       chunkSizeWarningLimit: 10000,
       rollupOptions: {
+        external: ["bun"],
         output: {
           entryFileNames: "[hash].js",
           chunkFileNames: "[hash].js",

package/src/cli/commands/BiomeCommands.ts

@@ -1,29 +0,0 @@
-import { $inject } from "alepha";
-import { $command } from "alepha/command";
-import { $logger } from "alepha/logger";
-import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
-
-export class BiomeCommands {
-  protected readonly log = $logger();
-  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`);
-    },
-  });
-
-  public readonly lint = $command({
-    name: "lint",
-    description: "Run linter across 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 check --formatter-enabled=false --fix`);
-    },
-  });
-}

package/src/cli/commands/ChangelogCommands.ts

@@ -1,389 +0,0 @@
-import { exec } from "node:child_process";
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { promisify } from "node:util";
-import { t } from "alepha";
-import { $command } from "alepha/command";
-
-const execAsync = promisify(exec);
-
-interface Commit {
-  hash: string;
-  type: string;
-  scope: string | null;
-  description: string;
-  breaking: boolean;
-}
-
-interface ChangelogEntry {
-  version: string;
-  date: string;
-  features: Commit[];
-  fixes: Commit[];
-  docs: Commit[];
-  improvements: Commit[];
-  breaking: Commit[];
-}
-
-interface ChangelogConfig {
-  /**
-   * Commit prefixes to ignore (e.g., "project", "release", "chore")
-   */
-  ignore?: string[];
-  /**
-   * Module scopes to recognize (e.g., "ui", "cli", "core")
-   * If not provided, all non-ignored scopes are included
-   */
-  scopes?: string[];
-}
-
-const DEFAULT_IGNORE = [
-  "project",
-  "release",
-  "starter",
-  "example",
-  "chore",
-  "ci",
-  "build",
-  "test",
-  "style",
-];
-
-function parseCommit(line: string, config: ChangelogConfig): Commit | null {
-  const match = line.match(/^([a-f0-9]+)\s+(.+)$/);
-  if (!match) return null;
-
-  const [, hash, message] = match;
-  const breaking =
-    message.includes("!:") || message.toLowerCase().includes("breaking");
-  const ignore = config.ignore ?? DEFAULT_IGNORE;
-
-  // Conventional commit: feat(scope): description or feat!: description
-  const conventionalMatch = message.match(
-    /^(feat|fix|docs|refactor|perf|revert)(?:\(([^)]+)\))?!?:\s*(.+)$/i,
-  );
-  if (conventionalMatch) {
-    const [, type, scope, description] = conventionalMatch;
-
-    // Skip if scope matches ignore list
-    if (scope) {
-      const baseScope = scope.split("/")[0];
-      if (ignore.includes(baseScope) || ignore.includes(scope)) {
-        return null;
-      }
-    }
-
-    // Skip if type (without scope) matches ignore list (e.g., "docs" in ignore)
-    if (!scope && ignore.includes(type.toLowerCase())) {
-      return null;
-    }
-
-    return {
-      hash: hash.substring(0, 8),
-      type: type.toLowerCase(),
-      scope: scope || null,
-      description: description.trim(),
-      breaking,
-    };
-  }
-
-  // Module-specific commit: module: description or module/submodule: description
-  const moduleMatch = message.match(
-    /^([a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)?):\s*(.+)$/i,
-  );
-  if (moduleMatch) {
-    const [, module, description] = moduleMatch;
-    const baseModule = module.split("/")[0];
-
-    // Skip ignored prefixes
-    if (ignore.includes(baseModule)) {
-      return null;
-    }
-
-    // If scopes are defined, check if this is a known scope
-    if (config.scopes && !config.scopes.includes(baseModule)) {
-      return null;
-    }
-
-    // Determine type based on description keywords
-    const desc = description.toLowerCase();
-    let type = "improve";
-    if (
-      desc.includes("fix") ||
-      desc.includes("bug") ||
-      desc.includes("issue")
-    ) {
-      type = "fix";
-    } else if (
-      desc.includes("add") ||
-      desc.includes("new") ||
-      desc.includes("implement")
-    ) {
-      type = "feat";
-    }
-
-    return {
-      hash: hash.substring(0, 8),
-      type,
-      scope: module,
-      description: description.trim(),
-      breaking,
-    };
-  }
-
-  return null;
-}
-
-function formatCommit(commit: Commit): string {
-  const scope = commit.scope ? `**${commit.scope}**: ` : "";
-  return `- ${scope}${commit.description} (\`${commit.hash}\`)`;
-}
-
-function generateChangelog(entries: ChangelogEntry[]): string {
-  let output = "# Changelog\n\n";
-  output +=
-    "All notable changes to this project will be documented in this file.\n\n";
-
-  for (const entry of entries) {
-    output += `## [${entry.version}] - ${entry.date}\n\n`;
-    output += formatEntry(entry);
-  }
-
-  return output;
-}
-
-function formatEntry(entry: ChangelogEntry): string {
-  let output = "";
-
-  if (entry.breaking.length > 0) {
-    output += "### Breaking Changes\n\n";
-    for (const commit of entry.breaking) {
-      output += `${formatCommit(commit)}\n`;
-    }
-    output += "\n";
-  }
-
-  if (entry.features.length > 0) {
-    output += "### Features\n\n";
-    for (const commit of entry.features) {
-      output += `${formatCommit(commit)}\n`;
-    }
-    output += "\n";
-  }
-
-  if (entry.fixes.length > 0) {
-    output += "### Bug Fixes\n\n";
-    for (const commit of entry.fixes) {
-      output += `${formatCommit(commit)}\n`;
-    }
-    output += "\n";
-  }
-
-  return output;
-}
-
-async function loadConfig(root: string): Promise<ChangelogConfig> {
-  try {
-    const pkgPath = join(root, "package.json");
-    const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
-    return pkg.changelog ?? {};
-  } catch {
-    return {};
-  }
-}
-
-export class ChangelogCommands {
-  public readonly changelog = $command({
-    name: "changelog",
-    description: "Generate CHANGELOG.md from git commits",
-    flags: t.object({
-      release: t.optional(
-        t.boolean({
-          when: ["--release", "-r"],
-          description:
-            "Output release notes for the latest version only (for GitHub Release)",
-        }),
-      ),
-      preview: t.optional(
-        t.boolean({
-          when: ["--preview", "-p"],
-          description: "Preview unreleased changes (commits since last tag)",
-        }),
-      ),
-      output: t.optional(
-        t.string({
-          when: ["--output", "-o"],
-          description:
-            "Output file path (defaults to CHANGELOG.md, use - for stdout)",
-        }),
-      ),
-      limit: t.optional(
-        t.number({
-          when: ["--limit", "-l"],
-          description: "Limit number of versions to include",
-        }),
-      ),
-    }),
-    handler: async ({ flags, run, root }) => {
-      const config = await loadConfig(root);
-
-      const git = async (cmd: string) => {
-        const { stdout } = await execAsync(`git ${cmd}`, { cwd: root });
-        return stdout;
-      };
-
-      // Get all tags sorted by version
-      const tagsOutput = await git("tag --sort=-version:refname");
-      const tags = tagsOutput
-        .trim()
-        .split("\n")
-        .filter((tag) => tag.match(/^\d+\.\d+\.\d+$/));
-
-      if (tags.length === 0) {
-        throw new Error("No version tags found");
-      }
-
-      // Preview mode: show unreleased changes
-      if (flags.preview) {
-        const latestTag = tags[0];
-        const commitsOutput = await git(`log ${latestTag}..HEAD --oneline`);
-
-        if (!commitsOutput.trim()) {
-          console.log("No unreleased changes since", latestTag);
-          return;
-        }
-
-        const entry: ChangelogEntry = {
-          version: "Unreleased",
-          date: new Date().toISOString().split("T")[0],
-          features: [],
-          fixes: [],
-          docs: [],
-          improvements: [],
-          breaking: [],
-        };
-
-        for (const line of commitsOutput.trim().split("\n")) {
-          if (!line.trim()) continue;
-          const commit = parseCommit(line, config);
-          if (!commit) continue;
-
-          if (commit.breaking) entry.breaking.push(commit);
-
-          switch (commit.type) {
-            case "feat":
-              entry.features.push(commit);
-              break;
-            case "fix":
-              entry.fixes.push(commit);
-              break;
-            case "docs":
-              entry.docs.push(commit);
-              break;
-            case "refactor":
-            case "perf":
-            case "improve":
-              entry.improvements.push(commit);
-              break;
-          }
-        }
-
-        const hasCommits =
-          entry.features.length > 0 ||
-          entry.fixes.length > 0 ||
-          entry.breaking.length > 0;
-
-        if (!hasCommits) {
-          console.log("No public changes since", latestTag);
-          return;
-        }
-
-        console.log(`## [Unreleased] - since ${latestTag}\n`);
-        console.log(formatEntry(entry));
-        return;
-      }
-
-      const entries: ChangelogEntry[] = [];
-      const limit = flags.limit || (flags.release ? 1 : tags.length);
-
-      for (let i = 0; i < Math.min(limit, tags.length); i++) {
-        const tag = tags[i];
-        const prevTag = tags[i + 1];
-
-        // Get tag date
-        const dateOutput = await git(`log -1 --format=%ci ${tag}`);
-        const date = dateOutput.trim().split(" ")[0];
-
-        // Get commits between tags
-        const range = prevTag ? `${prevTag}..${tag}` : tag;
-        const commitsOutput = await git(`log ${range} --oneline`);
-
-        const entry: ChangelogEntry = {
-          version: tag,
-          date,
-          features: [],
-          fixes: [],
-          docs: [],
-          improvements: [],
-          breaking: [],
-        };
-
-        for (const line of commitsOutput.trim().split("\n")) {
-          if (!line.trim()) continue;
-          const commit = parseCommit(line, config);
-          if (!commit) continue;
-
-          if (commit.breaking) entry.breaking.push(commit);
-
-          switch (commit.type) {
-            case "feat":
-              entry.features.push(commit);
-              break;
-            case "fix":
-              entry.fixes.push(commit);
-              break;
-            case "docs":
-              entry.docs.push(commit);
-              break;
-            case "refactor":
-            case "perf":
-            case "improve":
-              entry.improvements.push(commit);
-              break;
-          }
-        }
-
-        // Only add entry if it has any commits
-        const hasCommits =
-          entry.features.length > 0 ||
-          entry.fixes.length > 0 ||
-          entry.breaking.length > 0;
-
-        if (hasCommits) {
-          entries.push(entry);
-        }
-      }
-
-      if (entries.length === 0) {
-        console.log("No public commits found");
-        return;
-      }
-
-      let output: string;
-      if (flags.release) {
-        output = formatEntry(entries[0]);
-      } else {
-        output = generateChangelog(entries);
-      }
-
-      const outputPath = flags.output ?? "CHANGELOG.md";
-      if (outputPath === "-") {
-        console.log(output);
-      } else {
-        await run(`Writing ${outputPath}`, () =>
-          writeFile(join(root, outputPath), output, "utf8"),
-        );
-      }
-    },
-  });
-}