@nestjs-redisx/core 1.0.0

package/dist/index.js

@@ -0,0 +1,4925 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseRedisDriver: () => BaseRedisDriver,
+  CLIENT_MANAGER: () => CLIENT_MANAGER,
+  CommandError: () => CommandError,
+  ConnectionError: () => ConnectionError,
+  ConnectionStatus: () => ConnectionStatus,
+  DEFAULT_CLIENT_NAME: () => DEFAULT_CLIENT_NAME,
+  DEFAULT_COMMAND_TIMEOUT: () => DEFAULT_COMMAND_TIMEOUT,
+  DEFAULT_CONNECTION_TIMEOUT: () => DEFAULT_CONNECTION_TIMEOUT,
+  DEFAULT_DRIVER_TYPE: () => DEFAULT_DRIVER_TYPE,
+  DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT: () => DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT,
+  DEFAULT_HEALTH_CHECK_INTERVAL: () => DEFAULT_HEALTH_CHECK_INTERVAL,
+  DriverError: () => DriverError,
+  DriverEvent: () => DriverEvent,
+  DriverFactory: () => DriverFactory,
+  ErrorCode: () => ErrorCode,
+  InjectRedis: () => InjectRedis,
+  IoRedisAdapter: () => IoRedisAdapter,
+  MODULE_NAME: () => MODULE_NAME,
+  ManagerEvent: () => ManagerEvent,
+  NodeRedisAdapter: () => NodeRedisAdapter,
+  PLUGIN_REGISTRY: () => PLUGIN_REGISTRY,
+  PluginRegistryService: () => PluginRegistryService,
+  REDISX_CONFIG: () => REDISX_CONFIG,
+  REDISX_LOGGER: () => REDISX_LOGGER,
+  REDIS_CLIENT: () => REDIS_CLIENT,
+  REDIS_CLIENTS_INITIALIZATION: () => REDIS_CLIENTS_INITIALIZATION,
+  REDIS_CLIENTS_MAP: () => REDIS_CLIENTS_MAP,
+  REDIS_DRIVER: () => REDIS_DRIVER,
+  REDIS_MODULE_OPTIONS: () => REDIS_MODULE_OPTIONS,
+  REGISTERED_PLUGINS: () => REGISTERED_PLUGINS,
+  RedisAuthError: () => RedisAuthError,
+  RedisClientManager: () => RedisClientManager,
+  RedisClusterError: () => RedisClusterError,
+  RedisConfigError: () => RedisConfigError,
+  RedisConnectionError: () => RedisConnectionError,
+  RedisInvalidArgsError: () => RedisInvalidArgsError,
+  RedisKeyNotFoundError: () => RedisKeyNotFoundError,
+  RedisMaxRetriesError: () => RedisMaxRetriesError,
+  RedisModule: () => RedisModule,
+  RedisNotConnectedError: () => RedisNotConnectedError,
+  RedisNotSupportedError: () => RedisNotSupportedError,
+  RedisOperationError: () => RedisOperationError,
+  RedisOutOfMemoryError: () => RedisOutOfMemoryError,
+  RedisPipelineError: () => RedisPipelineError,
+  RedisPoolExhaustedError: () => RedisPoolExhaustedError,
+  RedisReadOnlyError: () => RedisReadOnlyError,
+  RedisScriptError: () => RedisScriptError,
+  RedisSentinelError: () => RedisSentinelError,
+  RedisService: () => RedisService,
+  RedisTLSError: () => RedisTLSError,
+  RedisTimeoutError: () => RedisTimeoutError,
+  RedisTransactionError: () => RedisTransactionError,
+  RedisTypeMismatchError: () => RedisTypeMismatchError,
+  RedisValidationError: () => RedisValidationError,
+  RedisXError: () => RedisXError,
+  TimeoutError: () => TimeoutError,
+  ValidationErrorCollector: () => ValidationErrorCollector,
+  createDriver: () => createDriver,
+  createDrivers: () => createDrivers,
+  detectAvailableDriver: () => detectAvailableDriver,
+  getClientToken: () => getClientToken,
+  getDriverToken: () => getDriverToken,
+  getErrorDomain: () => getErrorDomain,
+  getRecommendedDriver: () => getRecommendedDriver,
+  hasClass: () => hasClass,
+  hasExisting: () => hasExisting,
+  hasFactory: () => hasFactory,
+  isClusterConnection: () => isClusterConnection,
+  isErrorCode: () => isErrorCode,
+  isErrorDomain: () => isErrorDomain,
+  isSentinelConnection: () => isSentinelConnection,
+  isSingleConnection: () => isSingleConnection
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api/redis.module.ts
+var import_common5 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+
+// src/client/application/redis-client.manager.ts
+var import_events2 = __toESM(require("events"));
+var import_common2 = require("@nestjs/common");
+
+// src/driver/infrastructure/base.driver.ts
+var import_events = __toESM(require("events"));
+var import_common = require("@nestjs/common");
+
+// src/interfaces/redis-driver.interface.ts
+var DriverEvent = /* @__PURE__ */ ((DriverEvent2) => {
+  DriverEvent2["CONNECT"] = "connect";
+  DriverEvent2["READY"] = "ready";
+  DriverEvent2["DISCONNECT"] = "disconnect";
+  DriverEvent2["CLOSE"] = "close";
+  DriverEvent2["ERROR"] = "error";
+  DriverEvent2["RECONNECTING"] = "reconnecting";
+  DriverEvent2["END"] = "end";
+  return DriverEvent2;
+})(DriverEvent || {});
+
+// src/errors/error-codes.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["CONN_FAILED"] = "CONN_FAILED";
+  ErrorCode2["CONN_TIMEOUT"] = "CONN_TIMEOUT";
+  ErrorCode2["CONN_DISCONNECTED"] = "CONN_DISCONNECTED";
+  ErrorCode2["CONN_REFUSED"] = "CONN_REFUSED";
+  ErrorCode2["CONN_AUTH_FAILED"] = "CONN_AUTH_FAILED";
+  ErrorCode2["CONN_TLS_ERROR"] = "CONN_TLS_ERROR";
+  ErrorCode2["CONN_CLUSTER_DOWN"] = "CONN_CLUSTER_DOWN";
+  ErrorCode2["CONN_CLUSTER_MOVED"] = "CONN_CLUSTER_MOVED";
+  ErrorCode2["CONN_CLUSTER_ASK"] = "CONN_CLUSTER_ASK";
+  ErrorCode2["CONN_CLUSTER_ERROR"] = "CONN_CLUSTER_ERROR";
+  ErrorCode2["CONN_SENTINEL_FAILOVER"] = "CONN_SENTINEL_FAILOVER";
+  ErrorCode2["CONN_SENTINEL_NO_MASTER"] = "CONN_SENTINEL_NO_MASTER";
+  ErrorCode2["CONN_SENTINEL_ERROR"] = "CONN_SENTINEL_ERROR";
+  ErrorCode2["DRIVER_NOT_CONNECTED"] = "DRIVER_NOT_CONNECTED";
+  ErrorCode2["CONN_MAX_RETRIES"] = "CONN_MAX_RETRIES";
+  ErrorCode2["CONN_POOL_EXHAUSTED"] = "CONN_POOL_EXHAUSTED";
+  ErrorCode2["OP_FAILED"] = "OP_FAILED";
+  ErrorCode2["OP_TIMEOUT"] = "OP_TIMEOUT";
+  ErrorCode2["OP_KEY_NOT_FOUND"] = "OP_KEY_NOT_FOUND";
+  ErrorCode2["OP_TYPE_MISMATCH"] = "OP_TYPE_MISMATCH";
+  ErrorCode2["OP_SCRIPT_ERROR"] = "OP_SCRIPT_ERROR";
+  ErrorCode2["OP_SCRIPT_TIMEOUT"] = "OP_SCRIPT_TIMEOUT";
+  ErrorCode2["OP_TRANSACTION_FAILED"] = "OP_TRANSACTION_FAILED";
+  ErrorCode2["OP_PIPELINE_FAILED"] = "OP_PIPELINE_FAILED";
+  ErrorCode2["OP_INVALID_ARGS"] = "OP_INVALID_ARGS";
+  ErrorCode2["OP_NOT_SUPPORTED"] = "OP_NOT_SUPPORTED";
+  ErrorCode2["OP_OUT_OF_MEMORY"] = "OP_OUT_OF_MEMORY";
+  ErrorCode2["OP_NO_AUTH"] = "OP_NO_AUTH";
+  ErrorCode2["OP_WRONG_PASS"] = "OP_WRONG_PASS";
+  ErrorCode2["OP_READONLY"] = "OP_READONLY";
+  ErrorCode2["OP_BUSY_KEY"] = "OP_BUSY_KEY";
+  ErrorCode2["OP_NOT_CONNECTED"] = "OP_NOT_CONNECTED";
+  ErrorCode2["CFG_INVALID"] = "CFG_INVALID";
+  ErrorCode2["CFG_MISSING_REQUIRED"] = "CFG_MISSING_REQUIRED";
+  ErrorCode2["CFG_INVALID_CONNECTION_TYPE"] = "CFG_INVALID_CONNECTION_TYPE";
+  ErrorCode2["CFG_INVALID_HOST_PORT"] = "CFG_INVALID_HOST_PORT";
+  ErrorCode2["CFG_INVALID_DB"] = "CFG_INVALID_DB";
+  ErrorCode2["CFG_INVALID_TTL"] = "CFG_INVALID_TTL";
+  ErrorCode2["CFG_INVALID_TIMEOUT"] = "CFG_INVALID_TIMEOUT";
+  ErrorCode2["CFG_INVALID_RETRY"] = "CFG_INVALID_RETRY";
+  ErrorCode2["CFG_VALIDATION_FAILED"] = "CFG_VALIDATION_FAILED";
+  ErrorCode2["CFG_INCOMPATIBLE"] = "CFG_INCOMPATIBLE";
+  ErrorCode2["CFG_DRIVER_NOT_SUPPORTED"] = "CFG_DRIVER_NOT_SUPPORTED";
+  ErrorCode2["CFG_INVALID_CLUSTER_NODES"] = "CFG_INVALID_CLUSTER_NODES";
+  ErrorCode2["CFG_INVALID_SENTINEL"] = "CFG_INVALID_SENTINEL";
+  ErrorCode2["CFG_INVALID_TLS"] = "CFG_INVALID_TLS";
+  ErrorCode2["CACHE_KEY_INVALID"] = "CACHE_KEY_INVALID";
+  ErrorCode2["CACHE_KEY_TOO_LONG"] = "CACHE_KEY_TOO_LONG";
+  ErrorCode2["CACHE_SERIALIZATION_FAILED"] = "CACHE_SERIALIZATION_FAILED";
+  ErrorCode2["CACHE_DESERIALIZATION_FAILED"] = "CACHE_DESERIALIZATION_FAILED";
+  ErrorCode2["CACHE_TAG_INDEX_CORRUPTED"] = "CACHE_TAG_INDEX_CORRUPTED";
+  ErrorCode2["CACHE_STAMPEDE_TIMEOUT"] = "CACHE_STAMPEDE_TIMEOUT";
+  ErrorCode2["CACHE_LOADER_FAILED"] = "CACHE_LOADER_FAILED";
+  ErrorCode2["CACHE_L1_ERROR"] = "CACHE_L1_ERROR";
+  ErrorCode2["CACHE_L2_ERROR"] = "CACHE_L2_ERROR";
+  ErrorCode2["CACHE_SET_FAILED"] = "CACHE_SET_FAILED";
+  ErrorCode2["CACHE_DELETE_FAILED"] = "CACHE_DELETE_FAILED";
+  ErrorCode2["CACHE_CLEAR_FAILED"] = "CACHE_CLEAR_FAILED";
+  ErrorCode2["CACHE_OPERATION_FAILED"] = "CACHE_OPERATION_FAILED";
+  ErrorCode2["CACHE_OPERATION_TIMEOUT"] = "CACHE_OPERATION_TIMEOUT";
+  ErrorCode2["CACHE_TAG_INVALIDATION_FAILED"] = "CACHE_TAG_INVALIDATION_FAILED";
+  ErrorCode2["LOCK_ACQUISITION_FAILED"] = "LOCK_ACQUISITION_FAILED";
+  ErrorCode2["LOCK_ACQUISITION_TIMEOUT"] = "LOCK_ACQUISITION_TIMEOUT";
+  ErrorCode2["LOCK_EXTENSION_FAILED"] = "LOCK_EXTENSION_FAILED";
+  ErrorCode2["LOCK_RELEASE_FAILED"] = "LOCK_RELEASE_FAILED";
+  ErrorCode2["LOCK_NOT_OWNED"] = "LOCK_NOT_OWNED";
+  ErrorCode2["LOCK_EXPIRED"] = "LOCK_EXPIRED";
+  ErrorCode2["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
+  ErrorCode2["RATE_LIMIT_SCRIPT_ERROR"] = "RATE_LIMIT_SCRIPT_ERROR";
+  ErrorCode2["IDEMPOTENCY_KEY_INVALID"] = "IDEMPOTENCY_KEY_INVALID";
+  ErrorCode2["IDEMPOTENCY_IN_PROGRESS"] = "IDEMPOTENCY_IN_PROGRESS";
+  ErrorCode2["IDEMPOTENCY_PREVIOUS_FAILED"] = "IDEMPOTENCY_PREVIOUS_FAILED";
+  ErrorCode2["STREAM_CONSUMER_GROUP_ERROR"] = "STREAM_CONSUMER_GROUP_ERROR";
+  ErrorCode2["STREAM_ACK_FAILED"] = "STREAM_ACK_FAILED";
+  ErrorCode2["STREAM_READ_FAILED"] = "STREAM_READ_FAILED";
+  ErrorCode2["PLUGIN_INVALID"] = "PLUGIN_INVALID";
+  ErrorCode2["PLUGIN_DUPLICATE"] = "PLUGIN_DUPLICATE";
+  ErrorCode2["PLUGIN_NOT_FOUND"] = "PLUGIN_NOT_FOUND";
+  ErrorCode2["PLUGIN_REGISTER_FAILED"] = "PLUGIN_REGISTER_FAILED";
+  ErrorCode2["PLUGIN_INIT_FAILED"] = "PLUGIN_INIT_FAILED";
+  ErrorCode2["PLUGIN_CIRCULAR_DEPENDENCY"] = "PLUGIN_CIRCULAR_DEPENDENCY";
+  ErrorCode2["PLUGIN_DEPENDENCY_MISSING"] = "PLUGIN_DEPENDENCY_MISSING";
+  ErrorCode2["CLIENT_NOT_FOUND"] = "CLIENT_NOT_FOUND";
+  ErrorCode2["CLIENT_ALREADY_EXISTS"] = "CLIENT_ALREADY_EXISTS";
+  ErrorCode2["NOT_INITIALIZED"] = "NOT_INITIALIZED";
+  ErrorCode2["OPERATION_FAILED"] = "OPERATION_FAILED";
+  ErrorCode2["OPERATION_TIMEOUT"] = "OPERATION_TIMEOUT";
+  ErrorCode2["SERIALIZATION_FAILED"] = "SERIALIZATION_FAILED";
+  ErrorCode2["VALIDATION_FAILED"] = "VALIDATION_FAILED";
+  ErrorCode2["UNKNOWN"] = "UNKNOWN";
+  return ErrorCode2;
+})(ErrorCode || {});
+function isErrorCode(value) {
+  return Object.values(ErrorCode).includes(value);
+}
+function getErrorDomain(code) {
+  const parts = code.split("_");
+  return parts[0] || "UNKNOWN";
+}
+function isErrorDomain(code, domain) {
+  return getErrorDomain(code) === domain;
+}
+
+// src/errors/base.error.ts
+var RedisXError = class _RedisXError extends Error {
+  /**
+   * Creates a new RedisXError.
+   *
+   * @param message - Human-readable error message
+   * @param code - Error code for programmatic handling
+   * @param cause - Original error that caused this error
+   * @param context - Additional context for debugging
+   */
+  constructor(message, code, cause, context) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.context = context;
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = this.constructor.name;
+    this.timestamp = /* @__PURE__ */ new Date();
+    Error.captureStackTrace(this, this.constructor);
+  }
+  /**
+   * Timestamp when error was created.
+   */
+  timestamp;
+  /**
+   * Checks if error is of specific code.
+   *
+   * @param code - Error code to check
+   * @returns True if error matches code
+   *
+   * @example
+   * ```typescript
+   * if (error.is(ErrorCode.CONN_FAILED)) {
+   *   // Handle connection error
+   * }
+   * ```
+   */
+  is(code) {
+    return this.code === code;
+  }
+  /**
+   * Checks if error is any of specified codes.
+   *
+   * @param codes - Array of error codes to check
+   * @returns True if error matches any code
+   *
+   * @example
+   * ```typescript
+   * if (error.isAnyOf([ErrorCode.LOCK_EXPIRED, ErrorCode.LOCK_NOT_OWNED])) {
+   *   // Handle lock error
+   * }
+   * ```
+   */
+  isAnyOf(codes) {
+    return codes.includes(this.code);
+  }
+  /**
+   * Serializes error to JSON for logging.
+   *
+   * @returns JSON representation of error
+   *
+   * @example
+   * ```typescript
+   * logger.error('Operation failed', error.toJSON());
+   * ```
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      timestamp: this.timestamp.toISOString(),
+      context: this.context,
+      cause: this.cause ? {
+        name: this.cause.name,
+        message: this.cause.message,
+        stack: this.cause.stack
+      } : void 0,
+      stack: this.stack
+    };
+  }
+  /**
+   * Creates error string for logging.
+   *
+   * @returns Formatted error string
+   */
+  toString() {
+    let str = `${this.name} [${this.code}]: ${this.message}`;
+    if (this.cause) {
+      str += `
+  Caused by: ${this.cause.message}`;
+    }
+    if (this.context && Object.keys(this.context).length > 0) {
+      str += `
+  Context: ${JSON.stringify(this.context)}`;
+    }
+    return str;
+  }
+  /**
+   * Wraps unknown error in RedisXError.
+   *
+   * @param error - Error to wrap
+   * @param code - Error code to assign
+   * @returns RedisXError instance
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await someOperation();
+   * } catch (err) {
+   *   throw RedisXError.wrap(err, ErrorCode.CACHE_LOADER_FAILED);
+   * }
+   * ```
+   */
+  static wrap(error, code = "UNKNOWN" /* UNKNOWN */) {
+    if (error instanceof _RedisXError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      return new GenericRedisXError(error.message, code, error);
+    }
+    return new GenericRedisXError(String(error), code, void 0, { originalError: error });
+  }
+  /**
+   * Checks if value is a RedisXError.
+   *
+   * @param error - Value to check
+   * @returns True if value is RedisXError
+   */
+  static isRedisXError(error) {
+    return error instanceof _RedisXError;
+  }
+};
+var GenericRedisXError = class extends RedisXError {
+  constructor(message, code, cause, context) {
+    super(message, code, cause, context);
+  }
+};
+
+// src/errors/connection.errors.ts
+var RedisConnectionError = class _RedisConnectionError extends RedisXError {
+  constructor(message, code, host, port, cause, context) {
+    super(message, code, cause, {
+      ...context,
+      host,
+      port
+    });
+    this.host = host;
+    this.port = port;
+  }
+  /**
+   * Creates connection error with default code.
+   */
+  static create(message, host, port, cause) {
+    return new _RedisConnectionError(message, "CONN_FAILED" /* CONN_FAILED */, host, port, cause);
+  }
+};
+var RedisTimeoutError = class extends RedisConnectionError {
+  constructor(operation, timeoutMs, host, port, cause) {
+    const message = operation === "Connection" ? `Connection to ${host}:${port} timed out after ${timeoutMs}ms` : `Operation "${operation}" timed out after ${timeoutMs}ms`;
+    super(message, operation === "Connection" ? "CONN_TIMEOUT" /* CONN_TIMEOUT */ : "OP_TIMEOUT" /* OP_TIMEOUT */, host, port, cause, { operation, timeoutMs });
+    this.operation = operation;
+    this.timeoutMs = timeoutMs;
+  }
+};
+var RedisClusterError = class _RedisClusterError extends RedisConnectionError {
+  constructor(message, code, host, port, cause, context) {
+    super(message, code, host, port, cause, context);
+  }
+  /**
+   * Creates cluster down error.
+   */
+  static clusterDown(host, port) {
+    return new _RedisClusterError("Redis cluster is down or unreachable", "CONN_CLUSTER_DOWN" /* CONN_CLUSTER_DOWN */, host, port);
+  }
+  /**
+   * Creates MOVED redirection error.
+   */
+  static moved(slot, targetHost, targetPort, cause) {
+    return new _RedisClusterError(`Slot ${slot} moved to ${targetHost}:${targetPort}`, "CONN_CLUSTER_MOVED" /* CONN_CLUSTER_MOVED */, targetHost, targetPort, cause, { slot, targetHost, targetPort });
+  }
+  /**
+   * Creates ASK redirection error.
+   */
+  static ask(slot, targetHost, targetPort, cause) {
+    return new _RedisClusterError(`ASK redirection for slot ${slot} to ${targetHost}:${targetPort}`, "CONN_CLUSTER_ASK" /* CONN_CLUSTER_ASK */, targetHost, targetPort, cause, { slot, targetHost, targetPort });
+  }
+  /**
+   * Creates generic cluster error.
+   */
+  static generic(message, host, port, cause) {
+    return new _RedisClusterError(message, "CONN_CLUSTER_ERROR" /* CONN_CLUSTER_ERROR */, host, port, cause);
+  }
+};
+var RedisSentinelError = class _RedisSentinelError extends RedisConnectionError {
+  constructor(message, code, masterName, host, port, cause, context) {
+    super(message, code, host, port, cause, {
+      ...context,
+      masterName
+    });
+    this.masterName = masterName;
+  }
+  /**
+   * Creates no master found error.
+   */
+  static noMaster(masterName, sentinels) {
+    return new _RedisSentinelError(`No master found for "${masterName}"`, "CONN_SENTINEL_NO_MASTER" /* CONN_SENTINEL_NO_MASTER */, masterName, void 0, void 0, void 0, { sentinels });
+  }
+  /**
+   * Creates sentinel failover error.
+   */
+  static failover(masterName, oldMaster, newMaster) {
+    return new _RedisSentinelError(`Sentinel failover in progress for "${masterName}"`, "CONN_SENTINEL_FAILOVER" /* CONN_SENTINEL_FAILOVER */, masterName, void 0, void 0, void 0, { oldMaster, newMaster });
+  }
+  /**
+   * Creates generic sentinel error.
+   */
+  static generic(message, masterName, cause) {
+    return new _RedisSentinelError(message, "CONN_SENTINEL_ERROR" /* CONN_SENTINEL_ERROR */, masterName, void 0, void 0, cause);
+  }
+};
+var RedisAuthError = class extends RedisConnectionError {
+  constructor(message = "Redis authentication failed", host, port, cause) {
+    super(message, "CONN_AUTH_FAILED" /* CONN_AUTH_FAILED */, host, port, cause);
+  }
+};
+var RedisTLSError = class extends RedisConnectionError {
+  constructor(message = "TLS/SSL connection failed", host, port, cause) {
+    super(message, "CONN_TLS_ERROR" /* CONN_TLS_ERROR */, host, port, cause);
+  }
+};
+var RedisMaxRetriesError = class extends RedisConnectionError {
+  constructor(maxRetries, host, port, cause) {
+    super(`Maximum connection retries (${maxRetries}) exceeded`, "CONN_MAX_RETRIES" /* CONN_MAX_RETRIES */, host, port, cause, { maxRetries });
+    this.maxRetries = maxRetries;
+  }
+};
+var RedisPoolExhaustedError = class extends RedisConnectionError {
+  constructor(poolSize, waitingClients, cause) {
+    super(`Connection pool exhausted (size: ${poolSize}, waiting: ${waitingClients})`, "CONN_POOL_EXHAUSTED" /* CONN_POOL_EXHAUSTED */, void 0, void 0, cause, { poolSize, waitingClients });
+    this.poolSize = poolSize;
+    this.waitingClients = waitingClients;
+  }
+};
+
+// src/errors/operation.errors.ts
+var RedisOperationError = class _RedisOperationError extends RedisXError {
+  constructor(message, code, command, cause, context) {
+    super(message, code, cause, {
+      ...context,
+      command
+    });
+    this.command = command;
+  }
+  /**
+   * Creates operation error with default code.
+   */
+  static create(message, command, cause) {
+    return new _RedisOperationError(message, "OP_FAILED" /* OP_FAILED */, command, cause);
+  }
+  /**
+   * Creates operation error from command and arguments.
+   */
+  static fromCommand(command, args, cause) {
+    return new _RedisOperationError(`Command "${command}" failed: ${cause?.message ?? "Unknown error"}`, "OP_FAILED" /* OP_FAILED */, command, cause, { argsCount: args.length });
+  }
+};
+var RedisKeyNotFoundError = class extends RedisOperationError {
+  constructor(key, command, cause) {
+    super(`Key "${key}" not found`, "OP_KEY_NOT_FOUND" /* OP_KEY_NOT_FOUND */, command, cause, { key });
+    this.key = key;
+  }
+};
+var RedisTypeMismatchError = class _RedisTypeMismatchError extends RedisOperationError {
+  constructor(key, expected, actual, command, cause) {
+    super(`Type mismatch for key "${key}": expected ${expected}, got ${actual}`, "OP_TYPE_MISMATCH" /* OP_TYPE_MISMATCH */, command, cause, { key, expected, actual });
+    this.key = key;
+    this.expected = expected;
+    this.actual = actual;
+  }
+  /**
+   * Creates type mismatch from Redis WRONGTYPE error.
+   */
+  static fromRedisError(key, command, cause) {
+    const message = cause.message.toLowerCase();
+    let expected = "unknown";
+    const actual = "unknown";
+    if (message.includes("wrongtype")) {
+      if (command.startsWith("L") || command.startsWith("R") || command.startsWith("BLPOP")) {
+        expected = "list";
+      } else if (command.startsWith("S") && !command.startsWith("SET")) {
+        expected = "set";
+      } else if (command.startsWith("Z")) {
+        expected = "zset";
+      } else if (command.startsWith("H")) {
+        expected = "hash";
+      }
+    }
+    return new _RedisTypeMismatchError(key, expected, actual, command, cause);
+  }
+};
+var RedisScriptError = class _RedisScriptError extends RedisOperationError {
+  constructor(message, scriptSha, cause, context) {
+    super(message, "OP_SCRIPT_ERROR" /* OP_SCRIPT_ERROR */, "EVALSHA", cause, {
+      ...context,
+      scriptSha
+    });
+    this.scriptSha = scriptSha;
+  }
+  /**
+   * Creates script timeout error.
+   */
+  static timeout(timeoutMs, scriptSha) {
+    return new _RedisScriptError(`Script execution timed out after ${timeoutMs}ms`, scriptSha, void 0, { timeoutMs });
+  }
+  /**
+   * Creates script not found error (NOSCRIPT).
+   */
+  static notFound(scriptSha) {
+    return new _RedisScriptError(`Script not found in Redis cache: ${scriptSha}`, scriptSha, void 0, { reason: "NOSCRIPT" });
+  }
+};
+var RedisTransactionError = class _RedisTransactionError extends RedisOperationError {
+  constructor(message, cause, context) {
+    super(message, "OP_TRANSACTION_FAILED" /* OP_TRANSACTION_FAILED */, "EXEC", cause, context);
+  }
+  /**
+   * Creates transaction aborted error (WATCH failure).
+   */
+  static aborted() {
+    return new _RedisTransactionError("Transaction aborted: watched key was modified", void 0, { reason: "WATCH" });
+  }
+};
+var RedisPipelineError = class extends RedisOperationError {
+  constructor(message, totalCommands, failedCommands, cause) {
+    super(message, "OP_PIPELINE_FAILED" /* OP_PIPELINE_FAILED */, "PIPELINE", cause, { totalCommands, failedCommands });
+    this.totalCommands = totalCommands;
+    this.failedCommands = failedCommands;
+  }
+};
+var RedisInvalidArgsError = class extends RedisOperationError {
+  constructor(command, reason, args) {
+    super(`Invalid arguments for ${command}: ${reason}`, "OP_INVALID_ARGS" /* OP_INVALID_ARGS */, command, void 0, { args, reason });
+    this.args = args;
+  }
+};
+var RedisOutOfMemoryError = class extends RedisOperationError {
+  constructor(command, key, cause) {
+    super(`Redis out of memory while executing ${command}${key ? ` on key "${key}"` : ""}`, "OP_OUT_OF_MEMORY" /* OP_OUT_OF_MEMORY */, command, cause, { key });
+    this.key = key;
+  }
+};
+var RedisReadOnlyError = class extends RedisOperationError {
+  constructor(command, key, cause) {
+    super(`Cannot write to read-only replica: ${command}${key ? ` (key: ${key})` : ""}`, "OP_READONLY" /* OP_READONLY */, command, cause, { key });
+    this.key = key;
+  }
+};
+var RedisNotSupportedError = class extends RedisOperationError {
+  constructor(command, reason) {
+    super(`Command ${command} not supported: ${reason}`, "OP_NOT_SUPPORTED" /* OP_NOT_SUPPORTED */, command, void 0, { reason });
+    this.reason = reason;
+  }
+};
+var RedisNotConnectedError = class extends RedisOperationError {
+  constructor(command) {
+    super(`Cannot execute ${command ?? "operation"}: driver not connected`, "OP_NOT_CONNECTED" /* OP_NOT_CONNECTED */, command);
+  }
+};
+
+// src/errors/config.errors.ts
+var RedisConfigError = class _RedisConfigError extends RedisXError {
+  constructor(message, code, cause, context) {
+    super(message, code, cause, context);
+  }
+  /**
+   * Creates generic config error.
+   */
+  static create(message, cause, context) {
+    return new _RedisConfigError(message, "CFG_INVALID" /* CFG_INVALID */, cause, context);
+  }
+  /**
+   * Creates missing required field error.
+   */
+  static missingRequired(field, parent) {
+    const path = parent ? `${parent}.${field}` : field;
+    return new _RedisConfigError(`Missing required configuration field: ${path}`, "CFG_MISSING_REQUIRED" /* CFG_MISSING_REQUIRED */, void 0, { field, parent, path });
+  }
+  /**
+   * Creates invalid connection type error.
+   */
+  static invalidConnectionType(type, validTypes) {
+    return new _RedisConfigError(`Invalid connection type "${type}". Must be one of: ${validTypes.join(", ")}`, "CFG_INVALID_CONNECTION_TYPE" /* CFG_INVALID_CONNECTION_TYPE */, void 0, { type, validTypes });
+  }
+  /**
+   * Creates invalid host/port error.
+   */
+  static invalidHostPort(host, port, reason) {
+    const message = reason ? `Invalid host/port configuration: ${reason}` : `Invalid host "${host}" or port "${port}"`;
+    return new _RedisConfigError(message, "CFG_INVALID_HOST_PORT" /* CFG_INVALID_HOST_PORT */, void 0, { host, port, reason });
+  }
+  /**
+   * Creates invalid database number error.
+   */
+  static invalidDb(db, max = 15) {
+    return new _RedisConfigError(`Invalid database number ${db}. Must be between 0 and ${max}`, "CFG_INVALID_DB" /* CFG_INVALID_DB */, void 0, { db, max });
+  }
+  /**
+   * Creates invalid TTL error.
+   */
+  static invalidTTL(ttl, reason) {
+    const message = reason ? `Invalid TTL ${ttl}: ${reason}` : `Invalid TTL ${ttl}. Must be a positive number`;
+    return new _RedisConfigError(message, "CFG_INVALID_TTL" /* CFG_INVALID_TTL */, void 0, { ttl, reason });
+  }
+  /**
+   * Creates invalid timeout error.
+   */
+  static invalidTimeout(timeout, field, reason) {
+    const message = reason ? `Invalid ${field} timeout ${timeout}: ${reason}` : `Invalid ${field} timeout ${timeout}. Must be a positive number`;
+    return new _RedisConfigError(message, "CFG_INVALID_TIMEOUT" /* CFG_INVALID_TIMEOUT */, void 0, { timeout, field, reason });
+  }
+  /**
+   * Creates invalid retry configuration error.
+   */
+  static invalidRetry(reason, context) {
+    return new _RedisConfigError(`Invalid retry configuration: ${reason}`, "CFG_INVALID_RETRY" /* CFG_INVALID_RETRY */, void 0, context);
+  }
+  /**
+   * Creates incompatible configuration error.
+   */
+  static incompatible(option1, option2, reason) {
+    const message = reason ? `Incompatible configuration: ${option1} and ${option2} - ${reason}` : `Configuration options "${option1}" and "${option2}" are incompatible`;
+    return new _RedisConfigError(message, "CFG_INCOMPATIBLE" /* CFG_INCOMPATIBLE */, void 0, { option1, option2, reason });
+  }
+  /**
+   * Creates driver not supported error.
+   */
+  static driverNotSupported(driver, supportedDrivers) {
+    return new _RedisConfigError(`Driver "${driver}" is not supported. Available drivers: ${supportedDrivers.join(", ")}`, "CFG_DRIVER_NOT_SUPPORTED" /* CFG_DRIVER_NOT_SUPPORTED */, void 0, { driver, supportedDrivers });
+  }
+  /**
+   * Creates invalid cluster nodes error.
+   */
+  static invalidClusterNodes(reason, nodes) {
+    return new _RedisConfigError(`Invalid cluster nodes configuration: ${reason}`, "CFG_INVALID_CLUSTER_NODES" /* CFG_INVALID_CLUSTER_NODES */, void 0, { reason, nodes, nodeCount: nodes?.length });
+  }
+  /**
+   * Creates invalid sentinel configuration error.
+   */
+  static invalidSentinel(reason, context) {
+    return new _RedisConfigError(`Invalid sentinel configuration: ${reason}`, "CFG_INVALID_SENTINEL" /* CFG_INVALID_SENTINEL */, void 0, context);
+  }
+  /**
+   * Creates invalid TLS configuration error.
+   */
+  static invalidTLS(reason, context) {
+    return new _RedisConfigError(`Invalid TLS configuration: ${reason}`, "CFG_INVALID_TLS" /* CFG_INVALID_TLS */, void 0, context);
+  }
+};
+var RedisValidationError = class _RedisValidationError extends RedisConfigError {
+  constructor(field, errors, cause) {
+    const errorMessages = errors.map((e) => `${e.field}: ${e.message}`).join("; ");
+    super(`Validation failed for "${field}": ${errorMessages}`, "CFG_VALIDATION_FAILED" /* CFG_VALIDATION_FAILED */, cause, { field, errors, errorCount: errors.length });
+    this.field = field;
+    this.errors = errors;
+  }
+  /**
+   * Creates validation error from single field.
+   */
+  static single(field, message, value) {
+    return new _RedisValidationError(field, [{ field, message, value }]);
+  }
+  /**
+   * Creates validation error from multiple fields.
+   */
+  static multiple(parent, errors) {
+    return new _RedisValidationError(parent, errors);
+  }
+  /**
+   * Adds a validation error to the list.
+   */
+  addError(field, message, value) {
+    this.errors.push({ field, message, value });
+    return this;
+  }
+  /**
+   * Checks if validation has errors.
+   */
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+  /**
+   * Gets all error messages.
+   */
+  getMessages() {
+    return this.errors.map((e) => `${e.field}: ${e.message}`);
+  }
+  /**
+   * Gets errors for specific field.
+   */
+  getFieldErrors(field) {
+    return this.errors.filter((e) => e.field === field);
+  }
+};
+var ValidationErrorCollector = class {
+  constructor(parent) {
+    this.parent = parent;
+  }
+  errors = [];
+  /**
+   * Adds a validation error.
+   */
+  add(field, message, value) {
+    this.errors.push({ field, message, value });
+    return this;
+  }
+  /**
+   * Checks if there are any errors.
+   */
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+  /**
+   * Gets error count.
+   */
+  count() {
+    return this.errors.length;
+  }
+  /**
+   * Throws if there are any errors.
+   */
+  throwIfErrors() {
+    if (this.hasErrors()) {
+      throw new RedisValidationError(this.parent, this.errors);
+    }
+  }
+  /**
+   * Gets all errors.
+   */
+  getErrors() {
+    return [...this.errors];
+  }
+  /**
+   * Clears all errors.
+   */
+  clear() {
+    this.errors = [];
+  }
+};
+
+// src/shared/errors/driver.error.ts
+var DriverError = class extends RedisConnectionError {
+  constructor(message, code, cause, context) {
+    super(message, code, void 0, void 0, cause, context);
+  }
+};
+var ConnectionError = class extends RedisConnectionError {
+  constructor(message, cause, host, port) {
+    super(message, "CONN_FAILED" /* CONN_FAILED */, host, port, cause);
+    this.host = host;
+    this.port = port;
+  }
+};
+var TimeoutError = class extends RedisTimeoutError {
+  constructor(operation, timeoutMs, cause) {
+    super(operation, timeoutMs, void 0, void 0, cause);
+  }
+};
+var CommandError = class extends RedisOperationError {
+  command;
+  args;
+  constructor(command, args, cause) {
+    const message = `Command "${command}" failed: ${cause?.message ?? "Unknown error"}`;
+    super(message, "OP_FAILED" /* OP_FAILED */, command, cause, { argsCount: args.length });
+    this.command = command;
+    this.args = args;
+  }
+};
+
+// src/driver/infrastructure/base.driver.ts
+var BaseRedisDriver = class {
+  constructor(config, options) {
+    this.config = config;
+    this.eventEmitter = new import_events.default();
+    this.logger = new import_common.Logger(this.constructor.name);
+    this.enableLogging = options?.enableLogging ?? false;
+  }
+  eventEmitter;
+  logger;
+  connected = false;
+  connecting = false;
+  enableLogging;
+  async connect() {
+    if (this.connected) {
+      this.log("Already connected, skipping connect");
+      return;
+    }
+    if (this.connecting) {
+      this.log("Connection in progress, waiting...");
+      return new Promise((resolve, reject) => {
+        const onConnect = () => {
+          cleanup();
+          resolve();
+        };
+        const onError = (error) => {
+          cleanup();
+          reject(error);
+        };
+        const cleanup = () => {
+          this.off("ready" /* READY */, onConnect);
+          this.off("error" /* ERROR */, onError);
+        };
+        this.once("ready" /* READY */, onConnect);
+        this.once("error" /* ERROR */, onError);
+      });
+    }
+    try {
+      this.connecting = true;
+      this.log("Connecting to Redis...");
+      this.emit("connect" /* CONNECT */);
+      await this.doConnect();
+      this.connected = true;
+      this.connecting = false;
+      this.log("Connected to Redis");
+      this.emit("ready" /* READY */);
+    } catch (error) {
+      this.connecting = false;
+      this.log("Connection failed", error);
+      this.emit("error" /* ERROR */, error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (!this.connected) {
+      this.log("Not connected, skipping disconnect");
+      return;
+    }
+    try {
+      this.log("Disconnecting from Redis...");
+      this.emit("disconnect" /* DISCONNECT */);
+      await this.doDisconnect();
+      this.connected = false;
+      this.log("Disconnected from Redis");
+      this.emit("close" /* CLOSE */);
+    } catch (error) {
+      this.log("Disconnect failed", error);
+      this.emit("error" /* ERROR */, error);
+      throw error;
+    }
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async ping(message) {
+    this.assertConnected();
+    const result = message ? await this.executeCommand("PING", message) : await this.executeCommand("PING");
+    return String(result);
+  }
+  async select(db) {
+    this.assertConnected();
+    await this.executeCommand("SELECT", db);
+  }
+  async get(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("GET", key);
+    return result === null || result === void 0 ? null : String(result);
+  }
+  async set(key, value, options) {
+    this.assertConnected();
+    const args = [key, value];
+    if (options) {
+      if (options.ex !== void 0) {
+        args.push("EX", options.ex);
+      }
+      if (options.px !== void 0) {
+        args.push("PX", options.px);
+      }
+      if (options.exat !== void 0) {
+        args.push("EXAT", options.exat);
+      }
+      if (options.pxat !== void 0) {
+        args.push("PXAT", options.pxat);
+      }
+      if (options.nx) {
+        args.push("NX");
+      }
+      if (options.xx) {
+        args.push("XX");
+      }
+      if (options.get) {
+        args.push("GET");
+      }
+      if (options.keepttl) {
+        args.push("KEEPTTL");
+      }
+    }
+    const result = await this.executeCommand("SET", ...args);
+    return result === "OK" ? "OK" : null;
+  }
+  async mget(...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("MGET", ...keys);
+    return result.map((v) => v === null || v === void 0 ? null : String(v));
+  }
+  async mset(data) {
+    this.assertConnected();
+    const args = [];
+    for (const [key, value] of Object.entries(data)) {
+      args.push(key, value);
+    }
+    await this.executeCommand("MSET", ...args);
+    return "OK";
+  }
+  async setnx(key, value) {
+    this.assertConnected();
+    const result = await this.executeCommand("SETNX", key, value);
+    return Number(result);
+  }
+  async setex(key, seconds, value) {
+    this.assertConnected();
+    await this.executeCommand("SETEX", key, seconds, value);
+    return "OK";
+  }
+  async getdel(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("GETDEL", key);
+    return result === null || result === void 0 ? null : String(result);
+  }
+  async getex(key, options) {
+    this.assertConnected();
+    const args = [key];
+    if (options.ex !== void 0) {
+      args.push("EX", options.ex);
+    }
+    if (options.px !== void 0) {
+      args.push("PX", options.px);
+    }
+    const result = await this.executeCommand("GETEX", ...args);
+    return result === null || result === void 0 ? null : String(result);
+  }
+  async incr(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("INCR", key);
+    return Number(result);
+  }
+  async incrby(key, increment) {
+    this.assertConnected();
+    const result = await this.executeCommand("INCRBY", key, increment);
+    return Number(result);
+  }
+  async decr(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("DECR", key);
+    return Number(result);
+  }
+  async decrby(key, decrement) {
+    this.assertConnected();
+    const result = await this.executeCommand("DECRBY", key, decrement);
+    return Number(result);
+  }
+  async append(key, value) {
+    this.assertConnected();
+    const result = await this.executeCommand("APPEND", key, value);
+    return Number(result);
+  }
+  async strlen(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("STRLEN", key);
+    return Number(result);
+  }
+  async incrbyfloat(key, increment) {
+    this.assertConnected();
+    const result = await this.executeCommand("INCRBYFLOAT", key, increment);
+    return String(result);
+  }
+  async getrange(key, start, end) {
+    this.assertConnected();
+    const result = await this.executeCommand("GETRANGE", key, start, end);
+    return String(result);
+  }
+  async setrange(key, offset, value) {
+    this.assertConnected();
+    const result = await this.executeCommand("SETRANGE", key, offset, value);
+    return Number(result);
+  }
+  async msetnx(data) {
+    this.assertConnected();
+    const args = [];
+    for (const [key, value] of Object.entries(data)) {
+      args.push(key, value);
+    }
+    const result = await this.executeCommand("MSETNX", ...args);
+    return Number(result);
+  }
+  async del(...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("DEL", ...keys);
+    return Number(result);
+  }
+  async exists(...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("EXISTS", ...keys);
+    return Number(result);
+  }
+  async expire(key, seconds) {
+    this.assertConnected();
+    const result = await this.executeCommand("EXPIRE", key, seconds);
+    return Number(result);
+  }
+  async pexpire(key, milliseconds) {
+    this.assertConnected();
+    const result = await this.executeCommand("PEXPIRE", key, milliseconds);
+    return Number(result);
+  }
+  async expireat(key, timestamp) {
+    this.assertConnected();
+    const result = await this.executeCommand("EXPIREAT", key, timestamp);
+    return Number(result);
+  }
+  async ttl(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("TTL", key);
+    return Number(result);
+  }
+  async pttl(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("PTTL", key);
+    return Number(result);
+  }
+  async persist(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("PERSIST", key);
+    return Number(result);
+  }
+  async rename(key, newKey) {
+    this.assertConnected();
+    await this.executeCommand("RENAME", key, newKey);
+    return "OK";
+  }
+  async renamenx(key, newKey) {
+    this.assertConnected();
+    const result = await this.executeCommand("RENAMENX", key, newKey);
+    return Number(result);
+  }
+  async type(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("TYPE", key);
+    return String(result);
+  }
+  async scan(cursor, options) {
+    this.assertConnected();
+    const args = [cursor];
+    if (options?.match) {
+      args.push("MATCH", options.match);
+    }
+    if (options?.count) {
+      args.push("COUNT", options.count);
+    }
+    if (options?.type) {
+      args.push("TYPE", options.type);
+    }
+    const result = await this.executeCommand("SCAN", ...args);
+    const [newCursor, keys] = result;
+    return [String(newCursor), keys];
+  }
+  async unlink(...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("UNLINK", ...keys);
+    return Number(result);
+  }
+  async copy(source, destination, options) {
+    this.assertConnected();
+    const args = [source, destination];
+    if (options?.db !== void 0) {
+      args.push("DB", options.db);
+    }
+    if (options?.replace) {
+      args.push("REPLACE");
+    }
+    const result = await this.executeCommand("COPY", ...args);
+    return Number(result);
+  }
+  async keys(pattern) {
+    this.assertConnected();
+    const result = await this.executeCommand("KEYS", pattern);
+    return result;
+  }
+  async touch(...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("TOUCH", ...keys);
+    return Number(result);
+  }
+  async object(subcommand, key) {
+    this.assertConnected();
+    const result = await this.executeCommand("OBJECT", subcommand, key);
+    if (result === null) return null;
+    if (subcommand === "ENCODING") return String(result);
+    return Number(result);
+  }
+  async dump(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("DUMP", key);
+    return result === null ? null : String(result);
+  }
+  async restore(key, ttl, serializedValue, options) {
+    this.assertConnected();
+    const args = [key, ttl, serializedValue];
+    if (options?.replace) {
+      args.push("REPLACE");
+    }
+    if (options?.absttl) {
+      args.push("ABSTTL");
+    }
+    if (options?.idletime !== void 0) {
+      args.push("IDLETIME", options.idletime);
+    }
+    if (options?.freq !== void 0) {
+      args.push("FREQ", options.freq);
+    }
+    await this.executeCommand("RESTORE", ...args);
+    return "OK";
+  }
+  async time() {
+    this.assertConnected();
+    const result = await this.executeCommand("TIME");
+    const [seconds, microseconds] = result;
+    return [String(seconds), String(microseconds)];
+  }
+  async hget(key, field) {
+    this.assertConnected();
+    const result = await this.executeCommand("HGET", key, field);
+    return result === null || result === void 0 ? null : String(result);
+  }
+  async hset(key, field, value) {
+    this.assertConnected();
+    const result = await this.executeCommand("HSET", key, field, value);
+    return Number(result);
+  }
+  async hmset(key, data) {
+    this.assertConnected();
+    const args = [key];
+    for (const [field, value] of Object.entries(data)) {
+      args.push(field, value);
+    }
+    await this.executeCommand("HMSET", ...args);
+    return "OK";
+  }
+  async hmget(key, ...fields) {
+    this.assertConnected();
+    const result = await this.executeCommand("HMGET", key, ...fields);
+    return result.map((v) => v === null || v === void 0 ? null : String(v));
+  }
+  async hgetall(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("HGETALL", key);
+    return result;
+  }
+  async hdel(key, ...fields) {
+    this.assertConnected();
+    const result = await this.executeCommand("HDEL", key, ...fields);
+    return Number(result);
+  }
+  async hexists(key, field) {
+    this.assertConnected();
+    const result = await this.executeCommand("HEXISTS", key, field);
+    return Number(result);
+  }
+  async hkeys(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("HKEYS", key);
+    return result;
+  }
+  async hvals(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("HVALS", key);
+    return result;
+  }
+  async hlen(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("HLEN", key);
+    return Number(result);
+  }
+  async hincrby(key, field, increment) {
+    this.assertConnected();
+    const result = await this.executeCommand("HINCRBY", key, field, increment);
+    return Number(result);
+  }
+  async hscan(key, cursor, options) {
+    this.assertConnected();
+    const args = [key, cursor];
+    if (options?.match) {
+      args.push("MATCH", options.match);
+    }
+    if (options?.count) {
+      args.push("COUNT", options.count);
+    }
+    const result = await this.executeCommand("HSCAN", ...args);
+    const [newCursor, fields] = result;
+    return [String(newCursor), fields];
+  }
+  async hsetnx(key, field, value) {
+    this.assertConnected();
+    const result = await this.executeCommand("HSETNX", key, field, value);
+    return Number(result);
+  }
+  async hincrbyfloat(key, field, increment) {
+    this.assertConnected();
+    const result = await this.executeCommand("HINCRBYFLOAT", key, field, increment);
+    return String(result);
+  }
+  async hstrlen(key, field) {
+    this.assertConnected();
+    const result = await this.executeCommand("HSTRLEN", key, field);
+    return Number(result);
+  }
+  async hrandfield(key, count, withValues) {
+    this.assertConnected();
+    const args = [key];
+    if (count !== void 0) {
+      args.push(count);
+      if (withValues) {
+        args.push("WITHVALUES");
+      }
+    }
+    const result = await this.executeCommand("HRANDFIELD", ...args);
+    return result;
+  }
+  async lpush(key, ...values) {
+    this.assertConnected();
+    const result = await this.executeCommand("LPUSH", key, ...values);
+    return Number(result);
+  }
+  async rpush(key, ...values) {
+    this.assertConnected();
+    const result = await this.executeCommand("RPUSH", key, ...values);
+    return Number(result);
+  }
+  async lpop(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("LPOP", key);
+    return result === null || result === void 0 ? null : String(result);
+  }
+  async rpop(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("RPOP", key);
+    return result === null || result === void 0 ? null : String(result);
+  }
+  async llen(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("LLEN", key);
+    return Number(result);
+  }
+  async lrange(key, start, stop) {
+    this.assertConnected();
+    const result = await this.executeCommand("LRANGE", key, start, stop);
+    return result;
+  }
+  async ltrim(key, start, stop) {
+    this.assertConnected();
+    await this.executeCommand("LTRIM", key, start, stop);
+    return "OK";
+  }
+  async lindex(key, index) {
+    this.assertConnected();
+    const result = await this.executeCommand("LINDEX", key, index);
+    return result === null || result === void 0 ? null : String(result);
+  }
+  async lset(key, index, value) {
+    this.assertConnected();
+    await this.executeCommand("LSET", key, index, value);
+    return "OK";
+  }
+  async linsert(key, position, pivot, element) {
+    this.assertConnected();
+    const result = await this.executeCommand("LINSERT", key, position, pivot, element);
+    return Number(result);
+  }
+  async lrem(key, count, element) {
+    this.assertConnected();
+    const result = await this.executeCommand("LREM", key, count, element);
+    return Number(result);
+  }
+  async lpos(key, element, options) {
+    this.assertConnected();
+    const args = [key, element];
+    if (options?.rank !== void 0) {
+      args.push("RANK", options.rank);
+    }
+    if (options?.count !== void 0) {
+      args.push("COUNT", options.count);
+    }
+    if (options?.maxlen !== void 0) {
+      args.push("MAXLEN", options.maxlen);
+    }
+    const result = await this.executeCommand("LPOS", ...args);
+    if (result === null) return null;
+    if (Array.isArray(result)) return result.map(Number);
+    return Number(result);
+  }
+  async blpop(keys, timeout) {
+    this.assertConnected();
+    const result = await this.executeCommand("BLPOP", ...keys, timeout);
+    if (!result) return null;
+    const [key, value] = result;
+    return [key, value];
+  }
+  async brpop(keys, timeout) {
+    this.assertConnected();
+    const result = await this.executeCommand("BRPOP", ...keys, timeout);
+    if (!result) return null;
+    const [key, value] = result;
+    return [key, value];
+  }
+  async lmove(source, destination, from, to) {
+    this.assertConnected();
+    const result = await this.executeCommand("LMOVE", source, destination, from, to);
+    return result === null ? null : String(result);
+  }
+  async blmove(source, destination, from, to, timeout) {
+    this.assertConnected();
+    const result = await this.executeCommand("BLMOVE", source, destination, from, to, timeout);
+    return result === null ? null : String(result);
+  }
+  async sadd(key, ...members) {
+    this.assertConnected();
+    const result = await this.executeCommand("SADD", key, ...members);
+    return Number(result);
+  }
+  async srem(key, ...members) {
+    this.assertConnected();
+    const result = await this.executeCommand("SREM", key, ...members);
+    return Number(result);
+  }
+  async smembers(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("SMEMBERS", key);
+    return result;
+  }
+  async sismember(key, member) {
+    this.assertConnected();
+    const result = await this.executeCommand("SISMEMBER", key, member);
+    return Number(result);
+  }
+  async scard(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("SCARD", key);
+    return Number(result);
+  }
+  async srandmember(key, count) {
+    this.assertConnected();
+    const args = [key];
+    if (count !== void 0) {
+      args.push(count);
+    }
+    const result = await this.executeCommand("SRANDMEMBER", ...args);
+    return result;
+  }
+  async spop(key, count) {
+    this.assertConnected();
+    const args = [key];
+    if (count !== void 0) {
+      args.push(count);
+    }
+    const result = await this.executeCommand("SPOP", ...args);
+    return result;
+  }
+  async sscan(key, cursor, options) {
+    this.assertConnected();
+    const args = [key, cursor];
+    if (options?.match) {
+      args.push("MATCH", options.match);
+    }
+    if (options?.count) {
+      args.push("COUNT", options.count);
+    }
+    const result = await this.executeCommand("SSCAN", ...args);
+    const [newCursor, members] = result;
+    return [String(newCursor), members];
+  }
+  async smove(source, destination, member) {
+    this.assertConnected();
+    const result = await this.executeCommand("SMOVE", source, destination, member);
+    return Number(result);
+  }
+  async sinter(...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("SINTER", ...keys);
+    return result;
+  }
+  async sinterstore(destination, ...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("SINTERSTORE", destination, ...keys);
+    return Number(result);
+  }
+  async sunion(...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("SUNION", ...keys);
+    return result;
+  }
+  async sunionstore(destination, ...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("SUNIONSTORE", destination, ...keys);
+    return Number(result);
+  }
+  async sdiff(...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("SDIFF", ...keys);
+    return result;
+  }
+  async sdiffstore(destination, ...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("SDIFFSTORE", destination, ...keys);
+    return Number(result);
+  }
+  async smismember(key, ...members) {
+    this.assertConnected();
+    const result = await this.executeCommand("SMISMEMBER", key, ...members);
+    return result.map(Number);
+  }
+  async zadd(key, ...args) {
+    this.assertConnected();
+    const result = await this.executeCommand("ZADD", key, ...args);
+    return Number(result);
+  }
+  async zrem(key, ...members) {
+    this.assertConnected();
+    const result = await this.executeCommand("ZREM", key, ...members);
+    return Number(result);
+  }
+  async zrange(key, start, stop, withScores) {
+    this.assertConnected();
+    const args = [key, start, stop];
+    if (withScores) {
+      args.push("WITHSCORES");
+    }
+    const result = await this.executeCommand("ZRANGE", ...args);
+    return result;
+  }
+  async zrangebyscore(key, min, max, withScores) {
+    this.assertConnected();
+    const args = [key, min, max];
+    if (withScores) {
+      args.push("WITHSCORES");
+    }
+    const result = await this.executeCommand("ZRANGEBYSCORE", ...args);
+    return result;
+  }
+  async zscore(key, member) {
+    this.assertConnected();
+    const result = await this.executeCommand("ZSCORE", key, member);
+    return result === null || result === void 0 ? null : String(result);
+  }
+  async zcard(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("ZCARD", key);
+    return Number(result);
+  }
+  async zrank(key, member) {
+    this.assertConnected();
+    const result = await this.executeCommand("ZRANK", key, member);
+    return result === null || result === void 0 ? null : Number(result);
+  }
+  async zincrby(key, increment, member) {
+    this.assertConnected();
+    const result = await this.executeCommand("ZINCRBY", key, increment, member);
+    return String(result);
+  }
+  async zscan(key, cursor, options) {
+    this.assertConnected();
+    const args = [key, cursor];
+    if (options?.match) {
+      args.push("MATCH", options.match);
+    }
+    if (options?.count) {
+      args.push("COUNT", options.count);
+    }
+    const result = await this.executeCommand("ZSCAN", ...args);
+    const [newCursor, members] = result;
+    return [String(newCursor), members];
+  }
+  async zrevrank(key, member) {
+    this.assertConnected();
+    const result = await this.executeCommand("ZREVRANK", key, member);
+    return result === null || result === void 0 ? null : Number(result);
+  }
+  async zcount(key, min, max) {
+    this.assertConnected();
+    const result = await this.executeCommand("ZCOUNT", key, min, max);
+    return Number(result);
+  }
+  async zlexcount(key, min, max) {
+    this.assertConnected();
+    const result = await this.executeCommand("ZLEXCOUNT", key, min, max);
+    return Number(result);
+  }
+  async zpopmin(key, count) {
+    this.assertConnected();
+    const args = [key];
+    if (count !== void 0) {
+      args.push(count);
+    }
+    const result = await this.executeCommand("ZPOPMIN", ...args);
+    return result;
+  }
+  async zpopmax(key, count) {
+    this.assertConnected();
+    const args = [key];
+    if (count !== void 0) {
+      args.push(count);
+    }
+    const result = await this.executeCommand("ZPOPMAX", ...args);
+    return result;
+  }
+  async bzpopmin(keys, timeout) {
+    this.assertConnected();
+    const result = await this.executeCommand("BZPOPMIN", ...keys, timeout);
+    if (!result) return null;
+    const [key, member, score] = result;
+    return [key, member, String(score)];
+  }
+  async bzpopmax(keys, timeout) {
+    this.assertConnected();
+    const result = await this.executeCommand("BZPOPMAX", ...keys, timeout);
+    if (!result) return null;
+    const [key, member, score] = result;
+    return [key, member, String(score)];
+  }
+  async zunionstore(destination, keys, options) {
+    this.assertConnected();
+    const args = [destination, keys.length, ...keys];
+    if (options?.weights) {
+      args.push("WEIGHTS", ...options.weights);
+    }
+    if (options?.aggregate) {
+      args.push("AGGREGATE", options.aggregate);
+    }
+    const result = await this.executeCommand("ZUNIONSTORE", ...args);
+    return Number(result);
+  }
+  async zinterstore(destination, keys, options) {
+    this.assertConnected();
+    const args = [destination, keys.length, ...keys];
+    if (options?.weights) {
+      args.push("WEIGHTS", ...options.weights);
+    }
+    if (options?.aggregate) {
+      args.push("AGGREGATE", options.aggregate);
+    }
+    const result = await this.executeCommand("ZINTERSTORE", ...args);
+    return Number(result);
+  }
+  async zmscore(key, ...members) {
+    this.assertConnected();
+    const result = await this.executeCommand("ZMSCORE", key, ...members);
+    return result.map((v) => v === null || v === void 0 ? null : String(v));
+  }
+  async zrandmember(key, count, withScores) {
+    this.assertConnected();
+    const args = [key];
+    if (count !== void 0) {
+      args.push(count);
+      if (withScores) {
+        args.push("WITHSCORES");
+      }
+    }
+    const result = await this.executeCommand("ZRANDMEMBER", ...args);
+    return result;
+  }
+  async zrevrangebyscore(key, max, min, options) {
+    this.assertConnected();
+    const args = [key, max, min];
+    if (options?.withScores) {
+      args.push("WITHSCORES");
+    }
+    if (options?.limit) {
+      args.push("LIMIT", options.limit.offset, options.limit.count);
+    }
+    const result = await this.executeCommand("ZREVRANGEBYSCORE", ...args);
+    return result;
+  }
+  async publish(channel, message) {
+    this.assertConnected();
+    const result = await this.executeCommand("PUBLISH", channel, message);
+    return Number(result);
+  }
+  async subscribe(...channels) {
+    this.assertConnected();
+    await this.executeCommand("SUBSCRIBE", ...channels);
+  }
+  async unsubscribe(...channels) {
+    this.assertConnected();
+    await this.executeCommand("UNSUBSCRIBE", ...channels);
+  }
+  async psubscribe(...patterns) {
+    this.assertConnected();
+    await this.executeCommand("PSUBSCRIBE", ...patterns);
+  }
+  async punsubscribe(...patterns) {
+    this.assertConnected();
+    await this.executeCommand("PUNSUBSCRIBE", ...patterns);
+  }
+  async xadd(key, id, fields, options) {
+    this.assertConnected();
+    const args = [key];
+    if (options?.noMkStream) {
+      args.push("NOMKSTREAM");
+    }
+    if (options?.maxLen !== void 0) {
+      args.push("MAXLEN");
+      if (options.approximate) {
+        args.push("~");
+      }
+      args.push(options.maxLen);
+    }
+    if (options?.minId !== void 0) {
+      args.push("MINID");
+      if (options.approximate) {
+        args.push("~");
+      }
+      args.push(options.minId);
+    }
+    args.push(id);
+    for (const [field, value] of Object.entries(fields)) {
+      args.push(field, value);
+    }
+    const result = await this.executeCommand("XADD", ...args);
+    return String(result);
+  }
+  async xread(streams, options) {
+    this.assertConnected();
+    const args = [];
+    if (options?.count !== void 0) {
+      args.push("COUNT", options.count);
+    }
+    if (options?.block !== void 0) {
+      args.push("BLOCK", options.block);
+    }
+    args.push("STREAMS");
+    for (const stream of streams) {
+      args.push(stream.key);
+    }
+    for (const stream of streams) {
+      args.push(stream.id);
+    }
+    const result = await this.executeCommand("XREAD", ...args);
+    if (!result) return null;
+    return this.parseStreamReadResult(result);
+  }
+  async xreadgroup(group, consumer, streams, options) {
+    this.assertConnected();
+    const args = ["GROUP", group, consumer];
+    if (options?.count !== void 0) {
+      args.push("COUNT", options.count);
+    }
+    if (options?.block !== void 0) {
+      args.push("BLOCK", options.block);
+    }
+    if (options?.noAck) {
+      args.push("NOACK");
+    }
+    args.push("STREAMS");
+    for (const stream of streams) {
+      args.push(stream.key);
+    }
+    for (const stream of streams) {
+      args.push(stream.id);
+    }
+    const result = await this.executeCommand("XREADGROUP", ...args);
+    if (!result) return null;
+    return this.parseStreamReadResult(result);
+  }
+  async xrange(key, start, end, options) {
+    this.assertConnected();
+    const args = [key, start, end];
+    if (options?.count !== void 0) {
+      args.push("COUNT", options.count);
+    }
+    const result = await this.executeCommand("XRANGE", ...args);
+    return this.parseStreamEntries(result);
+  }
+  async xrevrange(key, end, start, options) {
+    this.assertConnected();
+    const args = [key, end, start];
+    if (options?.count !== void 0) {
+      args.push("COUNT", options.count);
+    }
+    const result = await this.executeCommand("XREVRANGE", ...args);
+    return this.parseStreamEntries(result);
+  }
+  async xlen(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("XLEN", key);
+    return Number(result);
+  }
+  async xinfo(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("XINFO", "STREAM", key);
+    return this.parseIStreamInfo(result);
+  }
+  async xtrim(key, maxLen, approximate) {
+    this.assertConnected();
+    const args = [key, "MAXLEN"];
+    if (approximate) {
+      args.push("~");
+    }
+    args.push(maxLen);
+    const result = await this.executeCommand("XTRIM", ...args);
+    return Number(result);
+  }
+  async xgroupCreate(key, group, id, mkstream) {
+    this.assertConnected();
+    const args = [key, group, id];
+    if (mkstream) {
+      args.push("MKSTREAM");
+    }
+    await this.executeCommand("XGROUP", "CREATE", ...args);
+    return "OK";
+  }
+  async xgroupDestroy(key, group) {
+    this.assertConnected();
+    const result = await this.executeCommand("XGROUP", "DESTROY", key, group);
+    return Number(result);
+  }
+  async xgroupDelConsumer(key, group, consumer) {
+    this.assertConnected();
+    const result = await this.executeCommand("XGROUP", "DELCONSUMER", key, group, consumer);
+    return Number(result);
+  }
+  async xgroupSetId(key, group, id) {
+    this.assertConnected();
+    await this.executeCommand("XGROUP", "SETID", key, group, id);
+    return "OK";
+  }
+  async xack(key, group, ...ids) {
+    this.assertConnected();
+    const result = await this.executeCommand("XACK", key, group, ...ids);
+    return Number(result);
+  }
+  async xpending(key, group) {
+    this.assertConnected();
+    const result = await this.executeCommand("XPENDING", key, group);
+    return this.parseIStreamPendingInfo(result);
+  }
+  async xpendingRange(key, group, start, end, count, consumer) {
+    this.assertConnected();
+    const args = [key, group, start, end, count];
+    if (consumer) {
+      args.push(consumer);
+    }
+    const result = await this.executeCommand("XPENDING", ...args);
+    return this.parseStreamPendingEntries(result);
+  }
+  async xclaim(key, group, consumer, minIdleTime, ...ids) {
+    this.assertConnected();
+    const result = await this.executeCommand("XCLAIM", key, group, consumer, minIdleTime, ...ids);
+    return this.parseStreamEntries(result);
+  }
+  async xdel(key, ...ids) {
+    this.assertConnected();
+    const result = await this.executeCommand("XDEL", key, ...ids);
+    return Number(result);
+  }
+  parseStreamReadResult(result) {
+    return result.map((streamData) => {
+      const [key, entries] = streamData;
+      return {
+        key,
+        entries: this.parseStreamEntries(entries)
+      };
+    });
+  }
+  parseStreamEntries(entries) {
+    return entries.map((entry) => {
+      const [id, fields] = entry;
+      return {
+        id,
+        fields: this.parseFieldArray(fields)
+      };
+    });
+  }
+  parseFieldArray(fields) {
+    const result = {};
+    for (let i = 0; i < fields.length; i += 2) {
+      const key = fields[i];
+      const value = fields[i + 1];
+      if (key !== void 0 && value !== void 0) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  parseIStreamInfo(result) {
+    const info = {};
+    for (let i = 0; i < result.length; i += 2) {
+      const key = String(result[i]).toLowerCase().replace(/-/g, "");
+      info[key] = result[i + 1];
+    }
+    return {
+      length: Number(info["length"] ?? 0),
+      groups: Number(info["groups"] ?? 0),
+      firstEntry: info["firstentry"] ? this.parseStreamEntries([info["firstentry"]])[0] ?? null : null,
+      lastEntry: info["lastentry"] ? this.parseStreamEntries([info["lastentry"]])[0] ?? null : null,
+      lastGeneratedId: String(info["lastgeneratedid"] ?? "0-0"),
+      radixTreeKeys: Number(info["radixtreekeys"] ?? 0),
+      radixTreeNodes: Number(info["radixtreenodes"] ?? 0)
+    };
+  }
+  parseIStreamPendingInfo(result) {
+    const [count, minId, maxId, consumers] = result;
+    return {
+      count: Number(count),
+      minId,
+      maxId,
+      consumers: consumers ? consumers.map((c) => {
+        const [name, pending] = c;
+        return { name, count: Number(pending) };
+      }) : []
+    };
+  }
+  parseStreamPendingEntries(result) {
+    return result.map((entry) => {
+      const [id, consumer, idleTime, deliveryCount] = entry;
+      return {
+        id,
+        consumer,
+        idleTime: Number(idleTime),
+        deliveryCount: Number(deliveryCount)
+      };
+    });
+  }
+  pipeline() {
+    this.assertConnected();
+    return this.createPipeline();
+  }
+  multi() {
+    this.assertConnected();
+    return this.createMulti();
+  }
+  /** Registry mapping SHA → script source for NOSCRIPT fallback */
+  scriptRegistry = /* @__PURE__ */ new Map();
+  async eval(script, keys, args) {
+    this.assertConnected();
+    const result = await this.executeCommand("EVAL", script, keys.length, ...keys, ...args);
+    return result;
+  }
+  async evalsha(sha, keys, args) {
+    this.assertConnected();
+    try {
+      return await this.executeCommand("EVALSHA", sha, keys.length, ...keys, ...args);
+    } catch (error) {
+      if (this.isNoscriptError(error)) {
+        const script = this.scriptRegistry.get(sha);
+        if (script) {
+          return this.eval(script, keys, args);
+        }
+      }
+      throw error;
+    }
+  }
+  async scriptLoad(script) {
+    this.assertConnected();
+    const result = await this.executeCommand("SCRIPT", "LOAD", script);
+    const sha = String(result);
+    this.scriptRegistry.set(sha, script);
+    return sha;
+  }
+  isNoscriptError(error) {
+    const msg = error?.message ?? "";
+    return msg.includes("NOSCRIPT");
+  }
+  async scriptExists(...shas) {
+    this.assertConnected();
+    const result = await this.executeCommand("SCRIPT", "EXISTS", ...shas);
+    return result.map(Number);
+  }
+  async scriptFlush() {
+    this.assertConnected();
+    await this.executeCommand("SCRIPT", "FLUSH");
+    return "OK";
+  }
+  async pfadd(key, ...elements) {
+    this.assertConnected();
+    const result = await this.executeCommand("PFADD", key, ...elements);
+    return Number(result);
+  }
+  async pfcount(...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("PFCOUNT", ...keys);
+    return Number(result);
+  }
+  async pfmerge(destination, ...sources) {
+    this.assertConnected();
+    await this.executeCommand("PFMERGE", destination, ...sources);
+    return "OK";
+  }
+  async geoadd(key, ...members) {
+    this.assertConnected();
+    const result = await this.executeCommand("GEOADD", key, ...members);
+    return Number(result);
+  }
+  async geodist(key, member1, member2, unit) {
+    this.assertConnected();
+    const args = [key, member1, member2];
+    if (unit) {
+      args.push(unit);
+    }
+    const result = await this.executeCommand("GEODIST", ...args);
+    return result === null ? null : String(result);
+  }
+  async geohash(key, ...members) {
+    this.assertConnected();
+    const result = await this.executeCommand("GEOHASH", key, ...members);
+    return result.map((v) => v === null ? null : String(v));
+  }
+  async geopos(key, ...members) {
+    this.assertConnected();
+    const result = await this.executeCommand("GEOPOS", key, ...members);
+    return result.map((pos) => {
+      if (!pos) return null;
+      return [String(pos[0]), String(pos[1])];
+    });
+  }
+  async geosearch(key, options) {
+    this.assertConnected();
+    const args = [key];
+    if (options.member) {
+      args.push("FROMMEMBER", options.member);
+    } else if (options.coord) {
+      args.push("FROMLONLAT", options.coord.longitude, options.coord.latitude);
+    }
+    if (options.radius) {
+      args.push("BYRADIUS", options.radius.value, options.radius.unit);
+    } else if (options.box) {
+      args.push("BYBOX", options.box.width, options.box.height, options.box.unit);
+    }
+    if (options.sort) {
+      args.push(options.sort);
+    }
+    if (options.count !== void 0) {
+      args.push("COUNT", options.count);
+      if (options.any) {
+        args.push("ANY");
+      }
+    }
+    if (options.withCoord) {
+      args.push("WITHCOORD");
+    }
+    if (options.withDist) {
+      args.push("WITHDIST");
+    }
+    if (options.withHash) {
+      args.push("WITHHASH");
+    }
+    const result = await this.executeCommand("GEOSEARCH", ...args);
+    return this.parseIGeoSearchResult(result, options);
+  }
+  async geosearchstore(destination, source, options) {
+    this.assertConnected();
+    const args = [destination, source];
+    if (options.member) {
+      args.push("FROMMEMBER", options.member);
+    } else if (options.coord) {
+      args.push("FROMLONLAT", options.coord.longitude, options.coord.latitude);
+    }
+    if (options.radius) {
+      args.push("BYRADIUS", options.radius.value, options.radius.unit);
+    } else if (options.box) {
+      args.push("BYBOX", options.box.width, options.box.height, options.box.unit);
+    }
+    if (options.sort) {
+      args.push(options.sort);
+    }
+    if (options.count !== void 0) {
+      args.push("COUNT", options.count);
+      if (options.any) {
+        args.push("ANY");
+      }
+    }
+    if (options.storedist) {
+      args.push("STOREDIST");
+    }
+    const result = await this.executeCommand("GEOSEARCHSTORE", ...args);
+    return Number(result);
+  }
+  parseIGeoSearchResult(result, options) {
+    const hasExtra = options.withCoord || options.withDist || options.withHash;
+    if (!hasExtra) {
+      return result;
+    }
+    return result.map((item) => {
+      if (!Array.isArray(item)) {
+        return item;
+      }
+      const geoResult = { member: String(item[0]) };
+      let idx = 1;
+      if (options.withDist && item[idx] !== void 0) {
+        geoResult.distance = String(item[idx]);
+        idx++;
+      }
+      if (options.withHash && item[idx] !== void 0) {
+        geoResult.hash = Number(item[idx]);
+        idx++;
+      }
+      if (options.withCoord && item[idx] !== void 0) {
+        const coords = item[idx];
+        geoResult.coordinates = [String(coords[0]), String(coords[1])];
+      }
+      return geoResult;
+    });
+  }
+  async setbit(key, offset, value) {
+    this.assertConnected();
+    const result = await this.executeCommand("SETBIT", key, offset, value);
+    return Number(result);
+  }
+  async getbit(key, offset) {
+    this.assertConnected();
+    const result = await this.executeCommand("GETBIT", key, offset);
+    return Number(result);
+  }
+  async bitcount(key, start, end, mode) {
+    this.assertConnected();
+    const args = [key];
+    if (start !== void 0 && end !== void 0) {
+      args.push(start, end);
+      if (mode) {
+        args.push(mode);
+      }
+    }
+    const result = await this.executeCommand("BITCOUNT", ...args);
+    return Number(result);
+  }
+  async bitop(operation, destKey, ...keys) {
+    this.assertConnected();
+    const result = await this.executeCommand("BITOP", operation, destKey, ...keys);
+    return Number(result);
+  }
+  async bitpos(key, bit, start, end, mode) {
+    this.assertConnected();
+    const args = [key, bit];
+    if (start !== void 0) {
+      args.push(start);
+      if (end !== void 0) {
+        args.push(end);
+        if (mode) {
+          args.push(mode);
+        }
+      }
+    }
+    const result = await this.executeCommand("BITPOS", ...args);
+    return Number(result);
+  }
+  async flushdb() {
+    this.assertConnected();
+    await this.executeCommand("FLUSHDB");
+    return "OK";
+  }
+  async flushall() {
+    this.assertConnected();
+    await this.executeCommand("FLUSHALL");
+    return "OK";
+  }
+  async info(section) {
+    this.assertConnected();
+    const args = section ? [section] : [];
+    const result = await this.executeCommand("INFO", ...args);
+    return String(result);
+  }
+  async dbsize() {
+    this.assertConnected();
+    const result = await this.executeCommand("DBSIZE");
+    return Number(result);
+  }
+  async cluster(subcommand, ...args) {
+    this.assertConnected();
+    return this.executeCommand("CLUSTER", subcommand, ...args);
+  }
+  async sentinel(subcommand, ...args) {
+    this.assertConnected();
+    return this.executeCommand("SENTINEL", subcommand, ...args);
+  }
+  on(event, handler) {
+    this.eventEmitter.on(event, handler);
+  }
+  once(event, handler) {
+    this.eventEmitter.once(event, handler);
+  }
+  off(event, handler) {
+    this.eventEmitter.off(event, handler);
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.eventEmitter.removeAllListeners(event);
+    } else {
+      this.eventEmitter.removeAllListeners();
+    }
+  }
+  /**
+   * Asserts that driver is connected.
+   * @throws DriverError if not connected
+   */
+  assertConnected() {
+    if (!this.connected) {
+      throw new DriverError("Driver is not connected. Call connect() first.", "DRIVER_NOT_CONNECTED");
+    }
+  }
+  /**
+   * Emits driver event.
+   */
+  emit(event, data) {
+    this.eventEmitter.emit(event, data);
+  }
+  /**
+   * Logs message if logging is enabled.
+   */
+  log(message, data) {
+    if (this.enableLogging) {
+      if (data) {
+        this.logger.debug(`${message} ${JSON.stringify(data)}`);
+      } else {
+        this.logger.debug(message);
+      }
+    }
+  }
+  /**
+   * Wraps execution with timeout.
+   */
+  async withTimeout(promise, timeoutMs, operation) {
+    return Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(new TimeoutError(operation, timeoutMs)), timeoutMs))]);
+  }
+};
+
+// src/driver/infrastructure/ioredis.adapter.ts
+var import_ioredis = __toESM(require("ioredis"));
+
+// src/types/index.ts
+var ConnectionStatus = /* @__PURE__ */ ((ConnectionStatus2) => {
+  ConnectionStatus2["DISCONNECTED"] = "disconnected";
+  ConnectionStatus2["CONNECTING"] = "connecting";
+  ConnectionStatus2["CONNECTED"] = "connected";
+  ConnectionStatus2["RECONNECTING"] = "reconnecting";
+  ConnectionStatus2["ERROR"] = "error";
+  return ConnectionStatus2;
+})(ConnectionStatus || {});
+function isSingleConnection(config) {
+  return !("type" in config) || config.type === "single";
+}
+function isClusterConnection(config) {
+  return "type" in config && config.type === "cluster";
+}
+function isSentinelConnection(config) {
+  return "type" in config && config.type === "sentinel";
+}
+function hasFactory(options) {
+  return options.useFactory !== void 0;
+}
+function hasExisting(options) {
+  return options.useExisting !== void 0;
+}
+function hasClass(options) {
+  return options.useClass !== void 0;
+}
+
+// src/driver/infrastructure/ioredis.adapter.ts
+var IoRedisAdapter = class extends BaseRedisDriver {
+  client = null;
+  constructor(config, options) {
+    super(config, options);
+  }
+  async doConnect() {
+    try {
+      if (isSingleConnection(this.config)) {
+        this.client = this.createSingleClient(this.config);
+      } else if (isClusterConnection(this.config)) {
+        this.client = this.createClusterClient(this.config);
+      } else if (isSentinelConnection(this.config)) {
+        this.client = this.createSentinelClient(this.config);
+      } else {
+        throw new ConnectionError("Unknown connection type");
+      }
+      this.setupEventHandlers();
+      await new Promise((resolve, reject) => {
+        const onReady = () => {
+          cleanup();
+          resolve();
+        };
+        const onError = (error) => {
+          cleanup();
+          reject(new ConnectionError("Connection failed", error));
+        };
+        const cleanup = () => {
+          this.client?.off("ready", onReady);
+          this.client?.off("error", onError);
+        };
+        this.client?.once("ready", onReady);
+        this.client?.once("error", onError);
+        if (this.client) {
+          if (this.client instanceof import_ioredis.default) {
+            this.client.connect().catch(reject);
+          } else if (this.client instanceof import_ioredis.Cluster) {
+            this.client.connect().catch(reject);
+          }
+        }
+      });
+    } catch (error) {
+      if (this.client) {
+        this.client.disconnect();
+        this.client = null;
+      }
+      throw error instanceof ConnectionError ? error : new ConnectionError("Failed to connect", error);
+    }
+  }
+  async doDisconnect() {
+    if (!this.client) {
+      return;
+    }
+    try {
+      await this.client.quit();
+    } catch {
+      this.client.disconnect();
+    } finally {
+      this.client = null;
+    }
+  }
+  async executeCommand(command, ...args) {
+    if (!this.client) {
+      throw new ConnectionError("Client not initialized");
+    }
+    try {
+      const method = command.toLowerCase();
+      const fn = this.client[method];
+      if (typeof fn !== "function") {
+        throw new CommandError(command, args);
+      }
+      return await fn.apply(this.client, args);
+    } catch (error) {
+      throw new CommandError(command, args, error);
+    }
+  }
+  createPipeline() {
+    if (!this.client) {
+      throw new ConnectionError("Client not initialized");
+    }
+    const ioPipeline = this.client.pipeline();
+    return new IoRedisPipelineAdapter(ioPipeline);
+  }
+  createMulti() {
+    if (!this.client) {
+      throw new ConnectionError("Client not initialized");
+    }
+    const ioMulti = this.client.multi();
+    return new IoRedisMultiAdapter(ioMulti);
+  }
+  createSingleClient(config) {
+    if (!isSingleConnection(config)) {
+      throw new ConnectionError("Invalid single connection configuration");
+    }
+    const options = {
+      host: config.host ?? "localhost",
+      port: config.port ?? 6379,
+      password: config.password,
+      db: config.db ?? 0,
+      keyPrefix: config.keyPrefix,
+      connectTimeout: config.connectTimeout ?? 1e4,
+      commandTimeout: config.commandTimeout ?? 5e3,
+      keepAlive: config.keepAlive ?? 0,
+      enableReadyCheck: config.enableAutoReconnect ?? true,
+      maxRetriesPerRequest: config.maxRetriesPerRequest ?? 3,
+      retryStrategy: config.retryStrategy,
+      reconnectOnError: config.reconnectOnError,
+      lazyConnect: true
+    };
+    if (config.tls?.enabled) {
+      options.tls = {
+        ca: config.tls.ca,
+        cert: config.tls.cert,
+        key: config.tls.key,
+        rejectUnauthorized: config.tls.rejectUnauthorized ?? true
+      };
+    }
+    return new import_ioredis.default(options);
+  }
+  createClusterClient(config) {
+    if (!isClusterConnection(config)) {
+      throw new ConnectionError("Invalid cluster configuration");
+    }
+    const nodes = config.nodes.map((node) => ({
+      host: node.host,
+      port: node.port
+    }));
+    const options = {
+      redisOptions: {
+        password: config.password,
+        db: config.db ?? 0,
+        keyPrefix: config.keyPrefix,
+        connectTimeout: config.connectTimeout ?? 1e4,
+        commandTimeout: config.commandTimeout ?? 5e3,
+        maxRetriesPerRequest: config.maxRetriesPerRequest ?? 3
+      },
+      clusterRetryStrategy: config.retryStrategy,
+      enableReadyCheck: config.clusterOptions?.enableReadyCheck ?? false,
+      maxRedirections: config.clusterOptions?.maxRedirections ?? 16,
+      retryDelayOnClusterDown: config.clusterOptions?.retryDelayOnClusterDown ?? 100,
+      retryDelayOnFailover: config.clusterOptions?.retryDelayOnFailover ?? 100,
+      scaleReads: config.clusterOptions?.scaleReads ?? "master",
+      lazyConnect: true,
+      // Pass through any additional cluster options (e.g., natMap)
+      ...config.clusterOptions
+    };
+    return new import_ioredis.Cluster(nodes, options);
+  }
+  createSentinelClient(config) {
+    if (!isSentinelConnection(config)) {
+      throw new ConnectionError("Invalid sentinel configuration");
+    }
+    const options = {
+      sentinels: config.sentinels,
+      name: config.name,
+      password: config.password,
+      db: config.db ?? 0,
+      keyPrefix: config.keyPrefix,
+      connectTimeout: config.connectTimeout ?? 1e4,
+      commandTimeout: config.commandTimeout ?? 5e3,
+      maxRetriesPerRequest: config.maxRetriesPerRequest ?? 3,
+      retryStrategy: config.retryStrategy,
+      sentinelRetryStrategy: config.sentinelOptions?.sentinelRetryStrategy,
+      sentinelPassword: config.sentinelOptions?.sentinelPassword,
+      enableTLSForSentinelMode: config.sentinelOptions?.enableTLSForSentinelMode,
+      lazyConnect: true,
+      // NAT mapping for Docker/firewall scenarios
+      // Maps internal Redis addresses to external accessible addresses
+      natMap: config.sentinelOptions?.natMap
+    };
+    return new import_ioredis.default(options);
+  }
+  setupEventHandlers() {
+    if (!this.client) {
+      return;
+    }
+    this.client.on("connect", () => {
+      this.emit("connect" /* CONNECT */);
+    });
+    this.client.on("ready", () => {
+      this.emit("ready" /* READY */);
+    });
+    this.client.on("error", (error) => {
+      this.emit("error" /* ERROR */, error);
+    });
+    this.client.on("close", () => {
+      this.emit("close" /* CLOSE */);
+    });
+    this.client.on("reconnecting", () => {
+      this.emit("reconnecting" /* RECONNECTING */);
+    });
+    this.client.on("end", () => {
+      this.emit("end" /* END */);
+    });
+  }
+  /**
+   * Gets underlying ioredis client.
+   * For advanced usage only.
+   */
+  getClient() {
+    return this.client;
+  }
+};
+var IoRedisPipelineAdapter = class {
+  constructor(pipeline) {
+    this.pipeline = pipeline;
+  }
+  async exec() {
+    const results = await this.pipeline.exec();
+    if (!results) {
+      return [];
+    }
+    return results.map(([error, result]) => [error, result]);
+  }
+  get(key) {
+    this.pipeline.get(key);
+    return this;
+  }
+  set(key, value, options) {
+    if (options?.ex) {
+      this.pipeline.set(key, value, "EX", options.ex);
+    } else if (options?.px) {
+      this.pipeline.set(key, value, "PX", options.px);
+    } else {
+      this.pipeline.set(key, value);
+    }
+    return this;
+  }
+  del(...keys) {
+    this.pipeline.del(...keys);
+    return this;
+  }
+  mget(...keys) {
+    this.pipeline.mget(...keys);
+    return this;
+  }
+  mset(data) {
+    this.pipeline.mset(data);
+    return this;
+  }
+  expire(key, seconds) {
+    this.pipeline.expire(key, seconds);
+    return this;
+  }
+  ttl(key) {
+    this.pipeline.ttl(key);
+    return this;
+  }
+  incr(key) {
+    this.pipeline.incr(key);
+    return this;
+  }
+  incrby(key, increment) {
+    this.pipeline.incrby(key, increment);
+    return this;
+  }
+  hget(key, field) {
+    this.pipeline.hget(key, field);
+    return this;
+  }
+  hset(key, field, value) {
+    this.pipeline.hset(key, field, value);
+    return this;
+  }
+  hmset(key, data) {
+    this.pipeline.hmset(key, data);
+    return this;
+  }
+  hgetall(key) {
+    this.pipeline.hgetall(key);
+    return this;
+  }
+  lpush(key, ...values) {
+    this.pipeline.lpush(key, ...values);
+    return this;
+  }
+  rpush(key, ...values) {
+    this.pipeline.rpush(key, ...values);
+    return this;
+  }
+  sadd(key, ...members) {
+    this.pipeline.sadd(key, ...members);
+    return this;
+  }
+  srem(key, ...members) {
+    this.pipeline.srem(key, ...members);
+    return this;
+  }
+  zadd(key, ...args) {
+    this.pipeline.zadd(key, ...args);
+    return this;
+  }
+  zrem(key, ...members) {
+    this.pipeline.zrem(key, ...members);
+    return this;
+  }
+};
+var IoRedisMultiAdapter = class extends IoRedisPipelineAdapter {
+  constructor(multi) {
+    super(multi);
+    this.multi = multi;
+  }
+  discard() {
+    this.multi.discard();
+  }
+};
+
+// src/driver/infrastructure/node-redis.adapter.ts
+var import_redis = require("redis");
+var RETRY_BASE_DELAY_MS = 100;
+var RETRY_MAX_DELAY_MS = 3e4;
+var NodeRedisAdapter = class extends BaseRedisDriver {
+  client = null;
+  isSentinel = false;
+  isCluster = false;
+  keyPrefix;
+  constructor(config, options) {
+    super(config, options);
+    this.keyPrefix = config.keyPrefix ?? "";
+  }
+  async doConnect() {
+    try {
+      if (isSingleConnection(this.config)) {
+        this.client = this.createSingleClient(this.config);
+        this.isSentinel = false;
+      } else if (isClusterConnection(this.config)) {
+        this.client = this.createClusterClient(this.config);
+        this.isSentinel = false;
+        this.isCluster = true;
+      } else if (isSentinelConnection(this.config)) {
+        this.client = await this.createSentinelClient(this.config);
+        this.isSentinel = true;
+      } else {
+        throw new ConnectionError("Unknown connection type");
+      }
+      this.setupEventHandlers();
+      if (!this.isSentinel) {
+        await this.client.connect();
+      }
+    } catch (error) {
+      if (this.client) {
+        await this.safeDisconnect();
+        this.client = null;
+      }
+      throw error instanceof ConnectionError ? error : new ConnectionError("Failed to connect", error);
+    }
+  }
+  async doDisconnect() {
+    if (!this.client) {
+      return;
+    }
+    try {
+      if (this.isSentinel) {
+        await this.client.close();
+      } else {
+        await this.client.quit();
+      }
+    } catch {
+      await this.safeDisconnect();
+    } finally {
+      this.client = null;
+      this.isSentinel = false;
+      this.isCluster = false;
+    }
+  }
+  async executeCommand(command, ...args) {
+    if (!this.client) {
+      throw new ConnectionError("Client not initialized");
+    }
+    try {
+      const commandArgs = this.convertArgs(args);
+      const prefixedArgs = this.applyKeyPrefix(command, commandArgs);
+      if (this.isSentinel) {
+        return await this.client.use(async (client) => {
+          return await client.sendCommand([command, ...prefixedArgs]);
+        });
+      }
+      if (this.isCluster) {
+        const firstKey = this.getFirstKey(command, prefixedArgs);
+        const isReadonly = this.isReadonlyCommand(command);
+        return await this.client.sendCommand(firstKey, isReadonly, [command, ...prefixedArgs]);
+      }
+      return await this.client.sendCommand([command, ...prefixedArgs]);
+    } catch (error) {
+      throw new CommandError(command, args, error);
+    }
+  }
+  createPipeline() {
+    if (!this.client) {
+      throw new ConnectionError("Client not initialized");
+    }
+    if (this.isSentinel) {
+      return new NodeRedisSentinelPipelineAdapter(this.client, this.keyPrefix);
+    }
+    return new NodeRedisPipelineAdapter(this.client, this.keyPrefix);
+  }
+  createMulti() {
+    if (!this.client) {
+      throw new ConnectionError("Client not initialized");
+    }
+    if (this.isSentinel) {
+      return new NodeRedisSentinelMultiAdapter(this.client, this.keyPrefix);
+    }
+    return new NodeRedisMultiAdapter(this.client, this.keyPrefix);
+  }
+  /**
+   * Override hgetall to convert array response to object.
+   * Node-redis sendCommand returns ['field1', 'value1', 'field2', 'value2']
+   * but we need { field1: 'value1', field2: 'value2' }
+   */
+  async hgetall(key) {
+    this.assertConnected();
+    const result = await this.executeCommand("HGETALL", key);
+    if (Array.isArray(result)) {
+      const obj = {};
+      for (let i = 0; i < result.length; i += 2) {
+        obj[result[i]] = result[i + 1];
+      }
+      return obj;
+    }
+    return result ?? {};
+  }
+  /**
+   * Override scan to normalize cursor response.
+   * Node-redis sendCommand returns [cursor, [keys...]]
+   */
+  async scan(cursor, options) {
+    this.assertConnected();
+    const args = [cursor];
+    if (options?.match) {
+      args.push("MATCH", options.match);
+    }
+    if (options?.count) {
+      args.push("COUNT", options.count);
+    }
+    const result = await this.executeCommand("SCAN", ...args);
+    if (Array.isArray(result) && result.length === 2) {
+      return [String(result[0]), result[1]];
+    }
+    return ["0", []];
+  }
+  /**
+   * Override hscan to normalize cursor response.
+   */
+  async hscan(key, cursor, options) {
+    this.assertConnected();
+    const args = [key, cursor];
+    if (options?.match) {
+      args.push("MATCH", options.match);
+    }
+    if (options?.count) {
+      args.push("COUNT", options.count);
+    }
+    const result = await this.executeCommand("HSCAN", ...args);
+    if (Array.isArray(result) && result.length === 2) {
+      return [String(result[0]), result[1]];
+    }
+    return ["0", []];
+  }
+  /**
+   * Override sscan to normalize cursor response.
+   */
+  async sscan(key, cursor, options) {
+    this.assertConnected();
+    const args = [key, cursor];
+    if (options?.match) {
+      args.push("MATCH", options.match);
+    }
+    if (options?.count) {
+      args.push("COUNT", options.count);
+    }
+    const result = await this.executeCommand("SSCAN", ...args);
+    if (Array.isArray(result) && result.length === 2) {
+      return [String(result[0]), result[1]];
+    }
+    return ["0", []];
+  }
+  /**
+   * Override zscan to normalize cursor response.
+   */
+  async zscan(key, cursor, options) {
+    this.assertConnected();
+    const args = [key, cursor];
+    if (options?.match) {
+      args.push("MATCH", options.match);
+    }
+    if (options?.count) {
+      args.push("COUNT", options.count);
+    }
+    const result = await this.executeCommand("ZSCAN", ...args);
+    if (Array.isArray(result) && result.length === 2) {
+      return [String(result[0]), result[1]];
+    }
+    return ["0", []];
+  }
+  /**
+   * Override info to return string.
+   */
+  async info(section) {
+    this.assertConnected();
+    const result = await this.executeCommand("INFO", ...section ? [section] : []);
+    return String(result ?? "");
+  }
+  createSingleClient(config) {
+    if (!isSingleConnection(config)) {
+      throw new ConnectionError("Invalid single connection configuration");
+    }
+    const options = {
+      socket: {
+        host: config.host ?? "localhost",
+        port: config.port ?? 6379,
+        connectTimeout: config.connectTimeout ?? 1e4,
+        reconnectStrategy: config.retryStrategy ? (retries) => config.retryStrategy?.(retries) ?? false : this.getDefaultReconnectStrategy()
+      },
+      password: config.password,
+      database: config.db ?? 0,
+      commandsQueueMaxLength: config.enableOfflineQueue === false ? 0 : void 0
+    };
+    if (config.tls?.enabled) {
+      options.socket = {
+        ...options.socket,
+        tls: true,
+        ca: config.tls.ca,
+        cert: config.tls.cert,
+        key: config.tls.key,
+        rejectUnauthorized: config.tls.rejectUnauthorized ?? true
+      };
+    }
+    return (0, import_redis.createClient)(options);
+  }
+  createClusterClient(config) {
+    if (!isClusterConnection(config)) {
+      throw new ConnectionError("Invalid cluster configuration");
+    }
+    const options = {
+      rootNodes: config.nodes.map((node) => ({
+        socket: {
+          host: node.host,
+          port: node.port
+        }
+      })),
+      defaults: {
+        password: config.password,
+        database: config.db ?? 0,
+        socket: {
+          connectTimeout: config.connectTimeout ?? 1e4,
+          reconnectStrategy: config.retryStrategy ? (retries) => config.retryStrategy?.(retries) ?? false : this.getDefaultReconnectStrategy()
+        }
+      },
+      maxCommandRedirections: config.clusterOptions?.maxRedirections ?? 16,
+      useReplicas: config.clusterOptions?.scaleReads === "slave"
+    };
+    if (config.clusterOptions?.natMap) {
+      options.nodeAddressMap = config.clusterOptions.natMap;
+    }
+    return (0, import_redis.createCluster)(options);
+  }
+  /**
+   * Creates a Redis Sentinel client using the proper createSentinel API.
+   * Returns already connected sentinel instance.
+   *
+   * NOTE: node-redis does not support natMap/nodeAddressMap for Sentinel.
+   * For Docker/NAT environments, use ioredis driver which supports sentinelOptions.natMap.
+   */
+  async createSentinelClient(config) {
+    if (!isSentinelConnection(config)) {
+      throw new ConnectionError("Invalid sentinel configuration");
+    }
+    const sentinelConfig = config;
+    const sentinelRootNodes = sentinelConfig.sentinels.map((sentinel2) => ({
+      host: sentinel2.host,
+      port: sentinel2.port
+    }));
+    const options = {
+      name: sentinelConfig.name,
+      sentinelRootNodes,
+      // Pool size for master connections
+      masterPoolSize: sentinelConfig.sentinelOptions?.masterPoolSize ?? 1,
+      // Pool size for replica connections (0 = no replicas)
+      replicaPoolSize: sentinelConfig.sentinelOptions?.replicaPoolSize ?? 0,
+      // Interval to scan for topology changes (ms)
+      scanInterval: sentinelConfig.sentinelOptions?.scanInterval ?? 1e4,
+      // Max retries on topology change
+      maxCommandRediscovers: sentinelConfig.sentinelOptions?.maxCommandRediscovers ?? 16
+    };
+    const nodeClientOptions = {
+      password: sentinelConfig.password,
+      database: sentinelConfig.db ?? 0,
+      socket: {
+        connectTimeout: sentinelConfig.connectTimeout ?? 1e4,
+        reconnectStrategy: sentinelConfig.retryStrategy ? (retries) => sentinelConfig.retryStrategy?.(retries) ?? false : this.getDefaultReconnectStrategy()
+      }
+    };
+    if (sentinelConfig.tls?.enabled) {
+      nodeClientOptions.socket = {
+        ...nodeClientOptions.socket,
+        tls: true,
+        ca: sentinelConfig.tls.ca,
+        cert: sentinelConfig.tls.cert,
+        key: sentinelConfig.tls.key,
+        rejectUnauthorized: sentinelConfig.tls.rejectUnauthorized ?? true
+      };
+    }
+    options.nodeClientOptions = nodeClientOptions;
+    const sentinelClientOptions = {
+      socket: {
+        connectTimeout: sentinelConfig.connectTimeout ?? 1e4
+      }
+    };
+    if (sentinelConfig.sentinelOptions?.sentinelPassword) {
+      sentinelClientOptions.password = sentinelConfig.sentinelOptions.sentinelPassword;
+    }
+    if (sentinelConfig.sentinelOptions?.enableTLSForSentinelMode && sentinelConfig.tls?.enabled) {
+      sentinelClientOptions.socket = {
+        ...sentinelClientOptions.socket,
+        tls: true,
+        ca: sentinelConfig.tls.ca,
+        cert: sentinelConfig.tls.cert,
+        key: sentinelConfig.tls.key,
+        rejectUnauthorized: sentinelConfig.tls.rejectUnauthorized ?? true
+      };
+    }
+    options.sentinelClientOptions = sentinelClientOptions;
+    const sentinel = (0, import_redis.createSentinel)(options);
+    sentinel.on("error", (error) => {
+      this.emit("error" /* ERROR */, error);
+    });
+    await sentinel.connect();
+    return sentinel;
+  }
+  /**
+   * Safely disconnect the client, ignoring errors.
+   */
+  async safeDisconnect() {
+    try {
+      if (this.isSentinel) {
+        await this.client?.close();
+      } else if (this.client) {
+        await this.client.disconnect();
+      }
+    } catch {
+    }
+  }
+  /**
+   * Default reconnection strategy: exponential backoff with max 30s delay.
+   * Returns a function that calculates delay based on retry count.
+   */
+  getDefaultReconnectStrategy() {
+    return (retries) => {
+      if (retries > 10) {
+        return false;
+      }
+      return Math.min(retries * RETRY_BASE_DELAY_MS * Math.pow(2, retries - 1), RETRY_MAX_DELAY_MS);
+    };
+  }
+  /**
+   * Get the first key from command arguments for cluster slot routing.
+   * Returns undefined for commands that don't require a key.
+   */
+  getFirstKey(command, args) {
+    const cmd = command.toUpperCase();
+    const noKeyCommands = /* @__PURE__ */ new Set(["PING", "INFO", "DBSIZE", "TIME", "LASTSAVE", "BGSAVE", "BGREWRITEAOF", "SLAVEOF", "REPLICAOF", "DEBUG", "CONFIG", "CLIENT", "CLUSTER", "COMMAND", "FLUSHALL", "FLUSHDB", "SELECT", "SWAPDB", "PUBLISH", "PUBSUB", "SCRIPT", "SLOWLOG", "ACL", "MODULE", "LATENCY", "MEMORY", "OBJECT", "WAIT", "SHUTDOWN", "SYNC", "PSYNC", "REPLCONF", "ASKING", "READONLY", "READWRITE", "AUTH", "ECHO", "QUIT"]);
+    if (noKeyCommands.has(cmd) || args.length === 0) {
+      return void 0;
+    }
+    if ((cmd === "EVAL" || cmd === "EVALSHA") && args.length > 2) {
+      const numkeys = parseInt(args[1], 10);
+      if (numkeys > 0) {
+        return args[2];
+      }
+      return void 0;
+    }
+    return args[0];
+  }
+  /**
+   * Check if a command is readonly (doesn't modify data).
+   * Used for cluster to route reads to replicas if enabled.
+   */
+  isReadonlyCommand(command) {
+    const readonlyCommands = /* @__PURE__ */ new Set(["GET", "MGET", "STRLEN", "GETRANGE", "SUBSTR", "BITCOUNT", "BITPOS", "GETBIT", "EXISTS", "TYPE", "TTL", "PTTL", "EXPIRETIME", "PEXPIRETIME", "HGET", "HMGET", "HGETALL", "HKEYS", "HVALS", "HLEN", "HEXISTS", "HSCAN", "HSTRLEN", "HRANDFIELD", "LINDEX", "LLEN", "LRANGE", "LPOS", "SMEMBERS", "SISMEMBER", "SCARD", "SRANDMEMBER", "SSCAN", "SMISMEMBER", "ZRANGE", "ZREVRANGE", "ZRANGEBYSCORE", "ZREVRANGEBYSCORE", "ZRANK", "ZREVRANK", "ZCOUNT", "ZLEXCOUNT", "ZCARD", "ZSCORE", "ZMSCORE", "ZRANDMEMBER", "ZSCAN", "PFCOUNT", "GEODIST", "GEOHASH", "GEOPOS", "GEORADIUS_RO", "GEORADIUSBYMEMBER_RO", "GEOSEARCH", "XLEN", "XRANGE", "XREVRANGE", "XREAD", "XINFO", "XPENDING", "SCAN", "KEYS", "DBSIZE", "DEBUG", "DUMP", "OBJECT", "RANDOMKEY", "INFO", "PING", "TIME", "LASTSAVE", "ECHO"]);
+    return readonlyCommands.has(command.toUpperCase());
+  }
+  /**
+   * Convert arguments to proper types for sendCommand.
+   * sendCommand expects string[] but we need to handle numbers properly.
+   */
+  convertArgs(args) {
+    return args.map((arg) => {
+      if (arg === null || arg === void 0) {
+        return "";
+      }
+      if (typeof arg === "number") {
+        return String(arg);
+      }
+      if (typeof arg === "boolean") {
+        return arg ? "1" : "0";
+      }
+      if (Buffer.isBuffer(arg)) {
+        return arg.toString();
+      }
+      if (Array.isArray(arg)) {
+        return arg.map((item) => String(item)).join(" ");
+      }
+      if (typeof arg === "object") {
+        return JSON.stringify(arg);
+      }
+      return String(arg);
+    });
+  }
+  /**
+   * Apply key prefix to key-based commands.
+   * This emulates ioredis keyPrefix functionality.
+   */
+  applyKeyPrefix(command, args) {
+    if (!this.keyPrefix || args.length === 0) {
+      return args;
+    }
+    const singleKeyCommands = /* @__PURE__ */ new Set(["GET", "SET", "DEL", "EXISTS", "EXPIRE", "EXPIREAT", "PEXPIRE", "PEXPIREAT", "TTL", "PTTL", "PERSIST", "TYPE", "RENAME", "RENAMENX", "DUMP", "RESTORE", "INCR", "INCRBY", "INCRBYFLOAT", "DECR", "DECRBY", "APPEND", "STRLEN", "GETRANGE", "SETRANGE", "GETSET", "SETNX", "SETEX", "PSETEX", "GETEX", "GETDEL", "HGET", "HSET", "HSETNX", "HDEL", "HEXISTS", "HGETALL", "HINCRBY", "HINCRBYFLOAT", "HKEYS", "HVALS", "HLEN", "HMGET", "HMSET", "HSCAN", "HSTRLEN", "HRANDFIELD", "LPUSH", "RPUSH", "LPOP", "RPOP", "LLEN", "LRANGE", "LINDEX", "LSET", "LREM", "LTRIM", "LINSERT", "LPOS", "LPUSHX", "RPUSHX", "SADD", "SREM", "SMEMBERS", "SISMEMBER", "SCARD", "SPOP", "SRANDMEMBER", "SSCAN", "SMISMEMBER", "ZADD", "ZREM", "ZSCORE", "ZRANK", "ZREVRANK", "ZRANGE", "ZREVRANGE", "ZRANGEBYSCORE", "ZREVRANGEBYSCORE", "ZCOUNT", "ZLEXCOUNT", "ZCARD", "ZINCRBY", "ZPOPMIN", "ZPOPMAX", "ZMSCORE", "ZRANDMEMBER", "ZSCAN", "PFADD", "PFCOUNT", "GEOADD", "GEODIST", "GEOHASH", "GEOPOS", "GEOSEARCH", "SETBIT", "GETBIT", "BITCOUNT", "BITPOS", "XADD", "XLEN", "XRANGE", "XREVRANGE", "XREAD", "XTRIM", "XINFO", "XDEL", "XGROUP", "XREADGROUP", "XACK", "XPENDING", "XCLAIM", "XAUTOCLAIM", "WATCH", "UNWATCH", "OBJECT", "DEBUG", "MEMORY", "COPY", "TOUCH", "UNLINK", "SCAN"]);
+    const multiKeyCommands = /* @__PURE__ */ new Set(["MGET", "DEL", "EXISTS", "TOUCH", "UNLINK", "WATCH"]);
+    const destSourceCommands = /* @__PURE__ */ new Set(["RENAME", "RENAMENX", "COPY", "BITOP", "SINTERSTORE", "SUNIONSTORE", "SDIFFSTORE", "ZUNIONSTORE", "ZINTERSTORE", "PFMERGE", "GEOSEARCHSTORE", "LMOVE", "BLMOVE"]);
+    const cmd = command.toUpperCase();
+    if (multiKeyCommands.has(cmd)) {
+      return args.map((arg) => this.keyPrefix + arg);
+    }
+    if (destSourceCommands.has(cmd)) {
+      if (args.length > 0) {
+        const result = [...args];
+        result[0] = this.keyPrefix + result[0];
+        if (args.length > 1 && ["RENAME", "RENAMENX", "COPY", "LMOVE", "BLMOVE"].includes(cmd)) {
+          result[1] = this.keyPrefix + result[1];
+        }
+        return result;
+      }
+    }
+    if (singleKeyCommands.has(cmd)) {
+      if (args.length > 0) {
+        const result = [...args];
+        result[0] = this.keyPrefix + result[0];
+        return result;
+      }
+    }
+    if (cmd === "MSET" || cmd === "MSETNX") {
+      const result = [];
+      for (let i = 0; i < args.length; i += 2) {
+        result.push(this.keyPrefix + args[i]);
+        const value = args[i + 1];
+        if (value !== void 0) {
+          result.push(value);
+        }
+      }
+      return result;
+    }
+    return args;
+  }
+  setupEventHandlers() {
+    if (!this.client) {
+      return;
+    }
+    if (this.isSentinel) {
+      return;
+    }
+    this.client.on("connect", () => {
+      this.emit("connect" /* CONNECT */);
+    });
+    this.client.on("ready", () => {
+      this.emit("ready" /* READY */);
+    });
+    this.client.on("error", (error) => {
+      this.emit("error" /* ERROR */, error);
+    });
+    this.client.on("end", () => {
+      this.emit("end" /* END */);
+    });
+    this.client.on("reconnecting", () => {
+      this.emit("reconnecting" /* RECONNECTING */);
+    });
+  }
+  /**
+   * Gets underlying node-redis client.
+   * For advanced usage only.
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Returns true if connected to Redis Sentinel.
+   */
+  isSentinelMode() {
+    return this.isSentinel;
+  }
+};
+var NodeRedisPipelineAdapter = class {
+  constructor(client, keyPrefix = "") {
+    this.client = client;
+    this.keyPrefix = keyPrefix;
+  }
+  commands = [];
+  async exec() {
+    const multi = this.client.multi();
+    for (const { command, args } of this.commands) {
+      multi.addCommand([command, ...args.map(String)]);
+    }
+    try {
+      const results = await multi.exec();
+      return results.map((result) => [null, result]);
+    } catch (error) {
+      return [[error, null]];
+    }
+  }
+  prefixKey(key) {
+    return this.keyPrefix ? this.keyPrefix + key : key;
+  }
+  get(key) {
+    this.commands.push({ command: "GET", args: [this.prefixKey(key)] });
+    return this;
+  }
+  set(key, value, options) {
+    const args = [this.prefixKey(key), value];
+    if (options?.ex) {
+      args.push("EX", options.ex);
+    } else if (options?.px) {
+      args.push("PX", options.px);
+    }
+    this.commands.push({ command: "SET", args });
+    return this;
+  }
+  del(...keys) {
+    this.commands.push({ command: "DEL", args: keys.map((k) => this.prefixKey(k)) });
+    return this;
+  }
+  mget(...keys) {
+    this.commands.push({ command: "MGET", args: keys.map((k) => this.prefixKey(k)) });
+    return this;
+  }
+  mset(data) {
+    const args = [];
+    for (const [key, value] of Object.entries(data)) {
+      args.push(this.prefixKey(key), value);
+    }
+    this.commands.push({ command: "MSET", args });
+    return this;
+  }
+  expire(key, seconds) {
+    this.commands.push({ command: "EXPIRE", args: [this.prefixKey(key), seconds] });
+    return this;
+  }
+  ttl(key) {
+    this.commands.push({ command: "TTL", args: [this.prefixKey(key)] });
+    return this;
+  }
+  incr(key) {
+    this.commands.push({ command: "INCR", args: [this.prefixKey(key)] });
+    return this;
+  }
+  incrby(key, increment) {
+    this.commands.push({ command: "INCRBY", args: [this.prefixKey(key), increment] });
+    return this;
+  }
+  hget(key, field) {
+    this.commands.push({ command: "HGET", args: [this.prefixKey(key), field] });
+    return this;
+  }
+  hset(key, field, value) {
+    this.commands.push({ command: "HSET", args: [this.prefixKey(key), field, value] });
+    return this;
+  }
+  hmset(key, data) {
+    const args = [this.prefixKey(key)];
+    for (const [field, value] of Object.entries(data)) {
+      args.push(field, value);
+    }
+    this.commands.push({ command: "HMSET", args });
+    return this;
+  }
+  hgetall(key) {
+    this.commands.push({ command: "HGETALL", args: [this.prefixKey(key)] });
+    return this;
+  }
+  lpush(key, ...values) {
+    this.commands.push({ command: "LPUSH", args: [this.prefixKey(key), ...values] });
+    return this;
+  }
+  rpush(key, ...values) {
+    this.commands.push({ command: "RPUSH", args: [this.prefixKey(key), ...values] });
+    return this;
+  }
+  sadd(key, ...members) {
+    this.commands.push({ command: "SADD", args: [this.prefixKey(key), ...members] });
+    return this;
+  }
+  srem(key, ...members) {
+    this.commands.push({ command: "SREM", args: [this.prefixKey(key), ...members] });
+    return this;
+  }
+  zadd(key, ...args) {
+    this.commands.push({ command: "ZADD", args: [this.prefixKey(key), ...args] });
+    return this;
+  }
+  zrem(key, ...members) {
+    this.commands.push({ command: "ZREM", args: [this.prefixKey(key), ...members] });
+    return this;
+  }
+};
+var NodeRedisMultiAdapter = class extends NodeRedisPipelineAdapter {
+  constructor(client, keyPrefix = "") {
+    super(client, keyPrefix);
+  }
+  discard() {
+    this.commands = [];
+  }
+};
+var NodeRedisSentinelPipelineAdapter = class {
+  constructor(sentinel, keyPrefix = "") {
+    this.sentinel = sentinel;
+    this.keyPrefix = keyPrefix;
+  }
+  commands = [];
+  async exec() {
+    return await this.sentinel.use(async (client) => {
+      const multi = client.multi();
+      for (const { command, args } of this.commands) {
+        multi.addCommand([command, ...args.map(String)]);
+      }
+      try {
+        const results = await multi.exec();
+        return results.map((result) => [null, result]);
+      } catch (error) {
+        return [[error, null]];
+      }
+    });
+  }
+  prefixKey(key) {
+    return this.keyPrefix ? this.keyPrefix + key : key;
+  }
+  get(key) {
+    this.commands.push({ command: "GET", args: [this.prefixKey(key)] });
+    return this;
+  }
+  set(key, value, options) {
+    const args = [this.prefixKey(key), value];
+    if (options?.ex) {
+      args.push("EX", options.ex);
+    } else if (options?.px) {
+      args.push("PX", options.px);
+    }
+    this.commands.push({ command: "SET", args });
+    return this;
+  }
+  del(...keys) {
+    this.commands.push({ command: "DEL", args: keys.map((k) => this.prefixKey(k)) });
+    return this;
+  }
+  mget(...keys) {
+    this.commands.push({ command: "MGET", args: keys.map((k) => this.prefixKey(k)) });
+    return this;
+  }
+  mset(data) {
+    const args = [];
+    for (const [key, value] of Object.entries(data)) {
+      args.push(this.prefixKey(key), value);
+    }
+    this.commands.push({ command: "MSET", args });
+    return this;
+  }
+  expire(key, seconds) {
+    this.commands.push({ command: "EXPIRE", args: [this.prefixKey(key), seconds] });
+    return this;
+  }
+  ttl(key) {
+    this.commands.push({ command: "TTL", args: [this.prefixKey(key)] });
+    return this;
+  }
+  incr(key) {
+    this.commands.push({ command: "INCR", args: [this.prefixKey(key)] });
+    return this;
+  }
+  incrby(key, increment) {
+    this.commands.push({ command: "INCRBY", args: [this.prefixKey(key), increment] });
+    return this;
+  }
+  hget(key, field) {
+    this.commands.push({ command: "HGET", args: [this.prefixKey(key), field] });
+    return this;
+  }
+  hset(key, field, value) {
+    this.commands.push({ command: "HSET", args: [this.prefixKey(key), field, value] });
+    return this;
+  }
+  hmset(key, data) {
+    const args = [this.prefixKey(key)];
+    for (const [field, value] of Object.entries(data)) {
+      args.push(field, value);
+    }
+    this.commands.push({ command: "HMSET", args });
+    return this;
+  }
+  hgetall(key) {
+    this.commands.push({ command: "HGETALL", args: [this.prefixKey(key)] });
+    return this;
+  }
+  lpush(key, ...values) {
+    this.commands.push({ command: "LPUSH", args: [this.prefixKey(key), ...values] });
+    return this;
+  }
+  rpush(key, ...values) {
+    this.commands.push({ command: "RPUSH", args: [this.prefixKey(key), ...values] });
+    return this;
+  }
+  sadd(key, ...members) {
+    this.commands.push({ command: "SADD", args: [this.prefixKey(key), ...members] });
+    return this;
+  }
+  srem(key, ...members) {
+    this.commands.push({ command: "SREM", args: [this.prefixKey(key), ...members] });
+    return this;
+  }
+  zadd(key, ...args) {
+    this.commands.push({ command: "ZADD", args: [this.prefixKey(key), ...args] });
+    return this;
+  }
+  zrem(key, ...members) {
+    this.commands.push({ command: "ZREM", args: [this.prefixKey(key), ...members] });
+    return this;
+  }
+};
+var NodeRedisSentinelMultiAdapter = class extends NodeRedisSentinelPipelineAdapter {
+  constructor(sentinel, keyPrefix = "") {
+    super(sentinel, keyPrefix);
+  }
+  discard() {
+    this.commands = [];
+  }
+};
+
+// src/driver/application/driver.factory.ts
+function createDriver(config, options) {
+  const driverType = options?.type ?? "ioredis";
+  const enableLogging = options?.enableLogging ?? false;
+  switch (driverType) {
+    case "ioredis":
+      return new IoRedisAdapter(config, { enableLogging });
+    case "node-redis":
+      return new NodeRedisAdapter(config, { enableLogging });
+    default:
+      throw new RedisXError(`Unsupported driver type: ${driverType}. Supported types: ioredis, node-redis`, "CFG_INVALID" /* CFG_INVALID */, void 0, { driverType });
+  }
+}
+var DriverFactory = class {
+  /**
+   * Creates a driver instance.
+   */
+  create(config, options) {
+    return createDriver(config, options);
+  }
+  /**
+   * Gets supported driver types.
+   */
+  getSupportedTypes() {
+    return ["ioredis", "node-redis"];
+  }
+  /**
+   * Checks if driver type is supported.
+   */
+  isSupported(type) {
+    return type === "ioredis" || type === "node-redis";
+  }
+  /**
+   * Gets default driver type.
+   */
+  getDefaultType() {
+    return "ioredis";
+  }
+};
+function createDrivers(configs, options) {
+  const drivers = {};
+  for (const [name, config] of Object.entries(configs)) {
+    drivers[name] = createDriver(config, options);
+  }
+  return drivers;
+}
+function detectAvailableDriver() {
+  try {
+    require.resolve("ioredis");
+    return "ioredis";
+  } catch {
+    try {
+      require.resolve("redis");
+      return "node-redis";
+    } catch {
+      return null;
+    }
+  }
+}
+function getRecommendedDriver() {
+  return "ioredis";
+}
+
+// src/shared/constants/injection-tokens.constants.ts
+var REDIS_MODULE_OPTIONS = /* @__PURE__ */ Symbol.for("REDIS_MODULE_OPTIONS");
+var REDIS_CLIENT = /* @__PURE__ */ Symbol.for("REDIS_CLIENT");
+var REDIS_CLIENTS_MAP = /* @__PURE__ */ Symbol.for("REDIS_CLIENTS_MAP");
+var CLIENT_MANAGER = /* @__PURE__ */ Symbol.for("CLIENT_MANAGER");
+var REDIS_DRIVER = /* @__PURE__ */ Symbol.for("REDIS_DRIVER");
+var REDISX_CONFIG = /* @__PURE__ */ Symbol.for("REDISX_CONFIG");
+var PLUGIN_REGISTRY = /* @__PURE__ */ Symbol.for("PLUGIN_REGISTRY");
+var REGISTERED_PLUGINS = /* @__PURE__ */ Symbol.for("REGISTERED_PLUGINS");
+var REDISX_LOGGER = /* @__PURE__ */ Symbol.for("REDISX_LOGGER");
+function getClientToken(name) {
+  return /* @__PURE__ */ Symbol.for(`REDIS_CLIENT:${name}`);
+}
+function getDriverToken(name) {
+  return /* @__PURE__ */ Symbol.for(`REDIS_DRIVER:${name}`);
+}
+var DEFAULT_CLIENT_NAME = "default";
+var DEFAULT_DRIVER_TYPE = "ioredis";
+var MODULE_NAME = "RedisXModule";
+var DEFAULT_CONNECTION_TIMEOUT = 1e4;
+var DEFAULT_COMMAND_TIMEOUT = 5e3;
+var DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT = 5e3;
+var REDIS_CLIENTS_INITIALIZATION = /* @__PURE__ */ Symbol.for("REDIS_CLIENTS_INITIALIZATION");
+var DEFAULT_HEALTH_CHECK_INTERVAL = 3e4;
+
+// src/client/domain/interfaces/client-manager.interface.ts
+var ManagerEvent = /* @__PURE__ */ ((ManagerEvent2) => {
+  ManagerEvent2["CONNECTED"] = "manager:connected";
+  ManagerEvent2["DISCONNECTED"] = "manager:disconnected";
+  ManagerEvent2["RECONNECTING"] = "manager:reconnecting";
+  ManagerEvent2["ERROR"] = "manager:error";
+  ManagerEvent2["CREATED"] = "manager:created";
+  ManagerEvent2["REMOVED"] = "manager:removed";
+  return ManagerEvent2;
+})(ManagerEvent || {});
+
+// src/client/application/redis-client.manager.ts
+var RedisClientManager = class {
+  logger = new import_common2.Logger(RedisClientManager.name);
+  /**
+   * Registered clients.
+   */
+  clients = /* @__PURE__ */ new Map();
+  /**
+   * Event emitter for client events.
+   */
+  eventEmitter = new import_events2.default();
+  /**
+   * Whether manager is shutting down.
+   */
+  isShuttingDown = false;
+  /**
+   * Default reconnection options.
+   */
+  defaultIReconnectionOptions = {
+    maxAttempts: Infinity,
+    initialDelay: 1e3,
+    maxDelay: 3e4,
+    backoffMultiplier: 2,
+    enableJitter: true
+  };
+  /**
+   * Default driver type.
+   */
+  defaultDriverType = "ioredis";
+  /**
+   * Gets Redis client by name with lazy connection.
+   */
+  async getClient(name = DEFAULT_CLIENT_NAME) {
+    if (this.isShuttingDown) {
+      throw new RedisXError("Client manager is shutting down", "CONN_FAILED" /* CONN_FAILED */, void 0, { clientName: name });
+    }
+    const managedClient = this.clients.get(name);
+    if (!managedClient) {
+      throw new RedisXError(`Client "${name}" not found. Available clients: ${Array.from(this.clients.keys()).join(", ")}`, "CFG_INVALID" /* CFG_INVALID */, void 0, { clientName: name });
+    }
+    if (!managedClient.driver.isConnected() && !managedClient.everConnected) {
+      await this.connectClient(managedClient);
+    }
+    return managedClient.driver;
+  }
+  /**
+   * Creates and registers a new Redis client.
+   */
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async createClient(name, config, options) {
+    if (this.clients.has(name)) {
+      throw new RedisXError(`Client "${name}" already exists`, "CFG_INVALID" /* CFG_INVALID */, void 0, { clientName: name });
+    }
+    const driver = createDriver(config, {
+      type: options?.driverType ?? this.defaultDriverType,
+      enableLogging: false
+    });
+    const reconnectionOptions = {
+      ...this.defaultIReconnectionOptions,
+      ...options?.reconnection
+    };
+    const metadata = {
+      name,
+      config,
+      status: "disconnected" /* DISCONNECTED */,
+      reconnectAttempts: 0,
+      ...options?.metadata || {}
+    };
+    const managedClient = {
+      name,
+      driver,
+      config,
+      metadata,
+      reconnectionOptions,
+      status: "disconnected" /* DISCONNECTED */,
+      stats: this.createInitialStats(name),
+      reconnection: {
+        attempts: 0,
+        nextDelay: reconnectionOptions.initialDelay
+      },
+      everConnected: false,
+      lastError: null
+    };
+    this.setupDriverEventHandlers(managedClient);
+    this.clients.set(name, managedClient);
+    this.emitEvent("manager:created" /* CREATED */, {
+      name,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    return driver;
+  }
+  /**
+   * Checks if client exists.
+   */
+  hasClient(name) {
+    return this.clients.has(name);
+  }
+  /**
+   * Gets all registered client names.
+   */
+  getClientNames() {
+    return Array.from(this.clients.keys());
+  }
+  /**
+   * Closes specific client connection.
+   */
+  async closeClient(name) {
+    const managedClient = this.clients.get(name);
+    if (!managedClient) {
+      throw new RedisXError(`Client "${name}" not found`, "CFG_INVALID" /* CFG_INVALID */, void 0, { clientName: name });
+    }
+    await this.disconnectClient(managedClient);
+    this.clients.delete(name);
+    this.emitEvent("manager:removed" /* REMOVED */, {
+      name,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Closes all client connections.
+   */
+  async closeAll() {
+    this.isShuttingDown = true;
+    const closePromises = Array.from(this.clients.values()).map(
+      (client) => this.disconnectClient(client).catch((error) => {
+        this.logger.error(`Error closing client ${client.name}:`, error);
+      })
+    );
+    await Promise.all(closePromises);
+    this.clients.clear();
+  }
+  /**
+   * Performs health check on client(s).
+   */
+  async healthCheck(name) {
+    if (name) {
+      const managedClient = this.clients.get(name);
+      if (!managedClient) {
+        throw new RedisXError(`Client "${name}" not found`, "CFG_INVALID" /* CFG_INVALID */, void 0, { clientName: name });
+      }
+      return this.checkClientHealth(managedClient);
+    } else {
+      const healthChecks = await Promise.all(Array.from(this.clients.values()).map((client) => this.checkClientHealth(client)));
+      return healthChecks;
+    }
+  }
+  /**
+   * Gets connection statistics.
+   */
+  getStats() {
+    const stats = {
+      totalClients: this.clients.size,
+      connectedClients: 0,
+      disconnectedClients: 0,
+      errorClients: 0,
+      clients: {},
+      collectedAt: /* @__PURE__ */ new Date()
+    };
+    for (const [name, client] of this.clients) {
+      stats.clients[name] = { ...client.stats };
+      if (client.status === "connected" /* CONNECTED */) {
+        stats.connectedClients++;
+      } else if (client.status === "error" /* ERROR */) {
+        stats.errorClients++;
+      } else {
+        stats.disconnectedClients++;
+      }
+    }
+    return stats;
+  }
+  /**
+   * Gets client metadata.
+   */
+  getMetadata(name) {
+    const managedClient = this.clients.get(name);
+    if (!managedClient) {
+      throw new RedisXError(`Client "${name}" not found`, "CFG_INVALID" /* CFG_INVALID */, void 0, { clientName: name });
+    }
+    return { ...managedClient.metadata };
+  }
+  /**
+   * Updates client metadata.
+   */
+  updateMetadata(name, metadata) {
+    const managedClient = this.clients.get(name);
+    if (!managedClient) {
+      throw new RedisXError(`Client "${name}" not found`, "CFG_INVALID" /* CFG_INVALID */, void 0, { clientName: name });
+    }
+    Object.assign(managedClient.metadata, metadata);
+  }
+  /**
+   * Registers event listener.
+   */
+  on(event, handler) {
+    this.eventEmitter.on(event, handler);
+  }
+  /**
+   * Unregisters event listener.
+   */
+  off(event, handler) {
+    this.eventEmitter.off(event, handler);
+  }
+  /**
+   * NestJS lifecycle hook - cleanup on module destroy.
+   */
+  async onModuleDestroy() {
+    await this.closeAll();
+  }
+  /**
+   * Connects client with error handling.
+   */
+  async connectClient(managedClient) {
+    try {
+      managedClient.status = "connecting" /* CONNECTING */;
+      await managedClient.driver.connect();
+      managedClient.status = "connected" /* CONNECTED */;
+      managedClient.everConnected = true;
+      managedClient.stats.connectedAt = /* @__PURE__ */ new Date();
+      managedClient.reconnection.attempts = 0;
+      managedClient.reconnection.nextDelay = managedClient.reconnectionOptions.initialDelay;
+      managedClient.lastError = null;
+      this.emitEvent("manager:connected" /* CONNECTED */, {
+        name: managedClient.name,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    } catch (error) {
+      managedClient.status = "error" /* ERROR */;
+      managedClient.stats.errors++;
+      managedClient.lastError = error;
+      this.emitEvent("manager:error" /* ERROR */, {
+        name: managedClient.name,
+        timestamp: /* @__PURE__ */ new Date(),
+        error
+      });
+      throw error;
+    }
+  }
+  /**
+   * Disconnects client gracefully.
+   */
+  async disconnectClient(managedClient) {
+    if (managedClient.reconnection.timer) {
+      clearTimeout(managedClient.reconnection.timer);
+      managedClient.reconnection.timer = void 0;
+    }
+    if (managedClient.driver.isConnected()) {
+      try {
+        await managedClient.driver.disconnect();
+      } catch (error) {
+        this.logger.error(`Error disconnecting client ${managedClient.name}:`, error);
+      }
+    }
+    managedClient.status = "disconnected" /* DISCONNECTED */;
+    this.emitEvent("manager:disconnected" /* DISCONNECTED */, {
+      name: managedClient.name,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Sets up driver event handlers for reconnection.
+   */
+  setupDriverEventHandlers(managedClient) {
+    const { driver, name } = managedClient;
+    driver.on("error" /* ERROR */, (error) => {
+      managedClient.stats.errors++;
+      managedClient.lastError = error;
+      if (managedClient.status === "connected" /* CONNECTED */) {
+        this.scheduleReconnection(managedClient);
+      }
+    });
+    driver.on("close" /* CLOSE */, () => {
+      if (managedClient.status === "connected" /* CONNECTED */ && !this.isShuttingDown) {
+        managedClient.status = "disconnected" /* DISCONNECTED */;
+        this.scheduleReconnection(managedClient);
+      }
+    });
+    driver.on("end" /* END */, () => {
+      if (managedClient.status === "connected" /* CONNECTED */ && !this.isShuttingDown) {
+        managedClient.status = "disconnected" /* DISCONNECTED */;
+        this.scheduleReconnection(managedClient);
+      }
+    });
+    driver.on("ready" /* READY */, () => {
+      if (managedClient.status === "reconnecting" /* RECONNECTING */) {
+        managedClient.status = "connected" /* CONNECTED */;
+        managedClient.reconnection.attempts = 0;
+        managedClient.reconnection.nextDelay = managedClient.reconnectionOptions.initialDelay;
+        this.emitEvent("manager:connected" /* CONNECTED */, {
+          name,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+    });
+  }
+  /**
+   * Schedules reconnection with exponential backoff.
+   */
+  scheduleReconnection(managedClient) {
+    const { reconnectionOptions, reconnection } = managedClient;
+    if (reconnection.attempts >= reconnectionOptions.maxAttempts) {
+      managedClient.status = "error" /* ERROR */;
+      this.emitEvent("manager:error" /* ERROR */, {
+        name: managedClient.name,
+        timestamp: /* @__PURE__ */ new Date(),
+        error: new Error(`Max reconnection attempts (${reconnectionOptions.maxAttempts}) exceeded`)
+      });
+      return;
+    }
+    if (reconnection.timer) {
+      clearTimeout(reconnection.timer);
+    }
+    let delay = reconnection.nextDelay;
+    if (reconnectionOptions.enableJitter) {
+      delay = delay * (0.5 + Math.random() * 0.5);
+    }
+    delay = Math.min(delay, reconnectionOptions.maxDelay);
+    managedClient.status = "reconnecting" /* RECONNECTING */;
+    reconnection.attempts++;
+    this.emitEvent("manager:reconnecting" /* RECONNECTING */, {
+      name: managedClient.name,
+      timestamp: /* @__PURE__ */ new Date(),
+      metadata: {
+        attempt: reconnection.attempts,
+        delay
+      }
+    });
+    reconnection.timer = setTimeout(async () => {
+      try {
+        await managedClient.driver.connect();
+        managedClient.status = "connected" /* CONNECTED */;
+        managedClient.stats.reconnections++;
+        reconnection.attempts = 0;
+        reconnection.nextDelay = reconnectionOptions.initialDelay;
+        this.emitEvent("manager:connected" /* CONNECTED */, {
+          name: managedClient.name,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      } catch {
+        reconnection.nextDelay = Math.min(reconnection.nextDelay * reconnectionOptions.backoffMultiplier, reconnectionOptions.maxDelay);
+        this.scheduleReconnection(managedClient);
+      }
+    }, delay);
+  }
+  /**
+   * Performs health check on single client.
+   */
+  async checkClientHealth(managedClient) {
+    const startTime = Date.now();
+    let latency = null;
+    let healthy = false;
+    try {
+      if (managedClient.driver.isConnected()) {
+        await managedClient.driver.ping();
+        latency = Date.now() - startTime;
+        healthy = true;
+        managedClient.stats.lastActivityAt = /* @__PURE__ */ new Date();
+        this.updateLatencyStats(managedClient, latency);
+      }
+    } catch (error) {
+      managedClient.stats.errors++;
+      managedClient.lastError = error;
+    }
+    return {
+      name: managedClient.name,
+      healthy,
+      status: managedClient.status,
+      latency,
+      lastError: managedClient.lastError?.message ?? null,
+      lastCheckAt: /* @__PURE__ */ new Date(),
+      metadata: {
+        driverType: this.defaultDriverType,
+        connectionType: managedClient.config.type,
+        reconnectAttempts: managedClient.reconnection.attempts,
+        uptime: this.calculateUptime(managedClient)
+      }
+    };
+  }
+  /**
+   * Creates initial statistics for new client.
+   */
+  createInitialStats(name) {
+    return {
+      name,
+      status: "disconnected" /* DISCONNECTED */,
+      commandsExecuted: 0,
+      errors: 0,
+      reconnections: 0,
+      averageLatency: 0,
+      peakLatency: 0,
+      lastActivityAt: null,
+      connectedAt: null,
+      uptime: 0
+    };
+  }
+  /**
+   * Updates latency statistics.
+   */
+  updateLatencyStats(managedClient, latency) {
+    const stats = managedClient.stats;
+    if (latency > stats.peakLatency) {
+      stats.peakLatency = latency;
+    }
+    if (stats.commandsExecuted === 0) {
+      stats.averageLatency = latency;
+    } else {
+      stats.averageLatency = (stats.averageLatency * stats.commandsExecuted + latency) / (stats.commandsExecuted + 1);
+    }
+    stats.commandsExecuted++;
+  }
+  /**
+   * Calculates client uptime in milliseconds.
+   */
+  calculateUptime(managedClient) {
+    if (!managedClient.stats.connectedAt) {
+      return 0;
+    }
+    if (managedClient.status !== "connected" /* CONNECTED */) {
+      return 0;
+    }
+    return Date.now() - managedClient.stats.connectedAt.getTime();
+  }
+  /**
+   * Emits manager event.
+   */
+  emitEvent(event, data) {
+    this.eventEmitter.emit(event, data);
+  }
+};
+RedisClientManager = __decorateClass([
+  (0, import_common2.Injectable)()
+], RedisClientManager);
+
+// src/application/redis.providers.ts
+function isISingleConnectionConfig(clients) {
+  return "type" in clients || "host" in clients || "nodes" in clients || "sentinels" in clients;
+}
+function createRedisProviders(options) {
+  return [
+    // Module options provider
+    {
+      provide: REDIS_MODULE_OPTIONS,
+      useValue: options
+    },
+    // Client manager provider
+    {
+      provide: CLIENT_MANAGER,
+      useFactory: () => {
+        return new RedisClientManager();
+      }
+    },
+    // Client providers (one per connection)
+    ...createClientProviders(options),
+    // REDIS_DRIVER alias to default client (for backwards compatibility and plugin usage)
+    {
+      provide: REDIS_DRIVER,
+      useFactory: async (manager) => {
+        return manager.getClient(DEFAULT_CLIENT_NAME);
+      },
+      inject: [CLIENT_MANAGER]
+    }
+  ];
+}
+function createAsyncProviders(options) {
+  const providers = [
+    // Client manager provider
+    {
+      provide: CLIENT_MANAGER,
+      useFactory: () => {
+        return new RedisClientManager();
+      }
+    }
+  ];
+  if (options.useExisting || options.useFactory) {
+    providers.push(createAsyncOptionsProvider(options));
+  }
+  if (options.useClass) {
+    providers.push(
+      {
+        provide: options.useClass,
+        useClass: options.useClass
+      },
+      createAsyncOptionsProvider(options)
+    );
+  }
+  providers.push(...createAsyncClientProviders(options));
+  providers.push({
+    provide: REDIS_DRIVER,
+    useFactory: async (manager, _init) => {
+      return manager.getClient(DEFAULT_CLIENT_NAME);
+    },
+    inject: [CLIENT_MANAGER, REDIS_CLIENTS_INITIALIZATION]
+  });
+  return providers;
+}
+function createAsyncOptionsProvider(options) {
+  if (options.useFactory) {
+    return {
+      provide: REDIS_MODULE_OPTIONS,
+      useFactory: options.useFactory,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      inject: options.inject || []
+    };
+  }
+  if (options.useExisting) {
+    return {
+      provide: REDIS_MODULE_OPTIONS,
+      useFactory: async (optionsFactory) => await optionsFactory.createRedisModuleOptions(),
+      inject: [options.useExisting]
+    };
+  }
+  if (options.useClass) {
+    return {
+      provide: REDIS_MODULE_OPTIONS,
+      useFactory: async (optionsFactory) => await optionsFactory.createRedisModuleOptions(),
+      inject: [options.useClass]
+    };
+  }
+  throw new Error("Invalid async options configuration");
+}
+function createClientProviders(options) {
+  const providers = [];
+  const driverType = options.global?.driver ?? "ioredis";
+  if (isISingleConnectionConfig(options.clients)) {
+    providers.push({
+      provide: getClientToken(DEFAULT_CLIENT_NAME),
+      useFactory: async (manager) => {
+        return manager.createClient(DEFAULT_CLIENT_NAME, options.clients, { driverType });
+      },
+      inject: [CLIENT_MANAGER]
+    });
+  } else {
+    const configs = options.clients;
+    for (const [name, config] of Object.entries(configs)) {
+      providers.push({
+        provide: getClientToken(name),
+        useFactory: async (manager) => {
+          return manager.createClient(name, config, { driverType });
+        },
+        inject: [CLIENT_MANAGER]
+      });
+    }
+  }
+  return providers;
+}
+function createAsyncClientProviders(_options) {
+  return [
+    {
+      provide: REDIS_CLIENTS_INITIALIZATION,
+      useFactory: async (moduleOptions, manager) => {
+        const driverType = moduleOptions.global?.driver ?? "ioredis";
+        if (isISingleConnectionConfig(moduleOptions.clients)) {
+          await manager.createClient(DEFAULT_CLIENT_NAME, moduleOptions.clients, { driverType });
+        } else {
+          const configs = moduleOptions.clients;
+          for (const [name, config] of Object.entries(configs)) {
+            await manager.createClient(name, config, { driverType });
+          }
+        }
+      },
+      inject: [REDIS_MODULE_OPTIONS, CLIENT_MANAGER]
+    },
+    {
+      provide: getClientToken(DEFAULT_CLIENT_NAME),
+      useFactory: async (manager, _init) => {
+        return manager.getClient(DEFAULT_CLIENT_NAME);
+      },
+      inject: [CLIENT_MANAGER, REDIS_CLIENTS_INITIALIZATION]
+    }
+  ];
+}
+
+// src/application/redis.service.ts
+var import_common3 = require("@nestjs/common");
+var RedisService = class {
+  constructor(clientManager) {
+    this.clientManager = clientManager;
+  }
+  /**
+   * Default Redis driver instance.
+   */
+  driver = null;
+  /**
+   * Gets default Redis driver.
+   * Lazy loads on first access.
+   */
+  async getDriver() {
+    if (!this.driver) {
+      this.driver = await this.clientManager.getClient(DEFAULT_CLIENT_NAME);
+    }
+    return this.driver;
+  }
+  /**
+   * Gets a named Redis client.
+   *
+   * @param name - Client name
+   * @returns Redis driver instance
+   *
+   * @example
+   * ```typescript
+   * const sessions = await this.redis.getClient('sessions');
+   * await sessions.set('session:123', data);
+   * ```
+   */
+  async getClient(name = DEFAULT_CLIENT_NAME) {
+    return this.clientManager.getClient(name);
+  }
+  /**
+   * Checks if default client is connected.
+   */
+  async isConnected() {
+    const driver = await this.getDriver();
+    return driver.isConnected();
+  }
+  /**
+   * Pings Redis server.
+   */
+  async ping(message) {
+    const driver = await this.getDriver();
+    return driver.ping(message);
+  }
+  /**
+   * Selects database.
+   */
+  async select(db) {
+    const driver = await this.getDriver();
+    return driver.select(db);
+  }
+  /**
+   * Gets value by key.
+   */
+  async get(key) {
+    const driver = await this.getDriver();
+    return driver.get(key);
+  }
+  /**
+   * Sets key-value pair with optional TTL.
+   */
+  async set(key, value, options) {
+    const driver = await this.getDriver();
+    return driver.set(key, value, options);
+  }
+  /**
+   * Gets multiple values.
+   */
+  async mget(...keys) {
+    const driver = await this.getDriver();
+    return driver.mget(...keys);
+  }
+  /**
+   * Sets multiple key-value pairs.
+   */
+  async mset(data) {
+    const driver = await this.getDriver();
+    return driver.mset(data);
+  }
+  /**
+   * Sets value only if key doesn't exist.
+   */
+  async setnx(key, value) {
+    const driver = await this.getDriver();
+    return driver.setnx(key, value);
+  }
+  /**
+   * Sets value with expiration in seconds.
+   */
+  async setex(key, seconds, value) {
+    const driver = await this.getDriver();
+    return driver.setex(key, seconds, value);
+  }
+  /**
+   * Gets value and deletes key.
+   */
+  async getdel(key) {
+    const driver = await this.getDriver();
+    return driver.getdel(key);
+  }
+  /**
+   * Gets value and sets expiration.
+   */
+  async getex(key, options) {
+    const driver = await this.getDriver();
+    return driver.getex(key, options);
+  }
+  /**
+   * Increments integer value by 1.
+   */
+  async incr(key) {
+    const driver = await this.getDriver();
+    return driver.incr(key);
+  }
+  /**
+   * Increments integer value by amount.
+   */
+  async incrby(key, increment) {
+    const driver = await this.getDriver();
+    return driver.incrby(key, increment);
+  }
+  /**
+   * Decrements integer value by 1.
+   */
+  async decr(key) {
+    const driver = await this.getDriver();
+    return driver.decr(key);
+  }
+  /**
+   * Decrements integer value by amount.
+   */
+  async decrby(key, decrement) {
+    const driver = await this.getDriver();
+    return driver.decrby(key, decrement);
+  }
+  /**
+   * Appends value to key.
+   */
+  async append(key, value) {
+    const driver = await this.getDriver();
+    return driver.append(key, value);
+  }
+  /**
+   * Deletes one or more keys.
+   */
+  async del(...keys) {
+    const driver = await this.getDriver();
+    return driver.del(...keys);
+  }
+  /**
+   * Checks if keys exist.
+   */
+  async exists(...keys) {
+    const driver = await this.getDriver();
+    return driver.exists(...keys);
+  }
+  /**
+   * Sets TTL on key (seconds).
+   */
+  async expire(key, seconds) {
+    const driver = await this.getDriver();
+    return driver.expire(key, seconds);
+  }
+  /**
+   * Sets TTL on key (milliseconds).
+   */
+  async pexpire(key, milliseconds) {
+    const driver = await this.getDriver();
+    return driver.pexpire(key, milliseconds);
+  }
+  /**
+   * Sets absolute expiration time.
+   */
+  async expireat(key, timestamp) {
+    const driver = await this.getDriver();
+    return driver.expireat(key, timestamp);
+  }
+  /**
+   * Gets TTL of key (seconds).
+   */
+  async ttl(key) {
+    const driver = await this.getDriver();
+    return driver.ttl(key);
+  }
+  /**
+   * Gets TTL of key (milliseconds).
+   */
+  async pttl(key) {
+    const driver = await this.getDriver();
+    return driver.pttl(key);
+  }
+  /**
+   * Removes expiration from key.
+   */
+  async persist(key) {
+    const driver = await this.getDriver();
+    return driver.persist(key);
+  }
+  /**
+   * Renames key.
+   */
+  async rename(key, newKey) {
+    const driver = await this.getDriver();
+    return driver.rename(key, newKey);
+  }
+  /**
+   * Renames key only if new key doesn't exist.
+   */
+  async renamenx(key, newKey) {
+    const driver = await this.getDriver();
+    return driver.renamenx(key, newKey);
+  }
+  /**
+   * Gets type of value stored at key.
+   */
+  async type(key) {
+    const driver = await this.getDriver();
+    return driver.type(key);
+  }
+  /**
+   * Scans keys matching pattern.
+   */
+  async scan(cursor, options) {
+    const driver = await this.getDriver();
+    return driver.scan(cursor, options);
+  }
+  /**
+   * Gets hash field value.
+   */
+  async hget(key, field) {
+    const driver = await this.getDriver();
+    return driver.hget(key, field);
+  }
+  /**
+   * Sets hash field value.
+   */
+  async hset(key, field, value) {
+    const driver = await this.getDriver();
+    return driver.hset(key, field, value);
+  }
+  /**
+   * Sets multiple hash fields.
+   */
+  async hmset(key, data) {
+    const driver = await this.getDriver();
+    return driver.hmset(key, data);
+  }
+  /**
+   * Gets multiple hash field values.
+   */
+  async hmget(key, ...fields) {
+    const driver = await this.getDriver();
+    return driver.hmget(key, ...fields);
+  }
+  /**
+   * Gets all fields and values of hash.
+   */
+  async hgetall(key) {
+    const driver = await this.getDriver();
+    return driver.hgetall(key);
+  }
+  /**
+   * Deletes hash fields.
+   */
+  async hdel(key, ...fields) {
+    const driver = await this.getDriver();
+    return driver.hdel(key, ...fields);
+  }
+  /**
+   * Checks if hash field exists.
+   */
+  async hexists(key, field) {
+    const driver = await this.getDriver();
+    return driver.hexists(key, field);
+  }
+  /**
+   * Gets all field names in hash.
+   */
+  async hkeys(key) {
+    const driver = await this.getDriver();
+    return driver.hkeys(key);
+  }
+  /**
+   * Gets all values in hash.
+   */
+  async hvals(key) {
+    const driver = await this.getDriver();
+    return driver.hvals(key);
+  }
+  /**
+   * Gets number of fields in hash.
+   */
+  async hlen(key) {
+    const driver = await this.getDriver();
+    return driver.hlen(key);
+  }
+  /**
+   * Increments hash field by integer.
+   */
+  async hincrby(key, field, increment) {
+    const driver = await this.getDriver();
+    return driver.hincrby(key, field, increment);
+  }
+  /**
+   * Scans hash fields.
+   */
+  async hscan(key, cursor, options) {
+    const driver = await this.getDriver();
+    return driver.hscan(key, cursor, options);
+  }
+  /**
+   * Pushes values to left of list.
+   */
+  async lpush(key, ...values) {
+    const driver = await this.getDriver();
+    return driver.lpush(key, ...values);
+  }
+  /**
+   * Pushes values to right of list.
+   */
+  async rpush(key, ...values) {
+    const driver = await this.getDriver();
+    return driver.rpush(key, ...values);
+  }
+  /**
+   * Pops value from left of list.
+   */
+  async lpop(key) {
+    const driver = await this.getDriver();
+    return driver.lpop(key);
+  }
+  /**
+   * Pops value from right of list.
+   */
+  async rpop(key) {
+    const driver = await this.getDriver();
+    return driver.rpop(key);
+  }
+  /**
+   * Gets list length.
+   */
+  async llen(key) {
+    const driver = await this.getDriver();
+    return driver.llen(key);
+  }
+  /**
+   * Gets list range.
+   */
+  async lrange(key, start, stop) {
+    const driver = await this.getDriver();
+    return driver.lrange(key, start, stop);
+  }
+  /**
+   * Trims list to specified range.
+   */
+  async ltrim(key, start, stop) {
+    const driver = await this.getDriver();
+    return driver.ltrim(key, start, stop);
+  }
+  /**
+   * Gets element at index.
+   */
+  async lindex(key, index) {
+    const driver = await this.getDriver();
+    return driver.lindex(key, index);
+  }
+  /**
+   * Sets element at index.
+   */
+  async lset(key, index, value) {
+    const driver = await this.getDriver();
+    return driver.lset(key, index, value);
+  }
+  /**
+   * Adds members to set.
+   */
+  async sadd(key, ...members) {
+    const driver = await this.getDriver();
+    return driver.sadd(key, ...members);
+  }
+  /**
+   * Removes members from set.
+   */
+  async srem(key, ...members) {
+    const driver = await this.getDriver();
+    return driver.srem(key, ...members);
+  }
+  /**
+   * Gets all members of set.
+   */
+  async smembers(key) {
+    const driver = await this.getDriver();
+    return driver.smembers(key);
+  }
+  /**
+   * Checks if member is in set.
+   */
+  async sismember(key, member) {
+    const driver = await this.getDriver();
+    return driver.sismember(key, member);
+  }
+  /**
+   * Gets number of members in set.
+   */
+  async scard(key) {
+    const driver = await this.getDriver();
+    return driver.scard(key);
+  }
+  /**
+   * Gets random member from set.
+   */
+  async srandmember(key, count) {
+    const driver = await this.getDriver();
+    return driver.srandmember(key, count);
+  }
+  /**
+   * Pops random member from set.
+   */
+  async spop(key, count) {
+    const driver = await this.getDriver();
+    return driver.spop(key, count);
+  }
+  /**
+   * Scans set members.
+   */
+  async sscan(key, cursor, options) {
+    const driver = await this.getDriver();
+    return driver.sscan(key, cursor, options);
+  }
+  /**
+   * Adds members to sorted set with scores.
+   */
+  async zadd(key, ...args) {
+    const driver = await this.getDriver();
+    return driver.zadd(key, ...args);
+  }
+  /**
+   * Removes members from sorted set.
+   */
+  async zrem(key, ...members) {
+    const driver = await this.getDriver();
+    return driver.zrem(key, ...members);
+  }
+  /**
+   * Gets members in range by index.
+   */
+  async zrange(key, start, stop, withScores) {
+    const driver = await this.getDriver();
+    return driver.zrange(key, start, stop, withScores);
+  }
+  /**
+   * Gets members in range by score.
+   */
+  async zrangebyscore(key, min, max, withScores) {
+    const driver = await this.getDriver();
+    return driver.zrangebyscore(key, min, max, withScores);
+  }
+  /**
+   * Gets score of member.
+   */
+  async zscore(key, member) {
+    const driver = await this.getDriver();
+    return driver.zscore(key, member);
+  }
+  /**
+   * Gets number of members in sorted set.
+   */
+  async zcard(key) {
+    const driver = await this.getDriver();
+    return driver.zcard(key);
+  }
+  /**
+   * Gets rank of member.
+   */
+  async zrank(key, member) {
+    const driver = await this.getDriver();
+    return driver.zrank(key, member);
+  }
+  /**
+   * Increments score of member.
+   */
+  async zincrby(key, increment, member) {
+    const driver = await this.getDriver();
+    return driver.zincrby(key, increment, member);
+  }
+  /**
+   * Scans sorted set members.
+   */
+  async zscan(key, cursor, options) {
+    const driver = await this.getDriver();
+    return driver.zscan(key, cursor, options);
+  }
+  /**
+   * Publishes message to channel.
+   */
+  async publish(channel, message) {
+    const driver = await this.getDriver();
+    return driver.publish(channel, message);
+  }
+  /**
+   * Subscribes to channels.
+   */
+  async subscribe(...channels) {
+    const driver = await this.getDriver();
+    return driver.subscribe(...channels);
+  }
+  /**
+   * Unsubscribes from channels.
+   */
+  async unsubscribe(...channels) {
+    const driver = await this.getDriver();
+    return driver.unsubscribe(...channels);
+  }
+  /**
+   * Subscribes to channels by pattern.
+   */
+  async psubscribe(...patterns) {
+    const driver = await this.getDriver();
+    return driver.psubscribe(...patterns);
+  }
+  /**
+   * Unsubscribes from channel patterns.
+   */
+  async punsubscribe(...patterns) {
+    const driver = await this.getDriver();
+    return driver.punsubscribe(...patterns);
+  }
+  /**
+   * Creates a pipeline for batching commands.
+   */
+  async pipeline() {
+    const driver = await this.getDriver();
+    return driver.pipeline();
+  }
+  /**
+   * Creates a multi/exec transaction.
+   */
+  async multi() {
+    const driver = await this.getDriver();
+    return driver.multi();
+  }
+  /**
+   * Evaluates Lua script.
+   */
+  async eval(script, keys, args) {
+    const driver = await this.getDriver();
+    return driver.eval(script, keys, args);
+  }
+  /**
+   * Evaluates Lua script by SHA.
+   */
+  async evalsha(sha, keys, args) {
+    const driver = await this.getDriver();
+    return driver.evalsha(sha, keys, args);
+  }
+  /**
+   * Loads Lua script and returns SHA.
+   */
+  async scriptLoad(script) {
+    const driver = await this.getDriver();
+    return driver.scriptLoad(script);
+  }
+  /**
+   * Checks if scripts exist.
+   */
+  async scriptExists(...shas) {
+    const driver = await this.getDriver();
+    return driver.scriptExists(...shas);
+  }
+  /**
+   * Flushes all scripts from cache.
+   */
+  async scriptFlush() {
+    const driver = await this.getDriver();
+    return driver.scriptFlush();
+  }
+  /**
+   * Flushes all keys from current database.
+   */
+  async flushdb() {
+    const driver = await this.getDriver();
+    return driver.flushdb();
+  }
+  /**
+   * Flushes all keys from all databases.
+   */
+  async flushall() {
+    const driver = await this.getDriver();
+    return driver.flushall();
+  }
+  /**
+   * Gets server info.
+   */
+  async info(section) {
+    const driver = await this.getDriver();
+    return driver.info(section);
+  }
+  /**
+   * Gets database size (number of keys).
+   */
+  async dbsize() {
+    const driver = await this.getDriver();
+    return driver.dbsize();
+  }
+  /**
+   * NestJS lifecycle hook - cleanup on module destroy.
+   */
+  async onModuleDestroy() {
+    await this.clientManager.closeAll();
+  }
+};
+RedisService = __decorateClass([
+  (0, import_common3.Injectable)(),
+  __decorateParam(0, (0, import_common3.Inject)(CLIENT_MANAGER))
+], RedisService);
+
+// src/plugin/application/plugin-registry.service.ts
+var import_common4 = require("@nestjs/common");
+var PluginRegistryService = class {
+  constructor(plugins, clientManager, options, moduleRef) {
+    this.plugins = plugins;
+    this.clientManager = clientManager;
+    this.options = options;
+    this.moduleRef = moduleRef;
+  }
+  logger = new import_common4.Logger(PluginRegistryService.name);
+  async onModuleInit() {
+    if (this.plugins.length === 0) {
+      return;
+    }
+    const sorted = this.sortByDependencies(this.plugins);
+    const context = this.createContext();
+    for (const plugin of sorted) {
+      if (plugin.onRegister) {
+        this.logger.debug(`Calling onRegister for plugin "${plugin.name}"`);
+        await plugin.onRegister(context);
+      }
+    }
+    for (const plugin of sorted) {
+      if (plugin.onModuleInit) {
+        this.logger.debug(`Calling onModuleInit for plugin "${plugin.name}"`);
+        await plugin.onModuleInit(context);
+      }
+    }
+  }
+  async onModuleDestroy() {
+    if (this.plugins.length === 0) {
+      return;
+    }
+    const sorted = this.sortByDependencies(this.plugins).reverse();
+    const context = this.createContext();
+    for (const plugin of sorted) {
+      if (plugin.onModuleDestroy) {
+        this.logger.debug(`Calling onModuleDestroy for plugin "${plugin.name}"`);
+        await plugin.onModuleDestroy(context);
+      }
+    }
+  }
+  createContext() {
+    const plugins = this.plugins;
+    const clientManager = this.clientManager;
+    const moduleRef = this.moduleRef;
+    const pluginClientManager = {
+      getClient(name) {
+        return clientManager.getClient(name);
+      },
+      hasClient(name) {
+        return clientManager.hasClient(name);
+      },
+      getClientNames() {
+        return clientManager.getClientNames();
+      }
+    };
+    const pluginLogger = {
+      debug: (message, context) => {
+        this.logger.debug(message, context ? JSON.stringify(context) : void 0);
+      },
+      info: (message, context) => {
+        this.logger.log(message, context ? JSON.stringify(context) : void 0);
+      },
+      warn: (message, context) => {
+        this.logger.warn(message, context ? JSON.stringify(context) : void 0);
+      },
+      error: (message, error, context) => {
+        this.logger.error(message, error?.stack, context ? JSON.stringify(context) : void 0);
+      }
+    };
+    const pluginConfig = {
+      clients: {},
+      plugins,
+      global: {
+        debug: this.options.global?.debug,
+        defaultTtl: this.options.global?.defaultTtl,
+        keyPrefix: this.options.global?.keyPrefix
+      }
+    };
+    return {
+      clientManager: pluginClientManager,
+      config: pluginConfig,
+      logger: pluginLogger,
+      moduleRef,
+      getPlugin: (name) => {
+        return plugins.find((p) => p.name === name);
+      },
+      hasPlugin: (name) => {
+        return plugins.some((p) => p.name === name);
+      }
+    };
+  }
+  /**
+   * Topological sort of plugins by dependencies (Kahn's algorithm).
+   * Plugins without dependencies maintain their original order.
+   * Throws on circular dependencies.
+   */
+  sortByDependencies(plugins) {
+    if (plugins.length === 0) {
+      return [];
+    }
+    const pluginMap = /* @__PURE__ */ new Map();
+    const inDegree = /* @__PURE__ */ new Map();
+    const adjacency = /* @__PURE__ */ new Map();
+    for (const plugin of plugins) {
+      pluginMap.set(plugin.name, plugin);
+      inDegree.set(plugin.name, 0);
+      adjacency.set(plugin.name, []);
+    }
+    for (const plugin of plugins) {
+      const deps = plugin.dependencies || [];
+      for (const dep of deps) {
+        if (!pluginMap.has(dep)) {
+          throw new RedisXError(`Plugin "${plugin.name}" depends on "${dep}" which is not registered`, "PLUGIN_DEPENDENCY_MISSING" /* PLUGIN_DEPENDENCY_MISSING */, void 0, { plugin: plugin.name, missingDependency: dep });
+        }
+        adjacency.get(dep).push(plugin.name);
+        inDegree.set(plugin.name, (inDegree.get(plugin.name) || 0) + 1);
+      }
+    }
+    const originalIndex = /* @__PURE__ */ new Map();
+    plugins.forEach((p, i) => originalIndex.set(p.name, i));
+    const queue = [];
+    for (const plugin of plugins) {
+      if (inDegree.get(plugin.name) === 0) {
+        queue.push(plugin.name);
+      }
+    }
+    queue.sort((a, b) => originalIndex.get(a) - originalIndex.get(b));
+    const sorted = [];
+    while (queue.length > 0) {
+      const name = queue.shift();
+      sorted.push(pluginMap.get(name));
+      const neighbors = adjacency.get(name) || [];
+      const newReady = [];
+      for (const neighbor of neighbors) {
+        const deg = inDegree.get(neighbor) - 1;
+        inDegree.set(neighbor, deg);
+        if (deg === 0) {
+          newReady.push(neighbor);
+        }
+      }
+      newReady.sort((a, b) => originalIndex.get(a) - originalIndex.get(b));
+      queue.push(...newReady);
+    }
+    if (sorted.length !== plugins.length) {
+      const remaining = plugins.filter((p) => !sorted.some((s) => s.name === p.name)).map((p) => p.name);
+      throw new RedisXError(`Circular dependency detected among plugins: ${remaining.join(", ")}`, "PLUGIN_CIRCULAR_DEPENDENCY" /* PLUGIN_CIRCULAR_DEPENDENCY */, void 0, { circularPlugins: remaining });
+    }
+    return sorted;
+  }
+};
+PluginRegistryService = __decorateClass([
+  (0, import_common4.Injectable)(),
+  __decorateParam(0, (0, import_common4.Inject)(REGISTERED_PLUGINS)),
+  __decorateParam(1, (0, import_common4.Inject)(CLIENT_MANAGER)),
+  __decorateParam(2, (0, import_common4.Inject)(REDIS_MODULE_OPTIONS))
+], PluginRegistryService);
+
+// src/api/redis.module.ts
+var RedisModule = class {
+  /**
+   * Configures Redis module synchronously.
+   *
+   * Creates a global module with Redis clients and plugins.
+   * All providers are available for injection everywhere.
+   *
+   * @param options - Redis module options
+   * @returns Dynamic module
+   *
+   * @example
+   * ```typescript
+   * RedisModule.forRoot({
+   *   clients: {
+   *     type: 'single',
+   *     host: 'localhost',
+   *     port: 6379,
+   *   },
+   *   plugins: [new CachePlugin(), new LocksPlugin()],
+   * })
+   * ```
+   */
+  static forRoot(options) {
+    const providers = createRedisProviders(options);
+    const pluginProviders = [];
+    const pluginExports = [];
+    const pluginControllers = [];
+    if (options.plugins && options.plugins.length > 0) {
+      options.plugins.forEach((plugin) => {
+        if (plugin.getProviders) {
+          const providers2 = plugin.getProviders();
+          if (Array.isArray(providers2)) {
+            pluginProviders.push(...providers2);
+          }
+        }
+        if (plugin.getExports) {
+          const exports2 = plugin.getExports();
+          if (Array.isArray(exports2)) {
+            pluginExports.push(...exports2);
+          }
+        }
+        if (plugin.getControllers) {
+          const controllers = plugin.getControllers();
+          if (Array.isArray(controllers)) {
+            pluginControllers.push(...controllers);
+          }
+        }
+      });
+    }
+    const plugins = options.plugins || [];
+    return {
+      module: RedisModule,
+      global: true,
+      imports: [import_core.DiscoveryModule],
+      // Required for plugins that scan providers (e.g., CachePlugin)
+      providers: [...providers, ...pluginProviders, { provide: REGISTERED_PLUGINS, useValue: plugins }, PluginRegistryService, RedisService],
+      controllers: pluginControllers,
+      exports: [CLIENT_MANAGER, RedisService, ...pluginExports]
+    };
+  }
+  /**
+   * Configures Redis module asynchronously.
+   *
+   * Allows configuration to be loaded asynchronously using factory function,
+   * existing provider, or class-based factory. Supports plugins.
+   *
+   * Note: Plugins must be provided in the async options (outside useFactory),
+   * not in the factory result. This is a standard NestJS pattern — plugins
+   * must be available at module construction time for NestJS DI.
+   *
+   * @param options - Async Redis module options
+   * @returns Dynamic module
+   *
+   * @example
+   * **Using factory with plugins:**
+   * ```typescript
+   * RedisModule.forRootAsync({
+   *   plugins: [new CachePlugin(), new LocksPlugin()],
+   *   useFactory: (config: ConfigService) => ({
+   *     clients: {
+   *       type: 'single',
+   *       host: config.get('REDIS_HOST'),
+   *       port: config.get('REDIS_PORT'),
+   *     },
+   *   }),
+   *   inject: [ConfigService],
+   * })
+   * ```
+   *
+   * @example
+   * **Using class:**
+   * ```typescript
+   * @Injectable()
+   * class RedisConfigService implements IRedisModuleOptionsFactory {
+   *   createRedisModuleOptions(): IRedisModuleOptions {
+   *     return {
+   *       clients: { type: 'single', host: 'localhost', port: 6379 },
+   *     };
+   *   }
+   * }
+   *
+   * RedisModule.forRootAsync({
+   *   plugins: [new CachePlugin()],
+   *   useClass: RedisConfigService,
+   * })
+   * ```
+   */
+  static forRootAsync(options) {
+    const baseProviders = createAsyncProviders(options);
+    const imports = options.imports || [];
+    const plugins = options.plugins || [];
+    const pluginProviders = [];
+    const pluginExports = [];
+    const pluginControllers = [];
+    if (plugins.length > 0) {
+      plugins.forEach((plugin) => {
+        if (plugin.getProviders) {
+          const providers = plugin.getProviders();
+          if (Array.isArray(providers)) {
+            pluginProviders.push(...providers);
+          }
+        }
+        if (plugin.getExports) {
+          const exports2 = plugin.getExports();
+          if (Array.isArray(exports2)) {
+            pluginExports.push(...exports2);
+          }
+        }
+        if (plugin.getControllers) {
+          const controllers = plugin.getControllers();
+          if (Array.isArray(controllers)) {
+            pluginControllers.push(...controllers);
+          }
+        }
+      });
+    }
+    return {
+      module: RedisModule,
+      global: true,
+      imports: [import_core.DiscoveryModule, ...imports],
+      // DiscoveryModule required for plugins
+      providers: [...baseProviders, ...pluginProviders, { provide: REGISTERED_PLUGINS, useValue: plugins }, PluginRegistryService, RedisService],
+      controllers: pluginControllers,
+      exports: [CLIENT_MANAGER, RedisService, ...pluginExports]
+    };
+  }
+};
+RedisModule = __decorateClass([
+  (0, import_common5.Module)({})
+], RedisModule);
+
+// src/api/decorators/inject-redis.decorator.ts
+var import_common6 = require("@nestjs/common");
+function InjectRedis(name = DEFAULT_CLIENT_NAME) {
+  return (0, import_common6.Inject)(getClientToken(name));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseRedisDriver,
+  CLIENT_MANAGER,
+  CommandError,
+  ConnectionError,
+  ConnectionStatus,
+  DEFAULT_CLIENT_NAME,
+  DEFAULT_COMMAND_TIMEOUT,
+  DEFAULT_CONNECTION_TIMEOUT,
+  DEFAULT_DRIVER_TYPE,
+  DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT,
+  DEFAULT_HEALTH_CHECK_INTERVAL,
+  DriverError,
+  DriverEvent,
+  DriverFactory,
+  ErrorCode,
+  InjectRedis,
+  IoRedisAdapter,
+  MODULE_NAME,
+  ManagerEvent,
+  NodeRedisAdapter,
+  PLUGIN_REGISTRY,
+  PluginRegistryService,
+  REDISX_CONFIG,
+  REDISX_LOGGER,
+  REDIS_CLIENT,
+  REDIS_CLIENTS_INITIALIZATION,
+  REDIS_CLIENTS_MAP,
+  REDIS_DRIVER,
+  REDIS_MODULE_OPTIONS,
+  REGISTERED_PLUGINS,
+  RedisAuthError,
+  RedisClientManager,
+  RedisClusterError,
+  RedisConfigError,
+  RedisConnectionError,
+  RedisInvalidArgsError,
+  RedisKeyNotFoundError,
+  RedisMaxRetriesError,
+  RedisModule,
+  RedisNotConnectedError,
+  RedisNotSupportedError,
+  RedisOperationError,
+  RedisOutOfMemoryError,
+  RedisPipelineError,
+  RedisPoolExhaustedError,
+  RedisReadOnlyError,
+  RedisScriptError,
+  RedisSentinelError,
+  RedisService,
+  RedisTLSError,
+  RedisTimeoutError,
+  RedisTransactionError,
+  RedisTypeMismatchError,
+  RedisValidationError,
+  RedisXError,
+  TimeoutError,
+  ValidationErrorCollector,
+  createDriver,
+  createDrivers,
+  detectAvailableDriver,
+  getClientToken,
+  getDriverToken,
+  getErrorDomain,
+  getRecommendedDriver,
+  hasClass,
+  hasExisting,
+  hasFactory,
+  isClusterConnection,
+  isErrorCode,
+  isErrorDomain,
+  isSentinelConnection,
+  isSingleConnection
+});
+//# sourceMappingURL=index.js.map