@okf/ootils 1.5.6 → 1.6.0

package/dist/node.js

@@ -165,16 +165,11 @@ var init_Annotations = __esm({
   }
 });
 
-// src/models/PlatformConfigs.ts
-var PlatformConfigs_exports = {};
-__export(PlatformConfigs_exports, {
-  default: () => PlatformConfigs_default
-});
-var import_mongoose2, platformConfigTypes, PlatformConfigsSchema, PlatformConfigs_default;
-var init_PlatformConfigs = __esm({
-  "src/models/PlatformConfigs.ts"() {
+// src/models/PlatformConfigs/platformConfigTypes.ts
+var platformConfigTypes;
+var init_platformConfigTypes = __esm({
+  "src/models/PlatformConfigs/platformConfigTypes.ts"() {
     "use strict";
-    import_mongoose2 = __toESM(require("mongoose"));
     platformConfigTypes = [
       "roles",
       "nav",
@@ -184,6 +179,20 @@ var init_PlatformConfigs = __esm({
       "theme",
       "ai"
     ];
+  }
+});
+
+// src/models/PlatformConfigs/index.ts
+var PlatformConfigs_exports = {};
+__export(PlatformConfigs_exports, {
+  default: () => PlatformConfigs_default
+});
+var import_mongoose2, PlatformConfigsSchema, PlatformConfigs_default;
+var init_PlatformConfigs = __esm({
+  "src/models/PlatformConfigs/index.ts"() {
+    "use strict";
+    import_mongoose2 = __toESM(require("mongoose"));
+    init_platformConfigTypes();
     PlatformConfigsSchema = new import_mongoose2.default.Schema(
       {
         type: {
@@ -583,46 +592,16 @@ var require_ElasticSearchConnector = __commonJS({
   }
 });
 
-// src/db/getDbByTenant.js
-var getDbByTenant_exports = {};
-__export(getDbByTenant_exports, {
-  getDbByTenant: () => getDbByTenant
-});
-var import_mongoose4, import_MongoConnector, getDbByTenant;
-var init_getDbByTenant = __esm({
-  "src/db/getDbByTenant.js"() {
-    "use strict";
-    import_mongoose4 = require("mongoose");
-    import_MongoConnector = __toESM(require_MongoConnector());
-    getDbByTenant = ({
-      tenant,
-      env: _env
-    }) => {
-      if (!tenant) throw new Error("tenant id has not been provided");
-      const env = _env || import_MongoConnector.MongoConnector.getEnv();
-      const dbConfigs = import_MongoConnector.MongoConnector.getDbConfigs();
-      const clusterConnections = import_MongoConnector.MongoConnector.getClusterConnections();
-      const { CLUSTER_NAME } = dbConfigs[env];
-      const dbName = `${tenant}_${env}`;
-      const connection = clusterConnections[CLUSTER_NAME];
-      if (!connection) {
-        throw new Error(`Connection not found for cluster: ${CLUSTER_NAME}`);
-      }
-      return connection.useDb(dbName, { useCache: true });
-    };
-  }
-});
-
 // src/models/AIChat.ts
-var import_mongoose5, AIChatSchema, AIChat_default;
+var import_mongoose4, AIChatSchema, AIChat_default;
 var init_AIChat = __esm({
   "src/models/AIChat.ts"() {
     "use strict";
-    import_mongoose5 = __toESM(require("mongoose"));
+    import_mongoose4 = __toESM(require("mongoose"));
     init_Annotations();
-    AIChatSchema = new import_mongoose5.default.Schema(
+    AIChatSchema = new import_mongoose4.default.Schema(
       {
-        userId: { type: import_mongoose5.default.Schema.Types.ObjectId, index: { unique: true } },
+        userId: { type: import_mongoose4.default.Schema.Types.ObjectId, index: { unique: true } },
         createdAt: Date,
         lastAcitivity: Date,
         messages: [
@@ -675,13 +654,43 @@ var init_models = __esm({
   }
 });
 
+// src/db/getDbByTenant.js
+var getDbByTenant_exports = {};
+__export(getDbByTenant_exports, {
+  getDbByTenant: () => getDbByTenant
+});
+var import_mongoose5, import_MongoConnector, getDbByTenant;
+var init_getDbByTenant = __esm({
+  "src/db/getDbByTenant.js"() {
+    "use strict";
+    import_mongoose5 = require("mongoose");
+    import_MongoConnector = __toESM(require_MongoConnector());
+    getDbByTenant = ({
+      tenant,
+      env: _env
+    }) => {
+      if (!tenant) throw new Error("tenant id has not been provided");
+      const env = _env || import_MongoConnector.MongoConnector.getEnv();
+      const dbConfigs = import_MongoConnector.MongoConnector.getDbConfigs();
+      const clusterConnections = import_MongoConnector.MongoConnector.getClusterConnections();
+      const { CLUSTER_NAME } = dbConfigs[env];
+      const dbName = `${tenant}_${env}`;
+      const connection = clusterConnections[CLUSTER_NAME];
+      if (!connection) {
+        throw new Error(`Connection not found for cluster: ${CLUSTER_NAME}`);
+      }
+      return connection.useDb(dbName, { useCache: true });
+    };
+  }
+});
+
 // src/db/getModelByTenant.js
 var require_getModelByTenant = __commonJS({
   "src/db/getModelByTenant.js"(exports2, module2) {
     "use strict";
     var { getDbByTenant: getDbByTenant2 } = (init_getDbByTenant(), __toCommonJS(getDbByTenant_exports));
     var { AIChatSchema: AIChatSchema2, AnnotationSchema: AnnotationSchema2, PlatformConfigsSchema: PlatformConfigsSchema2, TplSchema: TplSchema2 } = (init_models(), __toCommonJS(models_exports));
-    var getModelByTenant2 = ({ tenant, modelName, schema, env }) => {
+    var getModelByTenant3 = ({ tenant, modelName, schema, env }) => {
       if (!tenant) {
         throw new Error("tenant id has not been provided");
       }
@@ -691,32 +700,32 @@ var require_getModelByTenant = __commonJS({
       }
       return db.model(modelName);
     };
-    var getAnnotationsModelByTenant2 = ({ tenant, env, mongodb, dbConfigs, modelName }) => getModelByTenant2({
+    var getAnnotationsModelByTenant2 = ({ tenant, env, mongodb, dbConfigs, modelName }) => getModelByTenant3({
       tenant,
       modelName: modelName || "annotations",
       schema: AnnotationSchema2,
       env
     });
-    var getPlatformConfigsModelByTenant2 = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant2({
+    var getPlatformConfigsModelByTenant2 = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant3({
       tenant,
       modelName: "platformConfigs",
       schema: PlatformConfigsSchema2,
       env
     });
-    var getTplModelByTenant2 = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant2({
+    var getTplModelByTenant2 = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant3({
       tenant,
       modelName: "tpl",
       schema: TplSchema2,
       env
     });
-    var getAIChatModelByTenant2 = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant2({
+    var getAIChatModelByTenant2 = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant3({
       tenant,
       modelName: "aiChat",
       schema: AIChatSchema2,
       env
     });
     module2.exports = {
-      getModelByTenant: getModelByTenant2,
+      getModelByTenant: getModelByTenant3,
       getAIChatModelByTenant: getAIChatModelByTenant2,
       getAnnotationsModelByTenant: getAnnotationsModelByTenant2,
       getPlatformConfigsModelByTenant: getPlatformConfigsModelByTenant2,
@@ -1253,10 +1262,10 @@ var init_GLOBAL_BULLMQ_CONFIG = __esm({
 var require_GET_GLOBAL_BULLMQ_CONFIG = __commonJS({
   "src/bullmq/GET_GLOBAL_BULLMQ_CONFIG.js"(exports2, module2) {
     "use strict";
-    var { default: Redis } = require("ioredis");
+    var { default: Redis2 } = require("ioredis");
     var { BASE_BULLMQ_CONFIG: BASE_BULLMQ_CONFIG2 } = (init_GLOBAL_BULLMQ_CONFIG(), __toCommonJS(GLOBAL_BULLMQ_CONFIG_exports));
     function GET_GLOBAL_BULLMQ_CONFIG2({ env, redisCredentials }) {
-      const redisConnectionForBullMQ = new Redis({
+      const redisConnectionForBullMQ = new Redis2({
         host: redisCredentials.REDIS_HOST,
         port: redisCredentials.REDIS_PORT,
         password: redisCredentials.REDIS_PASSWORD,
@@ -1295,21 +1304,18 @@ __export(node_exports, {
   MongoConnector: () => import_MongoConnector2.MongoConnector,
   PlatformConfigsSchema: () => PlatformConfigs_default,
   ProducerManager: () => import_ProducerManager.ProducerManager,
+  RedisCacheConnector: () => RedisCacheConnector,
   TplSchema: () => Tpl_default,
   WorkerManager: () => import_WorkerManager.WorkerManager,
-  connectToRedis: () => connectToRedis,
   deleteVal: () => deleteVal,
   extractAllBlocksFromTpl: () => extractAllBlocksFromTpl,
   genTagId: () => genTagId,
-  getAIChatModelByTenant: () => import_getModelByTenant.getAIChatModelByTenant,
-  getAIConfigs: () => getAIConfigs,
-  getAnnotationsModelByTenant: () => import_getModelByTenant.getAnnotationsModelByTenant,
+  getAIChatModelByTenant: () => import_getModelByTenant2.getAIChatModelByTenant,
+  getAnnotationsModelByTenant: () => import_getModelByTenant2.getAnnotationsModelByTenant,
   getDbByTenant: () => getDbByTenant,
-  getModelByTenant: () => import_getModelByTenant.getModelByTenant,
-  getPlatformConfigsModelByTenant: () => import_getModelByTenant.getPlatformConfigsModelByTenant,
-  getRedisClient: () => getRedisClient,
-  getTpl: () => getTpl,
-  getTplModelByTenant: () => import_getModelByTenant.getTplModelByTenant,
+  getModelByTenant: () => import_getModelByTenant2.getModelByTenant,
+  getPlatformConfigsModelByTenant: () => import_getModelByTenant2.getPlatformConfigsModelByTenant,
+  getTplModelByTenant: () => import_getModelByTenant2.getTplModelByTenant,
   getVal: () => getVal,
   initializeGlobalConfig: () => initializeGlobalConfig,
   recursivelyExtractBlocks: () => _recursExtractBlocks,
@@ -1597,6 +1603,319 @@ var _extractBlocksFromSomeBuilders = ({
 // src/node.ts
 var import_MongoConnector2 = __toESM(require_MongoConnector());
 var import_ElasticSearchConnector = __toESM(require_ElasticSearchConnector());
+
+// src/RedisCacheConnector.js
+var import_ioredis = __toESM(require("ioredis"));
+init_models();
+var import_getModelByTenant = __toESM(require_getModelByTenant());
+init_platformConfigTypes();
+var BASE_SETTINGS_FOR_CONFIGS_CACHE = [
+  {
+    modelName: "tpl",
+    collectionName: "tpls",
+    schema: Tpl_default,
+    defaultQuery: [
+      {
+        status: {
+          $ne: "unpublished"
+        }
+      },
+      {
+        drafts: 0
+      }
+    ],
+    typeKey: "kp_content_type"
+  },
+  {
+    modelName: "platformConfigs",
+    collectionName: "platformConfigs",
+    schema: PlatformConfigs_default,
+    defaultQuery: [],
+    typeKey: "type"
+  }
+];
+var RedisCacheConnector = class _RedisCacheConnector {
+  constructor(options = {}) {
+    /**
+     * Initialize Redis client
+     */
+    __publicField(this, "connect", async () => {
+      try {
+        this.client = new import_ioredis.default({
+          host: this.host,
+          port: this.port,
+          password: this.password
+        });
+        this.client.on("connect", () => {
+          console.log("\u2705 Connected to our redis cache instance!");
+        });
+        await new Promise((resolve, reject) => {
+          this.client.on("ready", resolve);
+          this.client.on("error", reject);
+        });
+        return this.client;
+      } catch (err) {
+        console.error(err.message);
+        process.exit(1);
+      }
+    });
+    if (_RedisCacheConnector.instance) {
+      throw new Error(
+        "RedisCacheConnector instance already exists. Use RedisCacheConnector.getInstance() instead."
+      );
+    }
+    this.client = null;
+    this.host = options.host;
+    this.env = options.env;
+    this.port = options.port;
+    this.password = options.password;
+    _RedisCacheConnector.instance = this;
+    if (!this.host) {
+      throw new Error("Host must be provided in constructor options");
+    }
+    if (!this.port) {
+      throw new Error("Port must be provided in constructor options");
+    }
+    if (!this.password) {
+      throw new Error("Password must be provided in constructor options");
+    }
+    if (!this.env) {
+      throw new Error("Env must be provided in constructor options");
+    }
+  }
+  static getEnv() {
+    if (!_RedisCacheConnector.instance) {
+      throw new Error("RedisCacheConnector not initialized");
+    }
+    return _RedisCacheConnector.instance.env;
+  }
+  // Static method to get the instance
+  static getInstance() {
+    if (!_RedisCacheConnector.instance) {
+      throw new Error("RedisCacheConnector not initialized");
+    }
+    return _RedisCacheConnector.instance;
+  }
+  // Static method to get the client
+  static getClient() {
+    if (!_RedisCacheConnector.instance || !_RedisCacheConnector.instance.client) {
+      throw new Error(
+        "RedisCacheConnector not initialized or client not connected"
+      );
+    }
+    return _RedisCacheConnector.instance.client;
+  }
+  /**
+   * Find documents in Redis cache
+   * @param {Object} params - Search parameters
+   * @param {string} params.tenant - The tenant identifier
+   * @param {'platformConfigs'|'tpl'} params.modelName - The collection to search in
+   * @param {string} [params.type] - When modelName='platformConfigs': one of platformConfigTypes array values; when modelName='tpl': content type string. If omitted, returns all documents for the collection.
+   * @returns {Promise<Array>} Array of matching documents
+   * @see {platformConfigTypes} for valid platformConfigs type values
+   */
+  static async findConfigsInCache({ tenant, modelName, type }) {
+    try {
+      const client = this.getClient();
+      const environment = this.getEnv();
+      const keyPrefix = `${environment}:${tenant}:${modelName}:`;
+      const keys = await client.keys(`${keyPrefix}${type || "*"}`);
+      if (keys.length === 0) {
+        const { schema, typeKey } = BASE_SETTINGS_FOR_CONFIGS_CACHE.find(
+          (obj) => obj.modelName === modelName
+        );
+        const model = (0, import_getModelByTenant.getModelByTenant)({
+          tenant,
+          env: environment,
+          modelName,
+          schema
+        });
+        let findQuery = {};
+        if (type) {
+          findQuery = { [typeKey]: type };
+        }
+        const data = await model.find(findQuery);
+        await Promise.all(
+          data.map(
+            (doc) => this.setOneConfigInCache({
+              tenant,
+              modelName,
+              type: doc[typeKey],
+              val: doc
+            })
+          )
+        );
+        return data;
+      }
+      const cachedDocs = await Promise.all(
+        keys.map(async (key) => {
+          const value = await client.get(key);
+          return JSON.parse(value);
+        })
+      );
+      return cachedDocs;
+    } catch (error) {
+      console.error("Error in findConfigsInCache:", error);
+      throw error;
+    }
+  }
+  /**
+   * Find a single document in Redis cache (returns first match)
+   * @param {Object} params - Search parameters
+   * @param {string} params.tenant - The tenant identifier
+   * @param {'platformConfigs'|'tpl'} params.modelName - The collection to search in
+   * @param {string} [params.type] - When modelName='platformConfigs': one of platformConfigTypes array values; when modelName='tpl': content type string. If omitted, returns first document of any type.
+   * @returns {Promise<Object|undefined>} First matching document or undefined if none found
+   * @see {platformConfigTypes} for valid platformConfigs type values
+   */
+  static async findOneConfigInCache({ tenant, modelName, type }) {
+    const cacheData = await this.findConfigsInCache({
+      tenant,
+      modelName,
+      type
+    });
+    return cacheData?.[0];
+  }
+  /**
+   * Generate Redis key for config caching
+   * @private
+   * @param {Object} params - Parameters for key generation
+   * @param {string} params.tenant - The tenant identifier
+   * @param {'platformConfigs'|'tpl'} params.modelName - The model/collection name
+   * @param {string} params.type - The document type
+   * @param {string} [params.env] - Environment (defaults to current env)
+   * @returns {string} The Redis key
+   */
+  static _getRedisKeyForConfig({ tenant, modelName, type, env }) {
+    const environment = env || this.getEnv();
+    return `${environment}:${tenant}:${modelName}:${type}`;
+  }
+  /**
+   * Set a single config document in Redis cache
+   * @param {Object} params - Cache parameters
+   * @param {string} params.tenant - The tenant identifier
+   * @param {'platformConfigs'|'tpl'} params.modelName - The model/collection name
+   * @param {string} params.type - When modelName='platformConfigs': one of platformConfigTypes array values; when modelName='tpl': content type string
+   * @param {Object} params.val - The value to cache
+   * @param {string} [params.env] - Environment (defaults to current env)
+   * @returns {Promise<void>}
+   * @see {platformConfigTypes} for valid platformConfigs type values
+   */
+  static async setOneConfigInCache({ tenant, modelName, type, val, env }) {
+    const client = this.getClient();
+    const cacheKey = this._getRedisKeyForConfig({
+      tenant,
+      modelName,
+      type,
+      env
+    });
+    await client.set(cacheKey, JSON.stringify(val));
+  }
+  /**
+   * Invalidate (delete) a config from Redis cache and optionally set a new value
+   * @param {Object} params - Cache parameters
+   * @param {string} params.tenant - The tenant identifier
+   * @param {'platformConfigs'|'tpl'} params.modelName - The model/collection name
+   * @param {string} params.type - When modelName='platformConfigs': one of platformConfigTypes array values; when modelName='tpl': content type string
+   * @param {Object} [params.newVal] - New value to set after deletion
+   * @param {string} [params.env] - Environment (defaults to current env)
+   * @returns {Promise<void>}
+   * @see {platformConfigTypes} for valid platformConfigs type values
+   * @note According to the current usecases this function is called only after a database operation.
+   * We should include this function call within the MongoDB transaction.
+   * Otherwise, if the database operation succeeds but cache deletion fails, the cache will hold the outdated data.
+   * We can ignore setAsync failure as we are checking db also if cache is not present (inside findInCache function)
+   */
+  static async invalidateOneConfigInCache({
+    tenant,
+    modelName,
+    type,
+    newVal,
+    env
+  }) {
+    const client = this.getClient();
+    const cacheKey = this._getRedisKeyForConfig({
+      tenant,
+      modelName,
+      type,
+      env
+    });
+    await client.del(cacheKey);
+    if (newVal) {
+      try {
+        await client.set(cacheKey, JSON.stringify(newVal));
+      } catch (err) {
+        console.log("invalidateCache - Cache set failed: ", err);
+      }
+    }
+  }
+  /**
+   * Load all collections and templates into Redis cache for all tenants
+   * Clears existing cache and rebuilds it from database
+   * @returns {Promise<void>}
+   * @param {string} [params.tenant] - Tenant (either a single tenant or an array of tenants for whom the config cache should be refreshed)
+   * @static
+   */
+  static async loadTplsAndPlatformConfigsToCache({ tenant }) {
+    try {
+      const client = this.getClient();
+      const environment = this.getEnv();
+      if (!tenant) throw new Error("No tenant/s defined to recache");
+      console.log(`Loading configs and templates into cache...`);
+      const tenantCollectionPromises = toArray(tenant).map(async (tenant2) => {
+        return Promise.all(
+          BASE_SETTINGS_FOR_CONFIGS_CACHE.map(
+            async ({ modelName, schema, defaultQuery, typeKey }) => {
+              const model = (0, import_getModelByTenant.getModelByTenant)({
+                tenant: tenant2,
+                env: environment,
+                modelName,
+                schema
+              });
+              const keys = await client.keys(
+                `${environment}:${tenant2}:${modelName}:*`
+              );
+              if (keys.length) await client.del(keys);
+              const documents = await model.find(...defaultQuery);
+              await Promise.all(
+                documents.map(async (doc) => {
+                  const type = doc[typeKey];
+                  await this.setOneConfigInCache({
+                    tenant: tenant2,
+                    modelName,
+                    type,
+                    val: doc
+                  });
+                })
+              );
+              console.log(
+                `Successfully cached ${documents.length} documents from ${modelName} for tenant: ${tenant2} | env: ${environment}`
+              );
+            }
+          )
+        );
+      });
+      await Promise.all(tenantCollectionPromises);
+      console.log(`Finished caching for all tenants`);
+    } catch (error) {
+      console.error("Error in loadTplsAndPlatformConfigsToCache: ", error);
+      throw error;
+    }
+  }
+  /**
+   * Close the Redis client
+   */
+  async close() {
+    if (this.client) {
+      await this.client.quit();
+      console.log("\u2705 Redis client closed");
+      this.client = null;
+    }
+  }
+};
+RedisCacheConnector.instance = null;
+
+// src/node.ts
 init_getDbByTenant();
 
 // src/db/getGlobalConfig.ts
@@ -1621,119 +1940,7 @@ var updateGlobalConfig = (updates) => {
 };
 
 // src/node.ts
-var import_getModelByTenant = __toESM(require_getModelByTenant());
-
-// src/redis/functions.ts
-init_getDbByTenant();
-
-// src/redis/index.ts
-var import_ioredis = __toESM(require("ioredis"));
-var redisClient = null;
-var REDIS_CONFIG = {
-  port: Number(process.env.REDIS_PORT),
-  host: process.env.REDIS_HOST || "",
-  username: process.env.REDIS_USERNAME || "",
-  password: process.env.REDIS_PASSWORD || ""
-};
-var connectToRedis = async () => {
-  try {
-    redisClient = new import_ioredis.default(REDIS_CONFIG);
-    await redisClient.ping();
-    console.log("Redis connected successfully");
-  } catch (error) {
-    console.error(
-      "Redis connection failed:",
-      error instanceof Error && error.message
-    );
-    if (redisClient) {
-      redisClient.disconnect();
-    }
-    throw error;
-  }
-};
-var getRedisClient = () => {
-  if (!redisClient) {
-    throw new Error("Redis client not initialized. Call connectToRedis first.");
-  }
-  return redisClient;
-};
-
-// src/redis/functions.ts
-var findInCache = async ({
-  tenant,
-  modelName,
-  type,
-  query = {}
-}) => {
-  const key = `${process.env.ENV}:${tenant}:${modelName}:${type}`;
-  try {
-    const redisClient2 = getRedisClient();
-    const value = await redisClient2.get(key);
-    if (value) {
-      return JSON.parse(value);
-    }
-  } catch (error) {
-    console.warn(
-      `redis read failed for key ${key}`,
-      error instanceof Error && error.message
-    );
-  }
-  try {
-    const collection = getDbByTenant({
-      tenant,
-      env: process.env.ENV
-    }).collection(modelName);
-    const value = await collection.findOne(query);
-    if (!value) {
-      throw new Error(`${type} value not found in ${modelName} for ${tenant}`);
-    }
-    try {
-      const redisClient2 = getRedisClient();
-      await redisClient2.set(key, JSON.stringify(value));
-    } catch (error) {
-      console.warn(
-        `redis write failed for key ${key}:`,
-        error instanceof Error && error.message
-      );
-    }
-    return value;
-  } catch (error) {
-    throw new Error(
-      `db read failed:  ${error instanceof Error && error.message}`
-    );
-  }
-};
-var getTpl = async ({ name, tenant }) => {
-  if (!name || !tenant) {
-    throw new Error("Missing required parameters: name or tenant");
-  }
-  return await findInCache({
-    modelName: "tpl",
-    type: name,
-    tenant,
-    query: {
-      kp_content_type: name,
-      status: { $in: ["published", "editPublished"] }
-    }
-  });
-};
-var getAIConfigs = async ({
-  tenant
-}) => {
-  if (!tenant) {
-    throw new Error("Missing required parameter: tenant");
-  }
-  return await findInCache({
-    modelName: "platformConfigs",
-    type: "ai",
-    tenant,
-    query: {
-      type: "ai"
-    }
-  });
-};
-
-// src/node.ts
+var import_getModelByTenant2 = __toESM(require_getModelByTenant());
 init_models();
 var import_WorkerManager = __toESM(require_WorkerManager());
 var import_ProducerManager = __toESM(require_ProducerManager());
@@ -1751,20 +1958,17 @@ var import_GET_GLOBAL_BULLMQ_CONFIG = __toESM(require_GET_GLOBAL_BULLMQ_CONFIG()
   MongoConnector,
   PlatformConfigsSchema,
   ProducerManager,
+  RedisCacheConnector,
   TplSchema,
   WorkerManager,
-  connectToRedis,
   deleteVal,
   extractAllBlocksFromTpl,
   genTagId,
   getAIChatModelByTenant,
-  getAIConfigs,
   getAnnotationsModelByTenant,
   getDbByTenant,
   getModelByTenant,
   getPlatformConfigsModelByTenant,
-  getRedisClient,
-  getTpl,
   getTplModelByTenant,
   getVal,
   initializeGlobalConfig,