@okf/ootils 1.3.6 → 1.3.8

package/dist/node.js

@@ -5,6 +5,9 @@ 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 __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -30,297 +33,323 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/models/Annotations.js
-var require_Annotations = __commonJS({
-  "src/models/Annotations.js"(exports2, module2) {
+// src/bullmq/WorkerManager.js
+var require_WorkerManager = __commonJS({
+  "src/bullmq/WorkerManager.js"(exports2, module2) {
     "use strict";
-    var mongoose2 = require("mongoose");
-    var Schema = mongoose2.Schema;
-    var AnnotationSchema = new Schema(
-      {
-        // Tags section - dynamic structure for various tag categories
-        tags: {
-          type: Map,
-          of: new Schema({
-            data: [
-              {
-                _id: { type: Schema.Types.ObjectId },
-                display: String,
-                tagId: String
-              }
-            ],
-            collectionId: String,
-            _id: false
-          })
-        },
-        // Meta information
-        meta: {
-          contentType: { type: String, required: true },
-          kp_contributed_by: {
-            type: Schema.Types.ObjectId,
-            ref: "user"
-          },
-          valuePath: String,
-          documentId: {
-            type: Schema.Types.ObjectId
-          }
-        },
-        // Main content data - using Schema.Types.Mixed for dynamic structure
-        main: {
-          type: Schema.Types.Mixed,
-          default: {}
-        },
-        // Annotation specific details
-        annotations: {
-          tags: {
-            type: Map,
-            _id: false,
-            of: new Schema({
-              collectionId: String,
-              data: [
-                {
-                  _id: { type: Schema.Types.ObjectId },
-                  display: String,
-                  tagId: String
-                }
-              ]
-            })
-          },
-          fragment: {
-            isLexical: Boolean,
-            editorState: Object,
-            allText: String
-          },
-          annoKey: String,
-          author: {
-            id: { type: Schema.Types.ObjectId },
-            name: String
+    var WorkerManager2 = class {
+      constructor(workers = []) {
+        this.workers = workers;
+        this.activeWorkers = [];
+      }
+      startAllWorkers() {
+        if (this.workers.length === 0) {
+          console.log("No workers provided to start");
+          return [];
+        }
+        console.log("\u{1F680} Starting all workers...");
+        this.workers.forEach((WorkerClass) => {
+          try {
+            const workerInstance = new WorkerClass();
+            workerInstance.start();
+            this.activeWorkers.push({
+              name: WorkerClass.name,
+              instance: workerInstance
+            });
+            console.log(`\u2705 Started ${WorkerClass.name}`);
+          } catch (error) {
+            console.error(`\u274C Failed to start ${WorkerClass.name}:`, error);
           }
-        },
-        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
-        },
-        translations: Object
-      },
-      {
-        timestamps: true,
-        toJSON: { virtuals: true },
-        toObject: { virtuals: true },
-        strict: false
-        // This allows for flexible document structure beyond the defined schema
+        });
+        console.log(`\u{1F389} Successfully started ${this.activeWorkers.length} workers`);
+        return this.activeWorkers;
+      }
+      async shutdown() {
+        console.log("\u{1F6D1} Stopping all workers...");
+        const stopPromises = this.activeWorkers.map(
+          ({ name, instance }) => instance.stop().catch(
+            (err) => console.error(`\u274C Error stopping ${name}:`, err)
+          )
+        );
+        await Promise.all(stopPromises);
+        this.activeWorkers = [];
+        console.log("\u2705 All workers stopped");
+      }
+      getStatus() {
+        return this.activeWorkers.map(({ name, instance }) => ({
+          name,
+          queueId: instance.config?.id || "unknown",
+          isActive: !!instance.worker
+        }));
       }
-    );
-    AnnotationSchema.index({ "meta.contentType": 1 });
-    AnnotationSchema.index({ "meta.documentId": 1 });
-    AnnotationSchema.index({ createdAt: -1 });
-    AnnotationSchema.index({ "annotations.annoKey": 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";
-    });
-    module2.exports = AnnotationSchema;
+    module2.exports = { WorkerManager: WorkerManager2 };
   }
 });
 
-// src/models/PlatformConfigs.js
-var require_PlatformConfigs = __commonJS({
-  "src/models/PlatformConfigs.js"(exports2, module2) {
+// src/bullmq/BaseProducer.js
+var require_BaseProducer = __commonJS({
+  "src/bullmq/BaseProducer.js"(exports2, module2) {
     "use strict";
-    var mongoose2 = require("mongoose");
-    var platformConfigTypes = [
-      { id: "roles" },
-      { id: "contentTypes" },
-      { id: "contentCards" },
-      { id: "profileTypes" },
-      { id: "nav" },
-      { id: "deployment" },
-      { id: "userAgreement" },
-      { id: "localeData" },
-      { id: "theme" },
-      { id: "tagTypes" },
-      { id: "AI" }
-    ];
-    var PlatformConfigsSchema2 = new mongoose2.Schema(
-      {
-        type: {
-          type: String,
-          enum: platformConfigTypes.map((d) => d.id),
-          unique: true
-        },
-        roles: Array,
-        data: Object
-      },
-      { collection: "platformConfigs" }
-    );
-    module2.exports = PlatformConfigsSchema2;
+    var { Queue } = require("bullmq");
+    var BaseProducer2 = class {
+      constructor(config) {
+        this.config = config;
+        this.queue = new Queue(config.id, config.queueConfig);
+      }
+      async execute(params) {
+        throw new Error("execute() method must be implemented by subclass");
+      }
+      async addBulkJobs(jobs) {
+        try {
+          const results = await this.queue.addBulk(jobs);
+          console.log(`\u2705 ${this.constructor.name}: Successfully queued ${results.length} jobs`);
+          return results;
+        } catch (error) {
+          console.error(`\u274C ${this.constructor.name}: Failed to queue jobs:`, error);
+          throw error;
+        }
+      }
+      async addJob(name, data, opts = {}) {
+        try {
+          const job = await this.queue.add(name, data, opts);
+          console.log(`\u2705 ${this.constructor.name}: Successfully queued job ${job.id}`);
+          return job;
+        } catch (error) {
+          console.error(`\u274C ${this.constructor.name}: Failed to queue job:`, error);
+          throw error;
+        }
+      }
+      async getStatus() {
+        const waiting = await this.queue.getWaiting();
+        const active = await this.queue.getActive();
+        const completed = await this.queue.getCompleted();
+        const failed = await this.queue.getFailed();
+        return {
+          waiting: waiting.length,
+          active: active.length,
+          completed: completed.length,
+          failed: failed.length,
+          total: waiting.length + active.length + completed.length + failed.length
+        };
+      }
+      async getJobDetails(limit = 10) {
+        const waiting = await this.queue.getWaiting(0, limit - 1);
+        const active = await this.queue.getActive(0, limit - 1);
+        const completed = await this.queue.getCompleted(0, limit - 1);
+        const failed = await this.queue.getFailed(0, limit - 1);
+        return {
+          waiting: waiting.map((job) => ({
+            id: job.id,
+            batchIndex: job.data?.batchIndex,
+            totalBatches: job.data?.totalBatches,
+            rawRecordsCount: job.data?.rawBatchData?.length
+          })),
+          active: active.map((job) => ({
+            id: job.id,
+            batchIndex: job.data?.batchIndex,
+            totalBatches: job.data?.totalBatches,
+            progress: job.progress,
+            rawRecordsCount: job.data?.rawBatchData?.length
+          })),
+          completed: completed.map((job) => ({
+            id: job.id,
+            batchIndex: job.returnvalue?.batchIndex,
+            totalProcessed: job.returnvalue?.totalItemsProcessed,
+            summary: job.returnvalue?.summary
+          })),
+          failed: failed.map((job) => ({
+            id: job.id,
+            batchIndex: job.data?.batchIndex,
+            error: job.failedReason,
+            attempts: job.attemptsMade
+          }))
+        };
+      }
+      async stop() {
+        if (this.queue) {
+          await this.queue.close();
+          console.log(`\u{1F6D1} ${this.constructor.name} queue closed`);
+        }
+      }
+    };
+    module2.exports = { BaseProducer: BaseProducer2 };
   }
 });
 
-// src/models/Tpl.js
-var require_Tpl = __commonJS({
-  "src/models/Tpl.js"(exports2, module2) {
+// src/bullmq/BaseWorker.js
+var require_BaseWorker = __commonJS({
+  "src/bullmq/BaseWorker.js"(exports2, module2) {
     "use strict";
-    var mongoose2 = require("mongoose");
-    var TplSchema2 = new mongoose2.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: mongoose2.Schema.Types.ObjectId,
-        ref: "user"
-        // reference to the 'user' model
-      },
-      firstPublishedBy: {
-        type: mongoose2.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
+    var { Worker } = require("bullmq");
+    var BaseWorker2 = class {
+      constructor(config) {
+        this.config = config;
+        this.worker = null;
+      }
+      async execute(job) {
+        throw new Error("execute() method must be implemented by subclass");
+      }
+      start() {
+        this.worker = new Worker(
+          this.config.id,
+          this.execute.bind(this),
+          this.config.workerConfig
+        );
+        this.setupEventHandlers();
+        console.log(`\u{1F680} ${this.constructor.name} started for queue: ${this.config.id}`);
+        return this.worker;
+      }
+      setupEventHandlers() {
+        this.worker.on("completed", (job, returnValue) => {
+          this.onCompleted(job, returnValue);
+        });
+        this.worker.on("failed", (job, err) => {
+          this.onFailed(job, err);
+        });
+        this.worker.on("progress", (job, progress) => {
+          this.onProgress(job, progress);
+        });
+        this.worker.on("error", (error) => {
+          this.onError(error);
+        });
+      }
+      onCompleted(job, returnValue) {
+        console.log(`\u2705 Job ${job.id} completed in ${this.constructor.name}`);
+      }
+      onFailed(job, err) {
+        console.error(`\u{1F4A5} Job ${job.id} failed in ${this.constructor.name}:`, err.message);
+      }
+      onProgress(job, progress) {
+        console.log(`\u{1F4CA} Job ${job.id} progress in ${this.constructor.name}: ${progress}%`);
+      }
+      onError(error) {
+        console.error(`\u274C Worker error in ${this.constructor.name}:`, error);
+      }
+      async stop() {
+        if (this.worker) {
+          await this.worker.close();
+          console.log(`\u{1F6D1} ${this.constructor.name} stopped`);
         }
-      ],
-      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
+      }
+    };
+    module2.exports = { BaseWorker: BaseWorker2 };
+  }
+});
+
+// src/bullmq/GLOBAL_BULLMQ_CONFIG.js
+var GLOBAL_BULLMQ_CONFIG_exports = {};
+__export(GLOBAL_BULLMQ_CONFIG_exports, {
+  BASE_BULLMQ_CONFIG: () => BASE_BULLMQ_CONFIG
+});
+var BASE_BULLMQ_CONFIG;
+var init_GLOBAL_BULLMQ_CONFIG = __esm({
+  "src/bullmq/GLOBAL_BULLMQ_CONFIG.js"() {
+    "use strict";
+    BASE_BULLMQ_CONFIG = {
+      PLUGIN__MAD_USERS_SYNC_QUEUE: {
+        id: "plugin--mad-users-sync-queue",
+        queueConfig: {
+          defaultJobOptions: {
+            backoff: {
+              type: "exponential",
+              delay: 2e3
+            },
+            attempts: 3,
+            removeOnComplete: 100,
+            removeOnFail: 50
           }
         },
-        viewsCount: {
-          enable: {
-            type: Boolean,
-            default: false
+        workerConfig: {
+          concurrency: 1,
+          // Process jobs one at a time to avoid race conditions
+          limiter: {
+            max: 10,
+            // Max 10 jobs per...
+            duration: 6e4
+            // ...60 seconds (rate limiting)
           }
-        },
-        comments: {
-          enable: Boolean
-        },
-        reactions: {
-          type: Map,
-          of: {
-            enable: Boolean,
-            icon: String
+        }
+      },
+      // Chunk Processing Queue
+      CHUNK_PROCESSING_QUEUE: {
+        id: "chunk-processing-queue",
+        queueConfig: {
+          defaultJobOptions: {
+            backoff: {
+              type: "exponential",
+              delay: 2e3
+            },
+            attempts: 3,
+            removeOnComplete: 100,
+            removeOnFail: 50
           }
         },
-        csvExport: {
-          enable: Boolean,
-          excludeFields: Array,
-          enableUpdateExport: Boolean,
-          fieldsToSortAtEnd: Array,
-          fetchBatches: {
-            enable: Boolean,
-            batchSize: Number
+        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)
           }
-        },
-        //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
-    });
-    TplSchema2.virtual("layout").get(function() {
-      return this.category;
-    });
-    module2.exports = TplSchema2;
+        }
+      }
+    };
+  }
+});
+
+// src/bullmq/GET_GLOBAL_BULLMQ_CONFIG.js
+var require_GET_GLOBAL_BULLMQ_CONFIG = __commonJS({
+  "src/bullmq/GET_GLOBAL_BULLMQ_CONFIG.js"(exports2, module2) {
+    "use strict";
+    var { default: Redis } = 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({
+        host: redisCredentials.REDIS_HOST,
+        port: redisCredentials.REDIS_PORT,
+        password: redisCredentials.REDIS_PASSWORD,
+        maxRetriesPerRequest: null
+      });
+      return Object.keys(BASE_BULLMQ_CONFIG2).reduce((acc, key) => ({
+        ...acc,
+        [key]: {
+          ...BASE_BULLMQ_CONFIG2[key],
+          id: BASE_BULLMQ_CONFIG2[key].id + `_${env}`,
+          // suffix env to queue to keep it unique for each environment
+          queueConfig: {
+            connection: redisConnectionForBullMQ,
+            ...BASE_BULLMQ_CONFIG2[key].queueConfig
+          },
+          workerConfig: {
+            connection: redisConnectionForBullMQ,
+            ...BASE_BULLMQ_CONFIG2[key].workerConfig
+          }
+        }
+      }), {});
+    }
+    module2.exports = { GET_GLOBAL_BULLMQ_CONFIG: GET_GLOBAL_BULLMQ_CONFIG2 };
   }
 });
 
 // src/node.ts
 var node_exports = {};
 __export(node_exports, {
+  AIChatSchema: () => AIChat_default,
+  AnnotationSchema: () => Annotations_default,
+  BaseProducer: () => import_BaseProducer.BaseProducer,
+  BaseWorker: () => import_BaseWorker.BaseWorker,
+  GET_GLOBAL_BULLMQ_CONFIG: () => import_GET_GLOBAL_BULLMQ_CONFIG.GET_GLOBAL_BULLMQ_CONFIG,
+  PlatformConfigsSchema: () => PlatformConfigs_default,
+  TplSchema: () => Tpl_default,
+  WorkerManager: () => import_WorkerManager.WorkerManager,
   connectToRedis: () => connectToRedis,
   deleteVal: () => deleteVal,
   extractAllBlocksFromTpl: () => extractAllBlocksFromTpl,
   genTagId: () => genTagId,
+  getAIChatModelByTenant: () => getAIChatModelByTenant,
   getAIConfigs: () => getAIConfigs,
   getAnnotationsModelByTenant: () => getAnnotationsModelByTenant,
   getDbByTenant: () => getDbByTenant,
@@ -709,10 +738,317 @@ var getDbByTenant = ({
   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/db/getModelByTenant.ts
-var AnnotationsSchema = require_Annotations();
-var PlatformConfigsSchema = require_PlatformConfigs();
-var TplSchema = require_Tpl();
 var getModelByTenant = ({
   tenant,
   modelName,
@@ -731,22 +1067,28 @@ var getModelByTenant = ({
   }
   return db.model(modelName);
 };
-var getAnnotationsModelByTenant = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant({
+var getAnnotationsModelByTenant = ({ tenant, env, mongodb, dbConfigs, modelName }) => getModelByTenant({
   tenant,
-  modelName: "annotations",
-  schema: AnnotationsSchema,
+  modelName: modelName || "annotations",
+  schema: Annotations_default,
   env
 });
 var getPlatformConfigsModelByTenant = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant({
   tenant,
   modelName: "platformConfigs",
-  schema: PlatformConfigsSchema,
+  schema: PlatformConfigs_default,
   env
 });
 var getTplModelByTenant = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant({
   tenant,
   modelName: "tpl",
-  schema: TplSchema,
+  schema: Tpl_default,
+  env
+});
+var getAIChatModelByTenant = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant({
+  tenant,
+  modelName: "aiChat",
+  schema: AIChat_default,
   env
 });
 
@@ -856,12 +1198,27 @@ var getAIConfigs = async ({
     }
   });
 };
+
+// src/node.ts
+var import_WorkerManager = __toESM(require_WorkerManager());
+var import_BaseProducer = __toESM(require_BaseProducer());
+var import_BaseWorker = __toESM(require_BaseWorker());
+var import_GET_GLOBAL_BULLMQ_CONFIG = __toESM(require_GET_GLOBAL_BULLMQ_CONFIG());
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AIChatSchema,
+  AnnotationSchema,
+  BaseProducer,
+  BaseWorker,
+  GET_GLOBAL_BULLMQ_CONFIG,
+  PlatformConfigsSchema,
+  TplSchema,
+  WorkerManager,
   connectToRedis,
   deleteVal,
   extractAllBlocksFromTpl,
   genTagId,
+  getAIChatModelByTenant,
   getAIConfigs,
   getAnnotationsModelByTenant,
   getDbByTenant,