@okf/ootils 1.1.0 → 1.2.1

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,12 +20,313 @@ 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
+  add: () => add,
+  deleteVal: () => deleteVal,
+  getAnnotationsModelByTenant: () => getAnnotationsModelByTenant,
+  getDbByTenant: () => getDbByTenant,
+  getModelByTenant: () => getModelByTenant,
+  getPlatformConfigsModelByTenant: () => getPlatformConfigsModelByTenant,
+  getTplModelByTenant: () => getTplModelByTenant,
+  getVal: () => getVal,
+  initializeGlobalConfig: () => initializeGlobalConfig,
+  multiConnectToMongoDB: () => multiConnectToMongoDB,
+  setVal: () => setVal,
+  updateGlobalConfig: () => updateGlobalConfig
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -28,7 +334,285 @@ module.exports = __toCommonJS(index_exports);
 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;
+  if (valuePath === null && action === "set") {
+    data = value;
+    return data;
+  }
+  let dataRef = data;
+  const keysArray = valuePath.split(".");
+  const len = keysArray.length;
+  let valIsUndefined = false;
+  for (let i = 0; i < len - 1; i++) {
+    const key = keysArray[i];
+    if (!dataRef[key]) {
+      if (action === "set") {
+        const nextKey = keysArray[i + 1];
+        if (nextKey && !isNaN(parseInt(nextKey))) {
+          dataRef[key] = [];
+        } else {
+          dataRef[key] = {};
+        }
+      } else {
+        valIsUndefined = true;
+        break;
+      }
+    }
+    dataRef = dataRef[key];
+  }
+  if (valIsUndefined) return void 0;
+  if (action === "set") {
+    dataRef[keysArray[len - 1]] = value;
+    return data;
+  } else if (action === "delete") {
+    if (Array.isArray(dataRef)) {
+      dataRef.splice(parseInt(keysArray[len - 1]), 1);
+    } else {
+      delete dataRef[keysArray[len - 1]];
+    }
+    return data;
+  }
+};
+
+// src/utils/getterSetterDeleter/deleteVal.ts
+var deleteVal = (data, valuePath) => {
+  return set_deleteVal("delete", data, valuePath);
+};
+
+// src/utils/getterSetterDeleter/setVal.ts
+var setVal = (data, valuePath, value) => {
+  return set_deleteVal("set", data, valuePath, value);
+};
+
+// src/utils/getterSetterDeleter/utils/flattenArrayOfArrays.ts
+var flattenArrayOfArrays = ({
+  array,
+  flattenLastArray = true,
+  toReturn = []
+}) => {
+  array.map((ary) => {
+    if (Array.isArray(ary)) {
+      if (flattenLastArray === true) {
+        if (ary.some((childAry) => !Array.isArray(childAry))) {
+          toReturn.push(ary);
+        } else {
+          flattenArrayOfArrays({ array: ary, flattenLastArray, toReturn });
+        }
+      } else {
+        flattenArrayOfArrays({ array: ary, flattenLastArray, toReturn });
+      }
+    } else {
+      toReturn.push(ary);
+    }
+  });
+  return toReturn;
+};
+
+// src/utils/getterSetterDeleter/getVal.ts
+var getVal = (data, valuePath, options = {}, depthIdx = 0) => {
+  let value = null;
+  const getFinalVal = (data2, valuePath2, options2, depthIdx2) => {
+    return Array.isArray(data2) ? data2.map((R) => getValV2_getter(R, valuePath2, options2, depthIdx2)) : getValV2_getter(data2, valuePath2, options2, depthIdx2);
+  };
+  if (Array.isArray(valuePath)) {
+    for (let i = 0; i < valuePath.length; i++) {
+      value = getFinalVal(data, valuePath[i], options, depthIdx);
+      if (value) break;
+    }
+  } else {
+    value = getFinalVal(data, valuePath, options, depthIdx);
+  }
+  return value;
+};
+var getValV2_getter = (data, valuePath, options, depthIdx) => {
+  const { flattenIfValueIsArray = true } = options;
+  if (valuePath === null) return data;
+  let dataRef = data;
+  const keysArray = valuePath.split(".");
+  const len = keysArray.length;
+  let valIsUndefined = false;
+  let thisIterationFoundAry = false;
+  for (let i = 0; i < len - 1; i++) {
+    const key = keysArray[i];
+    if (!thisIterationFoundAry) {
+      if (!dataRef[key]) {
+        valIsUndefined = true;
+        break;
+      }
+      dataRef = dataRef[key];
+    } else {
+      const nestedAryResponse = dataRef.map((dataRefItem) => {
+        const remainingValuePath = keysArray.filter((dd, ii) => ii >= i).join(".");
+        return getVal(dataRefItem, remainingValuePath, options, depthIdx + 1);
+      });
+      return flattenArrayOfArrays({
+        array: nestedAryResponse,
+        flattenLastArray: depthIdx === 0 && flattenIfValueIsArray === false ? false : true
+      });
+    }
+    if (Array.isArray(dataRef) && Number.isNaN(parseInt(keysArray[i + 1]))) thisIterationFoundAry = true;
+  }
+  if (valIsUndefined) return void 0;
+  if (thisIterationFoundAry) {
+    const toReturn = dataRef.map((d) => d[keysArray[len - 1]]);
+    return flattenArrayOfArrays({
+      array: toReturn,
+      flattenLastArray: flattenIfValueIsArray
+    });
+  }
+  return dataRef[keysArray[len - 1]];
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  add
+  add,
+  deleteVal,
+  getAnnotationsModelByTenant,
+  getDbByTenant,
+  getModelByTenant,
+  getPlatformConfigsModelByTenant,
+  getTplModelByTenant,
+  getVal,
+  initializeGlobalConfig,
+  multiConnectToMongoDB,
+  setVal,
+  updateGlobalConfig
 });