@okf/ootils 1.2.0 → 1.3.0

package/dist/index.mjs

@@ -1,8 +1,437 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/models/Annotations.js
+var require_Annotations = __commonJS({
+  "src/models/Annotations.js"(exports, module) {
+    "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";
+    });
+    module.exports = AnnotationSchema;
+  }
+});
+
+// src/models/PlatformConfigs.js
+var require_PlatformConfigs = __commonJS({
+  "src/models/PlatformConfigs.js"(exports, module) {
+    "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" }
+    );
+    module.exports = PlatformConfigsSchema2;
+  }
+});
+
+// src/models/Tpl.js
+var require_Tpl = __commonJS({
+  "src/models/Tpl.js"(exports, module) {
+    "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;
+    });
+    module.exports = TplSchema2;
+  }
+});
+
 // src/utils/testFn.ts
 function add(a, b) {
   return a + b;
 }
 
+// src/db/mongodb.ts
+import mongoose from "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] = mongoose.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;
@@ -133,9 +562,127 @@ var getValV2_getter = (data, valuePath, options, depthIdx) => {
   }
   return dataRef[keysArray[len - 1]];
 };
+
+// src/redis/index.ts
+import IORedis from "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 IORedis(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"
+    }
+  });
+};
 export {
   add,
+  connectToRedis,
   deleteVal,
+  getAIConfigs,
+  getAnnotationsModelByTenant,
+  getDbByTenant,
+  getModelByTenant,
+  getPlatformConfigsModelByTenant,
+  getTpl,
+  getTplModelByTenant,
   getVal,
-  setVal
+  initializeGlobalConfig,
+  multiConnectToMongoDB,
+  setVal,
+  updateGlobalConfig
 };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Utility functions for both browser and Node.js",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -34,11 +34,16 @@
     "@semantic-release/github": "^11.0.1",
     "@semantic-release/npm": "^12.0.1",
     "@semantic-release/release-notes-generator": "^14.0.3",
+    "@types/ioredis": "^4.28.10",
     "@types/node": "^22.13.10",
     "commitizen": "^4.3.1",
     "cz-conventional-changelog": "^3.3.0",
     "semantic-release": "^24.2.3",
     "tsup": "^8.4.0",
     "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "ioredis": "^5.6.1",
+    "mongoose": "^8.15.1"
   }
 }