alepha 0.14.0 → 0.14.1

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",