@dynamatix/cat-shared 0.0.16 → 0.0.18

package/middlewares/audit.middleware.js

@@ -1,14 +1,34 @@
 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';
 
 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
+    };
+}
+
 function applyAuditMiddleware(schema, collectionName) {
-    // Handle create
+    // Handle creation audit
     schema.post('save', async function (doc) {
-        const auditConfig = await AuditLog.findOne({ collectionName });
+        const auditConfig = await AuditConfigModel.findOne({ collectionName });
         if (!auditConfig?.trackCreation) return;
 
         const context = getContext();
@@ -23,39 +43,51 @@ function applyAuditMiddleware(schema, collectionName) {
             createdBy: userId,
             contextId
         };
+
+        await AuditLog.create(log);
+
         if (onAuditLogCreated) {
-            onAuditLogCreated(logs, contextId); // 👈 Call the hook with the logs
+            await onAuditLogCreated([log], contextId);
         }
+    });
 
-        await AuditLog.create(log);
+    // Capture the original doc before update
+    schema.pre(['findOneAndUpdate', 'findByIdAndUpdate'], async function (next) {
+        this._originalDoc = await this.model.findOne(this.getQuery()).lean();
+        next();
     });
 
-    // Handle updates (after successful update)
+    // Handle update audits
     schema.post(['findOneAndUpdate', 'findByIdAndUpdate'], async function (result) {
-        if (!result) return; // No doc was updated
+        if (!result || !this._originalDoc) return;
 
         const auditConfig = await AuditConfigModel.findOne({ collectionName });
         if (!auditConfig?.fields?.length) return;
 
-        const query = this;
-        const update = query.getUpdate();
-
+        const update = this.getUpdate();
         const logs = [];
         const context = getContext();
         const userId = context?.userId || 'anonymous';
         const contextId = context?.contextId;
 
         for (const field of auditConfig.fields) {
-            if (update?.$set?.hasOwnProperty(field) || update?.hasOwnProperty(field)) {
+            const hasChanged =
+                update?.$set?.hasOwnProperty(field) || update?.hasOwnProperty(field);
+
+            if (hasChanged) {
                 const newValue = update?.$set?.[field] ?? update?.[field];
-                const oldValue = result[field];
+                const oldValue = this._originalDoc[field];
 
                 if (oldValue !== newValue) {
+                    // Resolve human-readable values
+                    const { oldValue: resolvedOld, newValue: resolvedNew } =
+                        await resolveAuditValues(field, oldValue, newValue);
+
                     logs.push({
                         name: `${collectionName}.${field}`,
                         recordId: result._id,
-                        oldValue,
-                        newValue,
+                        oldValue: resolvedOld,
+                        newValue: resolvedNew,
                         createdBy: userId,
                         contextId
                     });
@@ -63,16 +95,17 @@ function applyAuditMiddleware(schema, collectionName) {
             }
         }
 
-        if (logs.length) await AuditLog.insertMany(logs);
-        if (onAuditLogCreated) {
-            onAuditLogCreated(logs, contextId); // 👈 Call the hook with the logs
+        if (logs.length) {
+            await AuditLog.insertMany(logs);
+            if (onAuditLogCreated) {
+                await onAuditLogCreated(logs, contextId);
+            }
         }
     });
 }
 
-
 export function registerAuditHook(callback) {
     onAuditLogCreated = callback;
 }
 
-export default applyAuditMiddleware;
+export default applyAuditMiddleware;

package/models/index.js

@@ -1,2 +1,3 @@
 export { default as AuditConfigModel } from './audit-config.model.js';
-export { default as AuditModel } from './audit.model.js';
+export { default as AuditModel } from './audit.model.js';
+export { default as ValueReferenceMapModel } from './value-reference-map.model.js';

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

@@ -0,0 +1,12 @@
+import mongoose from 'mongoose';
+
+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'
+});
+
+valueReferenceMapSchema.index({ field: 1 }, { unique: true });
+
+const ValueReferenceMapModel = mongoose.model('ValueReferenceMap', valueReferenceMapSchema);
+export default ValueReferenceMapModel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamatix/cat-shared",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -13,5 +13,9 @@
     "./models": "./models/index.js",
     "./middlewares": "./middlewares/index.js",
     "./services": "./services/index.js"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.7",
+    "mongoose": "^8.13.1"
   }
 }

package/seeders/value-reference-map.seeder.js

@@ -0,0 +1,57 @@
+import mongoose from 'mongoose';
+import dotenv from 'dotenv';
+import ValueReferenceMapModel from '../models/value-reference-map.model.js';
+
+dotenv.config();
+
+const MONGO_URI = process.env.MONGO_URI;
+
+// Grouped definition (DRY)
+const groupedMappings = [
+    {
+        model: 'DocumentType',
+        displayField: 'name',
+        fields: ['documentTypeId']
+    },
+    {
+        model: 'User',
+        displayField: 'fullName',
+        fields: ['createdBy', 'updatedBy', 'ownerId']
+    }
+];
+
+// Flatten the mappings
+const referenceMappings = groupedMappings.flatMap(group =>
+    group.fields.map(field => ({
+        field,
+        model: group.model,
+        displayField: group.displayField
+    }))
+);
+
+async function seed() {
+    try {
+        console.log(MONGO_URI);
+        await mongoose.connect(MONGO_URI);
+        console.log('✅ Connected to MongoDB');
+
+        for (const mapping of referenceMappings) {
+            const existing = await ValueReferenceMapModel.findOne({ field: mapping.field });
+            if (!existing) {
+                await ValueReferenceMapModel.create(mapping);
+                console.log(`➕ Inserted mapping for '${mapping.field}'`);
+            } else {
+                console.log(`⚠️  Mapping for '${mapping.field}' already exists`);
+            }
+        }
+
+        console.log('\n🌱 Seeding complete ✅');
+    } catch (err) {
+        console.error('❌ Seeding failed', err);
+    } finally {
+        await mongoose.disconnect();
+        process.exit();
+    }
+}
+
+seed();