@dynamatix/cat-shared 0.0.17 → 0.0.19

package/middlewares/audit.middleware.js

@@ -1,11 +1,32 @@
 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 (after save)
+    // Handle creation audit
     schema.post('save', async function (doc) {
         const auditConfig = await AuditConfigModel.findOne({ collectionName });
         if (!auditConfig?.trackCreation) return;
@@ -30,13 +51,13 @@ function applyAuditMiddleware(schema, collectionName) {
         }
     });
 
-    // Capture original doc before update
+    // 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 || !this._originalDoc) return;
 
@@ -50,16 +71,23 @@ function applyAuditMiddleware(schema, collectionName) {
         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 = 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
                     });

package/models/forms/form-configuration.model.js

@@ -0,0 +1,158 @@
+import mongoose from 'mongoose';
+
+const formfieldSchema = new mongoose.Schema({
+    fieldName: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    isEditable:{
+        type: Boolean,
+        default: true
+    },
+    size: {
+        type: Number,
+        default: 6,
+        enum: [3,4,6,8,10,12],
+    },
+    layout:{
+        type: String,
+        enum: ['horizontal', 'vertical'],
+    },
+    label: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    dataType: {
+        type: String,
+        required: true,
+        enum: ['string', 'number', 'boolean', 'date', 'array', 'object', 'select', 'radio', 'list'] // Added common form field types
+    },
+    isRequired: {
+        type: Boolean,
+        default: false
+    },
+    helpText: {
+        type: String,
+        default: null
+    },
+    requiredErrorMessage:{
+        type: String,
+        default: 'Field is required'
+    },
+    defaultValue: {
+        type: mongoose.Schema.Types.Mixed
+    },
+    validationRules: {
+        type: mongoose.Schema.Types.Mixed,
+        default: {}
+    },
+    visibilityCondition: {
+        type: mongoose.Schema.Types.Mixed,
+        default: null
+    },
+    options: {
+        type: [mongoose.Schema.Types.Mixed],
+        default: []
+    },
+    section: {
+        type: String,
+        default: null
+    },
+    list:{
+        type: {
+            name: {
+                type: String,
+                required: true
+            },
+            label: {
+                type: String,
+                required: true
+            },
+            value: {
+                type: String,
+                required: true
+            },
+            optionFilterLogic: {
+                type: mongoose.Schema.Types.Mixed,
+                default: null
+            }
+        },
+        default: null
+    },
+    isSyncEnabled: {  // Fixed typo (was isSyncEnabed)
+        type: Boolean,
+        default: true
+    },
+    dataElement: { //<collectionName>.<fieldName>
+        type: String,
+        default: null
+    },
+    syncTargetDataElement: { //<collectionName>.<fieldName> of Apprivo
+        type: String,
+        default: null
+    },
+    order: {
+        type: Number,
+        default: 0
+    },
+    maxLength: {
+        type: Number,
+        default: null,
+        min: 0
+    }
+}, { timestamps: true });
+
+const formConfigurationSchema = new mongoose.Schema({
+    formName: {
+        type: String,
+        required: true,
+        trim: true,
+        unique: true // Consider making form names unique
+    },
+    apiPath: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    visibilityCondition: {
+        type: mongoose.Schema.Types.Mixed,
+        default: null
+    },
+    sections: [{
+        sectionName: {
+            type: String,
+            required: true,
+            trim: true
+        },
+        sectionLabel: {
+            type: String,
+            required: true,
+            trim: true
+        },
+        fields: [{
+            type: [formfieldSchema]
+        }],
+        order: {
+            type: Number,
+            default: 0
+        },
+        visibilityCondition: {  // Added section-level visibility
+            type: mongoose.Schema.Types.Mixed,
+            default: null
+        }
+    }],
+    isActive: {  // Consider adding status flag
+        type: Boolean,
+        default: true
+    },
+    version: {  // Consider adding versioning
+        type: Number,
+        default: 1
+    }
+}, { timestamps: true });
+
+const FormConfiguration = mongoose.model('FormConfiguration', formConfigurationSchema);
+
+module.exports = FormConfiguration;

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.17",
+  "version": "0.0.19",
   "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,66 @@
+import mongoose, { model } from 'mongoose';
+import dotenv from 'dotenv';
+import ValueReferenceMapModel from '../models/value-reference-map.model.js';
+
+dotenv.config();
+
+const MONGO_URI = 'mongodb+srv://qa-user:vw4sIy3lZpyTPoX0@gatehouse-testing.e08r2.mongodb.net/gatehouse-qa?retryWrites=true&w=majority';
+
+// Grouped definition (DRY)
+const groupedMappings = [
+    {
+        model: 'DocumentType',
+        displayField: 'name',
+        fields: ['documentTypeId']
+    },
+    {
+        model: 'User',
+        displayField: 'fullName',
+        fields: ['createdBy', 'updatedBy', 'ownerId','documentOwnerId']
+    },
+    {
+        model: 'Applicant',
+        displayField: 'firstName',
+        fields: ['documentOwnerId']
+    }
+];
+
+// 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.updateOne(
+                { field: mapping.field },
+                { $set: mapping }
+            );
+            console.log(`🔄 Updated mapping for '${mapping.field}'`);
+            } else {
+            await ValueReferenceMapModel.create(mapping);
+            console.log(`➕ Inserted mapping for '${mapping.field}'`);
+            }
+        }
+
+        console.log('\n🌱 Seeding complete ✅');
+    } catch (err) {
+        console.error('❌ Seeding failed', err);
+    } finally {
+        await mongoose.disconnect();
+        process.exit();
+    }
+}
+
+seed();