@dynamatix/gb-schemas 0.21.12 → 0.21.14

package/applicants/applicant-employment.model.js

@@ -18,7 +18,7 @@ const applicantEmploymentSchema = new mongoose.Schema({
 
     classLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
     contractRemaining: { type: String },
-    dateJoined: { type: Date },
+    dateJoined: { type: String },
     disabilityLiving: { type: String },
     employerName: { type: String },
     employerTelephone: { type: String },
@@ -37,8 +37,8 @@ const applicantEmploymentSchema = new mongoose.Schema({
     previousAddressLine3: { type: String },
     previousAddressPostCode: { type: String },
     previousBasicGrossIncome: { type: String },
-    previousDateJoined: { type: Date },
-    previousDateLeft: { type: Date },
+    previousDateJoined: { type: String },
+    previousDateLeft: { type: String },
     previousEmployerName: { type: String },
     previousEmployerTelephone: { type: String },
     previousJobTitle: { type: String },

package/applicants/applicant-income.model.js

@@ -20,8 +20,8 @@ const incomeSchema = new mongoose.Schema({
     businessType: { type: String, default: '4' },
     charteredCertifiedOrOther: { type: String, default: '' },
     contactName: { type: String, default: '' },
-    currentYearEnd: { type: Date, default: null },
-    dateEstablished: { type: Date, default: null },
+    currentYearEnd: { type: String, default: null },
+    dateEstablished: { type: String, default: null },
     doYouHaveAccountant: { type: String, default: false },
     isBusinessAddressDifferent: { type: String, default: false },
     nameOfBusiness: { type: String, default: '' },
@@ -38,7 +38,7 @@ const incomeSchema = new mongoose.Schema({
     registeredCountry: { type: String, default: 'GBR' },
     registeredPostCode: { type: String, default: '' },
     registeredTelephone: { type: String, default: '' },
-    selfEmployedDate: { type: Date, default: null },
+    selfEmployedDate: { type: String, default: null },
     turnover1: { type: String, default: 0.0 },
     turnover2: { type: String, default: 0.0 },
     turnover3: { type: String, default: 0.0 },

package/applicants/applicant.model.js

@@ -18,7 +18,7 @@ const applicantSchema = new mongoose.Schema({
     addressLine1: { type: String, default: null },
     addressLine2: { type: String, default: null },
     addressLine3: { type: String, default: null },
-    addressMovedDate: { type: Date, default: null },
+    addressMovedDate: { type: String, default: null },
     addressPostCode: { type: String, default: null },
     correspondenceAddressCity: { type: String, default: null },
     correspondenceAddressCountry: { type: String, default: null },
@@ -27,7 +27,7 @@ const applicantSchema = new mongoose.Schema({
     correspondenceAddressLine3: { type: String, default: null },
     correspondenceAddressPostCode: { type: String, default: null },
     countryOfResidenceLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    dateOfBirth: { type: Date, default: null },
+    dateOfBirth: { type: String, default: null },
     dependant10Age: { type: String, default: 0 },
     dependant1Age: { type: String, default: 0 },
     dependant2Age: { type: String, default: 0 },
@@ -74,7 +74,7 @@ const applicantSchema = new mongoose.Schema({
     previous1AddressLine1: { type: String, default: null },
     previous1AddressLine2: { type: String, default: null },
     previous1AddressLine3: { type: String, default: null },
-    previous1AddressMovedDate: { type: Date, default: null },
+    previous1AddressMovedDate: { type: String, default: null },
     previous1AddressPostCode: { type: String, default: null },
     previous1AddressPropertyOwnedBy: { type: String, default: null },
     previous2AddressCity: { type: String, default: null },
@@ -82,7 +82,7 @@ const applicantSchema = new mongoose.Schema({
     previous2AddressLine1: { type: String, default: null },
     previous2AddressLine2: { type: String, default: null },
     previous2AddressLine3: { type: String, default: null },
-    previous2AddressMovedDate: { type: Date, default: null },
+    previous2AddressMovedDate: { type: String, default: null },
     previous2AddressPostCode: { type: String, default: null },
     previous2AddressPropertyOwnedBy: { type: String, default: null },
     relationshipToOthersLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },

package/applications/application-audit.model.js

@@ -15,7 +15,7 @@ const applicationAuditSchema = new mongoose.Schema({
         required: true
     },
     auditDate: {
-        type: Date,
+        type: String,
         required: true
     },
     changeType: {

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

@@ -4,19 +4,19 @@ import mongooseEncryption from "../utils/encryption.middleware.js";
 const checkListItemSchema = new mongoose.Schema({
   additionalOfferConditions: { type: String, default: "" },
   appFormSignedNotes: { type: String, default: "" },
-  applicationCompletionDate: { type: Date },
+  applicationCompletionDate: { type: String },
   buildingInsuranceInsurerName: { type: String, default: "" },
   buildingInsurancePolicyNumber: { type: String, default: "" },
   buildingInsuranceReceived: { type: String, default: "" },
-  buildingInsuranceRenewalDate: { type: Date },
-  dateOfValuationReceived: { type: Date },
+  buildingInsuranceRenewalDate: { type: String },
+  dateOfValuationReceived: { type: String },
   feePaidDocumentsDownloaded: { type: String, default: "" },
   feePaidNotes: { type: String, default: "" },
   fundsNotes: { type: String, default: "" },
-  fundsReleasedDate: { type: Date },
+  fundsReleasedDate: { type: String },
   hasAllDocsReviewedAndAccepted: { type: String, default: "" },
   idnPorReceived: { type: String, default: "" },
-  legalCompletionDate: { type: Date },
+  legalCompletionDate: { type: String },
   legalDocsReceived: { type: String, default: "" },
   legalNotes: { type: String, default: "" },
   ninetyDaysValuationAmount: { type: String, default: "" },
@@ -26,21 +26,21 @@ const checkListItemSchema = new mongoose.Schema({
   offerOfferPrepared: { type: String, default: "" },
   offerOfferReviewed: { type: String, default: "" },
   offerSignedNotes: { type: String, default: "" },
-  offerSolicitorInstructedDate: { type: Date },
+  offerSolicitorInstructedDate: { type: String },
   packagingNotes: { type: String, default: "" },
   preOfferNotes: { type: String, default: "" },
   reinstatementAmount: { type: String, default: "" },
   rotReceived: { type: String, default: "" },
-  rotReceivedDate: { type: Date },
+  rotReceivedDate: { type: String },
   salesContractReceived: { type: String, default: "" },
   underwritingNotes: { type: String, default: "" },
   underwritingValuationNotes: { type: String, default: "" },
-  valuationAccepted: { type: Date },
+  valuationAccepted: { type: String },
   valuationFurtherConditions: { type: String, default: "" },
   valuationNotes: { type: String, default: "" },
-  valuationReceived: { type: Date },
-  valuationRequestedDate: { type: Date },
-  valuationScheduledDate: { type: Date },
+  valuationReceived: { type: String },
+  valuationRequestedDate: { type: String },
+  valuationScheduledDate: { type: String },
   valuationSurveyorDetails: { type: String, default: "" }
 });
 

package/applications/application-document.model.js

@@ -17,7 +17,7 @@ const documentSchema = new mongoose.Schema({
     documentTypeId: { type: String, required: false },
     fileName: { type: String, required: false },
     contentType: { type: String, required: false },
-    created: { type: Date, required: false },
+    created: { type: String, required: false },
     createdBy: { type: String, required: false },
     isGenerated: { type: String, required: false },
     data: { type: String, required: false },

package/applications/application-note.model.js

@@ -8,7 +8,7 @@ const noteSchema = new mongoose.Schema({
         default: null
     },
     createdOn: {
-        type: Date,
+        type: String,
         default: null
     },
     createdBy: {
@@ -29,7 +29,7 @@ const noteSchema = new mongoose.Schema({
         required: true
     },
     reminderDate: {
-        type: Date,
+        type: String,
         default: null
     },
     attachmentDocumentId: {

package/applications/application-offer.model.js

@@ -2,7 +2,7 @@ import mongoose from "mongoose";
 import mongooseEncryption from "../utils/encryption.middleware.js";
 
 const offerSchema = new mongoose.Schema({
-  date: { type: Date } // The date associated with the offer
+  date: { type: String } // The date associated with the offer
 });
 
 

package/applications/application-onboarding.model.js

@@ -4,7 +4,7 @@ import mongooseEncryption from "../utils/encryption.middleware.js";
 const onboardingSchema = new mongoose.Schema({
   errors: { type: String, default: "" }, 
   status: { type: String, default: "" }, 
-  statusDate: { type: Date },
+  statusDate: { type: String },
   warnings: { type: String, default: "" } 
 });
 

package/applications/application.model.js

@@ -27,7 +27,7 @@ const applicationSchema = new mongoose.Schema(
     isBrokerAssigned: { type: String, default: false },
     isFinanceRecommendedToApplicant: { type: String, required: true },
     isWorkflowTaskCreated: { type: String, required: true },
-    lastUpdated: { type: Date },
+    lastUpdated: { type: String },
     lendingTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
     networkClubName: { type: String, default: "" },
     isNetworkClubSubmission: { type: String, required: true },
@@ -44,7 +44,7 @@ const applicationSchema = new mongoose.Schema(
     sowSalary: { type: String, default: "" },
     statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
     submitReason: { type: String, default: "" },
-    submittedDate: { type: Date },
+    submittedDate: { type: String },
     underwriter: { type: String, default: "" },
     isValuationFeePaid: { type: String, required: true },
     withdrawalReason: { type: String, default: "" },
@@ -57,7 +57,7 @@ const applicationSchema = new mongoose.Schema(
       { type: mongoose.Schema.Types.ObjectId, ref: "Applicant" }
     ],
     statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    submittedDate: { type: Date },
+    submittedDate: { type: String },
     isValuationFeePaid: { type: String, required: true },
     isActive: { type: String, default: false },
     isUkResident: { type: String, default: true },

package/applications/document.model.js

@@ -17,7 +17,7 @@ const documentSchema = new mongoose.Schema({
     documentTypeId: { type: mongoose.Schema.Types.ObjectId, ref: "DocumentType", required: false },
     fileName: { type: String, required: false },
     contentType: { type: String, required: false },
-    created: { type: Date, required: false },
+    created: { type: String, required: false },
     createdBy: { type: String, required: false },
     isGenerated: { type: String, required: false },
     data: { type: String, required: false },

package/applications/productfeatures.model.js

@@ -49,7 +49,7 @@ const productFeaturesSchema = new mongoose.Schema({
     totalReversionRate: { type: String, default: null },
     initialRate: { type: String, required: true },
     fixedTerm: { type: String, required: true },
-    fixedTermEndDate: { type: Date, default: null },
+    fixedTermEndDate: { type: String, default: null },
     baseRate: { type: String, default: null },
     productRate: { type: String, default: null },
     apr: { type: String, default: null },
@@ -72,11 +72,11 @@ const productFeaturesSchema = new mongoose.Schema({
     ercCode: { type: String, default: '' },
     variableTerm: { type: String, default: null },
     totalFeePayable: { type: String, default: null },
-    dipIssueDate: { type: Date, default: null },
-    estimatedCompletionDate: { type: Date, default: null },
-    dipExpiryDate: { type: Date, default: null },
-    fixedRepaymentUntillDate: { type: Date, default: null },
-    rentalReviewDate: { type: Date, default: null },
+    dipIssueDate: { type: String, default: null },
+    estimatedCompletionDate: { type: String, default: null },
+    dipExpiryDate: { type: String, default: null },
+    fixedRepaymentUntillDate: { type: String, default: null },
+    rentalReviewDate: { type: String, default: null },
     totalReimbursementWithFee: { type: String, default: null },
     finalRentPayment: { type: String, default: null },
     clientDeposit: { type: String, default: null },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamatix/gb-schemas",
-  "version": "0.21.12",
+  "version": "0.21.14",
   "description": "All the schemas for gatehouse bank back-end",
   "main": "index.js",
   "scripts": {

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

@@ -5,9 +5,9 @@ const productCatalogueSchema = new mongoose.Schema({
     productCatalogueId: { type: String, required: true }, 
     name: { type: String, required: true },
     description: { type: String },
-    applyFrom: { type: Date, required: true },
-    applyUntil: { type: Date, required: true },
-    submitUntil: { type: Date, required: true },
+    applyFrom: { type: String, required: true },
+    applyUntil: { type: String, required: true },
+    submitUntil: { type: String, required: true },
     status: { type: String, required: true },
     lockedForEdit: { type: String, required: true },
     baseRateName: { type: String },

package/shared/apprivo-sync-journey.model.js

@@ -12,8 +12,7 @@ const ApprivoSyncJourneySchema = new mongoose.Schema({
   isFirstPull: { type: String, required: true },
   jobRunId: { type: mongoose.Schema.Types.ObjectId, ref: "Job_Run"},
   startTime: {type: Date, default: null},
-  endTime: {type: Date, default: null},
-  timestamp: { type: Date, default: Date.now }
+  endTime: { type: Date, default: null},
 }, {timestamps: true});
 
 const ApprivoSyncJourneyModel = mongoose.model('ApprivoSyncJourney', ApprivoSyncJourneySchema);

package/shared/error-log.model.js

@@ -4,10 +4,10 @@ const errorSchema = new mongoose.Schema({
     error_message: { type: String, required: true },
     status_code: { type: Number, required: true },
     route: { type: String, required: true },
-    timestamp: { type: Date, default: Date.now },
     user_agent: { type: String, required: true },
     stack_trace: [{ type: String }]
-});
+},
+{ timestamps: true });
 
 const ErrorLogModel = mongoose.model("Error_Log", errorSchema);
 export default ErrorLogModel;

package/users/user.model.js

@@ -19,11 +19,11 @@ const userSchema = new mongoose.Schema({
     }],
     claims: [ClaimSchema],
     externalData: { type: mongoose.Schema.Types.Mixed },
-    modifiedOn: { type: Date },
+    modifiedOn: { type: String },
     modifiedById: { type: String },
-    createdOnInApprivo: { type: Date, default: Date.now },
+    createdOnInApprivo: { type: String},
     createdById: { type: String },
-    deletedOn: { type: Date },
+    deletedOn: { type: String },
     deletedById: { type: String },
     token: { type: String }
 }, {

package/utils/encryption.js

@@ -8,77 +8,75 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// Configure dotenv with path to the .env file
-dotenv.config({ 
-  path: path.resolve(__dirname, '../../../../.env') // Adjust the path as needed
+// 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(",") || []; // Excluded collections from encryption
+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);
+};
 
-// Encrypt an object (ignores _id and fields from excluded collections).
+// Encrypt an object (excluding _id and ObjectId references)
 export const encryptObject = (obj, collectionName) => {
-    // Skip encryption if the collection is excluded
-    if (EXCLUDED_COLLECTIONS.includes(collectionName)) {
+    if (EXCLUDED_COLLECTIONS.includes(collectionName) || !obj || typeof obj !== 'object') {
         return obj;
     }
 
-    if (!obj || typeof obj !== "object") return obj;
     let encryptedObj = {};
-
     for (const key in obj) {
-        if (
-            key === "_id" ||
-            (Array.isArray(obj[key]) && obj[key].every(item => mongoose.isValidObjectId(item))) ||
-            mongoose.isValidObjectId(obj[key])
-        ) {
-            encryptedObj[key] = obj[key]; // Don't encrypt ObjectId references
+        if (key === '_id' || isObjectIdOrArray(obj[key])) {
+            encryptedObj[key] = obj[key]; // Skip _id and ObjectIds
         } else {
-            const iv = crypto.randomBytes(IV_LENGTH); // Generate IV
-            const cipher = crypto.createCipheriv("aes-256-gcm", SECRET_KEY, iv);
-
-            let encrypted = cipher.update(JSON.stringify(obj[key]), 'utf8', 'hex');
-            encrypted += cipher.final('hex');
-
-            const authTag = cipher.getAuthTag().toString('hex'); // Get auth tag for integrity check
-
-            encryptedObj[key] = `${iv.toString('hex')}:${authTag}:${encrypted}`;
+            try {
+                const iv = crypto.randomBytes(IV_LENGTH);
+                const cipher = crypto.createCipheriv('aes-256-gcm', SECRET_KEY, iv);
+                let encrypted = cipher.update(JSON.stringify(obj[key]), 'utf8', 'hex');
+                encrypted += cipher.final('hex');
+                const authTag = cipher.getAuthTag().toString('hex');
+                encryptedObj[key] = `${iv.toString('hex')}:${authTag}:${encrypted}`;
+            } catch (error) {
+                console.error(`Encryption error for key ${key}:`, error);
+                encryptedObj[key] = obj[key]; // Store original value if encryption fails
+            }
         }
     }
 
     return encryptedObj;
 };
 
-// Decrypt an object (ignores _id and fields from excluded collections)
+// Decrypt an object (excluding _id and ObjectId references)
 export const decryptObject = (obj, collectionName) => {
-    // Skip decryption if the collection is excluded
-    if (EXCLUDED_COLLECTIONS.includes(collectionName)) {
+    if (EXCLUDED_COLLECTIONS.includes(collectionName) || !obj || typeof obj !== 'object') {
         return obj;
     }
 
-    if (!obj || typeof obj !== "object") return obj;
     let decryptedObj = {};
-
     for (const key in obj) {
-        if (key === "_id") {
-            decryptedObj[key] = obj[key]; // Don't decrypt _id
+        if (key === '_id' || isObjectIdOrArray(obj[key])) {
+            decryptedObj[key] = obj[key]; // Skip _id and ObjectIds
         } else {
             try {
                 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);
+                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) {
-                decryptedObj[key] = obj[key]; // Return original if decryption fails
+                console.error(`Decryption error for key ${key}:`, error);
+                decryptedObj[key] = obj[key]; // Store original value if decryption fails
             }
         }
     }

package/utils/encryption.middleware.js

@@ -7,7 +7,7 @@ dotenv.config();
 const EXCLUDED_COLLECTIONS = process.env.EXCLUDED_COLLECTIONS?.split(",") || [];
 
 export default function mongooseEncryption(schema, options) {
-    console.log("========MONGOOSE ENCRYPTION IS IN PROGRESS");
+    console.log("========MONGOOSE ENCRYPTION IS IN PROGRESS========");
 
     const collectionName = options?.collection || schema.options.collection;
 
@@ -16,132 +16,74 @@ export default function mongooseEncryption(schema, options) {
         return;
     }
 
-    // Encrypt before saving (e.g., insert, update)
-    schema.pre("save", function (next) {
-        // Encrypt the document before saving to the database
-        this.set(encryptObject(this.toObject(), collectionName)); // Encrypt the document
+    // ** Encrypt query parameters before execution **
+    schema.pre(['find', 'findOne', 'findById'], function (next) {
+        const query = this.getQuery();
+        this.setQuery(encryptObject(query, collectionName));
         next();
     });
 
-    // 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();
-    });
-    
-    // Encrypt before creating a document
-    schema.pre("create", function (next) {
-        // Encrypt only the fields before saving to the database
-        this.set(encryptObject(this.toObject(), collectionName)); // Encrypt the document
-        next();
-    });
-
-    // Decrypt after creating a document
-    schema.post("create", function (docs) {
-        for (let doc of docs) {
-            doc.set(decryptObject(doc.toObject(), collectionName)); // Decrypt document fields
+    // ** Decrypt result after querying **
+    schema.post(['find', 'findOne', 'findById'], function (docs) {
+        if (Array.isArray(docs)) {
+            docs.forEach((doc) => doc && Object.assign(doc, decryptObject(doc.toObject(), collectionName)));
+        } else if (docs) {
+            Object.assign(docs, decryptObject(docs.toObject(), collectionName));
         }
     });
 
-
-    // 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 before saving (insert, update) **
+    schema.pre(['save', 'create'], function (next) {
+        this.set(encryptObject(this.toObject(), collectionName));
+        next();
     });
 
-    // Decrypt after update operations (single or multiple documents)
-    schema.post("update", 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
+    // ** Encrypt update operations **
+    schema.pre(['updateOne', 'findOneAndUpdate'], function (next) {
+        const update = this.getUpdate();
+        if (update) {
+            this.setUpdate(encryptObject(update, collectionName));
         }
+        next();
     });
 
-    // Encrypt after updateOne operations
-    schema.pre("updateOne", function (result) {
-        if (result && result.toObject) {
-            result.set(encryptObject(result.toObject(), collectionName)); // Decrypt single document
+    // ** Encrypt before bulkWrite operations **
+    schema.pre("bulkWrite", function (next) {
+        const operations = this.getUpdate();
+        if (operations) {
+            operations.forEach((operation) => {
+                if (operation.insertOne?.document) {
+                    operation.insertOne.document = encryptObject(operation.insertOne.document, collectionName);
+                } else if (operation.updateOne?.update) {
+                    operation.updateOne.update = encryptObject(operation.updateOne.update, collectionName);
+                } else if (operation.updateMany?.update) {
+                    operation.updateMany.update = encryptObject(operation.updateMany.update, collectionName);
+                }
+            });
         }
+        next();
     });
 
-    // Decrypt after updateOne operations
-    schema.post("updateOne", function (result) {
-        if (result && result.toObject) {
-            result.set(decryptObject(result.toObject(), collectionName)); // Decrypt single document
+    // ** Decrypt after creating a document **
+    schema.post("create", function (docs) {
+        if (Array.isArray(docs)) {
+            docs.forEach((doc) => Object.assign(doc, decryptObject(doc.toObject(), collectionName)));
+        } else {
+            Object.assign(docs, decryptObject(docs.toObject(), collectionName));
         }
     });
 
-    schema.pre("findOneAndUpdate", function (result) {
+    // ** Decrypt after update operations **
+    schema.post(["updateOne", "findOneAndUpdate"], function (result) {
         if (result && result.toObject) {
-            result.set(encryptObject(result.toObject(), collectionName)); // Decrypt single document
+            Object.assign(result, decryptObject(result.toObject(), collectionName));
         }
     });
 
-    // Decrypt after find operations (e.g., find, findMany)
-    schema.post("find", function (docs) {
-        console.log("find", docs);
-        docs.forEach(doc => {
-            doc.set(decryptObject(doc.toObject(), collectionName)); // Decrypt document fields
-        });
-    });
-
-    // Decrypt after findById operations
-    schema.post("findById", function (doc) {
-        console.log("findById", doc);
-        if (doc) doc.set(decryptObject(doc.toObject(), collectionName)); // Decrypt single document
-    });
-
-    // Decrypt after findOne operations
-    schema.post("findOne", function (doc) {
-        console.log("findOne", doc);
-        if (doc) doc.set(decryptObject(doc.toObject(), collectionName)); // Decrypt single document
-    });
-
-
-    // Decrypt after findOneAndUpdate operations
-    schema.post("findOneAndUpdate", function (doc) {
-        console.log("findOneAndUpdate", doc);
+    // ** Decrypt after findOneAndUpdate, findOneAndDelete, deleteOne, remove **
+    schema.post(["findOneAndUpdate", "findOneAndDelete", "deleteOne"], function (doc) {
         if (doc) {
-            doc.set(decryptObject(doc.toObject(), collectionName)); // Decrypt single document
-        }
-    });
-
-    // Decrypt after findOneAndDelete operations
-    schema.post("findOneAndDelete", function (doc) {
-        console.log("findOneAndDelete", doc);
-        if (doc) doc.set(decryptObject(doc.toObject(), collectionName)); // Decrypt single document
-    });
-
-    // Decrypt after deleteMany operations
-    schema.post("deleteMany", function (result) {
-        console.log("deleteMany", result);
-        if (Array.isArray(result)) {
-            result.forEach(doc => doc.set(decryptObject(doc.toObject(), collectionName))); // Decrypt document fields
+            Object.assign(doc, decryptObject(doc.toObject(), collectionName));
         }
     });
-
-    // Decrypt after deleteOne operations
-    schema.post("deleteOne", function (doc) {
-        console.log("deleteOne", doc);
-        if (doc) doc.set(decryptObject(doc.toObject(), collectionName)); // Decrypt single document
-    });
-
-    // Decrypt after remove operations
-    schema.post("remove", function (doc) {
-        console.log("remove", doc);
-        if (doc) doc.set(decryptObject(doc.toObject(), collectionName)); // Decrypt single document
-    });
 }