@dynamatix/cat-shared 0.0.82 → 0.0.83

package/middlewares/audit.middleware.js

@@ -12,11 +12,32 @@ const customResolvers = {
     // expenditureRationale: (doc) => `Rationale for ${doc.type}: ${doc.rationale}`
 };
 
-// Flexible description resolver
+// 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;
+}
+
+// Update resolveDescription to support expression-based descriptionField
 async function resolveDescription(field, doc) {
-    const config = await ValueReferenceMap.findOne({ field });
+    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];
@@ -41,6 +62,31 @@ async function resolveDescription(field, doc) {
     }
 }
 
+// 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) {
     // Handle creation audit
     schema.post('save', async function (doc) {
@@ -51,20 +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,
-            description: await resolveDescription('created', doc)
-        };
-        await AuditLog.create(log);
-        await updateContextAuditCount(contextId, 1);
+            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);
+            }
         }
     });
 
@@ -87,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);
@@ -96,16 +174,18 @@ function applyAuditMiddleware(schema, collectionName) {
                 const oldValue = this._originalDoc ? this._originalDoc[field] : '';
 
                 if (oldValue !== newValue) {
-                    // Flexible description
-                    const description = await resolveDescription(field, result);
-
+                    const fieldDescription = await resolveDescription(field, result);
                     logs.push({
-                        name: `${collectionName}.${field}`,
+                        name: fieldDescription,
+                        entity: entityDescription,
                         recordId: contextId || result._id,
                         oldValue,
                         newValue,
                         createdBy: userId,
-                        description
+                        externalData: {
+                            description: entityDescription,
+                            contextId: contextId || result._id
+                        }
                     });
                 }
             }

package/package.json

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