@dynamatix/cat-shared 0.0.138 → 0.0.140

package/middlewares/audit.middleware.js

@@ -1,426 +1,426 @@
-import AuditConfigModel from '../models/audit-config.model.js';
-import AuditLog from '../models/audit.model.js';
-import ValueReferenceMap from '../models/value-reference-map.model.js';
-import { getContext } from '../services/request-context.service.js';
-import mongoose from 'mongoose';
-import FormConfigurationModel from '../models/form-configuration.model.js';
-
-let onAuditLogCreated = null;
-
-// Simple utility to get nested property - much cleaner approach
-function getNestedProperty(obj, path) {
-    if (!obj || !path) return undefined;
-
-    // Handle flattened MongoDB keys first
-    if (obj[path] !== undefined) {
-        return obj[path];
-    }
-
-    // Handle nested path
-    return path.split('.').reduce((current, key) => {
-        if (current == null) return undefined;
-
-        // Try Mongoose get method first
-        if (current.get && typeof current.get === 'function') {
-            try {
-                return current.get(key);
-            } catch (e) {
-                // Fall through to direct access
-            }
-        }
-
-        // Direct access or _doc access for Mongoose
-        return current[key] ?? current._doc?.[key];
-    }, obj);
-}
-
-// Simple utility to check if nested property exists
-function hasNestedProperty(obj, path) {
-    if (!obj || !path) return false;
-
-    // Handle flattened MongoDB keys first
-    if (obj.hasOwnProperty(path)) {
-        return true;
-    }
-
-    // Check nested path
-    const keys = path.split('.');
-    let current = obj;
-
-    for (const key of keys) {
-        if (current == null) return false;
-
-        // Try Mongoose get method first
-        if (current.get && typeof current.get === 'function') {
-            try {
-                const value = current.get(key);
-                if (value !== undefined) {
-                    current = value;
-                    continue;
-                }
-            } catch (e) {
-                // Fall through to direct access
-            }
-        }
-
-        // Check direct access or _doc access
-        if (current[key] !== undefined) {
-            current = current[key];
-        } else if (current._doc?.[key] !== undefined) {
-            current = current._doc[key];
-        } else {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-// Optionally, define custom resolvers here
-const customResolvers = {
-    // Example:
-    // expenditureRationale: (doc) => `Rationale for ${doc.type}: ${doc.rationale}`
-};
-
-// Expression-based description resolver: resolves ${fieldName} in the expression using doc, and via Lookup if needed
-async function resolveExpressionDescription(doc, expression, resolverType) {
-    console.log("expression-", expression);
-    console.log("resolverType-", resolverType);
-    const matches = [...expression.matchAll(/\$\{([^}]+)\}/g)];
-    let result = expression;
-    for (const match of matches) {
-        const fieldName = match[1];
-        let value = getNestedProperty(doc, fieldName);
-        if (resolverType === 'lookup' && value && mongoose.models['Lookup']) {
-            const lookupDoc = await mongoose.models['Lookup'].findById(value).lean();
-            value = lookupDoc?.name || value;
-        }
-        result = result.replace(match[0], value ?? '');
-    }
-    return result;
-}
-
-// Update resolveDescription to support expression-based descriptionField
-async function resolveDescription(field, doc) {
-    const modelName = doc.constructor.modelName;
-    const config = await ValueReferenceMap.findOne({ field, model: modelName });
-    console.log("config-", config);
-    if (!config) return field;
-
-    if (config.descriptionField && config.descriptionField.includes('${')) {
-        console.log("config.descriptionField", config.descriptionField);
-        return await resolveExpressionDescription(doc, config.descriptionField, config.descriptionResolverType);
-    }
-    console.log("config.descriptionResolverType", config.descriptionResolverType);
-    switch (config.descriptionResolverType) {
-        case 'lookup': {
-            const lookupId = getNestedProperty(doc, config.descriptionField);
-            if (!lookupId) return '';
-            const lookupDoc = await mongoose.models['Lookup'].findById(lookupId).lean();
-            return lookupDoc?.name || '';
-        }
-        case 'direct':
-            return getNestedProperty(doc, config.descriptionField) || '';
-        case 'displayFieldReturn': // For case we just want to show display field value directly
-            return config.displayField || '';
-        case 'composite':
-            return (config.descriptionFields || [])
-                .map(f => getNestedProperty(doc, f))
-                .filter(Boolean)
-                .join(' ');
-        case 'custom':
-            if (typeof customResolvers?.[config.descriptionFunction] === 'function') {
-                return await customResolvers[config.descriptionFunction](doc);
-            }
-            return '';
-        default:
-            return '';
-    }
-}
-
-// Update resolveEntityDescription to support expression-based descriptionField
-async function resolveEntityDescription(doc, auditConfig) {
-    if (!auditConfig.descriptionResolutorForExternalData) return '';
-    const field = auditConfig.descriptionResolutorForExternalData;
-    const value = getNestedProperty(doc, field);
-    // Try to resolve via ValueReferenceMap
-    console.log("field-", field);
-    const map = await ValueReferenceMap.findOne({ field });
-    console.log("map-", map);
-    if (map?.descriptionResolverType === 'displayFieldReturn') {
-        return map.descriptionField;
-    }
-    if (map && map.descriptionField && map.descriptionField.includes('${')) {
-        return await resolveExpressionDescription(doc, map.descriptionField, map.descriptionResolverType);
-    }
-    if (map && value) {
-        const Model = mongoose.models[map.model];
-        if (Model) {
-            const refDoc = await Model.findById(value).lean();
-            return refDoc?.[map.displayField] || value;
-        }
-    }
-    // Fallback: If it's an ObjectId and Lookup model exists, resolve to name
-    if (mongoose.Types.ObjectId.isValid(value) && mongoose.models['Lookup']) {
-        const lookupDoc = await mongoose.models['Lookup'].findById(value).lean();
-        return lookupDoc?.name || value;
-    }
-    return value;
-}
-
-// Add new function to resolve deletion description
-async function resolveDeletionDescription(doc, auditConfig) {
-    if (!auditConfig.descriptionResolutorForDeletion) return '';
-    const expression = auditConfig.descriptionResolutorForDeletion;
-    return await resolveExpressionDescription(doc, expression, 'direct');
-}
-
-// Utility to build a fieldName -> dataType map from multiple formConfig.sections
-function buildFieldTypeMapFromConfigs(formConfigs) {
-    const map = {};
-    function extractFields(sections) {
-        for (const section of sections || []) {
-            if (section.fields) {
-                for (const f of section.fields) map[f.fieldName] = f.dataType;
-            }
-            if (section.sections) extractFields(section.sections);
-        }
-    }
-    for (const config of formConfigs) {
-        extractFields(config.sections);
-    }
-    return map;
-}
-
-function applyAuditMiddleware(schema, collectionName) {
-    // Handle creation audit
-    schema.post('save', async function (doc) {
-        const auditConfig = await AuditConfigModel.findOne({ collectionName });
-        if (!auditConfig?.trackCreation) return;
-
-        // Fetch all form configs and build fieldTypeMap once
-        const formConfigs = await FormConfigurationModel.find({ collectionName });
-        const fieldTypeMap = buildFieldTypeMapFromConfigs(formConfigs);
-
-        const context = getContext();
-        const userId = context?.userId || null;
-        const contextId = context?.contextId;
-
-        const entityDescription = await resolveEntityDescription(doc, auditConfig);
-        let logs = [];
-
-        // Per-field logs
-        if (auditConfig.fields?.length) {
-            for (const field of auditConfig.fields) {
-                let lookupName;
-                const newValue = getNestedProperty(doc, field);
-                if (field.endsWith('Lid')) {
-                    const newlookupDoc = await mongoose.models['Lookup'].findById(newValue).lean();
-                    if (newlookupDoc) {
-                        lookupName = newlookupDoc.name;
-                    } else {
-                        lookupName = '';
-                    }
-                }
-                const fieldDescription = await resolveDescription(field, doc);
-                // --- Add pound prefix if needed ---
-                let displayNewValue = lookupName || newValue;
-                const dataType = fieldTypeMap[field];
-                if (dataType === 'pound' && displayNewValue != null && displayNewValue !== '') {
-                    displayNewValue = `£${displayNewValue}`;
-                }
-                logs.push({
-                    name: fieldDescription,
-                    entity: entityDescription,
-                    recordId: contextId || doc._id,
-                    oldValue: null,
-                    newValue: displayNewValue,
-                    createdBy: userId,
-                    externalData: {
-                        description: entityDescription,
-                        contextId
-                    }
-                });
-            }
-        }
-        logs = logs.filter(log => {
-            // Convert null/undefined to empty string for comparison
-            const oldVal = log.oldValue ?? '';
-            const newVal = log.newValue ?? '';
-            return oldVal !== newVal;
-        });
-        if (logs.length) {
-            await AuditLog.insertMany(logs);
-            await updateContextAuditCount(contextId, logs.length);
-            if (onAuditLogCreated) {
-                await onAuditLogCreated(logs, contextId);
-            }
-        }
-    });
-
-    // Capture the original doc before update
-    schema.pre(['findOneAndUpdate', 'findByIdAndUpdate'], async function (next) {
-        this._originalDoc = await this.model.findOne(this.getQuery()).lean();
-        next();
-    });
-
-    // Handle update audits
-    schema.post(['findOneAndUpdate', 'findByIdAndUpdate'], async function (result) {
-        if (!result) return;
-
-        const auditConfig = await AuditConfigModel.findOne({ collectionName });
-        if (!auditConfig?.fields?.length) return;
-
-        // Fetch all form configs and build fieldTypeMap once
-        const formConfigs = await FormConfigurationModel.find({ collectionName });
-        const fieldTypeMap = buildFieldTypeMapFromConfigs(formConfigs);
-
-        const update = this.getUpdate();
-        let logs = [];
-        const context = getContext();
-        const userId = context?.userId || null;
-        const contextId = context?.contextId;
-
-        const entityDescription = await resolveEntityDescription(result, auditConfig);
-
-        for (const field of auditConfig.fields) {
-            console.log("field", field);
-            const hasChanged =
-                (update?.$set && hasNestedProperty(update.$set, field)) ||
-                (update && hasNestedProperty(update, field));
-            console.log("hasChanged", hasChanged);
-            if (hasChanged) {
-                const newValue = getNestedProperty(update?.$set, field) ?? getNestedProperty(update, field);
-                const oldValue = this._originalDoc ? getNestedProperty(this._originalDoc, field) : undefined;
-                let lookupOldName;
-                let lookupNewName;
-                if (field.endsWith('Lid')) {
-                    const newlookupDoc = await mongoose.models['Lookup'].findById(newValue).lean();
-                    if (newlookupDoc) {
-                        lookupNewName = newlookupDoc.name;
-                    } else {
-                        lookupNewName = '';
-                    }
-                    const oldlookupDoc = await mongoose.models['Lookup'].findById(oldValue).lean();
-                    if (oldlookupDoc) {
-                        lookupOldName = oldlookupDoc.name;
-                    } else {
-                        lookupOldName = '';
-                    }
-                }
-                // Convert null/undefined to empty string for comparison
-                let displayOldValue = lookupOldName ?? oldValue ?? '';
-                let displayNewValue = lookupNewName ?? newValue ?? '';
-                console.log("displayOldValue", displayOldValue);
-                console.log("displayNewValue", displayNewValue);
-                // --- Add pound prefix if needed ---
-                const dataType = fieldTypeMap[field];
-                if (dataType === 'pound') {
-                    if (displayOldValue != null && displayOldValue !== '') displayOldValue = `£${displayOldValue}`;
-                    if (displayNewValue != null && displayNewValue !== '') displayNewValue = `£${displayNewValue}`;
-                }
-                if (displayOldValue !== displayNewValue) {
-                    const fieldDescription = await resolveDescription(field, result);
-                    console.log("fieldDescription-", fieldDescription);
-                    logs.push({
-                        name: fieldDescription,
-                        entity: entityDescription,
-                        recordId: contextId || result._id,
-                        oldValue: displayOldValue,
-                        newValue: displayNewValue,
-                        createdBy: userId,
-                        externalData: {
-                            description: entityDescription,
-                            contextId: contextId || result._id
-                        }
-                    });
-                }
-            }
-        }
-        console.log("logs", logs);
-        logs = logs.filter(log => {
-            // Convert null/undefined to empty string for comparison
-            const oldVal = log.oldValue ?? '';
-            const newVal = log.newValue ?? '';
-            return oldVal !== newVal;
-        });
-        console.log("logs.length", logs.length);
-        if (logs.length) {
-            console.log("logs.length", logs.length);
-            await AuditLog.insertMany(logs);
-            await updateContextAuditCount(contextId, logs.length);
-            if (onAuditLogCreated) {
-                await onAuditLogCreated(logs, contextId);
-            }
-        }
-    });
-
-    // Handle delete audits
-    schema.pre(['findOneAndDelete', 'findByIdAndDelete', 'deleteOne', 'deleteMany'], async function (next) {
-        try {
-            // Fetch the document before deletion
-            const docToDelete = await this.model.findOne(this.getQuery()).lean();
-            if (docToDelete) {
-                // Store the document for use in post middleware
-                this._docToDelete = docToDelete;
-            }
-            next();
-        } catch (error) {
-            next(error);
-        }
-    });
-
-    schema.post(['findOneAndDelete', 'findByIdAndDelete', 'deleteOne', 'deleteMany'], async function (result) {
-        if (!result) return;
-
-        const auditConfig = await AuditConfigModel.findOne({ collectionName });
-        if (!auditConfig?.trackDeletion) return;
-
-        const context = getContext();
-        const userId = context?.userId || null;
-        const contextId = context?.contextId;
-
-        const entityDescription = await resolveEntityDescription(this._docToDelete, auditConfig);
-        const deletionDescription = await resolveDeletionDescription(this._docToDelete, auditConfig);
-
-        const log = {
-            name: deletionDescription || 'Entity Deletion',
-            entity: entityDescription,
-            recordId: contextId || this._docToDelete._id,
-            oldValue: '',
-            newValue: 'Deleted',
-            createdBy: userId,
-            externalData: {
-                description: entityDescription,
-                contextId: contextId || this._docToDelete._id
-            }
-        };
-        const oldVal = log.oldValue ?? '';
-        const newVal = log.newValue ?? '';
-        if (oldVal === newVal) {
-            return;
-        }
-        await AuditLog.create(log);
-        await updateContextAuditCount(contextId, 1);
-        if (onAuditLogCreated) {
-            await onAuditLogCreated([log], contextId);
-        }
-    });
-}
-
-async function updateContextAuditCount(contextId, count) {
-    count = Number(count);
-    if (!contextId || isNaN(count)) return;
-    const model = mongoose.models['Application'];
-    await model.findByIdAndUpdate(
-        { _id: contextId },
-        { $inc: { newAuditRecordsCount: count } },
-        { new: true, upsert: true }
-    );
-}
-
-export function registerAuditHook(callback) {
-    onAuditLogCreated = callback;
-}
-
+import AuditConfigModel from '../models/audit-config.model.js';
+import AuditLog from '../models/audit.model.js';
+import ValueReferenceMap from '../models/value-reference-map.model.js';
+import { getContext } from '../services/request-context.service.js';
+import mongoose from 'mongoose';
+import FormConfigurationModel from '../models/form-configuration.model.js';
+
+let onAuditLogCreated = null;
+
+// Simple utility to get nested property - much cleaner approach
+function getNestedProperty(obj, path) {
+    if (!obj || !path) return undefined;
+
+    // Handle flattened MongoDB keys first
+    if (obj[path] !== undefined) {
+        return obj[path];
+    }
+
+    // Handle nested path
+    return path.split('.').reduce((current, key) => {
+        if (current == null) return undefined;
+
+        // Try Mongoose get method first
+        if (current.get && typeof current.get === 'function') {
+            try {
+                return current.get(key);
+            } catch (e) {
+                // Fall through to direct access
+            }
+        }
+
+        // Direct access or _doc access for Mongoose
+        return current[key] ?? current._doc?.[key];
+    }, obj);
+}
+
+// Simple utility to check if nested property exists
+function hasNestedProperty(obj, path) {
+    if (!obj || !path) return false;
+
+    // Handle flattened MongoDB keys first
+    if (obj.hasOwnProperty(path)) {
+        return true;
+    }
+
+    // Check nested path
+    const keys = path.split('.');
+    let current = obj;
+
+    for (const key of keys) {
+        if (current == null) return false;
+
+        // Try Mongoose get method first
+        if (current.get && typeof current.get === 'function') {
+            try {
+                const value = current.get(key);
+                if (value !== undefined) {
+                    current = value;
+                    continue;
+                }
+            } catch (e) {
+                // Fall through to direct access
+            }
+        }
+
+        // Check direct access or _doc access
+        if (current[key] !== undefined) {
+            current = current[key];
+        } else if (current._doc?.[key] !== undefined) {
+            current = current._doc[key];
+        } else {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// Optionally, define custom resolvers here
+const customResolvers = {
+    // Example:
+    // expenditureRationale: (doc) => `Rationale for ${doc.type}: ${doc.rationale}`
+};
+
+// Expression-based description resolver: resolves ${fieldName} in the expression using doc, and via Lookup if needed
+async function resolveExpressionDescription(doc, expression, resolverType) {
+    console.log("expression-", expression);
+    console.log("resolverType-", resolverType);
+    const matches = [...expression.matchAll(/\$\{([^}]+)\}/g)];
+    let result = expression;
+    for (const match of matches) {
+        const fieldName = match[1];
+        let value = getNestedProperty(doc, fieldName);
+        if (resolverType === 'lookup' && value && mongoose.models['Lookup']) {
+            const lookupDoc = await mongoose.models['Lookup'].findById(value).lean();
+            value = lookupDoc?.name || value;
+        }
+        result = result.replace(match[0], value ?? '');
+    }
+    return result;
+}
+
+// Update resolveDescription to support expression-based descriptionField
+async function resolveDescription(field, doc) {
+    const modelName = doc.constructor.modelName;
+    const config = await ValueReferenceMap.findOne({ field, model: modelName });
+    console.log("config-", config);
+    if (!config) return field;
+
+    if (config.descriptionField && config.descriptionField.includes('${')) {
+        console.log("config.descriptionField", config.descriptionField);
+        return await resolveExpressionDescription(doc, config.descriptionField, config.descriptionResolverType);
+    }
+    console.log("config.descriptionResolverType", config.descriptionResolverType);
+    switch (config.descriptionResolverType) {
+        case 'lookup': {
+            const lookupId = getNestedProperty(doc, config.descriptionField);
+            if (!lookupId) return '';
+            const lookupDoc = await mongoose.models['Lookup'].findById(lookupId).lean();
+            return lookupDoc?.name || '';
+        }
+        case 'direct':
+            return getNestedProperty(doc, config.descriptionField) || '';
+        case 'displayFieldReturn': // For case we just want to show display field value directly
+            return config.displayField || '';
+        case 'composite':
+            return (config.descriptionFields || [])
+                .map(f => getNestedProperty(doc, f))
+                .filter(Boolean)
+                .join(' ');
+        case 'custom':
+            if (typeof customResolvers?.[config.descriptionFunction] === 'function') {
+                return await customResolvers[config.descriptionFunction](doc);
+            }
+            return '';
+        default:
+            return '';
+    }
+}
+
+// Update resolveEntityDescription to support expression-based descriptionField
+async function resolveEntityDescription(doc, auditConfig) {
+    if (!auditConfig.descriptionResolutorForExternalData) return '';
+    const field = auditConfig.descriptionResolutorForExternalData;
+    const value = getNestedProperty(doc, field);
+    // Try to resolve via ValueReferenceMap
+    console.log("field-", field);
+    const map = await ValueReferenceMap.findOne({ field });
+    console.log("map-", map);
+    if (map?.descriptionResolverType === 'displayFieldReturn') {
+        return map.descriptionField;
+    }
+    if (map && map.descriptionField && map.descriptionField.includes('${')) {
+        return await resolveExpressionDescription(doc, map.descriptionField, map.descriptionResolverType);
+    }
+    if (map && value) {
+        const Model = mongoose.models[map.model];
+        if (Model) {
+            const refDoc = await Model.findById(value).lean();
+            return refDoc?.[map.displayField] || value;
+        }
+    }
+    // Fallback: If it's an ObjectId and Lookup model exists, resolve to name
+    if (mongoose.Types.ObjectId.isValid(value) && mongoose.models['Lookup']) {
+        const lookupDoc = await mongoose.models['Lookup'].findById(value).lean();
+        return lookupDoc?.name || value;
+    }
+    return value;
+}
+
+// Add new function to resolve deletion description
+async function resolveDeletionDescription(doc, auditConfig) {
+    if (!auditConfig.descriptionResolutorForDeletion) return '';
+    const expression = auditConfig.descriptionResolutorForDeletion;
+    return await resolveExpressionDescription(doc, expression, 'direct');
+}
+
+// Utility to build a fieldName -> dataType map from multiple formConfig.sections
+function buildFieldTypeMapFromConfigs(formConfigs) {
+    const map = {};
+    function extractFields(sections) {
+        for (const section of sections || []) {
+            if (section.fields) {
+                for (const f of section.fields) map[f.fieldName] = f.dataType;
+            }
+            if (section.sections) extractFields(section.sections);
+        }
+    }
+    for (const config of formConfigs) {
+        extractFields(config.sections);
+    }
+    return map;
+}
+
+function applyAuditMiddleware(schema, collectionName) {
+    // Handle creation audit
+    schema.post('save', async function (doc) {
+        const auditConfig = await AuditConfigModel.findOne({ collectionName });
+        if (!auditConfig?.trackCreation) return;
+
+        // Fetch all form configs and build fieldTypeMap once
+        const formConfigs = await FormConfigurationModel.find({ collectionName });
+        const fieldTypeMap = buildFieldTypeMapFromConfigs(formConfigs);
+
+        const context = getContext();
+        const userId = context?.userId || null;
+        const contextId = context?.contextId;
+
+        const entityDescription = await resolveEntityDescription(doc, auditConfig);
+        let logs = [];
+
+        // Per-field logs
+        if (auditConfig.fields?.length) {
+            for (const field of auditConfig.fields) {
+                let lookupName;
+                const newValue = getNestedProperty(doc, field);
+                if (field.endsWith('Lid')) {
+                    const newlookupDoc = await mongoose.models['Lookup'].findById(newValue).lean();
+                    if (newlookupDoc) {
+                        lookupName = newlookupDoc.name;
+                    } else {
+                        lookupName = '';
+                    }
+                }
+                const fieldDescription = await resolveDescription(field, doc);
+                // --- Add pound prefix if needed ---
+                let displayNewValue = lookupName || newValue;
+                const dataType = fieldTypeMap[field];
+                if (dataType === 'pound' && displayNewValue != null && displayNewValue !== '') {
+                    displayNewValue = `£${displayNewValue}`;
+                }
+                logs.push({
+                    name: fieldDescription,
+                    entity: entityDescription,
+                    recordId: contextId || doc._id,
+                    oldValue: null,
+                    newValue: displayNewValue,
+                    createdBy: userId,
+                    externalData: {
+                        description: entityDescription,
+                        contextId
+                    }
+                });
+            }
+        }
+        logs = logs.filter(log => {
+            // Convert null/undefined to empty string for comparison
+            const oldVal = log.oldValue ?? '';
+            const newVal = log.newValue ?? '';
+            return oldVal !== newVal;
+        });
+        if (logs.length) {
+            await AuditLog.insertMany(logs);
+            await updateContextAuditCount(contextId, logs.length);
+            if (onAuditLogCreated) {
+                await onAuditLogCreated(logs, contextId);
+            }
+        }
+    });
+
+    // Capture the original doc before update
+    schema.pre(['findOneAndUpdate', 'findByIdAndUpdate'], async function (next) {
+        this._originalDoc = await this.model.findOne(this.getQuery()).lean();
+        next();
+    });
+
+    // Handle update audits
+    schema.post(['findOneAndUpdate', 'findByIdAndUpdate'], async function (result) {
+        if (!result) return;
+
+        const auditConfig = await AuditConfigModel.findOne({ collectionName });
+        if (!auditConfig?.fields?.length) return;
+
+        // Fetch all form configs and build fieldTypeMap once
+        const formConfigs = await FormConfigurationModel.find({ collectionName });
+        const fieldTypeMap = buildFieldTypeMapFromConfigs(formConfigs);
+
+        const update = this.getUpdate();
+        let logs = [];
+        const context = getContext();
+        const userId = context?.userId || null;
+        const contextId = context?.contextId;
+
+        const entityDescription = await resolveEntityDescription(result, auditConfig);
+
+        for (const field of auditConfig.fields) {
+            console.log("field", field);
+            const hasChanged =
+                (update?.$set && hasNestedProperty(update.$set, field)) ||
+                (update && hasNestedProperty(update, field));
+            console.log("hasChanged", hasChanged);
+            if (hasChanged) {
+                const newValue = getNestedProperty(update?.$set, field) ?? getNestedProperty(update, field);
+                const oldValue = this._originalDoc ? getNestedProperty(this._originalDoc, field) : undefined;
+                let lookupOldName;
+                let lookupNewName;
+                if (field.endsWith('Lid')) {
+                    const newlookupDoc = await mongoose.models['Lookup'].findById(newValue).lean();
+                    if (newlookupDoc) {
+                        lookupNewName = newlookupDoc.name;
+                    } else {
+                        lookupNewName = '';
+                    }
+                    const oldlookupDoc = await mongoose.models['Lookup'].findById(oldValue).lean();
+                    if (oldlookupDoc) {
+                        lookupOldName = oldlookupDoc.name;
+                    } else {
+                        lookupOldName = '';
+                    }
+                }
+                // Convert null/undefined to empty string for comparison
+                let displayOldValue = lookupOldName ?? oldValue ?? '';
+                let displayNewValue = lookupNewName ?? newValue ?? '';
+                console.log("displayOldValue", displayOldValue);
+                console.log("displayNewValue", displayNewValue);
+                // --- Add pound prefix if needed ---
+                const dataType = fieldTypeMap[field];
+                if (dataType === 'pound') {
+                    if (displayOldValue != null && displayOldValue !== '') displayOldValue = `£${displayOldValue}`;
+                    if (displayNewValue != null && displayNewValue !== '') displayNewValue = `£${displayNewValue}`;
+                }
+                if (displayOldValue !== displayNewValue) {
+                    const fieldDescription = await resolveDescription(field, result);
+                    console.log("fieldDescription-", fieldDescription);
+                    logs.push({
+                        name: fieldDescription,
+                        entity: entityDescription,
+                        recordId: contextId || result._id,
+                        oldValue: displayOldValue,
+                        newValue: displayNewValue,
+                        createdBy: userId,
+                        externalData: {
+                            description: entityDescription,
+                            contextId: contextId || result._id
+                        }
+                    });
+                }
+            }
+        }
+        console.log("logs", logs);
+        logs = logs.filter(log => {
+            // Convert null/undefined to empty string for comparison
+            const oldVal = log.oldValue ?? '';
+            const newVal = log.newValue ?? '';
+            return oldVal !== newVal;
+        });
+        console.log("logs.length", logs.length);
+        if (logs.length) {
+            console.log("logs.length", logs.length);
+            await AuditLog.insertMany(logs);
+            await updateContextAuditCount(contextId, logs.length);
+            if (onAuditLogCreated) {
+                await onAuditLogCreated(logs, contextId);
+            }
+        }
+    });
+
+    // Handle delete audits
+    schema.pre(['findOneAndDelete', 'findByIdAndDelete', 'deleteOne', 'deleteMany'], async function (next) {
+        try {
+            // Fetch the document before deletion
+            const docToDelete = await this.model.findOne(this.getQuery()).lean();
+            if (docToDelete) {
+                // Store the document for use in post middleware
+                this._docToDelete = docToDelete;
+            }
+            next();
+        } catch (error) {
+            next(error);
+        }
+    });
+
+    schema.post(['findOneAndDelete', 'findByIdAndDelete', 'deleteOne', 'deleteMany'], async function (result) {
+        if (!result) return;
+
+        const auditConfig = await AuditConfigModel.findOne({ collectionName });
+        if (!auditConfig?.trackDeletion) return;
+
+        const context = getContext();
+        const userId = context?.userId || null;
+        const contextId = context?.contextId;
+
+        const entityDescription = await resolveEntityDescription(this._docToDelete, auditConfig);
+        const deletionDescription = await resolveDeletionDescription(this._docToDelete, auditConfig);
+
+        const log = {
+            name: deletionDescription || 'Entity Deletion',
+            entity: entityDescription,
+            recordId: contextId || this._docToDelete._id,
+            oldValue: '',
+            newValue: 'Deleted',
+            createdBy: userId,
+            externalData: {
+                description: entityDescription,
+                contextId: contextId || this._docToDelete._id
+            }
+        };
+        const oldVal = log.oldValue ?? '';
+        const newVal = log.newValue ?? '';
+        if (oldVal === newVal) {
+            return;
+        }
+        await AuditLog.create(log);
+        await updateContextAuditCount(contextId, 1);
+        if (onAuditLogCreated) {
+            await onAuditLogCreated([log], contextId);
+        }
+    });
+}
+
+async function updateContextAuditCount(contextId, count) {
+    count = Number(count);
+    if (!contextId || isNaN(count)) return;
+    const model = mongoose.models['Application'];
+    await model.findByIdAndUpdate(
+        { _id: contextId },
+        { $inc: { newAuditRecordsCount: count } },
+        { new: true, upsert: true }
+    );
+}
+
+export function registerAuditHook(callback) {
+    onAuditLogCreated = callback;
+}
+
 export default applyAuditMiddleware;