@dynamatix/gb-schemas 0.23.5 → 0.23.7

package/applicants/applicant.model.js

@@ -9,7 +9,6 @@ import applicantCommitmentSchema from "./applicant-commitment.model.js";
 import applicantDirectDebitSchema from "./applicant-direct-debit.model.js";
 import creditProfileSchema from "./applicant-credit-profile.model.js";
 import incomeSchema from "./applicant-income.model.js";
-import mongooseEncryption from "../utils/encryption.middleware.js";
 
 const applicantSchema = new mongoose.Schema({
     applicantId: { type: String, required: true },
@@ -160,6 +159,5 @@ applicantSchema.virtual('vulnerabilityType').get(function () {
     return this.VulnerabilityTypeLid?.name ?? null;
 });
 
-applicantSchema.plugin(mongooseEncryption);
 const ApplicantModel = mongoose.model("Applicant", applicantSchema);
 export default ApplicantModel;

package/applications/application-audit.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const applicationAuditSchema = new mongoose.Schema({
     auditId: {
@@ -41,7 +41,5 @@ const applicationAuditSchema = new mongoose.Schema({
     }
 },{ timestamps: true });
 
-
-applicationAuditSchema.plugin(mongooseEncryption);
 const ApplicationAuditModel = mongoose.model('ApplicationAudit', applicationAuditSchema);
 export default ApplicationAuditModel;

package/applications/application-checklist-Item.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const checkListItemSchema = new mongoose.Schema({
   additionalOfferConditions: { type: String, default: "" },
@@ -44,6 +44,5 @@ const checkListItemSchema = new mongoose.Schema({
   valuationSurveyorDetails: { type: String, default: "" }
 });
 
-checkListItemSchema.plugin(mongooseEncryption);
 const ApplicationCheckListModel = mongoose.model("ApplicationCheckList", checkListItemSchema);
 export default ApplicationCheckListModel;

package/applications/application-document.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const documentSchema = new mongoose.Schema({
     applicationId: {
@@ -34,6 +34,5 @@ const documentSchema = new mongoose.Schema({
     timestamps: true
 });
 
-documentSchema.plugin(mongooseEncryption);
 const ApplicationDocumentModel = mongoose.model("ApplicationDocument", documentSchema);
 export default ApplicationDocumentModel;

package/applications/application-fieldconfig.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const fieldConfigSchema = new mongoose.Schema({
     fieldName: { type: String, required: true, unique: true },
@@ -7,6 +7,5 @@ const fieldConfigSchema = new mongoose.Schema({
 });
 
 
-fieldConfigSchema.plugin(mongooseEncryption);
 const ApplicationFieldConfigModel = mongoose.model('FieldConfig', fieldConfigSchema);
 export default ApplicationFieldConfigModel;

package/applications/application-legal.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const legalSchema = new mongoose.Schema({
   assignedSolicitor: { type: String, default: "" }, 
@@ -7,6 +7,5 @@ const legalSchema = new mongoose.Schema({
 });
 
 
-legalSchema.plugin(mongooseEncryption);
 const LegalModel = mongoose.model("Legal", legalSchema);
 export default LegalModel;

package/applications/application-mortgage.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const mortgageSchema = new mongoose.Schema({
     depositComeFrom: { type: String, required: true },          
@@ -29,5 +29,4 @@ const mortgageSchema = new mongoose.Schema({
     vendorsName: { type: String, default: "" }
 });
 
-mortgageSchema.plugin(mongooseEncryption);
 export default mortgageSchema;

package/applications/application-note.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const noteSchema = new mongoose.Schema({
     applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application", required: true },
@@ -73,6 +73,5 @@ const noteSchema = new mongoose.Schema({
     },
 });
 
-noteSchema.plugin(mongooseEncryption);
 const ApplictionNoteModel = mongoose.model("ApplictionNote", noteSchema);
 export default ApplictionNoteModel;

package/applications/application-offer.model.js

@@ -1,11 +1,9 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const offerSchema = new mongoose.Schema({
   date: { type: String } // The date associated with the offer
 });
 
-
-offerSchema.plugin(mongooseEncryption);
 const OfferModel = mongoose.model("Offer", offerSchema);
 export default OfferModel;

package/applications/application-onboarding.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const onboardingSchema = new mongoose.Schema({
   errors: { type: String, default: "" }, 
@@ -8,7 +8,5 @@ const onboardingSchema = new mongoose.Schema({
   warnings: { type: String, default: "" } 
 });
 
-
-onboardingSchema.plugin(mongooseEncryption);
 const ApplicationOnboardingModel = mongoose.model("ApplicationOnboarding", onboardingSchema);
 export default ApplicationOnboardingModel;

package/applications/application-rationale.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const rationaleSchema = new mongoose.Schema({
   applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application", required: true },
@@ -37,6 +37,5 @@ const rationaleSchema = new mongoose.Schema({
   propertyStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
 });
 
-rationaleSchema.plugin(mongooseEncryption);
 const ApplicationRationaleModel = mongoose.model("ApplicationRationale", rationaleSchema);
 export default ApplicationRationaleModel;

package/applications/application-risk-narrative.model.js

@@ -1,5 +1,4 @@
 import mongoose from 'mongoose';
-import mongooseEncryption from '../utils/encryption.middleware.js';
 
 const applicantionRiskNarrativeSchema = new mongoose.Schema({
     call1RequestedOn: { type: String },
@@ -11,7 +10,6 @@ const applicantionRiskNarrativeSchema = new mongoose.Schema({
     statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
 });
 
-applicantionRiskNarrativeSchema.plugin(mongooseEncryption);
 const ApplicationRiskNarrativeModel = mongoose.model('ApplicationRiskNarrative', applicantionRiskNarrativeSchema);
 export default ApplicationRiskNarrativeModel;
 

package/applications/application.model.js

@@ -2,7 +2,7 @@ import mongoose from "mongoose";
 import directDebitSchema from "./application-direct-debit.model.js";
 import creditProfileSchema from "./application-credit-profile.model.js";
 import mortgageSchema from "./application-mortgage.model.js";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const applicationSchema = new mongoose.Schema(
   {
@@ -147,6 +147,5 @@ applicationSchema.virtual('solicitorPhone').get(function () {
   return this.solicitorId ? this.solicitorId?.telephone : null;
 });
 
-applicationSchema.plugin(mongooseEncryption);
 const ApplicationModel = mongoose.model("Application", applicationSchema);
 export default ApplicationModel;

package/applications/broker.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const brokerSchema = new mongoose.Schema({
     brokerId: { type: String },
@@ -22,6 +22,5 @@ const brokerSchema = new mongoose.Schema({
     { timestamps: true });
 
 
-brokerSchema.plugin(mongooseEncryption);
 const BrokerModel = mongoose.model("Broker", brokerSchema);
 export default BrokerModel;

package/applications/document.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const documentSchema = new mongoose.Schema({
     applicationId: {
@@ -34,6 +34,5 @@ const documentSchema = new mongoose.Schema({
     timestamps: true
 });
 
-documentSchema.plugin(mongooseEncryption);
 const DocumentModel = mongoose.model("Document", documentSchema);
 export default DocumentModel;

package/applications/productfeatures.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const feeSchema = new mongoose.Schema({
     feeType: { type: String, required: true },
@@ -97,6 +97,5 @@ const productFeaturesSchema = new mongoose.Schema({
     calculations: calculationsSchema
 });
 
-productFeaturesSchema.plugin(mongooseEncryption);
 const ProductFeaturesModel = mongoose.model("ProductFeature", productFeaturesSchema);
 export default ProductFeaturesModel;

package/applications/solicitor.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const Schema = mongoose.Schema;
 
@@ -32,6 +32,5 @@ const solicitorSchema = new Schema({
     telephone: { type: String,},
 });
 
-solicitorSchema.plugin(mongooseEncryption);
 const SolicitorModel = mongoose.model("Solicitor", solicitorSchema);
 export default SolicitorModel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamatix/gb-schemas",
-  "version": "0.23.5",
+  "version": "0.23.7",
   "description": "All the schemas for gatehouse bank back-end",
   "main": "lookup.service.js",
   "scripts": {
@@ -18,6 +18,7 @@
   },
   "homepage": "https://github.com/DynamatixAnalyticsPvtLtd/gb-schemas#readme",
   "dependencies": {
+    "mongodb": "^6.14.2",
     "mongoose": "^8.9.5"
   },
   "exports": {

package/product-catalogues/product-catalogue.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const productCatalogueSchema = new mongoose.Schema({
     productCatalogueId: { type: String, required: true }, 
@@ -17,6 +17,5 @@ const productCatalogueSchema = new mongoose.Schema({
     timestamps: true
 });
 
-productCatalogueSchema.plugin(mongooseEncryption);
 const ProductCatalogueModel = mongoose.model('ProductCatalogue', productCatalogueSchema);
 export default ProductCatalogueModel;

package/product-catalogues/product-definitions.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const ruleSchema = new mongoose.Schema({
     ruleId: { type: String, required: true }, 
@@ -26,6 +26,5 @@ const productDefinitionsSchema = new mongoose.Schema({
     timestamps: true
 });
 
-productDefinitionsSchema.plugin(mongooseEncryption);
 const ProductDefinitionsModel = mongoose.model('ProductDefinitions', productDefinitionsSchema);
 export default ProductDefinitionsModel;

package/product-catalogues/product-variant.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const productVariantSchema = new mongoose.Schema({
     productCatalogueId: { ref: "ProductCatalogue", type: mongoose.Schema.Types.ObjectId, required: true },
@@ -12,6 +12,5 @@ const productVariantSchema = new mongoose.Schema({
     timestamps: true
 });
 
-productVariantSchema.plugin(mongooseEncryption);
 const ProductVariantModel = mongoose.model('ProductVariant', productVariantSchema);
 export default ProductVariantModel;

package/properties/property.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const dataStreetSchema = new mongoose.Schema({
     floorArea: { type: String, default: '' },
@@ -110,6 +110,5 @@ propertySchema.virtual('tenure').get(function () {
     return this.propertyTypeLid ? this.propertyTypeLid.name : null;
   });
 
-propertySchema.plugin(mongooseEncryption);
 const PropertyModel = mongoose.model("Property", propertySchema);
 export default PropertyModel;

package/shared/alert.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const alertSchema = new mongoose.Schema({
     alertTypeLid: {
@@ -23,7 +23,6 @@ const alertSchema = new mongoose.Schema({
     isActive: { type: String, default: true },
 }, { timestamps: true });
 
-alertSchema.plugin(mongooseEncryption);
 const AlertModel = mongoose.model("Alert", alertSchema);
 
 export default AlertModel;

package/shared/checklist.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const checklistSchema = new mongoose.Schema({
     checkTypeLid: {
@@ -31,7 +31,6 @@ const checklistSchema = new mongoose.Schema({
 
 checklistSchema.index({ checkDescription: 'text', source: 'text' });
 
-checklistSchema.plugin(mongooseEncryption);
 const CheckListModel = mongoose.model("CheckList", checklistSchema);
 
 export default CheckListModel;

package/shared/lookup-group.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const lookupGroupSchema = new mongoose.Schema({
     name: {
@@ -14,6 +14,5 @@ const lookupGroupSchema = new mongoose.Schema({
     ],
 });
 
-lookupGroupSchema.plugin(mongooseEncryption);
 const LookupGroupModel = mongoose.model('LookupGroup', lookupGroupSchema);
 export default LookupGroupModel;

package/shared/lookup.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const lookupSchema = new mongoose.Schema({
     name: {
@@ -19,6 +19,5 @@ const lookupSchema = new mongoose.Schema({
     }
 });
 
-lookupSchema.plugin(mongooseEncryption);
 const LookupModel = mongoose.model('Lookup', lookupSchema);
 export default LookupModel;

package/shared/task-document.model.js

@@ -1,5 +1,4 @@
 import mongoose from 'mongoose';
-import mongooseEncryption from '../utils/encryption.middleware.js';
 
 // Define the schema for TaskDocumentType
 const taskDocumentTypeSchema = new mongoose.Schema({
@@ -22,8 +21,6 @@ const taskDocumentTypeSchema = new mongoose.Schema({
     },
 });
 
-// Create the Mongoose model
-taskDocumentTypeSchema.plugin(mongooseEncryption);
 const TaskDocumentTypeModel = mongoose.model('TaskDocumentType', taskDocumentTypeSchema);
 
 export default TaskDocumentTypeModel;

package/shared/task.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const { Schema } = mongoose;
 
@@ -17,6 +17,5 @@ const taskSchema = new Schema({
     actionsOnSuccess: { type: [actionSchema], default: [] },
 }, { timestamps: true });
 
-taskSchema.plugin(mongooseEncryption);
 const TaskModel = mongoose.model("Task", taskSchema);
 export default TaskModel;

package/underwriters/underwriters.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 
 const underwritersSchema = new mongoose.Schema({
@@ -17,6 +17,5 @@ const underwritersSchema = new mongoose.Schema({
     timestamps: true
 });
 
-underwritersSchema.plugin(mongooseEncryption);
 const UnderwritersModel = mongoose.model('Underwriter', underwritersSchema);
 export default UnderwritersModel;

package/users/permission.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const permissionSchema = new mongoose.Schema({
     name: { type: String, required: true },
@@ -9,7 +9,6 @@ const permissionSchema = new mongoose.Schema({
     timestamps: true
 });
 
-permissionSchema.plugin(mongooseEncryption);
 const PermissionModel = mongoose.model('Permission', permissionSchema);
 
 export default PermissionModel;

package/users/role-group.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const RoleGroupSchema = new mongoose.Schema({
     groupId: { type: String, required: true },
@@ -13,6 +13,5 @@ const RoleGroupSchema = new mongoose.Schema({
     timestamps: true
 });
 
-RoleGroupSchema.plugin(mongooseEncryption);
 const RoleGroupModel = mongoose.model('RoleGroup', RoleGroupSchema);
 export default RoleGroupModel;

package/users/role.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const RoleSchema = new mongoose.Schema({
     roleId: { type: String, required: true },
@@ -12,7 +12,6 @@ const RoleSchema = new mongoose.Schema({
     timestamps: true
 });
 
-RoleSchema.plugin(mongooseEncryption);
 const RoleModel = mongoose.model('Role', RoleSchema);
 
 export default RoleModel;

package/users/tasks.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const TasksSchema = new mongoose.Schema({
     taskTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null }, // LookupGroup: TaskType ["Document", "Information"]
@@ -14,7 +14,6 @@ const TasksSchema = new mongoose.Schema({
     timestamps: true 
 });
 
-TasksSchema.plugin(mongooseEncryption);
 const TasksModel = mongoose.model("Tasks", TasksSchema);
 
 export default TasksModel;

package/users/user.model.js

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import mongooseEncryption from "../utils/encryption.middleware.js";
+
 
 const ClaimSchema = new mongoose.Schema({
     key: { type: String, required: true },
@@ -30,7 +30,6 @@ const userSchema = new mongoose.Schema({
     timestamps: true
 });
 
-userSchema.plugin(mongooseEncryption);
 const UserModel = mongoose.model('User', userSchema);
 
 export default UserModel;

package/utils/encryption.js

@@ -1,106 +0,0 @@
-import crypto from 'crypto';
-import dotenv from 'dotenv';
-import mongoose from 'mongoose';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-// Get current directory
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Load environment variables
-dotenv.config({
-    path: path.resolve(__dirname, '../../../../.env'),
-});
-
-// Encryption settings
-const SECRET_KEY = Buffer.from(process.env.ENCRYPTION_KEY, 'hex'); // 32 bytes for AES-256
-const IV_LENGTH = 16; // AES-GCM IV length
-const EXCLUDED_COLLECTIONS = process.env.EXCLUDED_COLLECTIONS?.split(',') || []; // Collections excluded from encryption
-
-// Function to check if a value is an ObjectId or array of ObjectIds
-const isObjectIdOrArray = (value) => {
-    if (Array.isArray(value)) {
-        return value.every((item) => mongoose.isValidObjectId(item));
-    }
-    return mongoose.isValidObjectId(value);
-};
-
-// **Deterministic IV Generation (for consistent encryption)**
-const deriveIV = (value) => {
-    const hash = crypto.createHash('sha256').update(value.toString()).digest();
-    return hash.slice(0, IV_LENGTH); // First 16 bytes as IV
-};
-
-// **Encrypt a Single Value Deterministically**
-const encryptValue = (value) => {
-    if(!value) {
-        return value;
-    }
-    const iv = deriveIV(value); // Same IV for same value (allows searching)
-    const cipher = crypto.createCipheriv('aes-256-gcm', SECRET_KEY, iv);
-
-    let encrypted = cipher.update(JSON.stringify(value), 'utf8', 'hex');
-    encrypted += cipher.final('hex');
-
-    const authTag = cipher.getAuthTag().toString('hex'); // Authentication tag
-
-    return `${iv.toString('hex')}:${authTag}:${encrypted}`;
-};
-
-// **Encrypt an Object (excluding ObjectId references & _id)**
-export const encryptObject = (obj, collectionName) => {
-    if (EXCLUDED_COLLECTIONS.includes(collectionName) || !obj || typeof obj !== 'object') {
-        return obj;
-    }
-
-    let encryptedObj = {};
-    for (const key in obj) {
-        if (key === '_id' || isObjectIdOrArray(obj[key])) {
-            encryptedObj[key] = obj[key]; // Keep _id and ObjectId references unchanged
-        } else {
-            try {
-                encryptedObj[key] = encryptValue(obj[key]);
-            } catch (error) {
-                console.error(`Encryption error for key "${key}":`, error);
-                encryptedObj[key] = obj[key]; // Fallback to original value
-            }
-        }
-    }
-
-    return encryptedObj;
-};
-
-// **Decrypt an Object (excluding ObjectId references & _id)**
-export const decryptObject = (obj, collectionName) => {
-    if (EXCLUDED_COLLECTIONS.includes(collectionName) || !obj || typeof obj !== 'object') {
-        return obj;
-    }
-
-    let decryptedObj = {};
-    for (const key in obj) {
-        if (key === '_id' || isObjectIdOrArray(obj[key])) {
-            decryptedObj[key] = obj[key]; // Keep _id and ObjectId references unchanged
-        } else {
-            try {
-                if(Array.isArray(obj[key]) || !obj[key]) {
-                    decryptedObj[key] = obj[key];
-                    continue;
-                }
-                const [ivHex, authTagHex, encryptedData] = obj[key].split(':');
-                const iv = Buffer.from(ivHex, 'hex');
-                const authTag = Buffer.from(authTagHex, 'hex');
-                const decipher = crypto.createDecipheriv('aes-256-gcm', SECRET_KEY, iv);
-                decipher.setAuthTag(authTag);
-                let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
-                decrypted += decipher.final('utf8');
-                decryptedObj[key] = JSON.parse(decrypted);
-            } catch (error) {
-                console.error(`Decryption error for key "${key}":`, error);
-                decryptedObj[key] = obj[key]; // Fallback to original value
-            }
-        }
-    }
-
-    return decryptedObj;
-};

package/utils/encryption.middleware.js

@@ -1,146 +0,0 @@
-import dotenv from 'dotenv';
-import { decryptObject, encryptObject } from '@dynamatix/gb-schemas/utils';
-
-dotenv.config();
-
-// Read excluded collections from .env
-const EXCLUDED_COLLECTIONS = process.env.EXCLUDED_COLLECTIONS?.split(",") || [];
-
-export default function mongooseEncryption(schema, options) {
-    console.log("========MONGOOSE ENCRYPTION IS IN PROGRESS");
-
-    const collectionName = options?.collection || schema.options.collection;
-
-    // Skip encryption for excluded collections
-    if (EXCLUDED_COLLECTIONS.includes(collectionName)) {
-        return;
-    }
-
-    // Encrypt query parameters before execution
-    schema.pre(['find', 'findOne', 'findById'], function (next) {
-        this.getQuery(); // Ensure the query is processed
-        const encryptedQuery = encryptObject(this.getQuery(), collectionName);
-        this.setQuery(encryptedQuery);
-        next();
-    });
-
-
-    // Encrypt before saving (e.g., insert, update)
-    schema.pre(['save','create'], function (next) {
-        // Encrypt the document before saving to the database
-        this.set(encryptObject(this.toObject(), collectionName)); // Encrypt the document
-        next();
-    });
-
-    // Encrypt before update operations (single or multiple documents)
-    schema.pre("update", function (result) {
-        if (Array.isArray(result)) {
-            result.forEach(doc => doc.set(decryptObject(doc.toObject(), collectionName)));
-        } else {
-            result.set(encryptObject(result.toObject(), collectionName)); // Decrypt single document
-        }
-    });
-
-    // Encrypt after updateOne operations
-    schema.pre(["updateOne","findOneAndUpdate"], function (result) {
-        if (result && result.toObject) {
-            result.set(encryptObject(result.toObject(), collectionName)); // Decrypt single document
-        }
-    });
-
-    // Encrypt before bulkWrite operations
-    schema.pre("bulkWrite", function (next, operations) {
-        operations.forEach(operation => {
-            if (operation.insertOne && operation.insertOne.document) {
-                operation.insertOne.document = encryptObject(operation.insertOne.document, collectionName);
-            } else if (operation.updateOne && operation.updateOne.update) {
-                operation.updateOne.update = encryptObject(operation.updateOne.update, collectionName);
-            } else if (operation.updateMany && operation.updateMany.update) {
-                operation.updateMany.update = encryptObject(operation.updateMany.update, collectionName);
-            }
-        });
-        next();
-    });
-    
-    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];
-                }
-            }
-        });
-
-        // ✅ 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","create","save"], function (result) {
-        if (Array.isArray(result)) {
-            result.forEach(doc => doc.set(decryptObject(doc.toObject(), collectionName)));
-        } else {
-            result.set(decryptObject(result.toObject(), collectionName)); // Decrypt single document
-        }
-    });
-
-    // Decrypt after updateOne operations
-    schema.post("updateOne", function (result) {
-        if (result && result.toObject) {
-            result.set(decryptObject(result.toObject(), collectionName)); // Decrypt single document
-        }
-    });
-
-
-    // Decrypt after findOneAndUpdate operations
-    schema.post(["findOneAndUpdate","findOneAndDelete","deleteOne","remove"], function (doc) {
-        if (doc) {
-            doc.set(decryptObject(doc.toObject(), collectionName)); // Decrypt single document
-        }
-    });
-
-    // Decrypt after deleteMany operations
-    schema.post("deleteMany", function (result) {
-        if (Array.isArray(result)) {
-            result.forEach(doc => doc.set(decryptObject(doc.toObject(), collectionName))); // Decrypt document fields
-        }
-    });
-}