alepha 0.13.8 → 0.14.1

package/src/redis/providers/RedisProvider.ts

@@ -1,167 +1,161 @@
-import {
-  createClient,
-  RESP_TYPES,
-  type RedisClientType,
-  type SetOptions,
-} from "@redis/client";
-import { $env, $hook, $inject, Alepha, type Static, t } from "alepha";
-import { $logger } from "alepha/logger";
-
-const envSchema = t.object({
-  REDIS_PORT: t.integer({
-    default: "6379",
-  }),
-  REDIS_HOST: t.text({
-    default: "localhost",
-  }),
-  REDIS_PASSWORD: t.optional(t.text()),
-});
-
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-}
-
-export type RedisClient = RedisClientType<
-  {},
-  {},
-  {},
-  3,
-  { 36: BufferConstructor }
->;
-export type RedisClientOptions = Parameters<typeof createClient>[0];
-export type RedisSetOptions = SetOptions;
-
 /**
- * Redis client provider.
+ * Abstract Redis provider interface.
+ *
+ * This abstract class defines the common interface for Redis operations.
+ * Implementations include:
+ * - {@link NodeRedisProvider} - Uses `@redis/client` for Node.js runtime
+ * - {@link BunRedisProvider} - Uses Bun's native `RedisClient` for Bun runtime
+ *
+ * @example
+ * ```ts
+ * // Inject the abstract provider - runtime selects the implementation
+ * const redis = alepha.inject(RedisProvider);
+ *
+ * // Use common operations
+ * await redis.set("key", "value");
+ * const value = await redis.get("key");
+ * ```
  */
-export class RedisProvider {
-  protected readonly log = $logger();
-  protected readonly alepha = $inject(Alepha);
-  protected readonly env = $env(envSchema);
-  protected readonly client = this.createClient();
-
-  public get publisher(): 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(),
-  });
+export abstract class RedisProvider {
+  /**
+   * Whether the Redis client is ready to accept commands.
+   */
+  public abstract readonly isReady: boolean;
 
   /**
    * Connect to the Redis server.
    */
-  public async connect(): Promise<void> {
-    this.log.debug("Connecting...");
-    await this.client.connect();
-    this.log.info("Connection OK");
-  }
+  public abstract connect(): Promise<void>;
 
   /**
    * Close the connection to the Redis server.
    */
-  public async close(): Promise<void> {
-    this.log.debug("Closing connection...");
-    await this.client.close();
-    this.log.info("Connection closed");
-  }
-
-  public duplicate(options?: Partial<RedisClientOptions>): RedisClient {
-    return this.client
-      .duplicate({
-        ...options,
-        RESP: 3,
-      })
-      .withTypeMapping({
-        [RESP_TYPES.BLOB_STRING]: Buffer,
-      });
-  }
-
-  public async get(key: string): Promise<Buffer | undefined> {
-    this.log.trace(`Getting key ${key}`);
-    const resp = await this.publisher.get(key);
-
-    if (resp === null) {
-      return undefined;
-    }
+  public abstract close(): Promise<void>;
 
-    return Buffer.from(resp);
-  }
+  /**
+   * Get the value of a key.
+   *
+   * @param key The key to get.
+   * @returns The value as a Buffer, or undefined if the key does not exist.
+   */
+  public abstract get(key: string): Promise<Buffer | undefined>;
 
-  public async set(
+  /**
+   * Set the value of a key.
+   *
+   * @param key The key to set.
+   * @param value The value to set (Buffer or string).
+   * @param options Optional set options (EX, PX, NX, XX, etc.).
+   * @returns The value as a Buffer.
+   */
+  public abstract set(
     key: string,
     value: Buffer | string,
     options?: RedisSetOptions,
-  ): Promise<Buffer> {
-    const buf = Buffer.isBuffer(value) ? value : Buffer.from(value, "utf-8");
-    const resp = await this.publisher.set(key, buf, options);
-
-    if (resp === "OK" || !resp) {
-      return buf;
-    }
-
-    return Buffer.from(resp);
-  }
-
-  public async has(key: string): Promise<boolean> {
-    const resp = await this.publisher.exists(key);
-    return resp > 0;
-  }
+  ): Promise<Buffer>;
 
-  public async keys(pattern: string): Promise<string[]> {
-    const keys = await this.publisher.keys(pattern);
-    return keys.map((key) => key.toString());
-  }
-
-  public async del(keys: string[]): Promise<void> {
-    if (keys.length === 0) {
-      return;
-    }
+  /**
+   * Check if a key exists.
+   *
+   * @param key The key to check.
+   * @returns True if the key exists.
+   */
+  public abstract has(key: string): Promise<boolean>;
 
-    await this.publisher.del(keys);
-  }
+  /**
+   * Get all keys matching a pattern.
+   *
+   * @param pattern The glob-style pattern to match.
+   * @returns Array of matching key names.
+   */
+  public abstract keys(pattern: string): Promise<string[]>;
 
   /**
-   * Redis subscriber client factory method.
+   * Delete one or more keys.
+   *
+   * @param keys The keys to delete.
    */
-  protected createClient(): RedisClient {
-    const url = new URL("redis://127.0.0.1:6379");
+  public abstract del(keys: string[]): Promise<void>;
 
-    if (this.env.REDIS_PASSWORD) {
-      url.password = this.env.REDIS_PASSWORD;
-    }
+  // ---------------------------------------------------------
+  // Queue operations (for alepha/queue-redis)
+  // ---------------------------------------------------------
 
-    if (this.env.REDIS_HOST) {
-      url.hostname = this.env.REDIS_HOST;
-    }
+  /**
+   * Push a value to the left (head) of a list.
+   *
+   * @param key The list key.
+   * @param value The value to push.
+   */
+  public abstract lpush(key: string, value: string): Promise<void>;
 
-    if (this.env.REDIS_PORT) {
-      url.port = String(this.env.REDIS_PORT);
-    }
+  /**
+   * Pop a value from the right (tail) of a list.
+   *
+   * @param key The list key.
+   * @returns The value, or undefined if the list is empty.
+   */
+  public abstract rpop(key: string): Promise<string | undefined>;
 
-    const client = createClient({
-      url: url.toString(),
-      RESP: 3,
-    }).withTypeMapping({
-      [RESP_TYPES.BLOB_STRING]: Buffer,
-    });
+  // ---------------------------------------------------------
+  // Pub/Sub operations (for alepha/topic-redis)
+  // ---------------------------------------------------------
 
-    client.on("error", (error) => {
-      if (this.alepha.isStarted()) {
-        this.log.error(error);
-      }
-    });
+  /**
+   * Publish a message to a channel.
+   *
+   * @param channel The channel name.
+   * @param message The message to publish.
+   */
+  public abstract publish(channel: string, message: string): Promise<void>;
+}
 
-    return client;
-  }
+/**
+ * Common Redis SET command options.
+ * Compatible with @redis/client SetOptions format.
+ */
+export interface RedisSetOptions {
+  /**
+   * Set the specified expire time, in seconds.
+   */
+  EX?: number;
+  /**
+   * Set the specified expire time, in milliseconds.
+   */
+  PX?: number;
+  /**
+   * Set the specified Unix time at which the key will expire, in seconds.
+   */
+  EXAT?: number;
+  /**
+   * Set the specified Unix time at which the key will expire, in milliseconds.
+   */
+  PXAT?: number;
+  /**
+   * Only set the key if it does not already exist.
+   */
+  NX?: boolean;
+  /**
+   * Only set the key if it already exists.
+   */
+  XX?: boolean;
+  /**
+   * Retain the time to live associated with the key.
+   */
+  KEEPTTL?: boolean;
+  /**
+   * Return the old string stored at key, or nil if key did not exist.
+   */
+  GET?: boolean;
+  /**
+   * Alternative expiration format (compatible with @redis/client).
+   */
+  expiration?: {
+    type: "EX" | "PX" | "EXAT" | "PXAT" | "KEEPTTL";
+    value: number;
+  };
+  /**
+   * Alternative condition format (compatible with @redis/client).
+   */
+  condition?: "NX" | "XX";
 }

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/plugins/viteAlephaBuild.ts

@@ -1,4 +1,5 @@
 import { readFile, unlink, writeFile } from "node:fs/promises";
+import { OPTIONS } from "alepha";
 import type { Plugin, UserConfig } from "vite";
 import { boot } from "../helpers/boot.ts";
 import { fileExists } from "../helpers/fileExists.ts";
@@ -14,6 +15,7 @@ import {
   generateVercel,
   prerenderPages,
   type VercelConfig,
+  type WranglerConfig,
 } from "../tasks/index.ts";
 
 export interface ViteAlephaBuildOptions {
@@ -43,7 +45,7 @@ export interface ViteAlephaBuildOptions {
    *
    * @default false
    */
-  cloudflare?: boolean;
+  cloudflare?: boolean | WranglerConfig;
 
   /**
    * If true, the build will be optimized for Docker deployment.
@@ -89,8 +91,9 @@ export async function viteAlephaBuild(
   let rootConfig: UserConfig = {};
 
   return {
-    name: "alepha-build",
+    name: "alepha:build",
     apply: "build",
+    [OPTIONS as any]: options,
     config(config, ctx) {
       const buildMode = process.env.ALEPHA_BUILD_MODE as
         | AlephaBuildMode
@@ -254,8 +257,11 @@ export async function viteAlephaBuild(
       }
 
       if (options.cloudflare) {
+        const config =
+          typeof options.cloudflare === "boolean" ? {} : options.cloudflare;
         await generateCloudflare({
           distDir,
+          config,
         });
       }
 

package/src/vite/plugins/viteAlephaDev.ts

@@ -132,12 +132,16 @@ export async function viteAlephaDev(
       });
 
       server.config.logger.info = (msg: string) => {
-        runner.app?.log?.info(msg.trim());
+        console.log(msg);
       };
 
       server.config.logger.clearScreen = () => {};
 
-      await runner.start(server);
+      // Return a function - it runs AFTER internal middlewares are set up
+      // and after buildStart has been called
+      return async () => {
+        await runner.start(server);
+      };
     },
     async closeBundle() {
       // Cleanup handled by runner

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",
@@ -144,7 +145,7 @@ export async function buildServer(
 
   await writeFile(
     `${opts.distDir}/index.js`,
-    `${warning}\nimport './server/${entryFile}';${template}`.trim(),
+    `${warning}\nimport './server/${entryFile}';\n\n${template}`.trim(),
   );
 
   return { entryFile };

package/src/vite/tasks/generateCloudflare.ts

@@ -1,4 +1,4 @@
-import { writeFile } from "node:fs/promises";
+import { access, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 
 export interface GenerateCloudflareOptions {
@@ -8,6 +8,15 @@ export interface GenerateCloudflareOptions {
    * @default "dist"
    */
   distDir?: string;
+
+  /**
+   * Additional Wrangler configuration options to merge into wrangler.jsonc.
+   */
+  config?: WranglerConfig;
+}
+
+export interface WranglerConfig {
+  [key: string]: any;
 }
 
 const WARNING_COMMENT =
@@ -27,30 +36,47 @@ export async function generateCloudflare(
   const distDir = opts.distDir ?? "dist";
   const root = process.cwd();
   const name = basename(root);
+  const hasAssets = await access(join(root, distDir, "public"))
+    .then(() => true)
+    .catch(() => false);
 
-  await writeWranglerConfig(root, distDir, name);
-  await writeWorkerEntryPoint(root, distDir);
-}
-
-/**
- * Write the wrangler.jsonc configuration file for Cloudflare Workers
- */
-async function writeWranglerConfig(
-  root: string,
-  distDir: string,
-  name: string,
-): Promise<void> {
-  const wrangler = {
+  const wrangler: WranglerConfig = {
     name,
     main: "./main.cloudflare.js",
     compatibility_flags: ["nodejs_compat"],
     compatibility_date: "2025-11-17",
+    ...opts.config,
   };
 
+  if (hasAssets) {
+    wrangler.assets ??= {
+      directory: "./public",
+      binding: "ASSETS",
+    };
+  }
+
+  const url = process.env.DATABASE_URL;
+  if (url?.startsWith("cloudflare-d1:")) {
+    const [name, id] = url
+      .replace("cloudflare-d1://", "")
+      .replace("cloudflare-d1:", "")
+      .split(":");
+    wrangler.d1_databases = wrangler.d1_databases || [];
+    wrangler.d1_databases.push({
+      binding: name,
+      database_name: name,
+      database_id: id,
+    });
+    wrangler.vars ??= {};
+    wrangler.vars.DATABASE_URL = `cloudflare-d1://${name}:${id}`;
+  }
+
   await writeFile(
     join(root, distDir, "wrangler.jsonc"),
     JSON.stringify(wrangler, null, 2),
   );
+
+  await writeWorkerEntryPoint(root, distDir);
 }
 
 /**
@@ -64,9 +90,11 @@ async function writeWorkerEntryPoint(
 import "./index.js";
 
 export default {
-  fetch: async (request) => {
+  fetch: async (request, env) => {
     const ctx = { req: request, res: undefined };
 
+    __alepha.set("cloudflare.env", env);
+
     await __alepha.start();
     await __alepha.events.emit("web:request", ctx);