@db-bridge/redis 1.0.0

package/dist/index.js

@@ -0,0 +1,1676 @@
+import { withTimeout, ConnectionError, CacheError } from '@db-bridge/core';
+import Redis from 'ioredis';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+
+// ../../node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "../../node_modules/eventemitter3/index.js"(exports$1, module) {
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter2.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+    EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter2.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter2.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter2;
+    }
+  }
+});
+
+// ../../node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3());
+
+// src/commands/redis-commands.ts
+var RedisCommands = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  get client() {
+    const client = this.adapter.getClient();
+    if (!client) {
+      throw new Error("Redis client not connected");
+    }
+    return client;
+  }
+  async hget(key, field) {
+    const result = await this.client.hget(this.adapter.getFullKey(key), field);
+    return result;
+  }
+  async hset(key, field, value) {
+    const result = await this.client.hset(this.adapter.getFullKey(key), field, value);
+    return result;
+  }
+  async hgetall(key) {
+    const result = await this.client.hgetall(this.adapter.getFullKey(key));
+    return result;
+  }
+  async hmset(key, data) {
+    const result = await this.client.hmset(this.adapter.getFullKey(key), data);
+    return result;
+  }
+  async hdel(key, ...fields) {
+    const result = await this.client.hdel(this.adapter.getFullKey(key), ...fields);
+    return result;
+  }
+  async lpush(key, ...values) {
+    const result = await this.client.lpush(this.adapter.getFullKey(key), ...values);
+    return result;
+  }
+  async rpush(key, ...values) {
+    const result = await this.client.rpush(this.adapter.getFullKey(key), ...values);
+    return result;
+  }
+  async lpop(key) {
+    const result = await this.client.lpop(this.adapter.getFullKey(key));
+    return result;
+  }
+  async rpop(key) {
+    const result = await this.client.rpop(this.adapter.getFullKey(key));
+    return result;
+  }
+  async lrange(key, start, stop) {
+    const result = await this.client.lrange(this.adapter.getFullKey(key), start, stop);
+    return result;
+  }
+  async llen(key) {
+    const result = await this.client.llen(this.adapter.getFullKey(key));
+    return result;
+  }
+  async sadd(key, ...members) {
+    const result = await this.client.sadd(this.adapter.getFullKey(key), ...members);
+    return result;
+  }
+  async srem(key, ...members) {
+    const result = await this.client.srem(this.adapter.getFullKey(key), ...members);
+    return result;
+  }
+  async smembers(key) {
+    const result = await this.client.smembers(this.adapter.getFullKey(key));
+    return result;
+  }
+  async sismember(key, member) {
+    const result = await this.client.sismember(this.adapter.getFullKey(key), member);
+    return result;
+  }
+  async scard(key) {
+    const result = await this.client.scard(this.adapter.getFullKey(key));
+    return result;
+  }
+  async zadd(key, ...args) {
+    const result = await this.client.zadd(this.adapter.getFullKey(key), ...args);
+    return result;
+  }
+  async zrem(key, ...members) {
+    const result = await this.client.zrem(this.adapter.getFullKey(key), ...members);
+    return result;
+  }
+  async zrange(key, start, stop, withScores) {
+    if (withScores) {
+      return this.client.zrange(this.adapter.getFullKey(key), start, stop, "WITHSCORES");
+    }
+    return this.client.zrange(this.adapter.getFullKey(key), start, stop);
+  }
+  async zrevrange(key, start, stop, withScores) {
+    if (withScores) {
+      return this.client.zrevrange(this.adapter.getFullKey(key), start, stop, "WITHSCORES");
+    }
+    return this.client.zrevrange(this.adapter.getFullKey(key), start, stop);
+  }
+  async zcard(key) {
+    const result = await this.client.zcard(this.adapter.getFullKey(key));
+    return result;
+  }
+  async publish(channel, message) {
+    const result = await this.client.publish(channel, message);
+    return result;
+  }
+  async subscribe(channels, callback) {
+    const subscriber = this.client.duplicate();
+    subscriber.on("message", callback);
+    await subscriber.subscribe(...channels);
+  }
+  async unsubscribe(channels) {
+    if (channels) {
+      await this.client.unsubscribe(...channels);
+    } else {
+      await this.client.unsubscribe();
+    }
+  }
+};
+
+// src/adapter/redis-adapter.ts
+var RedisAdapter = class extends import_index.default {
+  client;
+  isConnected = false;
+  _commands;
+  options;
+  constructor(options = {}) {
+    super();
+    this.options = {
+      redis: options.redis || {},
+      keyPrefix: options.keyPrefix || "db-bridge:",
+      ttl: options.ttl || 3600,
+      logger: options.logger,
+      enableCompression: options.enableCompression || false,
+      connectionTimeout: options.connectionTimeout || 1e4,
+      commandTimeout: options.commandTimeout || 5e3,
+      retryOptions: {
+        maxRetries: options.retryOptions?.maxRetries ?? 3,
+        retryDelay: options.retryOptions?.retryDelay ?? 1e3
+      }
+    };
+  }
+  async connect(config) {
+    if (this.isConnected) {
+      return;
+    }
+    const redisConfig = {
+      ...this.options.redis,
+      ...config,
+      lazyConnect: true,
+      enableOfflineQueue: false,
+      retryStrategy: (times) => {
+        const retryOptions = this.options.retryOptions;
+        if (times > retryOptions.maxRetries) {
+          return null;
+        }
+        return Math.min(times * retryOptions.retryDelay, 5e3);
+      }
+    };
+    this.client = new Redis(redisConfig);
+    this.client.on("error", (error) => {
+      this.options.logger?.error("Redis client error", error);
+      this.emit("error", error);
+    });
+    this.client.on("connect", () => {
+      this.isConnected = true;
+      this.options.logger?.info("Connected to Redis");
+      this.emit("connect");
+    });
+    this.client.on("close", () => {
+      this.isConnected = false;
+      this.options.logger?.info("Disconnected from Redis");
+      this.emit("disconnect");
+    });
+    try {
+      await withTimeout(
+        this.client.connect(),
+        this.options.connectionTimeout,
+        "Redis connection timeout"
+      );
+    } catch (error) {
+      throw new ConnectionError("Failed to connect to Redis", error);
+    }
+  }
+  async disconnect() {
+    if (this.client && this.isConnected) {
+      await this.client.quit();
+      this.client = void 0;
+      this.isConnected = false;
+    }
+  }
+  async get(key) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const value = await withTimeout(this.client.get(fullKey), this.options.commandTimeout);
+      if (!value) {
+        return null;
+      }
+      return this.deserialize(value);
+    } catch (error) {
+      throw new CacheError(`Failed to get key "${key}"`, key, error);
+    }
+  }
+  async set(key, value, ttl) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const serialized = this.serialize(value);
+      const expiry = ttl || this.options.ttl;
+      if (expiry > 0) {
+        await withTimeout(
+          this.client.setex(fullKey, expiry, serialized),
+          this.options.commandTimeout
+        );
+      } else {
+        await withTimeout(this.client.set(fullKey, serialized), this.options.commandTimeout);
+      }
+      this.emit("set", { key, ttl: expiry });
+    } catch (error) {
+      throw new CacheError(`Failed to set key "${key}"`, key, error);
+    }
+  }
+  async delete(key) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const result = await withTimeout(this.client.del(fullKey), this.options.commandTimeout);
+      const deleted = result > 0;
+      if (deleted) {
+        this.emit("delete", { key });
+      }
+      return deleted;
+    } catch (error) {
+      throw new CacheError(`Failed to delete key "${key}"`, key, error);
+    }
+  }
+  async exists(key) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const result = await withTimeout(this.client.exists(fullKey), this.options.commandTimeout);
+      return result > 0;
+    } catch (error) {
+      throw new CacheError(`Failed to check existence of key "${key}"`, key, error);
+    }
+  }
+  async clear() {
+    this.ensureConnected();
+    try {
+      const pattern = `${this.options.keyPrefix}*`;
+      const keys = await this.keys(pattern);
+      if (keys.length > 0) {
+        const pipeline = this.client.pipeline();
+        keys.forEach((key) => pipeline.del(key));
+        await pipeline.exec();
+      }
+      this.emit("clear", { count: keys.length });
+    } catch (error) {
+      throw new CacheError("Failed to clear cache", void 0, error);
+    }
+  }
+  async mget(keys) {
+    this.ensureConnected();
+    if (keys.length === 0) {
+      return [];
+    }
+    try {
+      const fullKeys = keys.map((key) => this.getFullKey(key));
+      const values = await withTimeout(this.client.mget(...fullKeys), this.options.commandTimeout);
+      return values.map((value) => {
+        if (!value) {
+          return null;
+        }
+        return this.deserialize(value);
+      });
+    } catch (error) {
+      throw new CacheError("Failed to get multiple keys", void 0, error);
+    }
+  }
+  async mset(items) {
+    this.ensureConnected();
+    if (items.length === 0) {
+      return;
+    }
+    try {
+      const pipeline = this.client.pipeline();
+      items.forEach(({ key, value, ttl }) => {
+        const fullKey = this.getFullKey(key);
+        const serialized = this.serialize(value);
+        const expiry = ttl || this.options.ttl;
+        if (expiry > 0) {
+          pipeline.setex(fullKey, expiry, serialized);
+        } else {
+          pipeline.set(fullKey, serialized);
+        }
+      });
+      await pipeline.exec();
+      this.emit("mset", { count: items.length });
+    } catch (error) {
+      throw new CacheError("Failed to set multiple keys", void 0, error);
+    }
+  }
+  async keys(pattern = "*") {
+    this.ensureConnected();
+    try {
+      const fullPattern = pattern.startsWith(this.options.keyPrefix) ? pattern : this.getFullKey(pattern);
+      const keys = await withTimeout(this.scanKeys(fullPattern), this.options.commandTimeout * 5);
+      return keys.map((key) => key.replace(this.options.keyPrefix, ""));
+    } catch (error) {
+      throw new CacheError("Failed to get keys", void 0, error);
+    }
+  }
+  async ttl(key) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const ttl = await withTimeout(this.client.ttl(fullKey), this.options.commandTimeout);
+      return ttl >= 0 ? ttl : -1;
+    } catch (error) {
+      throw new CacheError(`Failed to get TTL for key "${key}"`, key, error);
+    }
+  }
+  async expire(key, ttl) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const result = await withTimeout(
+        this.client.expire(fullKey, ttl),
+        this.options.commandTimeout
+      );
+      return result === 1;
+    } catch (error) {
+      throw new CacheError(`Failed to set expiry for key "${key}"`, key, error);
+    }
+  }
+  async increment(key, value = 1) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const result = await withTimeout(
+        this.client.incrby(fullKey, value),
+        this.options.commandTimeout
+      );
+      return result;
+    } catch (error) {
+      throw new CacheError(`Failed to increment key "${key}"`, key, error);
+    }
+  }
+  /**
+   * Alias for delete() to match Redis command naming
+   */
+  async del(key) {
+    return this.delete(key);
+  }
+  async decrement(key, value = 1) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const result = await withTimeout(
+        this.client.decrby(fullKey, value),
+        this.options.commandTimeout
+      );
+      return result;
+    } catch (error) {
+      throw new CacheError(`Failed to decrement key "${key}"`, key, error);
+    }
+  }
+  async ping() {
+    this.ensureConnected();
+    return this.client.ping();
+  }
+  async flushdb() {
+    this.ensureConnected();
+    await this.client.flushdb();
+  }
+  async mdel(keys) {
+    this.ensureConnected();
+    if (keys.length === 0) {
+      return 0;
+    }
+    const fullKeys = keys.map((k) => this.getFullKey(k));
+    return this.client.del(...fullKeys);
+  }
+  async persist(key) {
+    this.ensureConnected();
+    const fullKey = this.getFullKey(key);
+    const result = await this.client.persist(fullKey);
+    return result === 1;
+  }
+  /**
+   * Set key with NX (only if not exists) - useful for distributed locking
+   */
+  async setNX(key, value, ttl) {
+    this.ensureConnected();
+    const fullKey = this.getFullKey(key);
+    const serialized = JSON.stringify(value);
+    if (ttl) {
+      const result = await this.client.set(fullKey, serialized, "EX", ttl, "NX");
+      return result === "OK";
+    } else {
+      const result = await this.client.setnx(fullKey, serialized);
+      return result === 1;
+    }
+  }
+  // Hash operations
+  async hset(key, field, value) {
+    this.ensureConnected();
+    return this.client.hset(this.getFullKey(key), field, value);
+  }
+  async hget(key, field) {
+    this.ensureConnected();
+    return this.client.hget(this.getFullKey(key), field);
+  }
+  async hgetall(key) {
+    this.ensureConnected();
+    return this.client.hgetall(this.getFullKey(key));
+  }
+  async hexists(key, field) {
+    this.ensureConnected();
+    const result = await this.client.hexists(this.getFullKey(key), field);
+    return result === 1;
+  }
+  async hdel(key, ...fields) {
+    this.ensureConnected();
+    return this.client.hdel(this.getFullKey(key), ...fields);
+  }
+  // List operations
+  async lpush(key, ...values) {
+    this.ensureConnected();
+    return this.client.lpush(this.getFullKey(key), ...values);
+  }
+  async rpush(key, ...values) {
+    this.ensureConnected();
+    return this.client.rpush(this.getFullKey(key), ...values);
+  }
+  async lpop(key) {
+    this.ensureConnected();
+    return this.client.lpop(this.getFullKey(key));
+  }
+  async rpop(key) {
+    this.ensureConnected();
+    return this.client.rpop(this.getFullKey(key));
+  }
+  async llen(key) {
+    this.ensureConnected();
+    return this.client.llen(this.getFullKey(key));
+  }
+  async lrange(key, start, stop) {
+    this.ensureConnected();
+    return this.client.lrange(this.getFullKey(key), start, stop);
+  }
+  // Set operations
+  async sadd(key, ...members) {
+    this.ensureConnected();
+    return this.client.sadd(this.getFullKey(key), ...members);
+  }
+  async srem(key, ...members) {
+    this.ensureConnected();
+    return this.client.srem(this.getFullKey(key), ...members);
+  }
+  async smembers(key) {
+    this.ensureConnected();
+    return this.client.smembers(this.getFullKey(key));
+  }
+  async sismember(key, member) {
+    this.ensureConnected();
+    const result = await this.client.sismember(this.getFullKey(key), member);
+    return result === 1;
+  }
+  async scard(key) {
+    this.ensureConnected();
+    return this.client.scard(this.getFullKey(key));
+  }
+  // Sorted set operations
+  async zadd(key, score, member) {
+    this.ensureConnected();
+    return this.client.zadd(this.getFullKey(key), score, member);
+  }
+  async zrem(key, ...members) {
+    this.ensureConnected();
+    return this.client.zrem(this.getFullKey(key), ...members);
+  }
+  async zrange(key, start, stop) {
+    this.ensureConnected();
+    return this.client.zrange(this.getFullKey(key), start, stop);
+  }
+  async zrangeWithScores(key, start, stop) {
+    this.ensureConnected();
+    const result = await this.client.zrange(this.getFullKey(key), start, stop, "WITHSCORES");
+    const pairs = [];
+    for (let i = 0; i < result.length; i += 2) {
+      const member = result[i];
+      const score = result[i + 1];
+      if (member !== void 0 && score !== void 0) {
+        pairs.push([member, Number.parseFloat(score)]);
+      }
+    }
+    return pairs;
+  }
+  async zscore(key, member) {
+    this.ensureConnected();
+    const result = await this.client.zscore(this.getFullKey(key), member);
+    return result === null ? null : Number.parseFloat(result);
+  }
+  async zcard(key) {
+    this.ensureConnected();
+    return this.client.zcard(this.getFullKey(key));
+  }
+  // Scan iterator
+  async *scan(pattern) {
+    this.ensureConnected();
+    const fullPattern = this.getFullKey(pattern);
+    let cursor = "0";
+    do {
+      const [nextCursor, keys] = await this.client.scan(
+        cursor,
+        "MATCH",
+        fullPattern,
+        "COUNT",
+        100
+      );
+      cursor = nextCursor;
+      for (const key of keys) {
+        yield key.replace(this.options.keyPrefix, "");
+      }
+    } while (cursor !== "0");
+  }
+  ensureConnected() {
+    if (!this.client || !this.isConnected) {
+      throw new ConnectionError("Redis client not connected");
+    }
+  }
+  get commands() {
+    if (!this._commands) {
+      this._commands = new RedisCommands(this);
+    }
+    return this._commands;
+  }
+  getClient() {
+    return this.client;
+  }
+  getFullKey(key) {
+    return `${this.options.keyPrefix}${key}`;
+  }
+  serialize(value) {
+    try {
+      const json = JSON.stringify(value);
+      if (this.options.enableCompression && json.length > 1024) {
+        return this.compress(json);
+      }
+      return json;
+    } catch (error) {
+      throw new CacheError("Failed to serialize value", void 0, error);
+    }
+  }
+  deserialize(value) {
+    try {
+      if (this.options.enableCompression && this.isCompressed(value)) {
+        value = this.decompress(value);
+      }
+      return JSON.parse(value);
+    } catch (error) {
+      throw new CacheError("Failed to deserialize value", void 0, error);
+    }
+  }
+  compress(data) {
+    return data;
+  }
+  decompress(data) {
+    return data;
+  }
+  isCompressed(_data) {
+    return false;
+  }
+  async scanKeys(pattern) {
+    const keys = [];
+    let cursor = "0";
+    do {
+      const [nextCursor, scannedKeys] = await this.client.scan(
+        cursor,
+        "MATCH",
+        pattern,
+        "COUNT",
+        1e3
+      );
+      cursor = nextCursor;
+      keys.push(...scannedKeys);
+    } while (cursor !== "0");
+    return keys;
+  }
+};
+
+// src/adapter/redis-cache-adapter.ts
+var RedisCacheAdapter = class {
+  redis;
+  defaultTTL;
+  keyPrefix;
+  invalidationPatterns;
+  constructor(options) {
+    this.redis = options.redis;
+    this.defaultTTL = options.defaultTTL || 3600;
+    this.keyPrefix = options.keyPrefix || "query:";
+    this.invalidationPatterns = options.invalidationPatterns || /* @__PURE__ */ new Map();
+  }
+  async getCachedQuery(key, options) {
+    const fullKey = this.getQueryKey(key, options);
+    return this.redis.get(fullKey);
+  }
+  async setCachedQuery(key, result, options) {
+    const fullKey = this.getQueryKey(key, options);
+    const ttl = options?.ttl || this.defaultTTL;
+    await this.redis.set(fullKey, result, ttl);
+    if (options?.invalidateOn) {
+      await this.registerInvalidation(fullKey, options.invalidateOn);
+    }
+  }
+  async invalidateQueries(patterns) {
+    let invalidatedCount = 0;
+    for (const pattern of patterns) {
+      const keys = await this.redis.keys(`${this.keyPrefix}${pattern}`);
+      for (const key of keys) {
+        const deleted = await this.redis.delete(key);
+        if (deleted) {
+          invalidatedCount++;
+        }
+      }
+      const registeredKeys = this.invalidationPatterns.get(pattern) || [];
+      for (const key of registeredKeys) {
+        const deleted = await this.redis.delete(key);
+        if (deleted) {
+          invalidatedCount++;
+        }
+      }
+    }
+    return invalidatedCount;
+  }
+  async invalidateAll() {
+    const keys = await this.redis.keys(`${this.keyPrefix}*`);
+    if (keys.length > 0) {
+      await Promise.all(keys.map((key) => this.redis.delete(key)));
+    }
+    this.invalidationPatterns.clear();
+  }
+  async getStatistics() {
+    const keys = await this.redis.keys(`${this.keyPrefix}*`);
+    const totalSize = 0;
+    const patterns = /* @__PURE__ */ new Set();
+    return {
+      totalKeys: keys.length,
+      totalSize,
+      patterns: Array.from(patterns)
+    };
+  }
+  getQueryKey(key, options) {
+    if (options?.key) {
+      return `${this.keyPrefix}${options.key}`;
+    }
+    return `${this.keyPrefix}${key}`;
+  }
+  async registerInvalidation(key, patterns) {
+    for (const pattern of patterns) {
+      const existing = this.invalidationPatterns.get(pattern) || [];
+      existing.push(key);
+      this.invalidationPatterns.set(pattern, existing);
+    }
+  }
+};
+function createDatabaseAdapterWithCache(adapter, cacheAdapter, options) {
+  const cacheableCommands = options?.cacheableCommands || ["SELECT"];
+  const defaultTTL = options?.defaultTTL || 3600;
+  const originalQuery = adapter.query.bind(adapter);
+  adapter.query = async function(sql, params, queryOptions) {
+    const command = sql.trim().split(" ")[0]?.toUpperCase();
+    if (!queryOptions?.cache || !cacheableCommands.includes(command)) {
+      return originalQuery(sql, params, queryOptions);
+    }
+    const cacheOptions = typeof queryOptions.cache === "object" ? queryOptions.cache : {};
+    const cacheKey = generateQueryCacheKey(sql, params);
+    const cached = await cacheAdapter.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const result = await originalQuery(sql, params, queryOptions);
+    const ttl = cacheOptions.ttl || defaultTTL;
+    await cacheAdapter.set(cacheKey, result, ttl);
+    return result;
+  };
+  return adapter;
+}
+function generateQueryCacheKey(sql, params) {
+  const crypto = __require("crypto");
+  const hash = crypto.createHash("sha256");
+  hash.update(sql);
+  if (params) {
+    hash.update(JSON.stringify(params));
+  }
+  return hash.digest("hex");
+}
+var RedisConnectionManager = class extends import_index.default {
+  client;
+  isConnected = false;
+  config;
+  constructor(config = {}) {
+    super();
+    this.config = {
+      keyPrefix: config.keyPrefix || "db-bridge:",
+      connectionTimeout: config.connectionTimeout || 1e4,
+      retryOptions: {
+        maxRetries: config.retryOptions?.maxRetries ?? 3,
+        retryDelay: config.retryOptions?.retryDelay ?? 1e3
+      },
+      redis: config.redis || {}
+    };
+  }
+  async connect(overrideConfig) {
+    if (this.isConnected) {
+      return;
+    }
+    const redisConfig = {
+      ...this.config.redis,
+      ...overrideConfig,
+      lazyConnect: true,
+      enableOfflineQueue: false,
+      retryStrategy: (times) => {
+        if (times > this.config.retryOptions.maxRetries) {
+          return null;
+        }
+        return Math.min(times * this.config.retryOptions.retryDelay, 5e3);
+      }
+    };
+    this.client = new Redis(redisConfig);
+    this.setupEventHandlers();
+    try {
+      await withTimeout(
+        this.client.connect(),
+        this.config.connectionTimeout,
+        "Redis connection timeout"
+      );
+    } catch (error) {
+      throw new ConnectionError("Failed to connect to Redis", error);
+    }
+  }
+  async disconnect() {
+    if (this.client && this.isConnected) {
+      await this.client.quit();
+      this.client = void 0;
+      this.isConnected = false;
+    }
+  }
+  getClient() {
+    return this.client;
+  }
+  ensureConnected() {
+    if (!this.client || !this.isConnected) {
+      throw new ConnectionError("Redis client not connected");
+    }
+  }
+  getFullKey(key) {
+    return `${this.config.keyPrefix}${key}`;
+  }
+  setupEventHandlers() {
+    if (!this.client) {
+      return;
+    }
+    this.client.on("error", (error) => {
+      this.emit("error", error);
+    });
+    this.client.on("connect", () => {
+      this.isConnected = true;
+      this.emit("connect");
+    });
+    this.client.on("close", () => {
+      this.isConnected = false;
+      this.emit("disconnect");
+    });
+  }
+};
+
+// src/adapter/traits/basic-operations-trait.ts
+var BasicOperationsTrait = class extends RedisConnectionManager {
+  commandTimeout = 5e3;
+  setCommandTimeout(timeout) {
+    this.commandTimeout = timeout;
+  }
+  async get(key) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const value = await withTimeout(this.client.get(fullKey), this.commandTimeout);
+      if (!value) {
+        return null;
+      }
+      return this.deserialize(value);
+    } catch (error) {
+      throw new CacheError(`Failed to get key "${key}"`, key, error);
+    }
+  }
+  async set(key, value, ttl) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const serialized = this.serialize(value);
+      if (ttl && ttl > 0) {
+        await withTimeout(this.client.setex(fullKey, ttl, serialized), this.commandTimeout);
+      } else {
+        await withTimeout(this.client.set(fullKey, serialized), this.commandTimeout);
+      }
+      this.emit("set", { key, ttl });
+    } catch (error) {
+      throw new CacheError(`Failed to set key "${key}"`, key, error);
+    }
+  }
+  async delete(key) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const result = await withTimeout(this.client.del(fullKey), this.commandTimeout);
+      const deleted = result > 0;
+      if (deleted) {
+        this.emit("delete", { key });
+      }
+      return deleted;
+    } catch (error) {
+      throw new CacheError(`Failed to delete key "${key}"`, key, error);
+    }
+  }
+  async del(key) {
+    return this.delete(key);
+  }
+  async exists(key) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const result = await withTimeout(this.client.exists(fullKey), this.commandTimeout);
+      return result > 0;
+    } catch (error) {
+      throw new CacheError(`Failed to check existence of key "${key}"`, key, error);
+    }
+  }
+  async ttl(key) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const ttl = await withTimeout(this.client.ttl(fullKey), this.commandTimeout);
+      return ttl >= 0 ? ttl : -1;
+    } catch (error) {
+      throw new CacheError(`Failed to get TTL for key "${key}"`, key, error);
+    }
+  }
+  async expire(key, ttl) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const result = await withTimeout(this.client.expire(fullKey, ttl), this.commandTimeout);
+      return result === 1;
+    } catch (error) {
+      throw new CacheError(`Failed to set expiry for key "${key}"`, key, error);
+    }
+  }
+  serialize(value) {
+    try {
+      return JSON.stringify(value);
+    } catch (error) {
+      throw new CacheError("Failed to serialize value", void 0, error);
+    }
+  }
+  deserialize(value) {
+    try {
+      return JSON.parse(value);
+    } catch (error) {
+      throw new CacheError("Failed to deserialize value", void 0, error);
+    }
+  }
+};
+
+// src/adapter/traits/batch-operations-trait.ts
+var BatchOperationsTrait = class extends BasicOperationsTrait {
+  async mget(keys) {
+    this.ensureConnected();
+    if (keys.length === 0) {
+      return [];
+    }
+    try {
+      const fullKeys = keys.map((key) => this.getFullKey(key));
+      const values = await withTimeout(this.client.mget(...fullKeys), this.commandTimeout);
+      return values.map((value) => {
+        if (!value) {
+          return null;
+        }
+        return this.deserialize(value);
+      });
+    } catch (error) {
+      throw new CacheError("Failed to get multiple keys", void 0, error);
+    }
+  }
+  async mset(items) {
+    this.ensureConnected();
+    if (items.length === 0) {
+      return;
+    }
+    try {
+      const pipeline = this.client.pipeline();
+      items.forEach(({ key, value, ttl }) => {
+        const fullKey = this.getFullKey(key);
+        const serialized = this.serialize(value);
+        if (ttl && ttl > 0) {
+          pipeline.setex(fullKey, ttl, serialized);
+        } else {
+          pipeline.set(fullKey, serialized);
+        }
+      });
+      await pipeline.exec();
+      this.emit("mset", { count: items.length });
+    } catch (error) {
+      throw new CacheError("Failed to set multiple keys", void 0, error);
+    }
+  }
+  async clear() {
+    this.ensureConnected();
+    try {
+      const pattern = `${this.config.keyPrefix}*`;
+      const keys = await this.scanKeys(pattern);
+      if (keys.length > 0) {
+        const pipeline = this.client.pipeline();
+        keys.forEach((key) => pipeline.del(key));
+        await pipeline.exec();
+      }
+      this.emit("clear", { count: keys.length });
+    } catch (error) {
+      throw new CacheError("Failed to clear cache", void 0, error);
+    }
+  }
+  async keys(pattern = "*") {
+    this.ensureConnected();
+    try {
+      const fullPattern = pattern.startsWith(this.config.keyPrefix) ? pattern : this.getFullKey(pattern);
+      const keys = await withTimeout(this.scanKeys(fullPattern), this.commandTimeout * 5);
+      return keys.map((key) => key.replace(this.config.keyPrefix, ""));
+    } catch (error) {
+      throw new CacheError("Failed to get keys", void 0, error);
+    }
+  }
+  async scanKeys(pattern) {
+    const keys = [];
+    let cursor = "0";
+    do {
+      const [nextCursor, scannedKeys] = await this.client.scan(
+        cursor,
+        "MATCH",
+        pattern,
+        "COUNT",
+        1e3
+      );
+      cursor = nextCursor;
+      keys.push(...scannedKeys);
+    } while (cursor !== "0");
+    return keys;
+  }
+};
+
+// src/adapter/traits/counter-operations-trait.ts
+var CounterOperationsTrait = class extends BatchOperationsTrait {
+  async increment(key, value = 1) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const result = await withTimeout(this.client.incrby(fullKey, value), this.commandTimeout);
+      return result;
+    } catch (error) {
+      throw new CacheError(`Failed to increment key "${key}"`, key, error);
+    }
+  }
+  async decrement(key, value = 1) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const result = await withTimeout(this.client.decrby(fullKey, value), this.commandTimeout);
+      return result;
+    } catch (error) {
+      throw new CacheError(`Failed to decrement key "${key}"`, key, error);
+    }
+  }
+  async incr(key) {
+    return this.increment(key, 1);
+  }
+  async decr(key) {
+    return this.decrement(key, 1);
+  }
+  async incrby(key, value) {
+    return this.increment(key, value);
+  }
+  async decrby(key, value) {
+    return this.decrement(key, value);
+  }
+  async incrbyfloat(key, value) {
+    this.ensureConnected();
+    try {
+      const fullKey = this.getFullKey(key);
+      const result = await withTimeout(
+        this.client.incrbyfloat(fullKey, value),
+        this.commandTimeout
+      );
+      return result;
+    } catch (error) {
+      throw new CacheError(`Failed to increment float key "${key}"`, key, error);
+    }
+  }
+};
+
+// src/adapter/modular-redis-adapter.ts
+var ModularRedisAdapter = class extends CounterOperationsTrait {
+  _commands;
+  defaultTtl;
+  logger;
+  enableCompression;
+  constructor(options = {}) {
+    super({
+      redis: options.redis,
+      keyPrefix: options.keyPrefix,
+      connectionTimeout: options.connectionTimeout,
+      retryOptions: options.retryOptions
+    });
+    this.defaultTtl = options.ttl || 3600;
+    this.logger = options.logger;
+    this.enableCompression = options.enableCompression || false;
+    if (options.commandTimeout) {
+      this.setCommandTimeout(options.commandTimeout);
+    }
+    this.setupLogging();
+  }
+  async connect(config) {
+    await super.connect(config);
+    this.logger?.info("Connected to Redis");
+  }
+  async disconnect() {
+    await super.disconnect();
+    this.logger?.info("Disconnected from Redis");
+  }
+  async set(key, value, ttl) {
+    const effectiveTtl = ttl === void 0 ? this.defaultTtl : ttl;
+    await super.set(key, value, effectiveTtl);
+  }
+  get commands() {
+    if (!this._commands) {
+      this._commands = new RedisCommands(this);
+    }
+    return this._commands;
+  }
+  serialize(value) {
+    try {
+      const json = super.serialize(value);
+      if (this.enableCompression && json.length > 1024) {
+        return this.compress(json);
+      }
+      return json;
+    } catch (error) {
+      this.logger?.error("Serialization error", error);
+      throw error;
+    }
+  }
+  deserialize(value) {
+    try {
+      if (this.enableCompression && this.isCompressed(value)) {
+        value = this.decompress(value);
+      }
+      return super.deserialize(value);
+    } catch (error) {
+      this.logger?.error("Deserialization error", error);
+      throw error;
+    }
+  }
+  compress(data) {
+    return data;
+  }
+  decompress(data) {
+    return data;
+  }
+  isCompressed(_data) {
+    return false;
+  }
+  setupLogging() {
+    if (!this.logger) {
+      return;
+    }
+    this.on("error", (error) => {
+      this.logger?.error("Redis client error", error);
+    });
+    this.on("connect", () => {
+      this.logger?.debug("Redis connected");
+    });
+    this.on("disconnect", () => {
+      this.logger?.debug("Redis disconnected");
+    });
+    this.on("set", ({ key, ttl }) => {
+      this.logger?.debug("Cache set", { key, ttl });
+    });
+    this.on("delete", ({ key }) => {
+      this.logger?.debug("Cache delete", { key });
+    });
+    this.on("clear", ({ count }) => {
+      this.logger?.debug("Cache cleared", { count });
+    });
+    this.on("mset", ({ count }) => {
+      this.logger?.debug("Multiple cache set", { count });
+    });
+  }
+};
+var StreamBaseTrait = class extends import_index.default {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+  parseEntries(raw) {
+    return raw.map(([id, fields]) => ({
+      id,
+      fields: this.parseFields(fields)
+    }));
+  }
+  parseFields(raw) {
+    const fields = {};
+    for (let i = 0; i < raw.length; i += 2) {
+      fields[raw[i]] = raw[i + 1];
+    }
+    return fields;
+  }
+  parseStreamResults(raw) {
+    return raw.map(([stream, entries]) => [stream, this.parseEntries(entries)]);
+  }
+  camelCase(str) {
+    return str.replaceAll(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+  }
+  throwError(message, key, error) {
+    throw new CacheError(message, key, error);
+  }
+};
+
+// src/streams/traits/stream-crud-trait.ts
+var StreamCrudTrait = class extends StreamBaseTrait {
+  async xadd(key, _id = "*", fields, options) {
+    try {
+      const args = [key];
+      if (options?.maxlen) {
+        args.push("MAXLEN");
+        if (options.approximate) {
+          args.push("~");
+        }
+        args.push(options.maxlen);
+      }
+      args.push(_id);
+      Object.entries(fields).forEach(([field, value]) => {
+        args.push(field, String(value));
+      });
+      const resultId = await this.client.xadd(
+        key,
+        args[1],
+        ...args.slice(2)
+      );
+      return resultId || "";
+    } catch (error) {
+      this.throwError(`Failed to add to stream ${key}`, key, error);
+    }
+  }
+  async xdel(key, ...ids) {
+    try {
+      return await this.client.xdel(key, ...ids);
+    } catch (error) {
+      this.throwError(`Failed to delete from stream ${key}`, key, error);
+    }
+  }
+  async xtrim(key, maxlen, approximate = false) {
+    try {
+      const args = [key, "MAXLEN"];
+      if (approximate) {
+        args.push("~");
+      }
+      args.push(maxlen);
+      return approximate ? await this.client.xtrim(key, "MAXLEN", "~", maxlen) : await this.client.xtrim(key, "MAXLEN", maxlen);
+    } catch (error) {
+      this.throwError(`Failed to trim stream ${key}`, key, error);
+    }
+  }
+  async xlen(key) {
+    try {
+      return await this.client.xlen(key);
+    } catch (error) {
+      this.throwError(`Failed to get stream length ${key}`, key, error);
+    }
+  }
+};
+
+// src/streams/traits/stream-read-trait.ts
+var StreamReadTrait = class extends StreamCrudTrait {
+  async xread(streams, options) {
+    try {
+      const args = [];
+      if (options?.count) {
+        args.push("COUNT", options.count);
+      }
+      if (options?.block !== void 0) {
+        args.push("BLOCK", options.block);
+      }
+      args.push("STREAMS");
+      const keys = Object.keys(streams);
+      const ids = Object.values(streams);
+      args.push(...keys, ...ids);
+      const result = await this.client.xread(...args);
+      if (!result) {
+        return [];
+      }
+      return this.parseStreamResults(result);
+    } catch (error) {
+      this.throwError("Failed to read from streams", void 0, error);
+    }
+  }
+  async xrange(key, start = "-", end = "+", count) {
+    try {
+      const args = [key, start, end];
+      if (count) {
+        args.push("COUNT", count);
+      }
+      const result = count ? await this.client.xrange(key, start, end, "COUNT", count) : await this.client.xrange(key, start, end);
+      return this.parseEntries(result);
+    } catch (error) {
+      this.throwError(`Failed to read range from stream ${key}`, key, error);
+    }
+  }
+  async xrevrange(key, end = "+", start = "-", count) {
+    try {
+      const args = [key, end, start];
+      if (count) {
+        args.push("COUNT", count);
+      }
+      const result = count ? await this.client.xrevrange(key, end, start, "COUNT", count) : await this.client.xrevrange(key, end, start);
+      return this.parseEntries(result);
+    } catch (error) {
+      this.throwError(`Failed to read reverse range from stream ${key}`, key, error);
+    }
+  }
+};
+
+// src/streams/traits/stream-consumer-trait.ts
+var StreamConsumerTrait = class extends StreamReadTrait {
+  async xgroupCreate(key, groupName, id = "$", mkstream = false) {
+    try {
+      const args = [key, groupName, id];
+      if (mkstream) {
+        args.push("MKSTREAM");
+      }
+      if (mkstream) {
+        await this.client.xgroup("CREATE", key, groupName, id, "MKSTREAM");
+      } else {
+        await this.client.xgroup("CREATE", key, groupName, id);
+      }
+    } catch (error) {
+      if (!error.message?.includes("BUSYGROUP")) {
+        this.throwError(`Failed to create consumer group ${groupName}`, key, error);
+      }
+    }
+  }
+  async xgroupDestroy(key, groupName) {
+    try {
+      const result = await this.client.xgroup("DESTROY", key, groupName);
+      return result === 1;
+    } catch (error) {
+      this.throwError(`Failed to destroy consumer group ${groupName}`, key, error);
+    }
+  }
+  async xgroupSetId(key, groupName, id) {
+    try {
+      await this.client.xgroup("SETID", key, groupName, id);
+    } catch (error) {
+      this.throwError(`Failed to set ID for consumer group ${groupName}`, key, error);
+    }
+  }
+  async xreadgroup(groupName, consumerName, streams, options) {
+    try {
+      const args = ["GROUP", groupName, consumerName];
+      if (options?.count) {
+        args.push("COUNT", options.count);
+      }
+      if (options?.block !== void 0) {
+        args.push("BLOCK", options.block);
+      }
+      if (options?.noack) {
+        args.push("NOACK");
+      }
+      args.push("STREAMS");
+      const keys = Object.keys(streams);
+      const ids = Object.values(streams);
+      args.push(...keys, ...ids);
+      const result = await this.client.xreadgroup(...args);
+      if (!result) {
+        return [];
+      }
+      return this.parseStreamResults(result);
+    } catch (error) {
+      this.throwError("Failed to read from consumer group", void 0, error);
+    }
+  }
+  async xack(key, groupName, ...ids) {
+    try {
+      return await this.client.xack(key, groupName, ...ids);
+    } catch (error) {
+      this.throwError(`Failed to acknowledge messages in group ${groupName}`, key, error);
+    }
+  }
+  async xpending(key, groupName, options) {
+    try {
+      const args = [key, groupName];
+      if (options?.start && options?.end) {
+        args.push(options.start, options.end, options.count || 10);
+        if (options.consumer) {
+          args.push(options.consumer);
+        }
+      }
+      return await this.client.xpending(...args);
+    } catch (error) {
+      this.throwError(`Failed to get pending messages for group ${groupName}`, key, error);
+    }
+  }
+  async xclaim(key, groupName, consumerName, minIdleTime, ids, options) {
+    try {
+      const args = [key, groupName, consumerName, minIdleTime, ...ids];
+      if (options?.idle) {
+        args.push("IDLE", options.idle);
+      }
+      if (options?.time) {
+        args.push("TIME", options.time);
+      }
+      if (options?.retrycount) {
+        args.push("RETRYCOUNT", options.retrycount);
+      }
+      if (options?.force) {
+        args.push("FORCE");
+      }
+      if (options?.justid) {
+        args.push("JUSTID");
+      }
+      const result = await this.client.xclaim(...args);
+      if (options?.justid) {
+        return result;
+      }
+      return this.parseEntries(result);
+    } catch (error) {
+      this.throwError(`Failed to claim messages for consumer ${consumerName}`, key, error);
+    }
+  }
+};
+
+// src/streams/traits/stream-info-trait.ts
+var StreamInfoTrait = class extends StreamConsumerTrait {
+  async xinfo(subcommand, key, groupName) {
+    try {
+      const args = [subcommand, key];
+      if (groupName && subcommand === "CONSUMERS") {
+        args.push(groupName);
+      }
+      const result = await this.client.xinfo(...args);
+      if (subcommand === "STREAM") {
+        return this.parseStreamInfo(result);
+      } else if (subcommand === "GROUPS") {
+        return this.parseGroupsInfo(result);
+      } else {
+        return result;
+      }
+    } catch (error) {
+      this.throwError(`Failed to get info for stream ${key}`, key, error);
+    }
+  }
+  parseStreamInfo(raw) {
+    const info = {};
+    for (let i = 0; i < raw.length; i += 2) {
+      const key = raw[i];
+      const value = raw[i + 1];
+      switch (key) {
+        case "length":
+        case "radix-tree-keys":
+        case "radix-tree-nodes":
+        case "groups": {
+          info[this.camelCase(key)] = value;
+          break;
+        }
+        case "last-generated-id": {
+          info.lastGeneratedId = value;
+          break;
+        }
+        case "first-entry":
+        case "last-entry": {
+          if (value) {
+            info[this.camelCase(key)] = {
+              id: value[0],
+              fields: this.parseFields(value[1])
+            };
+          }
+          break;
+        }
+      }
+    }
+    return info;
+  }
+  parseGroupsInfo(raw) {
+    return raw.map((group) => {
+      const info = {};
+      for (let i = 0; i < group.length; i += 2) {
+        const key = group[i];
+        const value = group[i + 1];
+        switch (key) {
+          case "name":
+          case "consumers":
+          case "pending": {
+            info[key] = value;
+            break;
+          }
+          case "last-delivered-id": {
+            info.lastDeliveredId = value;
+            break;
+          }
+        }
+      }
+      return info;
+    });
+  }
+};
+
+// src/streams/modular-stream-manager.ts
+var ModularRedisStreamManager = class extends StreamInfoTrait {
+  constructor(client) {
+    super(client);
+  }
+  // Additional high-level methods can be added here
+  async createStreamWithGroup(key, groupName, options) {
+    await this.xadd(key, "*", { init: "true" }, options);
+    await this.xgroupCreate(key, groupName, "0");
+    const entries = await this.xrange(key, "-", "+", 1);
+    if (entries.length > 0 && entries[0]?.fields["init"] === "true") {
+      await this.xdel(key, entries[0].id);
+    }
+  }
+  async getStreamStats(key) {
+    const length = await this.xlen(key);
+    const info = await this.xinfo("STREAM", key);
+    let groups;
+    try {
+      const groupsInfo = await this.xinfo("GROUPS", key);
+      groups = Array.isArray(groupsInfo) ? groupsInfo : void 0;
+    } catch {
+    }
+    return { length, info, groups };
+  }
+  async consumeStream(groupName, consumerName, keys, options) {
+    const streams = {};
+    keys.forEach((key) => {
+      streams[key] = ">";
+    });
+    const messages = await this.xreadgroup(groupName, consumerName, streams, {
+      count: options?.count,
+      block: options?.block,
+      noack: options?.autoAck
+    });
+    let processedCount = 0;
+    for (const [streamKey, entries] of messages) {
+      for (const entry of entries) {
+        if (options?.processMessage) {
+          await options.processMessage(streamKey, entry);
+        }
+        if (!options?.autoAck) {
+          await this.xack(streamKey, groupName, entry.id);
+        }
+        processedCount++;
+      }
+    }
+    return processedCount;
+  }
+};
+
+export { ModularRedisAdapter, ModularRedisStreamManager, RedisAdapter, RedisCacheAdapter, RedisCommands, createDatabaseAdapterWithCache };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map