conduithub 1.0.0 → 1.1.0

package/dist/shared/conduithub.BzuAKyjY.mjs

@@ -0,0 +1,971 @@
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:path';
+import './conduithub.BNefRQsK.mjs';
+import { r as redisConfigSchema } from './conduithub.B16qn6pY.mjs';
+import { ConduitHub } from '../core/conduit-hub/index.mjs';
+import 'process';
+import 'readline';
+import 'uuid';
+import Redis from 'ioredis';
+import { BasePlugin } from '../core/plugin/index.mjs';
+
+function createNoopRedisClient() {
+  return {
+    set: async () => "OK",
+    get: async () => null,
+    del: async () => 0,
+    exists: async () => 0,
+    expire: async () => 1,
+    ttl: async () => -1,
+    hset: async () => 1,
+    hget: async () => null,
+    hgetall: async () => ({}),
+    hdel: async () => 0,
+    lpush: async () => 0,
+    rpush: async () => 0,
+    lpop: async () => null,
+    rpop: async () => null,
+    llen: async () => 0,
+    lrange: async () => [],
+    sadd: async () => 0,
+    srem: async () => 0,
+    smembers: async () => [],
+    sismember: async () => 0,
+    scard: async () => 0,
+    zadd: async () => 0,
+    zrange: async () => [],
+    ping: async () => "PONG",
+    flushdb: async () => "OK",
+    flushall: async () => "OK"
+  };
+}
+class RedisPlugin extends BasePlugin {
+  redis;
+  ioredisClient;
+  isConnected = false;
+  stats = {
+    totalCommands: 0,
+    successfulCommands: 0,
+    failedCommands: 0,
+    averageResponseTime: 0
+  };
+  async run(operation, payload, call) {
+    await this.executeHook("before-redis-operation", {
+      operation,
+      ...payload
+    });
+    const start = Date.now();
+    try {
+      const result = await call();
+      const duration = Date.now() - start;
+      this.stats.totalCommands++;
+      this.stats.successfulCommands++;
+      const n = this.stats.successfulCommands;
+      this.stats.averageResponseTime = this.stats.averageResponseTime + (duration - this.stats.averageResponseTime) / n;
+      this.stats.lastCommandTime = Date.now();
+      await this.executeHook("after-redis-operation", {
+        operation,
+        ...payload,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.stats.totalCommands++;
+      this.stats.failedCommands++;
+      await this.executeHook("after-redis-operation", {
+        operation,
+        ...payload,
+        error
+      });
+      this.logger.log?.("error", `Redis ${operation} failed`, error);
+      throw error;
+    }
+  }
+  constructor(config) {
+    const normalized = redisConfigSchema.parse(config ?? {});
+    super({
+      name: "redis",
+      version: "1.0.0",
+      enabled: true,
+      dependencies: [],
+      config: normalized
+    });
+  }
+  createRedisWrapper(redisClient) {
+    return {
+      set: async (key, value, options) => {
+        if (!options || Object.keys(options).length === 0) {
+          return redisClient.set(key, String(value));
+        }
+        const args = [];
+        if (typeof options.EX === "number") {
+          args.push("EX", options.EX);
+        }
+        if (typeof options.PX === "number") {
+          args.push("PX", options.PX);
+        }
+        if (options.NX) {
+          args.push("NX");
+        }
+        if (options.XX) {
+          args.push("XX");
+        }
+        return redisClient.set(key, String(value), ...args);
+      },
+      get: (key) => redisClient.get(key),
+      del: (key) => Array.isArray(key) ? redisClient.del(...key) : redisClient.del(key),
+      exists: (key) => Array.isArray(key) ? redisClient.exists(...key) : redisClient.exists(key),
+      expire: (key, seconds) => redisClient.expire(key, seconds),
+      ttl: (key) => redisClient.ttl(key),
+      hset: (key, field, value) => redisClient.hset(key, field, value),
+      hget: (key, field) => redisClient.hget(key, field),
+      hgetall: (key) => redisClient.hgetall(key),
+      hdel: (key, field) => Array.isArray(field) ? redisClient.hdel(key, ...field) : redisClient.hdel(key, field),
+      lpush: (key, ...elements) => redisClient.lpush(key, ...elements),
+      rpush: (key, ...elements) => redisClient.rpush(key, ...elements),
+      lpop: (key) => redisClient.lpop(key),
+      rpop: (key) => redisClient.rpop(key),
+      llen: (key) => redisClient.llen(key),
+      lrange: (key, start, stop) => redisClient.lrange(key, start, stop),
+      sadd: (key, ...members) => redisClient.sadd(key, ...members),
+      srem: (key, ...members) => redisClient.srem(key, ...members),
+      smembers: (key) => redisClient.smembers(key),
+      sismember: (key, member) => redisClient.sismember(key, member),
+      scard: (key) => redisClient.scard(key),
+      zadd: (key, score, member) => redisClient.zadd(key, score, member),
+      zrange: (key, start, stop) => redisClient.zrange(key, start, stop),
+      ping: () => redisClient.ping(),
+      flushdb: () => redisClient.flushdb(),
+      flushall: () => redisClient.flushall()
+    };
+  }
+  getMetadata() {
+    return {
+      name: "redis",
+      version: "1.0.0",
+      description: "Redis plugin for ConduitHub - provides Redis client functionality",
+      author: "ConduitHub",
+      dependencies: [],
+      hooks: ["before-redis-operation", "after-redis-operation"],
+      events: ["redis-connected", "redis-disconnected", "redis-error"]
+    };
+  }
+  async onInitialize() {
+    this.logger.log?.("info", "Initializing Redis plugin...");
+    const config = this.getConfig().config;
+    try {
+      const redisOptions = {
+        host: config.host,
+        port: config.port,
+        db: config.db,
+        retryDelayOnFailover: config.retryDelayOnFailover,
+        maxRetriesPerRequest: config.maxRetriesPerRequest,
+        connectTimeout: config.connectionTimeout,
+        commandTimeout: config.commandTimeout,
+        lazyConnect: config.lazyConnect ?? (process.env.VITEST === "true" || process.env.NODE_ENV === "test")
+      };
+      if (config.password) redisOptions.password = config.password;
+      if (config.username) redisOptions.username = config.username;
+      if (config.keyPrefix) redisOptions.keyPrefix = config.keyPrefix;
+      if (config.tls) redisOptions.tls = config.tls;
+      const redisClient = new Redis(redisOptions);
+      this.ioredisClient = redisClient;
+      this.redis = this.createRedisWrapper(redisClient);
+      this.logger.log?.("info", "Redis client initialized");
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        "Failed to connect to Redis server, using no-op client",
+        error
+      );
+      this.ioredisClient = void 0;
+      this.redis = createNoopRedisClient();
+    }
+  }
+  async onStart() {
+    this.isConnected = true;
+    const cfg = this.getConfig().config;
+    await this.emit("redis-connected", {
+      host: cfg.host,
+      port: cfg.port,
+      db: cfg.db,
+      connected: true,
+      timestamp: Date.now()
+    });
+    this.logger.log?.("info", "Redis plugin started");
+  }
+  async onStop() {
+    this.isConnected = false;
+    const cfg = this.getConfig().config;
+    await this.emit("redis-disconnected", {
+      host: cfg.host,
+      port: cfg.port,
+      db: cfg.db,
+      connected: false,
+      timestamp: Date.now()
+    });
+    this.logger.log?.("info", "Redis plugin stopped");
+  }
+  async onDestroy() {
+    try {
+      if (this.ioredisClient) {
+        await Promise.race([
+          this.ioredisClient.quit(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Quit timeout")), 1e3)
+          )
+        ]);
+        this.logger.log?.("info", "Redis connection closed gracefully");
+      }
+    } catch (error) {
+      this.logger.log?.("error", "Error closing Redis connection", error);
+      try {
+        if (this.ioredisClient) {
+          await Promise.race([
+            this.ioredisClient.disconnect(),
+            new Promise(
+              (_, reject) => setTimeout(
+                () => reject(new Error("Force disconnect timeout")),
+                500
+              )
+            )
+          ]);
+          this.logger.log?.("info", "Redis connection force disconnected");
+        }
+      } catch (disconnectError) {
+        this.logger.log?.(
+          "error",
+          "Error during force disconnect",
+          disconnectError
+        );
+      }
+    } finally {
+      this.ioredisClient = void 0;
+      this.redis = createNoopRedisClient();
+      this.logger.log?.("info", "Redis plugin destroyed");
+    }
+  }
+  async set(key, value, options) {
+    return this.run(
+      "set",
+      { key, value, options },
+      () => this.redis.set(key, value, options)
+    );
+  }
+  async get(key) {
+    return this.run("get", { key }, () => this.redis.get(key));
+  }
+  async del(key) {
+    return this.run("del", { key }, () => this.redis.del(key));
+  }
+  async exists(key) {
+    await this.executeHook("before-redis-operation", {
+      operation: "exists",
+      key
+    });
+    try {
+      const result = await this.redis.exists(key);
+      await this.executeHook("after-redis-operation", {
+        operation: "exists",
+        key,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis EXISTS operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async expire(key, seconds) {
+    await this.executeHook("before-redis-operation", {
+      operation: "expire",
+      key,
+      seconds
+    });
+    try {
+      const result = await this.redis.expire(key, seconds);
+      await this.executeHook("after-redis-operation", {
+        operation: "expire",
+        key,
+        seconds,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis EXPIRE operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async ttl(key) {
+    await this.executeHook("before-redis-operation", { operation: "ttl", key });
+    try {
+      const result = await this.redis.ttl(key);
+      await this.executeHook("after-redis-operation", {
+        operation: "ttl",
+        key,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis TTL operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  // Hash operations
+  async hset(key, field, value) {
+    await this.executeHook("before-redis-operation", {
+      operation: "hset",
+      key,
+      field,
+      value
+    });
+    try {
+      const result = await this.redis.hset(key, field, value);
+      await this.executeHook("after-redis-operation", {
+        operation: "hset",
+        key,
+        field,
+        value,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis HSET operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async hget(key, field) {
+    await this.executeHook("before-redis-operation", {
+      operation: "hget",
+      key,
+      field
+    });
+    try {
+      const result = await this.redis.hget(key, field);
+      await this.executeHook("after-redis-operation", {
+        operation: "hget",
+        key,
+        field,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis HGET operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async hgetall(key) {
+    await this.executeHook("before-redis-operation", {
+      operation: "hgetall",
+      key
+    });
+    try {
+      const result = await this.redis.hgetall(key);
+      await this.executeHook("after-redis-operation", {
+        operation: "hgetall",
+        key,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis HGETALL operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async hdel(key, field) {
+    await this.executeHook("before-redis-operation", {
+      operation: "hdel",
+      key,
+      field
+    });
+    try {
+      const result = await this.redis.hdel(key, field);
+      await this.executeHook("after-redis-operation", {
+        operation: "hdel",
+        key,
+        field,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis HDEL operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  // List operations
+  async lpush(key, ...elements) {
+    await this.executeHook("before-redis-operation", {
+      operation: "lpush",
+      key,
+      elements
+    });
+    try {
+      const result = await this.redis.lpush(key, ...elements);
+      await this.executeHook("after-redis-operation", {
+        operation: "lpush",
+        key,
+        elements,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis LPUSH operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async rpush(key, ...elements) {
+    await this.executeHook("before-redis-operation", {
+      operation: "rpush",
+      key,
+      elements
+    });
+    try {
+      const result = await this.redis.rpush(key, ...elements);
+      await this.executeHook("after-redis-operation", {
+        operation: "rpush",
+        key,
+        elements,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis RPUSH operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async lpop(key) {
+    await this.executeHook("before-redis-operation", {
+      operation: "lpop",
+      key
+    });
+    try {
+      const result = await this.redis.lpop(key);
+      await this.executeHook("after-redis-operation", {
+        operation: "lpop",
+        key,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis LPOP operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async rpop(key) {
+    await this.executeHook("before-redis-operation", {
+      operation: "rpop",
+      key
+    });
+    try {
+      const result = await this.redis.rpop(key);
+      await this.executeHook("after-redis-operation", {
+        operation: "rpop",
+        key,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis RPOP operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async llen(key) {
+    await this.executeHook("before-redis-operation", {
+      operation: "llen",
+      key
+    });
+    try {
+      const result = await this.redis.llen(key);
+      await this.executeHook("after-redis-operation", {
+        operation: "llen",
+        key,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis LLEN operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async lrange(key, start, stop) {
+    await this.executeHook("before-redis-operation", {
+      operation: "lrange",
+      key,
+      start,
+      stop
+    });
+    try {
+      const result = await this.redis.lrange(key, start, stop);
+      await this.executeHook("after-redis-operation", {
+        operation: "lrange",
+        key,
+        start,
+        stop,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis LRANGE operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  // Set operations
+  async sadd(key, ...members) {
+    await this.executeHook("before-redis-operation", {
+      operation: "sadd",
+      key,
+      members
+    });
+    try {
+      const result = await this.redis.sadd(key, ...members);
+      await this.executeHook("after-redis-operation", {
+        operation: "sadd",
+        key,
+        members,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis SADD operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async srem(key, ...members) {
+    await this.executeHook("before-redis-operation", {
+      operation: "srem",
+      key,
+      members
+    });
+    try {
+      const result = await this.redis.srem(key, ...members);
+      await this.executeHook("after-redis-operation", {
+        operation: "srem",
+        key,
+        members,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis SREM operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async smembers(key) {
+    await this.executeHook("before-redis-operation", {
+      operation: "smembers",
+      key
+    });
+    try {
+      const result = await this.redis.smembers(key);
+      await this.executeHook("after-redis-operation", {
+        operation: "smembers",
+        key,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis SMEMBERS operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async sismember(key, member) {
+    await this.executeHook("before-redis-operation", {
+      operation: "sismember",
+      key,
+      member
+    });
+    try {
+      const result = await this.redis.sismember(key, member);
+      await this.executeHook("after-redis-operation", {
+        operation: "sismember",
+        key,
+        member,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis SISMEMBER operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async scard(key) {
+    await this.executeHook("before-redis-operation", {
+      operation: "scard",
+      key
+    });
+    try {
+      const result = await this.redis.scard(key);
+      await this.executeHook("after-redis-operation", {
+        operation: "scard",
+        key,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis SCARD operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  // Sorted set operations
+  async zadd(key, score, member) {
+    await this.executeHook("before-redis-operation", {
+      operation: "zadd",
+      key,
+      score,
+      member
+    });
+    try {
+      const result = await this.redis.zadd(key, score, member);
+      await this.executeHook("after-redis-operation", {
+        operation: "zadd",
+        key,
+        score,
+        member,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis ZADD operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async zrange(key, start, stop) {
+    await this.executeHook("before-redis-operation", {
+      operation: "zrange",
+      key,
+      start,
+      stop
+    });
+    try {
+      const result = await this.redis.zrange(key, start, stop);
+      await this.executeHook("after-redis-operation", {
+        operation: "zrange",
+        key,
+        start,
+        stop,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.logger.log?.(
+        "error",
+        `Redis ZRANGE operation failed for key: ${key}`,
+        error
+      );
+      throw error;
+    }
+  }
+  // Utility methods
+  getConnectionInfo() {
+    const cfg = this.getConfig().config;
+    return {
+      host: cfg.host,
+      port: cfg.port,
+      db: cfg.db,
+      connected: this.isConnected,
+      timestamp: Date.now()
+    };
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  async ping() {
+    return this.run("ping", {}, () => this.redis.ping());
+  }
+  async flushdb() {
+    return this.run("flushdb", {}, () => this.redis.flushdb());
+  }
+  async flushall() {
+    return this.run("flushall", {}, () => this.redis.flushall());
+  }
+}
+
+let hub = null;
+let redisPlugin = null;
+function readRedisConfigFromEnv() {
+  const toNumber = (v) => v !== void 0 && v !== null && v !== "" && !Number.isNaN(Number(v)) ? Number(v) : void 0;
+  const toBoolean = (v) => v === "true" ? true : v === "false" ? false : void 0;
+  const host = process.env.REDIS_HOST;
+  const port = toNumber(process.env.REDIS_PORT);
+  const password = process.env.REDIS_PASSWORD;
+  const db = toNumber(process.env.REDIS_DB);
+  const username = process.env.REDIS_USERNAME;
+  const keyPrefix = process.env.REDIS_KEY_PREFIX;
+  const connectionTimeout = toNumber(process.env.REDIS_CONNECTION_TIMEOUT);
+  const commandTimeout = toNumber(process.env.REDIS_COMMAND_TIMEOUT);
+  const maxRetriesPerRequest = toNumber(
+    process.env.REDIS_MAX_RETRIES_PER_REQUEST
+  );
+  const retryDelayOnFailover = toNumber(
+    process.env.REDIS_RETRY_DELAY_ON_FAILOVER
+  );
+  const enableReadyCheck = toBoolean(process.env.REDIS_ENABLE_READY_CHECK);
+  const enableOfflineQueue = toBoolean(process.env.REDIS_ENABLE_OFFLINE_QUEUE);
+  const keepAlive = toBoolean(process.env.REDIS_KEEP_ALIVE);
+  const lazyConnect = toBoolean(process.env.REDIS_LAZY_CONNECT);
+  const familyEnv = process.env.REDIS_FAMILY;
+  const family = familyEnv === "IPv6" ? "IPv6" : familyEnv === "IPv4" ? "IPv4" : void 0;
+  const tlsCa = process.env.REDIS_TLS_CA;
+  const tlsCert = process.env.REDIS_TLS_CERT;
+  const tlsKey = process.env.REDIS_TLS_KEY;
+  const tlsRejectUnauthorized = toBoolean(
+    process.env.REDIS_TLS_REJECT_UNAUTHORIZED
+  );
+  const cfg = {};
+  if (host) cfg.host = host;
+  if (port !== void 0) cfg.port = port;
+  if (password) cfg.password = password;
+  if (db !== void 0) cfg.db = db;
+  if (username) cfg.username = username;
+  if (keyPrefix) cfg.keyPrefix = keyPrefix;
+  if (connectionTimeout !== void 0)
+    cfg.connectionTimeout = connectionTimeout;
+  if (commandTimeout !== void 0) cfg.commandTimeout = commandTimeout;
+  if (maxRetriesPerRequest !== void 0)
+    cfg.maxRetriesPerRequest = maxRetriesPerRequest;
+  if (retryDelayOnFailover !== void 0)
+    cfg.retryDelayOnFailover = retryDelayOnFailover;
+  if (enableReadyCheck !== void 0) cfg.enableReadyCheck = enableReadyCheck;
+  if (enableOfflineQueue !== void 0)
+    cfg.enableOfflineQueue = enableOfflineQueue;
+  if (keepAlive !== void 0) cfg.keepAlive = keepAlive;
+  if (lazyConnect !== void 0) cfg.lazyConnect = lazyConnect;
+  if (family !== void 0) cfg.family = family;
+  if (tlsCa || tlsCert || tlsKey || tlsRejectUnauthorized !== void 0) {
+    const tls = {
+      rejectUnauthorized: tlsRejectUnauthorized ?? true
+    };
+    if (tlsCa) tls.ca = tlsCa;
+    if (tlsCert) tls.cert = tlsCert;
+    if (tlsKey) tls.key = tlsKey;
+    cfg.tls = tls;
+  }
+  return cfg;
+}
+async function initRedis(override) {
+  if (redisPlugin) return redisPlugin;
+  const cfg = {
+    ...readRedisConfigFromEnv(),
+    ...override ?? {}
+  };
+  if (!hub) hub = ConduitHub.getInstance();
+  if (!hub.isInitialized) await hub.initialize({});
+  const plugin = new RedisPlugin(cfg);
+  await hub.registerPlugin(plugin);
+  await hub.startPlugin("RedisPlugin");
+  redisPlugin = plugin;
+  return plugin;
+}
+function getRedis() {
+  if (!redisPlugin)
+    throw new Error("RedisPlugin is not initialized. Call initRedis() first.");
+  return redisPlugin;
+}
+async function shutdownRedis() {
+  if (!hub) return;
+  try {
+    if (hub.isInitialized && hub.isPluginRegistered("RedisPlugin")) {
+      if (hub.isPluginRunning("RedisPlugin"))
+        await hub.stopPlugin("RedisPlugin");
+      await hub.unregisterPlugin("RedisPlugin");
+    }
+  } finally {
+    redisPlugin = null;
+  }
+}
+const redis = {
+  init: initRedis,
+  getPlugin: getRedis,
+  shutdown: shutdownRedis,
+  set: async (key, value, options) => {
+    const client = await initRedis();
+    return client.set(key, value, options);
+  },
+  get: async (key) => {
+    const client = await initRedis();
+    return client.get(key);
+  },
+  del: async (key) => {
+    const client = await initRedis();
+    return client.del(key);
+  },
+  exists: async (key) => {
+    const client = await initRedis();
+    return client.exists(key);
+  },
+  expire: async (key, seconds) => {
+    const client = await initRedis();
+    return client.expire(key, seconds);
+  },
+  ttl: async (key) => {
+    const client = await initRedis();
+    return client.ttl(key);
+  },
+  hset: async (key, field, value) => {
+    const client = await initRedis();
+    return client.hset(key, field, value);
+  },
+  hget: async (key, field) => {
+    const client = await initRedis();
+    return client.hget(key, field);
+  },
+  hgetall: async (key) => {
+    const client = await initRedis();
+    return client.hgetall(key);
+  },
+  hdel: async (key, field) => {
+    const client = await initRedis();
+    return client.hdel(key, field);
+  },
+  lpush: async (key, ...elements) => {
+    const client = await initRedis();
+    return client.lpush(key, ...elements);
+  },
+  rpush: async (key, ...elements) => {
+    const client = await initRedis();
+    return client.rpush(key, ...elements);
+  },
+  lpop: async (key) => {
+    const client = await initRedis();
+    return client.lpop(key);
+  },
+  rpop: async (key) => {
+    const client = await initRedis();
+    return client.rpop(key);
+  },
+  llen: async (key) => {
+    const client = await initRedis();
+    return client.llen(key);
+  },
+  lrange: async (key, start, stop) => {
+    const client = await initRedis();
+    return client.lrange(key, start, stop);
+  },
+  sadd: async (key, ...members) => {
+    const client = await initRedis();
+    return client.sadd(key, ...members);
+  },
+  srem: async (key, ...members) => {
+    const client = await initRedis();
+    return client.srem(key, ...members);
+  },
+  smembers: async (key) => {
+    const client = await initRedis();
+    return client.smembers(key);
+  },
+  sismember: async (key, member) => {
+    const client = await initRedis();
+    return client.sismember(key, member);
+  },
+  scard: async (key) => {
+    const client = await initRedis();
+    return client.scard(key);
+  },
+  zadd: async (key, score, member) => {
+    const client = await initRedis();
+    return client.zadd(key, score, member);
+  },
+  zrange: async (key, start, stop) => {
+    const client = await initRedis();
+    return client.zrange(key, start, stop);
+  },
+  ping: async () => {
+    const client = await initRedis();
+    return client.ping();
+  },
+  flushdb: async () => {
+    const client = await initRedis();
+    return client.flushdb();
+  },
+  flushall: async () => {
+    const client = await initRedis();
+    return client.flushall();
+  },
+  getConnectionInfo: async () => {
+    const client = await initRedis();
+    return client.getConnectionInfo();
+  },
+  getStats: async () => {
+    const client = await initRedis();
+    return client.getStats();
+  }
+};
+
+export { RedisPlugin as R, getRedis as g, initRedis as i, redis as r, shutdownRedis as s };