service-call-library-dev 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1122 @@
+"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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/logging/logger.service.ts
+var import_winston, LoggerService;
+var init_logger_service = __esm({
+  "src/logging/logger.service.ts"() {
+    "use strict";
+    import_winston = __toESM(require("winston"), 1);
+    LoggerService = class {
+      static {
+        this.logger = import_winston.default.createLogger({
+          level: process.env.LOG_LEVEL ?? "info",
+          format: import_winston.default.format.combine(
+            import_winston.default.format.timestamp(),
+            import_winston.default.format.errors({ stack: true }),
+            import_winston.default.format.json()
+          ),
+          transports: [new import_winston.default.transports.Console()]
+        });
+      }
+      static info(message, meta) {
+        this.logger.info(message, meta);
+      }
+      static error(message, meta) {
+        this.logger.error(message, meta);
+      }
+      static warn(message, meta) {
+        this.logger.warn(message, meta);
+      }
+      static debug(message, meta) {
+        this.logger.debug(message, meta);
+      }
+    };
+  }
+});
+
+// src/utils/zookeeperConfig.ts
+var getZooKeeperConfig;
+var init_zookeeperConfig = __esm({
+  "src/utils/zookeeperConfig.ts"() {
+    "use strict";
+    getZooKeeperConfig = () => {
+      const config = {
+        connectionString: process.env.ZOOKEEPER_CONNECTION_STRING,
+        infraPath: process.env.ZOOKEEPER_INFRA_PATH,
+        servicePath: process.env.ZOOKEEPER_SERVICE_PATH,
+        user: process.env.ZOOKEEPER_USER,
+        password: process.env.ZOOKEEPER_PASSWORD
+      };
+      if (!config.connectionString) {
+        throw new Error("ZOOKEEPER_CONNECTION_STRING is required");
+      }
+      return config;
+    };
+  }
+});
+
+// src/utils/zookeeperCrypto.ts
+var import_crypto, fs, path, LOG_PREFIX, INFRA_VALUE_REGEX, parseInfraValue, getPrivateKeyPath, decryptWithAlias, getServicePrivateKeyPath, decryptWithPrivateKey;
+var init_zookeeperCrypto = __esm({
+  "src/utils/zookeeperCrypto.ts"() {
+    "use strict";
+    import_crypto = __toESM(require("crypto"), 1);
+    fs = __toESM(require("fs"), 1);
+    path = __toESM(require("path"), 1);
+    init_logger_service();
+    LOG_PREFIX = "[ZK] ";
+    INFRA_VALUE_REGEX = /^devEnc:([A-Za-z0-9+/=_-]+):([A-Za-z0-9-_]+)$/;
+    parseInfraValue = (value) => {
+      const match = value.match(INFRA_VALUE_REGEX);
+      if (!match) return null;
+      return {
+        prefix: "devEnc",
+        encryptedData: match[1],
+        alias: match[2]
+      };
+    };
+    getPrivateKeyPath = (alias) => {
+      const baseDir = process.env.PRIVATE_KEY_DIR || path.join(process.cwd(), "keys");
+      return path.join(baseDir, `private_key_${alias}.pem`);
+    };
+    decryptWithAlias = (encryptedData, alias) => {
+      try {
+        const privateKeyPath = getPrivateKeyPath(alias);
+        if (!fs.existsSync(privateKeyPath)) {
+          throw new Error(`Private key file not found for alias '${alias}': ${privateKeyPath}`);
+        }
+        const privateKey = fs.readFileSync(privateKeyPath, "utf8");
+        const buffer = Buffer.from(encryptedData, "base64");
+        const attempts = [
+          {
+            key: privateKey,
+            padding: import_crypto.default.constants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: "sha256"
+          },
+          {
+            key: privateKey,
+            padding: import_crypto.default.constants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: "sha1"
+          },
+          {
+            key: privateKey,
+            padding: import_crypto.default.constants.RSA_PKCS1_PADDING
+          }
+        ];
+        let lastError = null;
+        for (const options of attempts) {
+          try {
+            const out = import_crypto.default.privateDecrypt(options, buffer);
+            return out.toString("utf-8");
+          } catch (error) {
+            lastError = error;
+          }
+        }
+        LoggerService.error(`${LOG_PREFIX}RSA decryption failed with alias '${alias}'`, {
+          error: lastError
+        });
+        throw new Error(`Decryption failed for alias '${alias}'`);
+      } catch (error) {
+        LoggerService.error(`${LOG_PREFIX}failed to decrypt with alias '${alias}'`, {
+          error: error?.message || error
+        });
+        throw new Error(`Decryption failed for alias '${alias}': ${error.message}`);
+      }
+    };
+    getServicePrivateKeyPath = () => {
+      const baseDir = process.env.PRIVATE_KEY_DIR || path.join(process.cwd(), "keys");
+      return path.join(baseDir, "private.pem");
+    };
+    decryptWithPrivateKey = (encryptedData) => {
+      try {
+        const privateKeyPath = getServicePrivateKeyPath();
+        if (!fs.existsSync(privateKeyPath)) {
+          throw new Error(`Private key file not found: ${privateKeyPath}`);
+        }
+        const privateKey = fs.readFileSync(privateKeyPath, "utf8");
+        const buffer = Buffer.from(encryptedData, "base64");
+        const attempts = [
+          {
+            key: privateKey,
+            padding: import_crypto.default.constants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: "sha256"
+          },
+          {
+            key: privateKey,
+            padding: import_crypto.default.constants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: "sha1"
+          },
+          {
+            key: privateKey,
+            padding: import_crypto.default.constants.RSA_PKCS1_PADDING
+          }
+        ];
+        let lastError = null;
+        for (const options of attempts) {
+          try {
+            const out = import_crypto.default.privateDecrypt(options, buffer);
+            return out.toString("utf-8");
+          } catch (error) {
+            lastError = error;
+          }
+        }
+        LoggerService.error(`${LOG_PREFIX}RSA decryption failed with private.pem`, {
+          error: lastError
+        });
+        throw new Error("All decryption attempts failed");
+      } catch (error) {
+        LoggerService.error(`${LOG_PREFIX}failed to decrypt with private.pem`, {
+          error: error?.message || error
+        });
+        throw new Error(`Decryption failed: ${error.message}`);
+      }
+    };
+  }
+});
+
+// src/utils/zookeeper.ts
+var zookeeper_exports = {};
+__export(zookeeper_exports, {
+  default: () => zookeeper_default,
+  registerRestartCallback: () => registerRestartCallback
+});
+var import_node_zookeeper_client, process2, SESSION_TIMEOUT, CONNECT_TIMEOUT, LOG_PREFIX2, isInfraDataBeingProcessed, isServiceDataBeingProcessed, hasLoadedInfraOnce, hasLoadedServiceOnce, currentClient, connectWatchdog, hasInfraPath, hasServicePath, restartCallback, registerRestartCallback, processEnvironmentData, decryptInfraValue, decryptServiceValue, handleZooKeeperData, connectToPath, cleanupClient, startZooKeeperClient, zookeeper_default;
+var init_zookeeper = __esm({
+  "src/utils/zookeeper.ts"() {
+    "use strict";
+    import_node_zookeeper_client = __toESM(require("node-zookeeper-client"), 1);
+    process2 = __toESM(require("process"), 1);
+    init_zookeeperConfig();
+    init_zookeeperCrypto();
+    SESSION_TIMEOUT = 3e7;
+    CONNECT_TIMEOUT = 1e7;
+    LOG_PREFIX2 = "[ZK] ";
+    isInfraDataBeingProcessed = false;
+    isServiceDataBeingProcessed = false;
+    hasLoadedInfraOnce = false;
+    hasLoadedServiceOnce = false;
+    currentClient = null;
+    connectWatchdog = null;
+    hasInfraPath = false;
+    hasServicePath = false;
+    restartCallback = null;
+    registerRestartCallback = (callback) => {
+      restartCallback = callback;
+    };
+    processEnvironmentData = (data, isInfraPath) => {
+      const pathType = isInfraPath ? "infra" : "service";
+      const lines = data.split("\n");
+      let processedCount = 0;
+      let encryptedCount = 0;
+      let errorCount = 0;
+      const errors = [];
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        const firstEqualIndex = line.indexOf("=");
+        if (firstEqualIndex === -1) continue;
+        const key = line.slice(0, firstEqualIndex).trim();
+        const value = line.slice(firstEqualIndex + 1).trim();
+        if (!key || value.length === 0) continue;
+        try {
+          if (value.startsWith("devEnc:") && isInfraPath) {
+            encryptedCount++;
+            let decryptedValue = decryptInfraValue(value);
+            decryptedValue = decryptedValue.replace(/(\r?\n)$/, "");
+            process2.env[key] = decryptedValue;
+          } else if (value.startsWith("devEnc:")) {
+            encryptedCount++;
+            let decryptedValue = decryptServiceValue(value);
+            decryptedValue = decryptedValue.replace(/(\r?\n)$/, "");
+            process2.env[key] = decryptedValue;
+          } else {
+            process2.env[key] = value;
+          }
+          processedCount++;
+        } catch (error) {
+          errorCount++;
+          errors.push({
+            key,
+            error: error?.message || "Unknown decryption error"
+          });
+        }
+      }
+      if (errorCount > 0) {
+        console.log(
+          JSON.stringify({
+            type: "ZK",
+            message: `${LOG_PREFIX2}errors processing environment variables`,
+            pathType,
+            processedCount,
+            encryptedCount,
+            errorCount,
+            errors: errors.slice(0, 10),
+            totalErrors: errors.length,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      }
+    };
+    decryptInfraValue = (value) => {
+      const encryptedValue = parseInfraValue(value);
+      if (!encryptedValue) {
+        throw new Error("Invalid encrypted value format");
+      }
+      const decryptedValue = decryptWithAlias(
+        encryptedValue.encryptedData,
+        encryptedValue.alias
+      );
+      return decryptedValue;
+    };
+    decryptServiceValue = (value) => {
+      const cleanValue = value.replace("devEnc:", "");
+      const encryptedValue = decryptWithPrivateKey(cleanValue);
+      return encryptedValue;
+    };
+    handleZooKeeperData = (client, zkPath, isInfraPath, resolve, reject) => {
+      const pathType = isInfraPath ? "infra" : "service";
+      const isBeingProcessed = isInfraPath ? isInfraDataBeingProcessed : isServiceDataBeingProcessed;
+      if (isBeingProcessed) return;
+      if (isInfraPath) {
+        isInfraDataBeingProcessed = true;
+      } else {
+        isServiceDataBeingProcessed = true;
+      }
+      client.getData(
+        zkPath,
+        (event) => {
+          if (event.type === import_node_zookeeper_client.default.Event.NODE_DATA_CHANGED) {
+            console.log(
+              JSON.stringify({
+                type: "ZK",
+                message: `${LOG_PREFIX2}Config changed detected, restarting application`,
+                pathType: isInfraPath ? "infra" : "service",
+                path: zkPath,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              })
+            );
+            if (restartCallback) {
+              restartCallback().catch((error) => {
+                console.log(
+                  JSON.stringify({
+                    type: "ZK",
+                    message: `${LOG_PREFIX2}Error during restart`,
+                    error: {
+                      message: error?.message || "Unknown error",
+                      stack: error?.stack
+                    },
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  })
+                );
+                process2.exit(0);
+              });
+            } else {
+              console.log(
+                JSON.stringify({
+                  type: "ZK",
+                  message: `${LOG_PREFIX2}No restart callback registered, exiting process`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                })
+              );
+              process2.exit(0);
+            }
+          }
+        },
+        (error, data) => {
+          if (isInfraPath) {
+            isInfraDataBeingProcessed = false;
+          } else {
+            isServiceDataBeingProcessed = false;
+          }
+          if (error) {
+            const errorMsg = `${LOG_PREFIX2}getData failed for ${pathType} path: ${zkPath}`;
+            console.log(
+              JSON.stringify({
+                type: "ZK",
+                message: errorMsg,
+                pathType,
+                path: zkPath,
+                error: {
+                  message: error?.message || "Unknown error",
+                  code: error?.code,
+                  name: error?.name,
+                  stack: error?.stack,
+                  errno: error?.errno
+                },
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              })
+            );
+            reject(new Error(errorMsg));
+            return;
+          }
+          if (!data) {
+            reject(
+              new Error(
+                `${LOG_PREFIX2}No data received for ${pathType} path: ${zkPath}`
+              )
+            );
+            return;
+          }
+          try {
+            const rawData = data.toString("utf8");
+            processEnvironmentData(rawData, isInfraPath);
+            if (isInfraPath) {
+              hasInfraPath = true;
+            } else {
+              hasServicePath = true;
+            }
+            if (isInfraPath) {
+              if (!hasLoadedInfraOnce) {
+                hasLoadedInfraOnce = true;
+                console.log(
+                  JSON.stringify({
+                    type: "ZK",
+                    message: `${LOG_PREFIX2}loaded infra environment variables`,
+                    path: zkPath
+                  })
+                );
+              }
+            } else {
+              if (!hasLoadedServiceOnce) {
+                hasLoadedServiceOnce = true;
+                console.log(
+                  JSON.stringify({
+                    type: "ZK",
+                    message: `${LOG_PREFIX2}loaded service environment variables`,
+                    path: zkPath
+                  })
+                );
+              }
+            }
+            if (hasInfraPath && hasServicePath) {
+              resolve();
+            }
+          } catch (error2) {
+            const errorMsg = `${LOG_PREFIX2}error processing data for ${pathType} path: ${zkPath}`;
+            console.log(
+              JSON.stringify({
+                type: "ZK",
+                message: errorMsg,
+                pathType,
+                path: zkPath,
+                error: {
+                  message: error2?.message || "Unknown error",
+                  code: error2?.code,
+                  name: error2?.name,
+                  stack: error2?.stack
+                },
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              })
+            );
+            reject(new Error(errorMsg));
+          }
+        }
+      );
+    };
+    connectToPath = (client, zkPath, isInfraPath, resolve, reject) => {
+      const pathType = isInfraPath ? "infra" : "service";
+      client.exists(
+        zkPath,
+        () => {
+        },
+        (error, stat) => {
+          if (error) {
+            const errorMsg = `${LOG_PREFIX2}exists check failed for ${pathType} path: ${zkPath}`;
+            console.log(
+              JSON.stringify({
+                type: "ZK",
+                message: errorMsg,
+                pathType,
+                path: zkPath,
+                error: {
+                  message: error?.message || "Unknown error",
+                  code: error?.code,
+                  name: error?.name,
+                  stack: error?.stack,
+                  errno: error?.errno
+                },
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              })
+            );
+            reject(new Error(errorMsg));
+            return;
+          }
+          if (stat) {
+            handleZooKeeperData(client, zkPath, isInfraPath, resolve, reject);
+          } else {
+            const errorMsg = `${LOG_PREFIX2}path does not exist: ${zkPath}`;
+            console.log(
+              JSON.stringify({
+                type: "ZK",
+                message: errorMsg,
+                pathType,
+                path: zkPath,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              })
+            );
+            reject(new Error(errorMsg));
+          }
+        }
+      );
+    };
+    cleanupClient = () => {
+      try {
+        if (currentClient?.close) currentClient.close();
+      } catch (e) {
+        if (e?.message) {
+          console.log(
+            JSON.stringify({
+              type: "ZK",
+              message: `${LOG_PREFIX2}error closing client`,
+              error: {
+                message: e?.message,
+                stack: e?.stack
+              },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+        }
+      }
+      currentClient = null;
+      if (connectWatchdog) {
+        clearTimeout(connectWatchdog);
+        connectWatchdog = null;
+      }
+    };
+    startZooKeeperClient = () => {
+      return new Promise((resolve, reject) => {
+        let resolved = false;
+        const safeResolve = () => {
+          if (!resolved) {
+            resolved = true;
+            resolve();
+          }
+        };
+        try {
+          const config = getZooKeeperConfig();
+          console.log(
+            JSON.stringify({
+              type: "ZK",
+              message: `${LOG_PREFIX2}initializing`,
+              config: {
+                connectionString: config.connectionString,
+                infraPath: config.infraPath,
+                servicePath: config.servicePath,
+                hasAuth: !!(config.user && config.password),
+                user: config.user || null,
+                sessionTimeout: SESSION_TIMEOUT
+              }
+            })
+          );
+          cleanupClient();
+          hasInfraPath = false;
+          hasServicePath = false;
+          hasLoadedInfraOnce = false;
+          hasLoadedServiceOnce = false;
+          isInfraDataBeingProcessed = false;
+          isServiceDataBeingProcessed = false;
+          const client = import_node_zookeeper_client.default.createClient(config.connectionString, {
+            sessionTimeout: SESSION_TIMEOUT,
+            retries: 0
+            // No retries - fail fast
+          });
+          currentClient = client;
+          if (config.user && config.password) {
+            client.addAuthInfo(
+              "digest",
+              Buffer.from(`${config.user}:${config.password}`)
+            );
+          }
+          connectWatchdog = setTimeout(() => {
+            if (currentClient === client) {
+              cleanupClient();
+              const errorMsg = `${LOG_PREFIX2}Connection timeout after ${CONNECT_TIMEOUT}ms`;
+              console.log(
+                JSON.stringify({
+                  type: "ZK",
+                  message: errorMsg,
+                  config: {
+                    connectionString: config.connectionString
+                  },
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                })
+              );
+              reject(new Error(errorMsg));
+            }
+          }, CONNECT_TIMEOUT);
+          client.on("connected", () => {
+            console.log(
+              JSON.stringify({
+                type: "ZK",
+                message: `${LOG_PREFIX2}connected`,
+                config: {
+                  connectionString: config.connectionString,
+                  infraPath: config.infraPath,
+                  servicePath: config.servicePath,
+                  user: config.user,
+                  password: config.password
+                }
+              })
+            );
+            if (connectWatchdog) {
+              clearTimeout(connectWatchdog);
+              connectWatchdog = null;
+            }
+            connectToPath(client, config.infraPath, true, safeResolve, reject);
+            connectToPath(client, config.servicePath, false, safeResolve, reject);
+          });
+          client.on("disconnected", () => {
+            console.log(
+              JSON.stringify({
+                type: "ZK",
+                message: `${LOG_PREFIX2}disconnected`,
+                config: {
+                  connectionString: config.connectionString
+                }
+              })
+            );
+            cleanupClient();
+            reject(new Error(`${LOG_PREFIX2}Disconnected from ZooKeeper`));
+          });
+          client.on("expired", () => {
+            console.log(
+              JSON.stringify({
+                type: "ZK",
+                message: `${LOG_PREFIX2}session expired`,
+                config: {
+                  connectionString: config.connectionString
+                }
+              })
+            );
+            cleanupClient();
+            reject(new Error(`${LOG_PREFIX2}ZooKeeper session expired`));
+          });
+          client.on("error", (error) => {
+            console.log(
+              JSON.stringify({
+                type: "ZK",
+                message: `${LOG_PREFIX2}error`,
+                error: {
+                  message: error?.message || "Unknown error",
+                  code: error?.code,
+                  name: error?.name,
+                  stack: error?.stack,
+                  errno: error?.errno,
+                  syscall: error?.syscall,
+                  address: error?.address,
+                  port: error?.port
+                },
+                config: {
+                  connectionString: config.connectionString
+                },
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              })
+            );
+            cleanupClient();
+            reject(
+              new Error(
+                `${LOG_PREFIX2}ZooKeeper error: ${error?.message || "Unknown error"}`
+              )
+            );
+          });
+          client.connect();
+        } catch (error) {
+          const config = getZooKeeperConfig();
+          console.log(
+            JSON.stringify({
+              type: "ZK",
+              message: `${LOG_PREFIX2}initialization failed`,
+              error: {
+                message: error?.message || "Unknown error",
+                code: error?.code,
+                name: error?.name,
+                stack: error?.stack,
+                errno: error?.errno,
+                syscall: error?.syscall
+              },
+              config: {
+                connectionString: config.connectionString,
+                infraPath: config.infraPath,
+                servicePath: config.servicePath,
+                hasAuth: !!(config.user && config.password)
+              },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+          cleanupClient();
+          reject(
+            new Error(
+              `${LOG_PREFIX2}Initialization exception: ${error?.message || "Unknown error"}`
+            )
+          );
+        }
+      });
+    };
+    zookeeper_default = startZooKeeperClient;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ServiceCallLibrary: () => ServiceCallLibrary,
+  TYPES: () => TYPES
+});
+module.exports = __toCommonJS(index_exports);
+var import_reflect_metadata = require("reflect-metadata");
+
+// src/inversify.container.ts
+var import_inversify7 = require("inversify");
+
+// src/configs/redis-client.ts
+var import_redis = require("redis");
+init_logger_service();
+var RedisClient = class _RedisClient {
+  constructor() {
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 2;
+    this.connectPromise = null;
+    this.client = (0, import_redis.createClient)({
+      socket: {
+        host: process.env.REDIS_HOST ?? "127.0.0.1",
+        port: Number(process.env.REDIS_PORT) || 6379,
+        reconnectStrategy: (retries) => {
+          this.reconnectAttempts = retries;
+          if (retries > this.maxReconnectAttempts) {
+            LoggerService.error("Redis reconnect attempts exceeded", {
+              retries,
+              host: process.env.REDIS_HOST ?? "127.0.0.1",
+              port: Number(process.env.REDIS_PORT) || 6379
+            });
+            return new Error("Redis reconnect attempts exceeded");
+          }
+          return 1e3;
+        }
+      },
+      password: process.env.REDIS_PASSWORD || void 0
+    });
+    this.client.on("error", (err) => {
+      LoggerService.error("Redis error", {
+        error: err?.message || err,
+        reconnectAttempts: this.reconnectAttempts
+      });
+    });
+    this.client.on("connect", () => {
+      LoggerService.info("Redis connected", {
+        host: process.env.REDIS_HOST ?? "127.0.0.1",
+        port: Number(process.env.REDIS_PORT) || 6379
+      });
+    });
+  }
+  static getInstance() {
+    if (!_RedisClient.instance) {
+      _RedisClient.instance = new _RedisClient();
+    }
+    return _RedisClient.instance;
+  }
+  async connect() {
+    if (this.client.isOpen) {
+      return this.client;
+    }
+    if (!this.connectPromise) {
+      this.connectPromise = this.client.connect().catch((err) => {
+        LoggerService.error("Redis initial connect error", {
+          error: err?.message || err
+        });
+        this.connectPromise = null;
+        throw err;
+      });
+    }
+    return await this.connectPromise;
+  }
+  getClient() {
+    return this.client;
+  }
+  async disconnect() {
+    if (this.client.isOpen) {
+      await this.client.quit();
+      LoggerService.info("Redis disconnected");
+    }
+  }
+  isConnected() {
+    return this.client.isOpen;
+  }
+};
+var redis_client_default = RedisClient.getInstance();
+
+// src/modules/cache/cacheService.ts
+var import_inversify = require("inversify");
+var CacheService = class {
+  constructor() {
+    this.client = redis_client_default.getClient();
+  }
+  async setValue(key, value, ttlInSeconds) {
+    const payload = JSON.stringify(value);
+    if (ttlInSeconds && ttlInSeconds > 0) {
+      await this.client.setEx(key, ttlInSeconds, payload);
+      return;
+    }
+    const result = await this.client.set(key, payload);
+    return result === null ? void 0 : result;
+  }
+  async getValue(key) {
+    const result = await this.client.get(key);
+    return result ? JSON.parse(result) : null;
+  }
+  async deleteValue(key) {
+    await this.client.del(key);
+  }
+  async hSet(key, hash) {
+    return this.client.hSet(key, hash);
+  }
+  async hmGet(key, ...fields) {
+    return this.client.hmGet(key, fields);
+  }
+  async hGetAll(key) {
+    return this.client.hGetAll(key);
+  }
+  async expire(key, ttlSeconds) {
+    return this.client.expire(key, ttlSeconds);
+  }
+  async sAdd(key, ...members) {
+    return this.client.sAdd(key, members);
+  }
+  async sMembers(key) {
+    return this.client.sMembers(key);
+  }
+  async sRem(key, ...members) {
+    return this.client.sRem(key, members);
+  }
+  async sCard(key) {
+    return this.client.sCard(key);
+  }
+  async del(...keys) {
+    return this.client.del(keys);
+  }
+  multi() {
+    return this.client.multi();
+  }
+};
+CacheService = __decorateClass([
+  (0, import_inversify.injectable)()
+], CacheService);
+
+// src/modules/cache/cacheController.ts
+var import_inversify2 = require("inversify");
+
+// src/inversify.types.ts
+var TYPES = {
+  CacheService: /* @__PURE__ */ Symbol.for("CacheService"),
+  CacheController: /* @__PURE__ */ Symbol.for("CacheController"),
+  SsoController: /* @__PURE__ */ Symbol.for("SsoController"),
+  SsoService: /* @__PURE__ */ Symbol.for("SsoService")
+};
+
+// src/types/cache.types.ts
+var REQUIRED_BIN_NAMES = ["bin1", "bin2", "bin3", "bin4", "bin5"];
+
+// src/modules/cache/cacheController.ts
+var SET_NAME_PREFIX = process.env.SCRIPT_SET_NAME_PREFIX ?? "scriptSet";
+var DEFAULT_EXPIRE_TIME_MS = Number(
+  process.env.SCRIPT_PUT_CACHE_EXPIRE_TIME_MS ?? 6e5
+);
+var CacheController = class {
+  constructor(cacheService) {
+    this.cacheService = cacheService;
+  }
+  async putScriptRecord(setName, key, record, ttlSeconds) {
+    for (const bin of REQUIRED_BIN_NAMES) {
+      if (typeof record[bin] === "undefined") {
+        throw new Error(`Field ${bin} is required`);
+      }
+    }
+    const safeRecord = {};
+    for (const bin of REQUIRED_BIN_NAMES) {
+      const value = record[bin];
+      if (typeof value !== "string") {
+        throw new Error(`Invalid value for ${bin}`);
+      }
+      safeRecord[bin] = value;
+    }
+    const redisKey = `${setName}:${key}`;
+    const ttl = typeof ttlSeconds === "number" ? ttlSeconds : Math.floor(DEFAULT_EXPIRE_TIME_MS / 1e3);
+    const multi = this.cacheService.multi();
+    const entries = Object.entries(safeRecord);
+    if (!entries.length) {
+      throw new Error("No record found to store in Redis");
+    }
+    for (const [field, value] of entries) {
+      multi.hSet(redisKey, field, value);
+    }
+    if (ttl > 0) {
+      multi.expire(redisKey, ttl);
+    }
+    for (const bin of REQUIRED_BIN_NAMES) {
+      const value = safeRecord[bin];
+      if (value) {
+        multi.sAdd(`index:${setName}:${bin}:${value}`, redisKey);
+      }
+    }
+    multi.sAdd(`set:${setName}:keys`, redisKey);
+    await multi.exec();
+    return { redisKey, ttl };
+  }
+  async getScriptRecord(setName, key) {
+    const redisKey = `${setName}:${key}`;
+    const values = await this.cacheService.hmGet(redisKey, ...REQUIRED_BIN_NAMES);
+    if (!values || values.every((v) => v === null)) {
+      return null;
+    }
+    const record = {};
+    REQUIRED_BIN_NAMES.forEach((bin, i) => {
+      record[bin] = values[i];
+    });
+    return record;
+  }
+  async equalScriptRecordsWithIndex(setName, binName, value) {
+    const indexKey = this.buildIndexKey(setName, binName, value);
+    const redisKeys = await this.cacheService.sMembers(indexKey);
+    if (!redisKeys.length) {
+      return [];
+    }
+    const multi = this.cacheService.multi();
+    for (const key of redisKeys) {
+      multi.hGetAll(key);
+    }
+    const responses = await multi.exec();
+    if (!responses) {
+      throw new Error("Pipeline execution failed");
+    }
+    return responses.map((record, idx) => {
+      const formattedRecord = {};
+      REQUIRED_BIN_NAMES.forEach((bin) => {
+        formattedRecord[bin] = record[bin] ?? null;
+      });
+      return {
+        redisKey: redisKeys[idx],
+        record: formattedRecord
+      };
+    });
+  }
+  async countScriptRecordsWithIndex(setName, binName, value) {
+    return this.cacheService.sCard(this.buildIndexKey(setName, binName, value));
+  }
+  async deleteScriptRecord(setName, key) {
+    const redisKey = `${setName}:${key}`;
+    const hash = await this.cacheService.hGetAll(redisKey);
+    if (!hash || !Object.keys(hash).length) {
+      return false;
+    }
+    const multi = this.cacheService.multi();
+    multi.del(redisKey);
+    for (const bin of REQUIRED_BIN_NAMES) {
+      const value = hash[bin];
+      if (value) {
+        multi.sRem(this.buildIndexKey(setName, bin, value), redisKey);
+      }
+    }
+    multi.sRem(`set:${setName}:keys`, redisKey);
+    await multi.exec();
+    return true;
+  }
+  async createBaseStructureForScript(totalSets = 5) {
+    const multi = this.cacheService.multi();
+    for (let s = 1; s <= totalSets; s++) {
+      const setName = `${SET_NAME_PREFIX}${s}`;
+      const keyStr = `${setName}_key`;
+      const redisKey = `${setName}:${keyStr}`;
+      const hashMap = {};
+      for (const bin of REQUIRED_BIN_NAMES) {
+        hashMap[bin] = "DUMMY";
+      }
+      for (const [field, val] of Object.entries(hashMap)) {
+        multi.hSet(redisKey, field, val);
+      }
+      multi.sAdd(`set:${setName}:keys`, redisKey);
+      for (const bin of REQUIRED_BIN_NAMES) {
+        multi.sAdd(this.buildIndexKey(setName, bin, hashMap[bin]), redisKey);
+      }
+    }
+    await multi.exec();
+  }
+  async setValue(key, value, ttlInSeconds) {
+    return this.cacheService.setValue(key, value, ttlInSeconds);
+  }
+  async getValue(key) {
+    return this.cacheService.getValue(key);
+  }
+  async deleteValue(key) {
+    await this.cacheService.deleteValue(key);
+  }
+  buildIndexKey(setName, binName, value) {
+    return `index:${setName}:${binName}:${value}`;
+  }
+};
+CacheController = __decorateClass([
+  (0, import_inversify2.injectable)(),
+  __decorateParam(0, (0, import_inversify2.inject)(TYPES.CacheService))
+], CacheController);
+
+// src/modules/sso/sso.controller.ts
+var import_inversify4 = require("inversify");
+var SsoController = class {
+  constructor(ssoService) {
+    this.ssoService = ssoService;
+  }
+  async getUserByAccesstoken(AccessToken) {
+    const getData = await this.ssoService.getUserByAccesstoken(AccessToken);
+    return getData;
+  }
+  async getUserByIdentity(identity, identityType) {
+    return await this.ssoService.getUserByIdentity(identity, identityType);
+  }
+};
+SsoController = __decorateClass([
+  (0, import_inversify4.injectable)(),
+  __decorateParam(0, (0, import_inversify4.inject)(TYPES.SsoService))
+], SsoController);
+
+// src/modules/sso/sso.service.ts
+var import_inversify6 = require("inversify");
+var SsoService = class {
+  async getUserByAccesstoken(AccessToken) {
+    let data = null;
+    try {
+      const response = await fetch(`${process.env.SsoUrl}/users`, {
+        method: "GET",
+        headers: {
+          "accept": "application/json",
+          "Accept-Language": "en",
+          "Authorization": `Bearer ${AccessToken}`
+        }
+      });
+      data = await response.json();
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      return {
+        data,
+        error: false,
+        errorMessage: ""
+      };
+    } catch (error) {
+      return {
+        data,
+        error: true,
+        errorMessage: error.message
+      };
+    }
+  }
+  async getUserByIdentity(identity, identityType) {
+    const url = `http://sso-sandbox.sandpod.ir/social/POD/users/${identity}?identityType=${identityType}`;
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "accept": "application/json",
+          "Accept-Language": "en",
+          "Authorization": `Bearer  ${process.env.AuthToken}`
+        }
+      });
+      const data = JSON.parse(await response.text());
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status} and error is ${data}`);
+      }
+      return {
+        data,
+        error: false,
+        errorMessage: ""
+      };
+    } catch (error) {
+      return {
+        data: null,
+        error: true,
+        errorMessage: error
+      };
+    }
+  }
+};
+SsoService = __decorateClass([
+  (0, import_inversify6.injectable)()
+], SsoService);
+
+// src/inversify.container.ts
+function createContainer(_options = {}) {
+  const container = new import_inversify7.Container();
+  container.bind(TYPES.CacheService).to(CacheService).inSingletonScope();
+  container.bind(TYPES.SsoService).to(SsoService).inSingletonScope();
+  container.bind(TYPES.CacheController).to(CacheController).inSingletonScope();
+  container.bind(TYPES.SsoController).to(SsoController).inSingletonScope();
+  return container;
+}
+
+// src/service-call-library.ts
+var ServiceCallLibrary = class {
+  constructor(options = {}) {
+    this.ready = null;
+    this.container = createContainer(options);
+    this.ssoController = this.container.get(TYPES.SsoController);
+    this.cacheController = this.container.get(TYPES.CacheController);
+  }
+  async init() {
+    if (!this.ready) {
+      this.ready = this.bootstrap();
+    }
+    await this.ready;
+  }
+  async bootstrap() {
+    await redis_client_default.connect();
+    const { default: initZookeeper } = await Promise.resolve().then(() => (init_zookeeper(), zookeeper_exports));
+    await initZookeeper();
+  }
+  get sso() {
+    return this.ssoController;
+  }
+  get cache() {
+    return this.cacheController;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServiceCallLibrary,
+  TYPES
+});
+//# sourceMappingURL=index.cjs.map