@okf/ootils 1.2.0 → 1.3.0

package/dist/index.js

@@ -1,8 +1,13 @@
 "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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,15 +20,316 @@ var __copyProps = (to, from, except, desc) => {
   }
   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);
 
+// src/models/Annotations.js
+var require_Annotations = __commonJS({
+  "src/models/Annotations.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: {
+            data: [
+              {
+                _id: { type: Schema.Types.ObjectId },
+                display: String,
+                tagId: String
+              }
+            ],
+            collectionId: String
+          }
+        },
+        // 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,
+            of: {
+              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
+          }
+        },
+        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
+      }
+    );
+    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;
+  }
+});
+
+// src/models/PlatformConfigs.js
+var require_PlatformConfigs = __commonJS({
+  "src/models/PlatformConfigs.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;
+  }
+});
+
+// src/models/Tpl.js
+var require_Tpl = __commonJS({
+  "src/models/Tpl.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
+        }
+      ],
+      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
+          }
+        },
+        //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/index.ts
 var index_exports = {};
 __export(index_exports, {
   add: () => add,
+  connectToRedis: () => connectToRedis,
   deleteVal: () => deleteVal,
+  getAIConfigs: () => getAIConfigs,
+  getAnnotationsModelByTenant: () => getAnnotationsModelByTenant,
+  getDbByTenant: () => getDbByTenant,
+  getModelByTenant: () => getModelByTenant,
+  getPlatformConfigsModelByTenant: () => getPlatformConfigsModelByTenant,
+  getTpl: () => getTpl,
+  getTplModelByTenant: () => getTplModelByTenant,
   getVal: () => getVal,
-  setVal: () => setVal
+  initializeGlobalConfig: () => initializeGlobalConfig,
+  multiConnectToMongoDB: () => multiConnectToMongoDB,
+  setVal: () => setVal,
+  updateGlobalConfig: () => updateGlobalConfig
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -32,6 +338,142 @@ function add(a, b) {
   return a + b;
 }
 
+// src/db/mongodb.ts
+var import_mongoose = __toESM(require("mongoose"));
+
+// 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,
+    dbConfigs: config.dbConfigs ? { ...config.dbConfigs } : void 0,
+    mongodb: config.mongodb ? { ...config.mongodb } : void 0
+  };
+  console.log(`Global config initialized for environment: ${config.env}`);
+};
+var updateGlobalConfig = (updates) => {
+  globalConfig = {
+    ...globalConfig,
+    ...updates,
+    // Handle nested objects properly
+    dbConfigs: updates.dbConfigs ? { ...globalConfig.dbConfigs, ...updates.dbConfigs } : globalConfig.dbConfigs,
+    mongodb: updates.mongodb ? { ...globalConfig.mongodb, ...updates.mongodb } : globalConfig.mongodb
+  };
+  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: 10
+  // 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/db/getModelByTenant.ts
+var AnnotationsSchema = require_Annotations();
+var PlatformConfigsSchema = require_PlatformConfigs();
+var TplSchema = require_Tpl();
+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 }) => getModelByTenant({
+  tenant,
+  modelName: "annotations",
+  schema: AnnotationsSchema,
+  env
+});
+var getPlatformConfigsModelByTenant = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant({
+  tenant,
+  modelName: "platformConfigs",
+  schema: PlatformConfigsSchema,
+  env
+});
+var getTplModelByTenant = ({ tenant, env, mongodb, dbConfigs }) => getModelByTenant({
+  tenant,
+  modelName: "tpl",
+  schema: TplSchema,
+  env
+});
+
 // src/utils/getterSetterDeleter/utils/set_deleteVal.ts
 var set_deleteVal = (action, data, valuePath, value) => {
   if (valuePath === void 0) return;
@@ -162,10 +604,128 @@ var getValV2_getter = (data, valuePath, options, depthIdx) => {
   }
   return dataRef[keysArray[len - 1]];
 };
+
+// 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: "tpls",
+    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"
+    }
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   add,
+  connectToRedis,
   deleteVal,
+  getAIConfigs,
+  getAnnotationsModelByTenant,
+  getDbByTenant,
+  getModelByTenant,
+  getPlatformConfigsModelByTenant,
+  getTpl,
+  getTplModelByTenant,
   getVal,
-  setVal
+  initializeGlobalConfig,
+  multiConnectToMongoDB,
+  setVal,
+  updateGlobalConfig
 });