@dynamatix/cat-shared 0.0.81 → 0.0.82

package/middlewares/audit.middleware.js

@@ -6,31 +6,39 @@ 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
-    ]);
-
-    return {
-        oldValue: oldDoc?.[map.displayField] || oldValue,
-        newValue: newDoc?.[map.displayField] || newValue
-    };
-}
-
-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];
+// Optionally, define custom resolvers here
+const customResolvers = {
+    // Example:
+    // expenditureRationale: (doc) => `Rationale for ${doc.type}: ${doc.rationale}`
+};
+
+// Flexible description resolver
+async function resolveDescription(field, doc) {
+    const config = await ValueReferenceMap.findOne({ field });
+    if (!config) return '';
+
+    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 '';
+    }
 }
 
 function applyAuditMiddleware(schema, collectionName) {
@@ -49,13 +57,9 @@ function applyAuditMiddleware(schema, collectionName) {
             oldValue: null,
             newValue: 'Document created',
             createdBy: userId,
-            contextId
+            contextId,
+            description: await resolveDescription('created', doc)
         };
-        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);
 
@@ -92,22 +96,16 @@ 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;
-                    }
+                    // Flexible description
+                    const description = await resolveDescription(field, result);
+
                     logs.push({
                         name: `${collectionName}.${field}`,
                         recordId: contextId || result._id,
-                        oldValue: resolvedOld,
-                        newValue: resolvedNew,
+                        oldValue,
+                        newValue,
                         createdBy: userId,
-                        externalData
+                        description
                     });
                 }
             }
@@ -138,4 +136,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.82",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"