conduithub 0.1.0 → 1.0.1

package/dist/shared/conduithub.cvEjE62V.cjs

@@ -0,0 +1,775 @@
+'use strict';
+
+const Redis = require('ioredis');
+const core_plugin_index = require('../core/plugin/index.cjs');
+const zod = require('zod');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const Redis__default = /*#__PURE__*/_interopDefaultCompat(Redis);
+
+const redisConfigSchema = zod.z.object({
+  host: zod.z.string().default("localhost"),
+  port: zod.z.number().default(6379),
+  password: zod.z.string().optional(),
+  db: zod.z.number().default(0),
+  username: zod.z.string().optional(),
+  url: zod.z.string().url().optional(),
+  keyPrefix: zod.z.string().optional(),
+  tls: zod.z.object({
+    ca: zod.z.string().optional(),
+    cert: zod.z.string().optional(),
+    key: zod.z.string().optional(),
+    rejectUnauthorized: zod.z.boolean().default(true)
+  }).optional(),
+  connectionTimeout: zod.z.number().default(5e4),
+  commandTimeout: zod.z.number().default(5e4),
+  maxRetriesPerRequest: zod.z.number().default(3),
+  retryDelayOnFailover: zod.z.number().default(100),
+  enableReadyCheck: zod.z.boolean().default(true),
+  enableOfflineQueue: zod.z.boolean().default(true),
+  keepAlive: zod.z.boolean().default(true),
+  lazyConnect: zod.z.boolean().default(false),
+  family: zod.z.enum(["IPv4", "IPv6"]).default("IPv4")
+});
+
+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 core_plugin_index.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 setOptions = {};
+        if (options.EX) setOptions.EX = options.EX;
+        if (options.PX) setOptions.PX = options.PX;
+        if (options.NX) setOptions.GET = false;
+        if (options.XX) setOptions.GET = false;
+        return redisClient.set(key, String(value), setOptions);
+      },
+      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
+      };
+      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__default(redisOptions);
+      await redisClient.ping();
+      this.ioredisClient = redisClient;
+      this.redis = this.createRedisWrapper(redisClient);
+      this.logger.log?.("info", "Successfully connected to Redis server");
+    } 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());
+  }
+}
+
+exports.RedisPlugin = RedisPlugin;