@dynamatix/cat-shared 0.0.81 → 0.0.83

package/middlewares/audit.middleware.js

@@ -6,31 +6,85 @@ import mongoose from 'mongoose';
 
 let onAuditLogCreated = null;
 
-// Generic resolver: fetch display values using ValueReferenceMap
-async function resolveAuditValues(field, oldValue, newValue) {
-    const map = await ValueReferenceMap.findOne({ field });
-    if (!map || (!oldValue && !newValue)) return { oldValue, newValue };
-
-    const Model = mongoose.models[map.model];
-    if (!Model) return { oldValue, newValue };
-
-    const [oldDoc, newDoc] = await Promise.all([
-        oldValue ? Model.findById(oldValue).lean() : null,
-        newValue ? Model.findById(newValue).lean() : null
-    ]);
+// 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) {
+    const matches = [...expression.matchAll(/\$\{([^}]+)\}/g)];
+    let result = expression;
+    for (const match of matches) {
+        const fieldName = match[1];
+        let value = 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;
+}
 
-    return {
-        oldValue: oldDoc?.[map.displayField] || oldValue,
-        newValue: newDoc?.[map.displayField] || newValue
-    };
+// 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 });
+    if (!config) return '';
+
+    if (config.descriptionField && config.descriptionField.includes('${')) {
+        return await resolveExpressionDescription(doc, config.descriptionField, config.descriptionResolverType);
+    }
+
+    switch (config.descriptionResolverType) {
+        case 'lookup': {
+            const lookupId = doc[config.descriptionField];
+            if (!lookupId) return '';
+            const lookupDoc = await mongoose.models['Lookup'].findById(lookupId).lean();
+            return lookupDoc?.name || '';
+        }
+        case 'direct':
+            return doc[config.descriptionField] || '';
+        case 'composite':
+            return (config.descriptionFields || [])
+                .map(f => doc[f])
+                .filter(Boolean)
+                .join(' ');
+        case 'custom':
+            if (typeof customResolvers?.[config.descriptionFunction] === 'function') {
+                return await customResolvers[config.descriptionFunction](doc);
+            }
+            return '';
+        default:
+            return '';
+    }
 }
 
-async function resolveExternalData(descriptionResolutorForExternalData, recordId) {
-    const map = await ValueReferenceMap.findOne({ field: descriptionResolutorForExternalData });
-    const Model = mongoose.models[map.model];
-    if (!Model) return "";
-    const doc = await Model.findById(recordId).lean()
-    return doc[map.displayField];
+// Update resolveEntityDescription to support expression-based descriptionField
+async function resolveEntityDescription(doc, auditConfig) {
+    if (!auditConfig.descriptionResolutorForExternalData) return '';
+    const field = auditConfig.descriptionResolutorForExternalData;
+    const value = doc[field];
+    // Try to resolve via ValueReferenceMap
+    const map = await ValueReferenceMap.findOne({ field });
+    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;
 }
 
 function applyAuditMiddleware(schema, collectionName) {
@@ -43,24 +97,50 @@ function applyAuditMiddleware(schema, collectionName) {
         const userId = context?.userId || 'anonymous';
         const contextId = context?.contextId;
 
-        const log = {
-            name: `${collectionName} created`,
+        const entityDescription = await resolveEntityDescription(doc, auditConfig);
+        const logs = [];
+
+        // Per-field logs
+        if (auditConfig.fields?.length) {
+            for (const field of auditConfig.fields) {
+                const newValue = doc[field];
+                const fieldDescription = await resolveDescription(field, doc);
+                logs.push({
+                    name: fieldDescription,
+                    entity: entityDescription,
+                    recordId: contextId || doc._id,
+                    oldValue: null,
+                    newValue,
+                    createdBy: userId,
+                    externalData: {
+                        description: entityDescription,
+                        contextId
+                    }
+                });
+            }
+        }
+
+        // Overall document creation log (optional)
+        logs.push({
+            name: 'created',
+            entity: entityDescription,
             recordId: contextId || doc._id,
             oldValue: null,
             newValue: 'Document created',
             createdBy: userId,
-            contextId
-        };
-        log.externalData = {};
-        if (auditConfig.descriptionResolutorForExternalData) {
-            log.externalData.description = await resolveExternalData(auditConfig.descriptionResolutorForExternalData, doc[auditConfig.descriptionResolutorForExternalData])
-            log.externalData.contextId = contextId;
-        }
-        await AuditLog.create(log);
-        await updateContextAuditCount(contextId, 1);
+            contextId,
+            externalData: {
+                description: entityDescription,
+                contextId
+            }
+        });
 
-        if (onAuditLogCreated) {
-            await onAuditLogCreated([log], contextId);
+        if (logs.length) {
+            await AuditLog.insertMany(logs);
+            await updateContextAuditCount(contextId, logs.length);
+            if (onAuditLogCreated) {
+                await onAuditLogCreated(logs, contextId);
+            }
         }
     });
 
@@ -83,6 +163,8 @@ function applyAuditMiddleware(schema, collectionName) {
         const userId = context?.userId || 'anonymous';
         const contextId = context?.contextId;
 
+        const entityDescription = await resolveEntityDescription(result, auditConfig);
+
         for (const field of auditConfig.fields) {
             const hasChanged =
                 update?.$set?.hasOwnProperty(field) || update?.hasOwnProperty(field);
@@ -92,22 +174,18 @@ function applyAuditMiddleware(schema, collectionName) {
                 const oldValue = this._originalDoc ? this._originalDoc[field] : '';
 
                 if (oldValue !== newValue) {
-                    // Resolve human-readable values
-                    const { oldValue: resolvedOld, newValue: resolvedNew } =
-                        await resolveAuditValues(field, oldValue, newValue);
-
-                    let externalData = {};
-                    if (auditConfig.descriptionResolutorForExternalData) {
-                        externalData.description = await resolveExternalData(auditConfig.descriptionResolutorForExternalData, result[auditConfig.descriptionResolutorForExternalData])
-                        externalData.contextId = contextId || result._id;
-                    }
+                    const fieldDescription = await resolveDescription(field, result);
                     logs.push({
-                        name: `${collectionName}.${field}`,
+                        name: fieldDescription,
+                        entity: entityDescription,
                         recordId: contextId || result._id,
-                        oldValue: resolvedOld,
-                        newValue: resolvedNew,
+                        oldValue,
+                        newValue,
                         createdBy: userId,
-                        externalData
+                        externalData: {
+                            description: entityDescription,
+                            contextId: contextId || result._id
+                        }
                     });
                 }
             }
@@ -138,4 +216,4 @@ export function registerAuditHook(callback) {
     onAuditLogCreated = callback;
 }
 
-export default applyAuditMiddleware;
+export default applyAuditMiddleware;

package/models/value-reference-map.model.js

@@ -4,6 +4,10 @@ const valueReferenceMapSchema = new mongoose.Schema({
     field: String,               // e.g. 'documentTypeId', 'createdBy', 'status'
     model: String,               // e.g. 'DocumentType', 'User', 'ApplicationStatus'
     displayField: String,        // e.g. 'name', 'fullName', 'label'
+    descriptionResolverType: { type: String, enum: ['direct', 'lookup', 'composite', 'custom'], default: 'direct' },
+    descriptionField: String,      // for direct/lookup
+    descriptionFields: [String],   // for composite
+    descriptionFunction: String    // for custom
 });
 
 valueReferenceMapSchema.index({ field: 1 }, { unique: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamatix/cat-shared",
-  "version": "0.0.81",
+  "version": "0.0.83",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"