@okf/ootils 1.3.10 → 1.4.0

package/dist/node.js

@@ -33,6 +33,613 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/models/Annotations.ts
+var Annotations_exports = {};
+__export(Annotations_exports, {
+  default: () => Annotations_default
+});
+var import_mongoose, AnnotationSchema, Annotations_default;
+var init_Annotations = __esm({
+  "src/models/Annotations.ts"() {
+    "use strict";
+    import_mongoose = require("mongoose");
+    AnnotationSchema = new import_mongoose.Schema(
+      {
+        // Tags section - dynamic structure for various tag categories
+        tags: {
+          type: Map,
+          of: new import_mongoose.Schema({
+            data: [
+              {
+                _id: { type: import_mongoose.Schema.Types.ObjectId },
+                display: String,
+                tagId: String
+              }
+            ],
+            collectionId: String
+          }, {
+            _id: false
+          })
+        },
+        // Meta information
+        meta: {
+          contentType: { type: String, required: true },
+          kp_contributed_by: {
+            type: import_mongoose.Schema.Types.ObjectId,
+            ref: "user"
+          },
+          valuePath: String,
+          documentId: {
+            type: import_mongoose.Schema.Types.ObjectId
+          }
+        },
+        // Main content data - using Schema.Types.Mixed for dynamic structure
+        main: {
+          type: import_mongoose.Schema.Types.Mixed,
+          default: {}
+        },
+        // Annotation specific details
+        annotations: {
+          tags: {
+            type: Map,
+            of: new import_mongoose.Schema({
+              collectionId: String,
+              data: [
+                {
+                  _id: { type: import_mongoose.Schema.Types.ObjectId },
+                  display: String,
+                  tagId: String
+                }
+              ]
+            }, {
+              _id: false
+            })
+          },
+          fragment: {
+            isLexical: Boolean,
+            editorState: Object,
+            allText: String
+          },
+          annoKey: String,
+          author: {
+            id: { type: import_mongoose.Schema.Types.ObjectId },
+            name: String
+          }
+        },
+        embeddings: Array,
+        contentEnhancedText: String,
+        // // Optional chunk related fields
+        // chunk: {
+        //   embeddings: Schema.Types.Mixed,
+        //   contentEnhancedText: String
+        // },
+        clusterId: String,
+        kp_date_published: Date,
+        createdAt: {
+          type: Date,
+          default: Date.now
+        },
+        updatedAt: {
+          type: Date,
+          default: Date.now
+        },
+        topicId: [{ type: import_mongoose.Schema.Types.ObjectId, ref: "generatedTopics" }],
+        translations: Object
+      },
+      {
+        timestamps: true,
+        toJSON: { virtuals: true },
+        toObject: { virtuals: true },
+        strict: false
+        // This allows for flexible document structure beyond the defined schema
+      }
+    );
+    AnnotationSchema.index({ "meta.contentType": 1 });
+    AnnotationSchema.index({ "meta.documentId": 1 });
+    AnnotationSchema.index({ createdAt: -1 });
+    AnnotationSchema.index({ "annotations.annoKey": 1 });
+    AnnotationSchema.index({ "kp_date_published": -1 });
+    AnnotationSchema.pre("save", function(next) {
+      this.updatedAt = /* @__PURE__ */ new Date();
+      next();
+    });
+    AnnotationSchema.methods.getMainField = function(fieldPath) {
+      if (!fieldPath) return null;
+      const parts = fieldPath.split(".");
+      let value = this.main;
+      for (const part of parts) {
+        if (!value || typeof value !== "object") return null;
+        value = value[part];
+      }
+      return value;
+    };
+    AnnotationSchema.virtual("displayTitle").get(function() {
+      return this.main?.title || "Untitled Annotation";
+    });
+    Annotations_default = AnnotationSchema;
+  }
+});
+
+// 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"() {
+    "use strict";
+    import_mongoose2 = __toESM(require("mongoose"));
+    platformConfigTypes = [
+      "roles",
+      "nav",
+      "deployment",
+      "userAgreement",
+      "localeData",
+      "theme",
+      "ai"
+    ];
+    PlatformConfigsSchema = new import_mongoose2.default.Schema(
+      {
+        type: {
+          type: String,
+          enum: platformConfigTypes,
+          unique: true
+        },
+        roles: Array,
+        data: Object
+      },
+      { collection: "platformConfigs" }
+    );
+    PlatformConfigs_default = PlatformConfigsSchema;
+  }
+});
+
+// src/models/Tpl.ts
+var Tpl_exports = {};
+__export(Tpl_exports, {
+  default: () => Tpl_default
+});
+var import_mongoose3, TplSchema, Tpl_default;
+var init_Tpl = __esm({
+  "src/models/Tpl.ts"() {
+    "use strict";
+    import_mongoose3 = __toESM(require("mongoose"));
+    TplSchema = new import_mongoose3.default.Schema({
+      dateFirstPublished: Date,
+      dateCreated: Date,
+      dateLastPublished: Date,
+      dateLastEdited: Date,
+      status: {
+        type: String,
+        default: "published",
+        // only cuz we dont want to go and add this property in all databases
+        enum: ["unpublished", "editPublished", "published"]
+      },
+      version: {
+        type: Number,
+        default: 0
+      },
+      versionPublishedBy: {
+        type: import_mongoose3.default.Schema.Types.ObjectId,
+        ref: "user"
+        // reference to the 'user' model
+      },
+      firstPublishedBy: {
+        type: import_mongoose3.default.Schema.Types.ObjectId,
+        ref: "user"
+        // reference to the 'user' model
+      },
+      kp_content_type: {
+        type: String,
+        required: true,
+        unique: true
+      },
+      category: {
+        //to deprecate and turn into 'layout'
+        type: String,
+        default: "knowledgeResources2"
+      },
+      kp_settings: [
+        {
+          type: Object
+        }
+      ],
+      kp_templates: {
+        type: Object
+      },
+      tplMeta: Object,
+      tplLocales: Object,
+      indexed: Object,
+      drafts: {
+        active: Object
+      },
+      rollbacks: Object,
+      //for 'remembering' hidden configurations
+      // OTHER CONFIGS
+      listing: Object,
+      //listing page configurations. this is new, currently only used in nct
+      general: {
+        content: {
+          title: String,
+          singular: String,
+          ctaText: String,
+          listingDesc: String
+        },
+        allowQuickTagCreation: { enable: Boolean },
+        segment: String,
+        settingsUIStyle: String,
+        hasUpdateType: Boolean,
+        annotation: {
+          enable: Boolean
+        },
+        participantModule: {
+          enable: Boolean
+        },
+        formFieldNumbering: {
+          enable: Boolean
+        },
+        postPblRedirPath: Object,
+        templateIndex: Object,
+        sharing: {
+          enable: Boolean,
+          trackShareCount: {
+            type: Boolean,
+            default: false
+          }
+        },
+        viewsCount: {
+          enable: {
+            type: Boolean,
+            default: false
+          }
+        },
+        comments: {
+          enable: Boolean
+        },
+        reactions: {
+          type: Map,
+          of: {
+            enable: Boolean,
+            icon: String
+          }
+        },
+        csvExport: {
+          enable: Boolean,
+          excludeFields: Array,
+          enableUpdateExport: Boolean,
+          fieldsToSortAtEnd: Array,
+          fetchBatches: {
+            enable: Boolean,
+            batchSize: Number
+          }
+        },
+        onboardingFlow: Object,
+        //only on profile tpls
+        selfServeSurveyConfig: Object,
+        //tci helpers - these exist only to show / not show certain UIs in the tci
+        disableKPSettings: Boolean
+      }
+      //general contenttype configs. mostly the stuff inside platformConfigs > contentTypes
+    }, {
+      toJSON: { virtuals: true },
+      // So `res.json()` and other `JSON.stringify()` functions include virtuals
+      toObject: { virtuals: true }
+      // So `toObject()` output includes virtuals
+    });
+    TplSchema.virtual("layout").get(function() {
+      return this.category;
+    });
+    Tpl_default = TplSchema;
+  }
+});
+
+// src/db/MongoConnector.js
+var require_MongoConnector = __commonJS({
+  "src/db/MongoConnector.js"(exports2, module2) {
+    "use strict";
+    var mongoose5 = require("mongoose");
+    var AnnotationsSchema = (init_Annotations(), __toCommonJS(Annotations_exports));
+    var PlatformConfigsSchema2 = (init_PlatformConfigs(), __toCommonJS(PlatformConfigs_exports));
+    var TplSchema2 = (init_Tpl(), __toCommonJS(Tpl_exports));
+    var MongoConnector3 = class _MongoConnector {
+      constructor(options) {
+        this.clusterConnections = {};
+        this.env = options.env;
+        this.dbConfigs = options.dbConfigs;
+        this.mongoOptions = options.mongoOptions || {
+          maxPoolSize: 20,
+          serverSelectionTimeoutMS: 5e3,
+          socketTimeoutMS: 45e3,
+          family: 4
+        };
+        _MongoConnector.instance = this;
+        if (!this.env) {
+          throw new Error("Environment must be provided in constructor options");
+        }
+        if (!this.dbConfigs) {
+          throw new Error("dbConfigs must be provided in constructor options");
+        }
+      }
+      /**
+       * Creates multiple MongoDB clusterConnections based on configuration (SYNCHRONOUS)
+       * @returns Object containing named database clusterConnections
+       */
+      multiConnectToMongoDB() {
+        const { connectTo } = this.dbConfigs[this.env];
+        if (!connectTo) {
+          throw new Error(
+            `No connection configuration found for environment: ${this.env}`
+          );
+        }
+        connectTo.forEach((connectToEnv) => {
+          const { CLUSTER_NAME, DB_URI } = this.dbConfigs[connectToEnv];
+          if (!CLUSTER_NAME || !DB_URI) {
+            throw new Error(
+              `Missing CLUSTER_NAME or DB_URI for environment: ${connectToEnv}`
+            );
+          }
+          this.clusterConnections[CLUSTER_NAME] = mongoose5.createConnection(
+            DB_URI,
+            this.mongoOptions
+          );
+          this.clusterConnections[CLUSTER_NAME].on("open", () => {
+            console.log(`\u2705 Mongoose connection open to ${CLUSTER_NAME}`);
+          });
+          this.clusterConnections[CLUSTER_NAME].on("error", (err) => {
+            console.error(
+              `\u274C Mongoose connection error: ${err.message} with connection info ${CLUSTER_NAME}`
+            );
+            process.exit(1);
+          });
+          this.clusterConnections[CLUSTER_NAME].on("disconnected", () => {
+            console.log(`\u{1F50C} Mongoose disconnected from ${CLUSTER_NAME}`);
+          });
+          this.clusterConnections[CLUSTER_NAME].on("reconnected", () => {
+            console.log(`\u{1F504} Mongoose reconnected to ${CLUSTER_NAME}`);
+          });
+        });
+        console.log(
+          `\u{1F389} Connected to ${Object.keys(this.clusterConnections).length} MongoDB databases`
+        );
+        return this.clusterConnections;
+      }
+      async multiConnectToMongoDBAsync() {
+        const { connectTo } = this.dbConfigs[this.env];
+        if (!connectTo) {
+          throw new Error(
+            `No connection configuration found for environment: ${this.env}`
+          );
+        }
+        await Promise.all(
+          connectTo.map(async (connectToEnv) => {
+            const { CLUSTER_NAME, DB_URI } = this.dbConfigs[connectToEnv];
+            if (!CLUSTER_NAME || !DB_URI) {
+              throw new Error(
+                `Missing CLUSTER_NAME or DB_URI for environment: ${connectToEnv}`
+              );
+            }
+            this.clusterConnections[CLUSTER_NAME] = await mongoose5.createConnection(
+              DB_URI,
+              this.mongoOptions
+            );
+            console.log(`Connected to MongoDB: ${CLUSTER_NAME}`);
+          })
+        );
+        return this.clusterConnections;
+      }
+      // Static method to get the full instance
+      static getInstance() {
+        if (!_MongoConnector.instance) {
+          throw new Error("MongoConnector not initialized");
+        }
+        return _MongoConnector.instance;
+      }
+      // Static method to get connections
+      static getClusterConnections() {
+        if (!_MongoConnector.instance) {
+          throw new Error("MongoConnector not initialized");
+        }
+        return _MongoConnector.instance.clusterConnections;
+      }
+      // Static method to get environment
+      static getEnv() {
+        if (!_MongoConnector.instance) {
+          throw new Error("MongoConnector not initialized");
+        }
+        return _MongoConnector.instance.env;
+      }
+      // Static method to get db configs
+      static getDbConfigs() {
+        if (!_MongoConnector.instance) {
+          throw new Error("MongoConnector not initialized");
+        }
+        return _MongoConnector.instance.dbConfigs;
+      }
+      /**
+       * Helper function to close clusterConnections object
+       */
+      async closeConnectionsObject(clusterConnections) {
+        const closePromises = Object.entries(clusterConnections).map(
+          async ([clusterName, connection]) => {
+            try {
+              if (connection.readyState === 1) {
+                await connection.close();
+                console.log(`\u2705 Closed MongoDB connection: ${clusterName}`);
+              }
+            } catch (error) {
+              console.error(
+                `\u274C Error closing MongoDB connection ${clusterName}:`,
+                error
+              );
+            }
+          }
+        );
+        await Promise.all(closePromises);
+      }
+      /**
+       * Graceful shutdown - close all MongoDB clusterConnections
+       */
+      async closeAllConnections() {
+        if (Object.keys(this.clusterConnections).length === 0) {
+          console.log("No active MongoDB cluster connections to close");
+          return;
+        }
+        console.log("\u{1F6D1} Closing MongoDB cluster connections gracefully...");
+        await this.closeConnectionsObject(this.clusterConnections);
+        this.clusterConnections = {};
+        console.log("\u{1F389} All MongoDB clusterConnections closed gracefully");
+      }
+    };
+    MongoConnector3.instance = null;
+    module2.exports = {
+      MongoConnector: MongoConnector3
+    };
+  }
+});
+
+// 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 init_AIChat = __esm({
+  "src/models/AIChat.ts"() {
+    "use strict";
+    import_mongoose5 = __toESM(require("mongoose"));
+    init_Annotations();
+    AIChatSchema = new import_mongoose5.default.Schema(
+      {
+        userId: { type: import_mongoose5.default.Schema.Types.ObjectId, index: { unique: true } },
+        createdAt: Date,
+        lastAcitivity: Date,
+        messages: [
+          {
+            id: String,
+            author: {
+              type: String,
+              enum: ["system", "user", "assistant"]
+            },
+            content: {
+              type: { type: String },
+              value: String
+            },
+            vectorSearchInfo: {
+              chunks: [Annotations_default]
+            },
+            args: {
+              query: String,
+              reframedQuery: String,
+              summary: Object
+            },
+            userFeedback: {
+              reaction: { type: String, enum: ["positive", "negative"] },
+              comments: String
+            }
+          }
+        ]
+      },
+      { collection: "aiChat" }
+    );
+    AIChat_default = AIChatSchema;
+  }
+});
+
+// src/models/index.ts
+var models_exports = {};
+__export(models_exports, {
+  AIChatSchema: () => AIChat_default,
+  AnnotationSchema: () => Annotations_default,
+  PlatformConfigsSchema: () => PlatformConfigs_default,
+  TplSchema: () => Tpl_default
+});
+var init_models = __esm({
+  "src/models/index.ts"() {
+    "use strict";
+    init_AIChat();
+    init_Annotations();
+    init_PlatformConfigs();
+    init_Tpl();
+  }
+});
+
+// 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 }) => {
+      if (!tenant) {
+        throw new Error("tenant id has not been provided");
+      }
+      const db = getDbByTenant2({ tenant, env });
+      if (!Object.keys(db.models).includes(modelName)) {
+        return db.model(modelName, schema);
+      }
+      return db.model(modelName);
+    };
+    var getAnnotationsModelByTenant2 = ({ tenant, env, mongodb, dbConfigs, modelName }) => getModelByTenant2({
+      tenant,
+      modelName: modelName || "annotations",
+      schema: AnnotationSchema2,
+      env
+    });
+    var getPlatformConfigsModelByTenant2 = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant2({
+      tenant,
+      modelName: "platformConfigs",
+      schema: PlatformConfigsSchema2,
+      env
+    });
+    var getTplModelByTenant2 = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant2({
+      tenant,
+      modelName: "tpl",
+      schema: TplSchema2,
+      env
+    });
+    var getAIChatModelByTenant2 = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant2({
+      tenant,
+      modelName: "aiChat",
+      schema: AIChatSchema2,
+      env
+    });
+    module2.exports = {
+      getModelByTenant: getModelByTenant2,
+      getAIChatModelByTenant: getAIChatModelByTenant2,
+      getAnnotationsModelByTenant: getAnnotationsModelByTenant2,
+      getPlatformConfigsModelByTenant: getPlatformConfigsModelByTenant2,
+      getTplModelByTenant: getTplModelByTenant2
+    };
+  }
+});
+
 // src/bullmq/WorkerManager.js
 var require_WorkerManager = __commonJS({
   "src/bullmq/WorkerManager.js"(exports2, module2) {
@@ -272,8 +879,32 @@ var init_GLOBAL_BULLMQ_CONFIG = __esm({
         }
       },
       // Chunk Processing Queue
-      CHUNK_PROCESSING_QUEUE: {
-        id: "chunk-processing-queue",
+      CREATE_CHUNKS_QUEUE: {
+        id: "create-chunks-queue",
+        queueConfig: {
+          defaultJobOptions: {
+            backoff: {
+              type: "exponential",
+              delay: 2e3
+            },
+            attempts: 3,
+            removeOnComplete: 100,
+            removeOnFail: 50
+          }
+        },
+        workerConfig: {
+          concurrency: 10,
+          // Process 10 jobs at once for chunk processing
+          limiter: {
+            max: 5,
+            // Max 50 jobs per...
+            duration: 6e4
+            // ...60 seconds (higher throughput for chunking)
+          }
+        }
+      },
+      CREATE_ANNOS_QUEUE: {
+        id: "create-annos-queue",
         queueConfig: {
           defaultJobOptions: {
             backoff: {
@@ -342,6 +973,7 @@ __export(node_exports, {
   BaseProducer: () => import_BaseProducer.BaseProducer,
   BaseWorker: () => import_BaseWorker.BaseWorker,
   GET_GLOBAL_BULLMQ_CONFIG: () => import_GET_GLOBAL_BULLMQ_CONFIG.GET_GLOBAL_BULLMQ_CONFIG,
+  MongoConnector: () => import_MongoConnector2.MongoConnector,
   PlatformConfigsSchema: () => PlatformConfigs_default,
   TplSchema: () => Tpl_default,
   WorkerManager: () => import_WorkerManager.WorkerManager,
@@ -349,18 +981,17 @@ __export(node_exports, {
   deleteVal: () => deleteVal,
   extractAllBlocksFromTpl: () => extractAllBlocksFromTpl,
   genTagId: () => genTagId,
-  getAIChatModelByTenant: () => getAIChatModelByTenant,
+  getAIChatModelByTenant: () => import_getModelByTenant.getAIChatModelByTenant,
   getAIConfigs: () => getAIConfigs,
-  getAnnotationsModelByTenant: () => getAnnotationsModelByTenant,
+  getAnnotationsModelByTenant: () => import_getModelByTenant.getAnnotationsModelByTenant,
   getDbByTenant: () => getDbByTenant,
-  getModelByTenant: () => getModelByTenant,
-  getPlatformConfigsModelByTenant: () => getPlatformConfigsModelByTenant,
+  getModelByTenant: () => import_getModelByTenant.getModelByTenant,
+  getPlatformConfigsModelByTenant: () => import_getModelByTenant.getPlatformConfigsModelByTenant,
   getRedisClient: () => getRedisClient,
   getTpl: () => getTpl,
-  getTplModelByTenant: () => getTplModelByTenant,
+  getTplModelByTenant: () => import_getModelByTenant.getTplModelByTenant,
   getVal: () => getVal,
   initializeGlobalConfig: () => initializeGlobalConfig,
-  multiConnectToMongoDB: () => multiConnectToMongoDB,
   recursivelyExtractBlocks: () => _recursExtractBlocks,
   setVal: () => setVal,
   toArray: () => toArray,
@@ -643,18 +1274,12 @@ var _extractBlocksFromSomeBuilders = ({
   }
 };
 
-// src/db/mongodb.ts
-var import_mongoose = __toESM(require("mongoose"));
+// src/node.ts
+var import_MongoConnector2 = __toESM(require_MongoConnector());
+init_getDbByTenant();
 
 // src/db/getGlobalConfig.ts
 var globalConfig = {};
-var getGlobalConfig = () => {
-  return {
-    env: globalConfig.env,
-    dbConfigs: globalConfig.dbConfigs ? { ...globalConfig.dbConfigs } : void 0,
-    mongodb: globalConfig.mongodb ? { ...globalConfig.mongodb } : void 0
-  };
-};
 var initializeGlobalConfig = (config) => {
   globalConfig = {
     env: config.env,
@@ -674,423 +1299,11 @@ var updateGlobalConfig = (updates) => {
   console.log("Global config updated:", Object.keys(updates));
 };
 
-// src/db/mongodb.ts
-var mongoOptions = {
-  // Note: These legacy options are no longer needed in newer versions of mongoose
-  // useUnifiedTopology, useNewUrlParser, useCreateIndex, useFindAndModify are deprecated
-  maxPoolSize: 20
-  // replaces poolSize
-};
-var multiConnectToMongoDB = ({ env, dbConfigs } = {}) => {
-  const globalConfig2 = getGlobalConfig();
-  const actualEnv = env || globalConfig2.env;
-  const actualDbConfigs = dbConfigs || globalConfig2.dbConfigs;
-  if (!actualEnv) {
-    throw new Error("Environment not provided and not found in global config");
-  }
-  if (!actualDbConfigs) {
-    throw new Error("dbConfigs not provided and not found in global config");
-  }
-  const { connectTo } = actualDbConfigs[actualEnv];
-  if (!connectTo) {
-    throw new Error(`No connection configuration found for environment: ${actualEnv}`);
-  }
-  const dbConnections = {};
-  connectTo.forEach((connectToEnv) => {
-    const { CLUSTER_NAME, DB_URI } = actualDbConfigs[connectToEnv];
-    if (!CLUSTER_NAME || !DB_URI) {
-      throw new Error(`Missing CLUSTER_NAME or DB_URI for environment: ${connectToEnv}`);
-    }
-    dbConnections[CLUSTER_NAME] = import_mongoose.default.createConnection(DB_URI, mongoOptions);
-    dbConnections[CLUSTER_NAME].on("open", () => {
-      console.log(`Mongoose connection open to ${CLUSTER_NAME}`);
-    });
-    dbConnections[CLUSTER_NAME].on("error", (err) => {
-      console.log(`Mongoose connection error: ${err.message} with connection info ${CLUSTER_NAME}`);
-      process.exit(1);
-    });
-  });
-  return dbConnections;
-};
-
-// src/db/getDbByTenant.ts
-var getDbByTenant = ({
-  tenant,
-  env
-}) => {
-  if (!tenant) throw new Error("tenant id has not been provided");
-  const globalConfig2 = getGlobalConfig();
-  const actualEnv = env || globalConfig2.env;
-  const dbConfigs = globalConfig2.dbConfigs;
-  const mongodb = globalConfig2.mongodb;
-  if (!dbConfigs) {
-    throw new Error("dbConfigs not found in global config");
-  }
-  if (!actualEnv) {
-    throw new Error("env not provided and not found in global config");
-  }
-  const { CLUSTER_NAME } = dbConfigs[actualEnv];
-  const dbName = `${tenant}_${actualEnv}`;
-  if (mongodb) {
-    const db = mongodb[CLUSTER_NAME].useDb(dbName, { useCache: true });
-    return db;
-  }
-  throw new Error("getDbByTenant : mongodb object doesnt exist");
-};
-
-// src/models/AIChat.ts
-var import_mongoose3 = __toESM(require("mongoose"));
-
-// src/models/Annotations.ts
-var import_mongoose2 = require("mongoose");
-var AnnotationSchema = new import_mongoose2.Schema(
-  {
-    // Tags section - dynamic structure for various tag categories
-    tags: {
-      type: Map,
-      of: new import_mongoose2.Schema({
-        data: [
-          {
-            _id: { type: import_mongoose2.Schema.Types.ObjectId },
-            display: String,
-            tagId: String
-          }
-        ],
-        collectionId: String
-      }, {
-        _id: false
-      })
-    },
-    // Meta information
-    meta: {
-      contentType: { type: String, required: true },
-      kp_contributed_by: {
-        type: import_mongoose2.Schema.Types.ObjectId,
-        ref: "user"
-      },
-      valuePath: String,
-      documentId: {
-        type: import_mongoose2.Schema.Types.ObjectId
-      }
-    },
-    // Main content data - using Schema.Types.Mixed for dynamic structure
-    main: {
-      type: import_mongoose2.Schema.Types.Mixed,
-      default: {}
-    },
-    // Annotation specific details
-    annotations: {
-      tags: {
-        type: Map,
-        of: new import_mongoose2.Schema({
-          collectionId: String,
-          data: [
-            {
-              _id: { type: import_mongoose2.Schema.Types.ObjectId },
-              display: String,
-              tagId: String
-            }
-          ]
-        }, {
-          _id: false
-        })
-      },
-      fragment: {
-        isLexical: Boolean,
-        editorState: Object,
-        allText: String
-      },
-      annoKey: String,
-      author: {
-        id: { type: import_mongoose2.Schema.Types.ObjectId },
-        name: String
-      }
-    },
-    embeddings: Array,
-    contentEnhancedText: String,
-    // // Optional chunk related fields
-    // chunk: {
-    //   embeddings: Schema.Types.Mixed,
-    //   contentEnhancedText: String
-    // },
-    clusterId: String,
-    kp_date_published: Date,
-    createdAt: {
-      type: Date,
-      default: Date.now
-    },
-    updatedAt: {
-      type: Date,
-      default: Date.now
-    },
-    topicId: [{ type: import_mongoose2.Schema.Types.ObjectId, ref: "generatedTopics" }],
-    translations: Object
-  },
-  {
-    timestamps: true,
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true },
-    strict: false
-    // This allows for flexible document structure beyond the defined schema
-  }
-);
-AnnotationSchema.index({ "meta.contentType": 1 });
-AnnotationSchema.index({ "meta.documentId": 1 });
-AnnotationSchema.index({ createdAt: -1 });
-AnnotationSchema.index({ "annotations.annoKey": 1 });
-AnnotationSchema.index({ "kp_date_published": -1 });
-AnnotationSchema.pre("save", function(next) {
-  this.updatedAt = /* @__PURE__ */ new Date();
-  next();
-});
-AnnotationSchema.methods.getMainField = function(fieldPath) {
-  if (!fieldPath) return null;
-  const parts = fieldPath.split(".");
-  let value = this.main;
-  for (const part of parts) {
-    if (!value || typeof value !== "object") return null;
-    value = value[part];
-  }
-  return value;
-};
-AnnotationSchema.virtual("displayTitle").get(function() {
-  return this.main?.title || "Untitled Annotation";
-});
-var Annotations_default = AnnotationSchema;
-
-// src/models/AIChat.ts
-var AIChatSchema = new import_mongoose3.default.Schema(
-  {
-    userId: { type: import_mongoose3.default.Schema.Types.ObjectId, index: { unique: true } },
-    createdAt: Date,
-    lastAcitivity: Date,
-    messages: [
-      {
-        id: String,
-        author: {
-          type: String,
-          enum: ["system", "user", "assistant"]
-        },
-        content: {
-          type: { type: String },
-          value: String
-        },
-        vectorSearchInfo: {
-          chunks: [Annotations_default]
-        },
-        args: {
-          query: String,
-          reframedQuery: String,
-          summary: Object
-        },
-        userFeedback: {
-          reaction: { type: String, enum: ["positive", "negative"] },
-          comments: String
-        }
-      }
-    ]
-  },
-  { collection: "aiChat" }
-);
-var AIChat_default = AIChatSchema;
-
-// src/models/PlatformConfigs.ts
-var import_mongoose4 = __toESM(require("mongoose"));
-var platformConfigTypes = [
-  "roles",
-  "nav",
-  "deployment",
-  "userAgreement",
-  "localeData",
-  "theme",
-  "AI"
-];
-var PlatformConfigsSchema = new import_mongoose4.default.Schema(
-  {
-    type: {
-      type: String,
-      enum: platformConfigTypes,
-      unique: true
-    },
-    roles: Array,
-    data: Object
-  },
-  { collection: "platformConfigs" }
-);
-var PlatformConfigs_default = PlatformConfigsSchema;
-
-// src/models/Tpl.ts
-var import_mongoose5 = __toESM(require("mongoose"));
-var TplSchema = new import_mongoose5.default.Schema({
-  dateFirstPublished: Date,
-  dateCreated: Date,
-  dateLastPublished: Date,
-  dateLastEdited: Date,
-  status: {
-    type: String,
-    default: "published",
-    // only cuz we dont want to go and add this property in all databases
-    enum: ["unpublished", "editPublished", "published"]
-  },
-  version: {
-    type: Number,
-    default: 0
-  },
-  versionPublishedBy: {
-    type: import_mongoose5.default.Schema.Types.ObjectId,
-    ref: "user"
-    // reference to the 'user' model
-  },
-  firstPublishedBy: {
-    type: import_mongoose5.default.Schema.Types.ObjectId,
-    ref: "user"
-    // reference to the 'user' model
-  },
-  kp_content_type: {
-    type: String,
-    required: true,
-    unique: true
-  },
-  category: {
-    //to deprecate and turn into 'layout'
-    type: String,
-    default: "knowledgeResources2"
-  },
-  kp_settings: [
-    {
-      type: Object
-    }
-  ],
-  kp_templates: {
-    type: Object
-  },
-  tplMeta: Object,
-  tplLocales: Object,
-  indexed: Object,
-  drafts: {
-    active: Object
-  },
-  rollbacks: Object,
-  //for 'remembering' hidden configurations
-  // OTHER CONFIGS
-  listing: Object,
-  //listing page configurations. this is new, currently only used in nct
-  general: {
-    content: {
-      title: String,
-      singular: String,
-      ctaText: String,
-      listingDesc: String
-    },
-    allowQuickTagCreation: { enable: Boolean },
-    segment: String,
-    settingsUIStyle: String,
-    hasUpdateType: Boolean,
-    annotation: {
-      enable: Boolean
-    },
-    participantModule: {
-      enable: Boolean
-    },
-    formFieldNumbering: {
-      enable: Boolean
-    },
-    postPblRedirPath: Object,
-    templateIndex: Object,
-    sharing: {
-      enable: Boolean,
-      trackShareCount: {
-        type: Boolean,
-        default: false
-      }
-    },
-    viewsCount: {
-      enable: {
-        type: Boolean,
-        default: false
-      }
-    },
-    comments: {
-      enable: Boolean
-    },
-    reactions: {
-      type: Map,
-      of: {
-        enable: Boolean,
-        icon: String
-      }
-    },
-    csvExport: {
-      enable: Boolean,
-      excludeFields: Array,
-      enableUpdateExport: Boolean,
-      fieldsToSortAtEnd: Array,
-      fetchBatches: {
-        enable: Boolean,
-        batchSize: Number
-      }
-    },
-    onboardingFlow: Object,
-    //only on profile tpls
-    selfServeSurveyConfig: Object,
-    //tci helpers - these exist only to show / not show certain UIs in the tci
-    disableKPSettings: Boolean
-  }
-  //general contenttype configs. mostly the stuff inside platformConfigs > contentTypes
-}, {
-  toJSON: { virtuals: true },
-  // So `res.json()` and other `JSON.stringify()` functions include virtuals
-  toObject: { virtuals: true }
-  // So `toObject()` output includes virtuals
-});
-TplSchema.virtual("layout").get(function() {
-  return this.category;
-});
-var Tpl_default = TplSchema;
+// src/node.ts
+var import_getModelByTenant = __toESM(require_getModelByTenant());
 
-// src/db/getModelByTenant.ts
-var getModelByTenant = ({
-  tenant,
-  modelName,
-  schema,
-  env
-}) => {
-  if (!tenant) {
-    throw new Error("tenant id has not been provided");
-  }
-  const db = getDbByTenant({
-    tenant,
-    env
-  });
-  if (!Object.keys(db.models).includes(modelName)) {
-    return db.model(modelName, schema);
-  }
-  return db.model(modelName);
-};
-var getAnnotationsModelByTenant = ({ tenant, env, mongodb, dbConfigs, modelName }) => getModelByTenant({
-  tenant,
-  modelName: modelName || "annotations",
-  schema: Annotations_default,
-  env
-});
-var getPlatformConfigsModelByTenant = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant({
-  tenant,
-  modelName: "platformConfigs",
-  schema: PlatformConfigs_default,
-  env
-});
-var getTplModelByTenant = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant({
-  tenant,
-  modelName: "tpl",
-  schema: Tpl_default,
-  env
-});
-var getAIChatModelByTenant = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant({
-  tenant,
-  modelName: "aiChat",
-  schema: AIChat_default,
-  env
-});
+// src/redis/functions.ts
+init_getDbByTenant();
 
 // src/redis/index.ts
 var import_ioredis = __toESM(require("ioredis"));
@@ -1200,6 +1413,7 @@ var getAIConfigs = async ({
 };
 
 // src/node.ts
+init_models();
 var import_WorkerManager = __toESM(require_WorkerManager());
 var import_BaseProducer = __toESM(require_BaseProducer());
 var import_BaseWorker = __toESM(require_BaseWorker());
@@ -1211,6 +1425,7 @@ var import_GET_GLOBAL_BULLMQ_CONFIG = __toESM(require_GET_GLOBAL_BULLMQ_CONFIG()
   BaseProducer,
   BaseWorker,
   GET_GLOBAL_BULLMQ_CONFIG,
+  MongoConnector,
   PlatformConfigsSchema,
   TplSchema,
   WorkerManager,
@@ -1229,7 +1444,6 @@ var import_GET_GLOBAL_BULLMQ_CONFIG = __toESM(require_GET_GLOBAL_BULLMQ_CONFIG()
   getTplModelByTenant,
   getVal,
   initializeGlobalConfig,
-  multiConnectToMongoDB,
   recursivelyExtractBlocks,
   setVal,
   toArray,