alepha 0.14.0 → 0.14.2

package/src/orm/services/QueryManager.ts

@@ -38,10 +38,8 @@ import type {
   PgQueryWhere,
   PgQueryWhereOrSQL,
 } from "../interfaces/PgQueryWhere.ts";
-import { PgJsonQueryManager } from "./PgJsonQueryManager.ts";
 
 export class QueryManager {
-  protected readonly jsonQueryManager = $inject(PgJsonQueryManager);
   protected readonly alepha = $inject(Alepha);
 
   /**
@@ -157,40 +155,16 @@ export class QueryManager {
         }
 
         if (operator) {
-          // Check if this is a JSONB column with nested query
-          // BUT skip primitive arrays - they should use native Drizzle operators
-          if (
-            this.jsonQueryManager.isJsonbColumn(schema, key) &&
-            !this.jsonQueryManager.isPrimitiveArray(schema, key) &&
-            typeof operator === "object" &&
-            !Array.isArray(operator) &&
-            this.jsonQueryManager.hasNestedQuery({ [key]: operator })
-          ) {
-            // Handle JSONB nested queries for objects and arrays of objects
-            const column = col(key);
-            const jsonbSql = this.buildJsonbQuery(
-              column,
-              operator,
-              schema,
-              key,
-              options.dialect,
-            );
-            if (jsonbSql) {
-              conditions.push(jsonbSql);
-            }
-          } else {
-            // Regular column query (including primitive arrays)
-            const column = col(key);
-            const sql = this.mapOperatorToSql(
-              operator,
-              column,
-              schema,
-              key,
-              options.dialect,
-            );
-            if (sql) {
-              conditions.push(sql);
-            }
+          const column = col(key);
+          const sql = this.mapOperatorToSql(
+            operator,
+            column,
+            schema,
+            key,
+            options.dialect,
+          );
+          if (sql) {
+            conditions.push(sql);
           }
         }
       }
@@ -203,95 +177,6 @@ export class QueryManager {
     return and(...conditions);
   }
 
-  /**
-   * Build a JSONB query for nested object/array queries.
-   */
-  protected buildJsonbQuery(
-    column: PgColumn,
-    nestedQuery: any,
-    schema: TObject,
-    columnName: string,
-    dialect: "postgresql" | "sqlite",
-  ): SQL | undefined {
-    // Parse the nested query to extract paths and operators
-    const queries = this.jsonQueryManager.parseNestedQuery(nestedQuery);
-
-    if (queries.length === 0) {
-      return undefined;
-    }
-
-    // Get the column schema for type inference
-    const columnSchema = schema.properties[columnName];
-
-    // Build conditions for each parsed query
-    const conditions: SQL[] = [];
-
-    for (const { path, operator } of queries) {
-      // Check if the operator is an array operator (arrayContains, arrayContained, arrayOverlaps)
-      const isArrayOperator =
-        operator.arrayContains !== undefined ||
-        operator.arrayContained !== undefined ||
-        operator.arrayOverlaps !== undefined;
-
-      // Check if this is an array property
-      const isArrayProp = this.jsonQueryManager.isArrayProperty(schema, [
-        columnName,
-        ...path,
-      ]);
-
-      if (isArrayProp && isArrayOperator) {
-        // Array operators on JSONB arrays should use buildJsonbCondition
-        // This handles cases like: { metadata: { permissions: { arrayContains: [...] } } }
-        const condition = this.jsonQueryManager.buildJsonbCondition(
-          column,
-          path,
-          operator,
-          dialect,
-          columnSchema,
-        );
-        if (condition) {
-          conditions.push(condition);
-        }
-      } else if (isArrayProp && !isArrayOperator) {
-        // Non-array operators on array properties use buildJsonbArrayCondition
-        // This handles cases like: { addresses: { city: { eq: "Wonderland" } } }
-        const condition = this.jsonQueryManager.buildJsonbArrayCondition(
-          column,
-          path,
-          "",
-          operator,
-          dialect,
-        );
-        if (condition) {
-          conditions.push(condition);
-        }
-      } else {
-        // Handle object queries
-        const condition = this.jsonQueryManager.buildJsonbCondition(
-          column,
-          path,
-          operator,
-          dialect,
-          columnSchema,
-        );
-        if (condition) {
-          conditions.push(condition);
-        }
-      }
-    }
-
-    if (conditions.length === 0) {
-      return undefined;
-    }
-
-    if (conditions.length === 1) {
-      return conditions[0];
-    }
-
-    // Multiple conditions - AND them together
-    return and(...conditions);
-  }
-
   /**
    * Check if an object has any filter operator properties.
    */

package/src/queue/redis/providers/RedisQueueProvider.ts

@@ -17,15 +17,10 @@ export class RedisQueueProvider implements QueueProvider {
   }
 
   public async push(queue: string, message: string): Promise<void> {
-    await this.redisProvider.publisher.LPUSH(this.prefix(queue), message);
+    await this.redisProvider.lpush(this.prefix(queue), message);
   }
 
   public async pop(queue: string): Promise<string | undefined> {
-    const value = await this.redisProvider.publisher.RPOP(this.prefix(queue));
-    if (value == null) {
-      return undefined;
-    }
-
-    return String(value);
+    return this.redisProvider.rpop(this.prefix(queue));
   }
 }

package/src/redis/index.ts

@@ -1,9 +1,17 @@
 import { $module, type Alepha } from "alepha";
+import { BunRedisProvider } from "./providers/BunRedisProvider.ts";
+import { BunRedisSubscriberProvider } from "./providers/BunRedisSubscriberProvider.ts";
+import { NodeRedisProvider } from "./providers/NodeRedisProvider.ts";
+import { NodeRedisSubscriberProvider } from "./providers/NodeRedisSubscriberProvider.ts";
 import { RedisProvider } from "./providers/RedisProvider.ts";
 import { RedisSubscriberProvider } from "./providers/RedisSubscriberProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
+export * from "./providers/BunRedisProvider.ts";
+export * from "./providers/BunRedisSubscriberProvider.ts";
+export * from "./providers/NodeRedisProvider.ts";
+export * from "./providers/NodeRedisSubscriberProvider.ts";
 export * from "./providers/RedisProvider.ts";
 export * from "./providers/RedisSubscriberProvider.ts";
 
@@ -12,11 +20,65 @@ export * from "./providers/RedisSubscriberProvider.ts";
 /**
  * Redis client provider for Alepha applications.
  *
- * @see {@link RedisProvider}
+ * Automatically selects the appropriate provider based on runtime:
+ * - Bun: Uses `BunRedisProvider` with Bun's native Redis client (7.9x faster than ioredis)
+ * - Node.js: Uses `NodeRedisProvider` with `@redis/client`
+ *
+ * @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");
+ *
+ * // For pub/sub
+ * const subscriber = alepha.inject(RedisSubscriberProvider);
+ * await subscriber.subscribe("channel", (message, channel) => {
+ *   console.log(`Received: ${message} on ${channel}`);
+ * });
+ * ```
+ *
+ * @see {@link RedisProvider} - Abstract base class
+ * @see {@link NodeRedisProvider} - Node.js implementation
+ * @see {@link BunRedisProvider} - Bun implementation
+ * @see {@link RedisSubscriberProvider} - Abstract subscriber base class
+ * @see {@link NodeRedisSubscriberProvider} - Node.js subscriber implementation
+ * @see {@link BunRedisSubscriberProvider} - Bun subscriber implementation
  * @module alepha.redis
  */
 export const AlephaRedis = $module({
   name: "alepha.redis",
-  services: [RedisProvider, RedisSubscriberProvider],
-  register: (alepha: Alepha) => alepha.with(RedisProvider),
+  services: [
+    NodeRedisProvider,
+    NodeRedisSubscriberProvider,
+    BunRedisProvider,
+    BunRedisSubscriberProvider,
+    RedisProvider,
+    RedisSubscriberProvider,
+  ],
+  register: (alepha: Alepha) => {
+    if (alepha.isBun()) {
+      alepha
+        .with({
+          provide: RedisProvider,
+          use: BunRedisProvider,
+        })
+        .with({
+          provide: RedisSubscriberProvider,
+          use: BunRedisSubscriberProvider,
+        });
+    } else {
+      alepha
+        .with({
+          provide: RedisProvider,
+          use: NodeRedisProvider,
+        })
+        .with({
+          provide: RedisSubscriberProvider,
+          use: NodeRedisSubscriberProvider,
+        });
+    }
+  },
 });

package/src/redis/providers/BunRedisProvider.ts

@@ -0,0 +1,304 @@
+import {
+  $env,
+  $hook,
+  $inject,
+  Alepha,
+  AlephaError,
+  type Static,
+  t,
+} from "alepha";
+import { $logger } from "alepha/logger";
+import type { RedisClient as BunRedisClient } from "bun";
+import { RedisProvider, type RedisSetOptions } from "./RedisProvider.ts";
+
+const envSchema = t.object({
+  REDIS_URL: t.optional(t.text()),
+  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>> {}
+}
+
+/**
+ * Bun Redis client provider using Bun's native Redis client.
+ *
+ * This provider uses Bun's built-in `RedisClient` class for Redis connections,
+ * which provides excellent performance (7.9x faster than ioredis) on the Bun runtime.
+ *
+ * @example
+ * ```ts
+ * // Set REDIS_URL environment variable
+ * // REDIS_URL=redis://localhost:6379
+ *
+ * // Or configure via REDIS_HOST, REDIS_PORT, REDIS_PASSWORD
+ *
+ * // Or configure programmatically
+ * alepha.with({
+ *   provide: RedisProvider,
+ *   use: BunRedisProvider,
+ * });
+ * ```
+ */
+export class BunRedisProvider extends RedisProvider {
+  protected readonly log = $logger();
+  protected readonly alepha = $inject(Alepha);
+  protected readonly env = $env(envSchema);
+  protected client?: BunRedisClient;
+
+  public get publisher(): BunRedisClient {
+    if (!this.client?.connected) {
+      throw new AlephaError("Redis client is not ready");
+    }
+
+    return this.client;
+  }
+
+  public override get isReady(): boolean {
+    return this.client?.connected ?? false;
+  }
+
+  protected readonly start = $hook({
+    on: "start",
+    handler: () => this.connect(),
+  });
+
+  protected readonly stop = $hook({
+    on: "stop",
+    handler: () => this.close(),
+  });
+
+  /**
+   * Connect to the Redis server.
+   */
+  public override async connect(): Promise<void> {
+    // Check if we're running in Bun
+    if (typeof Bun === "undefined") {
+      throw new AlephaError(
+        "BunRedisProvider requires the Bun runtime. Use NodeRedisProvider for Node.js.",
+      );
+    }
+
+    this.log.debug("Connecting...");
+
+    const { RedisClient } = await import("bun");
+
+    this.client = new RedisClient(this.getUrl(), {
+      autoReconnect: true,
+      enableAutoPipelining: true,
+    });
+
+    this.client.onconnect = () => {
+      this.log.trace("Redis connected");
+    };
+
+    this.client.onclose = (error) => {
+      if (this.alepha.isStarted() && error) {
+        this.log.error("Redis connection closed", error);
+      }
+    };
+
+    await this.client.connect();
+
+    this.log.info("Connection OK");
+  }
+
+  /**
+   * Close the connection to the Redis server.
+   */
+  public override async close(): Promise<void> {
+    if (this.client) {
+      this.log.debug("Closing connection...");
+      this.client.close();
+      this.client = undefined;
+      this.log.info("Connection closed");
+    }
+  }
+
+  /**
+   * Create a duplicate connection for pub/sub or other isolated operations.
+   */
+  public async duplicate(): Promise<BunRedisClient> {
+    if (typeof Bun === "undefined") {
+      throw new AlephaError("BunRedisProvider requires the Bun runtime.");
+    }
+
+    const { RedisClient } = await import("bun");
+
+    const client = new RedisClient(this.getUrl(), {
+      autoReconnect: true,
+      enableAutoPipelining: true,
+    });
+
+    client.onclose = (error) => {
+      if (this.alepha.isStarted() && error) {
+        this.log.error("Redis duplicate connection closed", error);
+      }
+    };
+
+    await client.connect();
+
+    return client;
+  }
+
+  public override async get(key: string): Promise<Buffer | undefined> {
+    this.log.trace(`Getting key ${key}`);
+    const resp = await this.publisher.getBuffer(key);
+
+    if (resp === null) {
+      return undefined;
+    }
+
+    return Buffer.from(resp);
+  }
+
+  public override async set(
+    key: string,
+    value: Buffer | string,
+    options?: RedisSetOptions,
+  ): Promise<Buffer> {
+    const buf = Buffer.isBuffer(value) ? value : Buffer.from(value, "utf-8");
+
+    // Build SET command arguments
+    const args: string[] = [key, buf.toString("binary")];
+
+    // Handle expiration object format (from alepha/cache-redis, alepha/lock-redis)
+    if (options?.expiration) {
+      if (options.expiration.type === "KEEPTTL") {
+        args.push("KEEPTTL");
+      } else {
+        args.push(options.expiration.type, String(options.expiration.value));
+      }
+    }
+
+    // Handle direct expiration properties
+    if (options?.EX !== undefined) {
+      args.push("EX", String(options.EX));
+    }
+    if (options?.PX !== undefined) {
+      args.push("PX", String(options.PX));
+    }
+    if (options?.EXAT !== undefined) {
+      args.push("EXAT", String(options.EXAT));
+    }
+    if (options?.PXAT !== undefined) {
+      args.push("PXAT", String(options.PXAT));
+    }
+    if (options?.KEEPTTL) {
+      args.push("KEEPTTL");
+    }
+
+    // Handle condition object format
+    if (options?.condition === "NX") {
+      args.push("NX");
+    } else if (options?.condition === "XX") {
+      args.push("XX");
+    }
+
+    // Handle direct condition properties
+    if (options?.NX) {
+      args.push("NX");
+    }
+    if (options?.XX) {
+      args.push("XX");
+    }
+    if (options?.GET) {
+      args.push("GET");
+    }
+
+    if (args.length === 2) {
+      // Simple set without options
+      await this.publisher.set(key, buf);
+    } else {
+      // Set with options via raw command
+      await this.publisher.send("SET", args);
+    }
+
+    return buf;
+  }
+
+  public override async has(key: string): Promise<boolean> {
+    return this.publisher.exists(key);
+  }
+
+  public override async keys(pattern: string): Promise<string[]> {
+    const keys = await this.publisher.send("KEYS", [pattern]);
+    if (!Array.isArray(keys)) {
+      return [];
+    }
+    return keys.map((key) =>
+      key instanceof Uint8Array ? Buffer.from(key).toString() : String(key),
+    );
+  }
+
+  public override async del(keys: string[]): Promise<void> {
+    if (keys.length === 0) {
+      return;
+    }
+
+    await this.publisher.send("DEL", keys);
+  }
+
+  // ---------------------------------------------------------
+  // Queue operations
+  // ---------------------------------------------------------
+
+  public override async lpush(key: string, value: string): Promise<void> {
+    await this.publisher.send("LPUSH", [key, value]);
+  }
+
+  public override async rpop(key: string): Promise<string | undefined> {
+    const value = await this.publisher.send("RPOP", [key]);
+    if (value == null) {
+      return undefined;
+    }
+    if (value instanceof Uint8Array) {
+      return Buffer.from(value).toString();
+    }
+    return String(value);
+  }
+
+  // ---------------------------------------------------------
+  // Pub/Sub operations
+  // ---------------------------------------------------------
+
+  public override async publish(
+    channel: string,
+    message: string,
+  ): Promise<void> {
+    await this.publisher.publish(channel, message);
+  }
+
+  /**
+   * Get the Redis connection URL.
+   */
+  protected getUrl(): string {
+    // Prefer REDIS_URL if set
+    if (this.env.REDIS_URL) {
+      return this.env.REDIS_URL;
+    }
+
+    // Build URL from components
+    const url = new URL("redis://127.0.0.1:6379");
+
+    if (this.env.REDIS_PASSWORD) {
+      url.password = this.env.REDIS_PASSWORD;
+    }
+
+    if (this.env.REDIS_HOST) {
+      url.hostname = this.env.REDIS_HOST;
+    }
+
+    if (this.env.REDIS_PORT) {
+      url.port = String(this.env.REDIS_PORT);
+    }
+
+    return url.toString();
+  }
+}

package/src/redis/providers/BunRedisSubscriberProvider.ts

@@ -0,0 +1,94 @@
+import { $hook, $inject, Alepha, AlephaError } from "alepha";
+import { $logger } from "alepha/logger";
+import type { RedisClient as BunRedisClient } from "bun";
+import { BunRedisProvider } from "./BunRedisProvider.ts";
+import {
+  RedisSubscriberProvider,
+  type SubscribeCallback,
+} from "./RedisSubscriberProvider.ts";
+
+/**
+ * Bun Redis subscriber provider for pub/sub operations.
+ *
+ * This provider creates a dedicated Redis connection for subscriptions,
+ * as Redis requires separate connections for pub/sub operations.
+ *
+ * @example
+ * ```ts
+ * const subscriber = alepha.inject(RedisSubscriberProvider);
+ * await subscriber.subscribe("channel", (message, channel) => {
+ *   console.log(`Received: ${message} on ${channel}`);
+ * });
+ * ```
+ */
+export class BunRedisSubscriberProvider extends RedisSubscriberProvider {
+  protected readonly log = $logger();
+  protected readonly alepha = $inject(Alepha);
+  protected readonly redisProvider = $inject(BunRedisProvider);
+  protected client?: BunRedisClient;
+
+  public get subscriber(): BunRedisClient {
+    if (!this.client?.connected) {
+      throw new AlephaError("Redis subscriber client is not ready");
+    }
+
+    return this.client;
+  }
+
+  public override get isReady(): boolean {
+    return this.client?.connected ?? false;
+  }
+
+  protected readonly start = $hook({
+    on: "start",
+    handler: () => this.connect(),
+  });
+
+  protected readonly stop = $hook({
+    on: "stop",
+    handler: () => this.close(),
+  });
+
+  /**
+   * Connect to the Redis server for subscriptions.
+   */
+  public override async connect(): Promise<void> {
+    this.log.debug("Connecting subscriber...");
+    this.client = await this.redisProvider.duplicate();
+    this.log.info("Subscriber connection OK");
+  }
+
+  /**
+   * Close the subscriber connection.
+   */
+  public override async close(): Promise<void> {
+    if (this.client) {
+      this.log.debug("Closing subscriber connection...");
+      this.client.close();
+      this.client = undefined;
+      this.log.info("Subscriber connection closed");
+    }
+  }
+
+  public override async subscribe(
+    channel: string,
+    callback: SubscribeCallback,
+  ): Promise<void> {
+    await this.subscriber.subscribe(channel, (message, ch) => {
+      // Bun's callback provides Buffer or string, normalize to string
+      const msg =
+        typeof message === "object" && message !== null
+          ? Buffer.from(message as Uint8Array).toString()
+          : String(message);
+      callback(msg, ch);
+    });
+  }
+
+  public override async unsubscribe(
+    channel: string,
+    _callback?: SubscribeCallback,
+  ): Promise<void> {
+    // Bun's unsubscribe doesn't support callback filtering
+    await this.subscriber.unsubscribe(channel);
+  }
+}