@dynamatix/gb-schemas 0.23.2 → 0.23.4

package/lookup.service.js

@@ -0,0 +1,55 @@
+import mongoose from "mongoose";
+import LookupGroupModel from "./shared/lookup-group.model.js";
+import LookupModel from "./shared/lookup.model.js";
+import { encryptObject } from "./utils/encryption.js";
+
+export class LookupService {
+    static async getLookupID(groupName, lookupName) {
+        // console.log("--------------groupName, lookupName",groupName, lookupName);
+        try {
+            let lookupGroup = await LookupGroupModel.find().populate('lookups').exec();
+            if (!lookupGroup) {
+                console.log(`Lookup group ${groupName} not found, creating`)
+                lookupGroup = await LookupGroupModel.create({ name: groupName })
+                console.log(`Lookup group ${groupName} not found, created`)
+            }
+
+            let lookup = await lookupGroup.lookups?.find(lookup => lookup.name === lookupName);
+            if (!lookup) {
+                console.log(`Lookup ${lookupName} not found for ${groupName}, creating`);
+                lookup = await LookupModel.create({
+                    lookupGroupId: lookupGroup._id,
+                    name: lookupName,
+                    text: lookupName
+                });
+                lookupGroup.lookups.push(lookup._id);
+                await lookupGroup.save();
+                console.log(`Lookup ${lookupName} not found for ${groupName}, created`)
+            }
+            return lookup._id;
+        } catch (error) {
+            console.error(error);
+            throw error;
+        }
+    }
+}
+
+
+const mongoConnectionString = 'mongodb+srv://gatehouse-uat:j6GX4cXBGFxDVXc1@gatehouse-uat.bvfhdhn.mongodb.net/gatehouse-uat-e?retryWrites=true&w=majority&appName=gatehouse-uat-e'
+
+const connectDB = async () => {
+    try {
+        await mongoose.connect(mongoConnectionString, {
+            useNewUrlParser: true,
+            useUnifiedTopology: true
+        });
+        console.log('Connected to MongoDB');
+    } catch (error) {
+        console.error('MongoDB connection error:', error);
+        process.exit(1);
+    }
+};
+
+await connectDB();
+const result = await LookupService.getLookupID('ApplicationType','Private Limited');
+console.log(result);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@dynamatix/gb-schemas",
-  "version": "0.23.2",
-  "description": "All the schemas for gatehouse bank back-end.",
-  "main": "index.js",
+  "version": "0.23.4",
+  "description": "All the schemas for gatehouse bank back-end",
+  "main": "lookup.service.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -27,6 +27,7 @@
     "./properties": "./properties/index.js",
     "./users": "./users/index.js",
     "./product-catalogues": "./product-catalogues/index.js",
+    "./underwriters": "./underwriters/index.js",
     "./utils": "./utils/index.js"
   }
 }

package/utils/encryption.middleware.js

@@ -62,23 +62,59 @@ export default function mongooseEncryption(schema, options) {
         next();
     });
     
-
-    // Decrypt result after querying
-    schema.post(['find', 'findOne', 'findById'], function (docs, next) {
-        if (Array.isArray(docs)) {
-            docs.forEach((doc, index) => {
-                if (doc) {
-                    const decrypted = decryptObject(doc.toObject(), this.collection.name);
-                    Object.assign(docs[index], decrypted); // ✅ Ensure changes persist
+    const decryptDocument = (doc, collectionName) => {
+        if (!doc || doc.$locals.hasDecrypted) return doc; // ✅ Skip if already decrypted
+
+        // ✅ Convert document to object before decrypting
+        const decrypted = decryptObject(doc.toObject(), collectionName);
+
+        // ✅ Preserve and decrypt populated fields
+        Object.keys(doc.toObject()).forEach((key) => {
+            if (doc.populated && doc.populated(key)) {
+                if (Array.isArray(doc[key])) {
+                    decrypted[key] = doc[key]
+                    // ✅ Decrypt each populated document in an array
+                    // decrypted[key] = doc[key].map((subDoc) =>
+                    //     subDoc.toObject ? decryptObject(subDoc.toObject(), "LookupModel") : subDoc
+                    // );
+                } else {
+                    // ✅ Decrypt a single populated document
+                    decrypted[key] = doc[key]?.toObject
+                        ? decryptObject(doc[key].toObject(), "LookupModel")
+                        : doc[key];
                 }
-            });
-        } else if (docs) {
-            const decrypted = decryptObject(docs.toObject(), this.collection.name);
-            Object.assign(docs, decrypted); // ✅ Ensure changes persist
-        }
+            }
+        });
+
+        // ✅ Set the flag to prevent duplicate decryption
+        doc.$locals.hasDecrypted = true;
+
+        return Object.assign(doc, decrypted); // ✅ Update the document safely
+    };
+
+    // ✅ Middleware for find()
+    schema.post(['find'], function (docs, next) {
+        if (!docs || !Array.isArray(docs)) return next(); // ✅ Skip if no document found
+
+        docs.forEach((doc, index) => {
+            docs[index] = decryptDocument(doc, this.collection.name);
+        });
+
         next();
     });
 
+    // ✅ Middleware for findOne() and findById()
+    schema.post(['findOne', 'findById'], function (doc, next) {
+        if (!doc) return next(); // ✅ Skip if no document found
+
+        doc = decryptDocument(doc, this.collection.name);
+
+        next();
+    });
+
+
+
+
     // Decrypt after update operations (single or multiple documents)
     schema.post("update", function (result) {
         if (Array.isArray(result)) {