@dynamatix/cat-shared 0.0.79 → 0.0.80

package/README.md

@@ -1,7 +1,7 @@
-This is the shared library for Catura Services.
-# Purpose
-
-The purposes of this repository are to include:
-- All the models of Catura
-- Shared services in Catura
+This is the shared library for Catura Services.
+# Purpose
+
+The purposes of this repository are to include:
+- All the models of Catura
+- Shared services in Catura
 - Shared middlewares in Catura

package/index.js

@@ -1,3 +1,3 @@
-export * from './models/index.js';
-export * from './middlewares/index.js';
+export * from './models/index.js';
+export * from './middlewares/index.js';
 export * from './services/index.js';

package/middlewares/audit.middleware.js

@@ -1,140 +1,140 @@
-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
-    };
-}
-
-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];
-}
-
-function applyAuditMiddleware(schema, collectionName) {
-    // Handle creation audit
-    schema.post('save', async function (doc) {
-        const auditConfig = await AuditConfigModel.findOne({ collectionName });
-        if (!auditConfig?.trackCreation) return;
-
-        const context = getContext();
-        const userId = context?.userId || 'anonymous';
-        const contextId = context?.contextId;
-
-        const log = {
-            name: `${collectionName} created`,
-            recordId: contextId || doc._id,
-            oldValue: null,
-            newValue: 'Document created',
-            createdBy: userId,
-            contextId
-        };
-        if (auditConfig.descriptionResolutorForExternalData) {
-            log.externalData.description = await resolveExternalData(auditConfig.descriptionResolutorForExternalData, doc[descriptionResolutorForExternalData])
-            log.externalData.contextId = contextId;
-        }
-        await AuditLog.create(log);
-        await updateContextAuditCount(contextId, 1);
-
-        if (onAuditLogCreated) {
-            await onAuditLogCreated([log], contextId);
-        }
-    });
-
-    // Capture the original doc before update
-    schema.pre(['findOneAndUpdate', 'findByIdAndUpdate'], async function (next) {
-        this._originalDoc = await this.model.findOne(this.getQuery()).lean();
-        next();
-    });
-
-    // Handle update audits
-    schema.post(['findOneAndUpdate', 'findByIdAndUpdate'], async function (result) {
-        if (!result) return;
-
-        const auditConfig = await AuditConfigModel.findOne({ collectionName });
-        if (!auditConfig?.fields?.length) return;
-
-        const update = this.getUpdate();
-        const logs = [];
-        const context = getContext();
-        const userId = context?.userId || 'anonymous';
-        const contextId = context?.contextId;
-
-        for (const field of auditConfig.fields) {
-            const hasChanged =
-                update?.$set?.hasOwnProperty(field) || update?.hasOwnProperty(field);
-
-            if (hasChanged) {
-                const newValue = update?.$set?.[field] ?? update?.[field];
-                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;
-                    }
-                    logs.push({
-                        name: `${collectionName}.${field}`,
-                        recordId: contextId || result._id,
-                        oldValue: resolvedOld,
-                        newValue: resolvedNew,
-                        createdBy: userId,
-                        externalData
-                    });
-                }
-            }
-        }
-
-        if (logs.length) {
-            await AuditLog.insertMany(logs);
-            await updateContextAuditCount(contextId, logs.length);
-            if (onAuditLogCreated) {
-                await onAuditLogCreated(logs, contextId);
-            }
-        }
-    });
-}
-
-async function updateContextAuditCount(contextId, count) {
-    count = Number(count);
-    if (!contextId || isNaN(count)) return;
-    const model = mongoose.models['Application'];
-    await model.findByIdAndUpdate(
-        { _id: contextId },
-        { $inc: { newAuditRecordsCount: count } },
-        { new: true, upsert: true }
-    );
-}
-
-export function registerAuditHook(callback) {
-    onAuditLogCreated = callback;
-}
-
-export default applyAuditMiddleware;
+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
+    };
+}
+
+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];
+}
+
+function applyAuditMiddleware(schema, collectionName) {
+    // Handle creation audit
+    schema.post('save', async function (doc) {
+        const auditConfig = await AuditConfigModel.findOne({ collectionName });
+        if (!auditConfig?.trackCreation) return;
+
+        const context = getContext();
+        const userId = context?.userId || 'anonymous';
+        const contextId = context?.contextId;
+
+        const log = {
+            name: `${collectionName} created`,
+            recordId: contextId || doc._id,
+            oldValue: null,
+            newValue: 'Document created',
+            createdBy: userId,
+            contextId
+        };
+        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);
+
+        if (onAuditLogCreated) {
+            await onAuditLogCreated([log], contextId);
+        }
+    });
+
+    // Capture the original doc before update
+    schema.pre(['findOneAndUpdate', 'findByIdAndUpdate'], async function (next) {
+        this._originalDoc = await this.model.findOne(this.getQuery()).lean();
+        next();
+    });
+
+    // Handle update audits
+    schema.post(['findOneAndUpdate', 'findByIdAndUpdate'], async function (result) {
+        if (!result) return;
+
+        const auditConfig = await AuditConfigModel.findOne({ collectionName });
+        if (!auditConfig?.fields?.length) return;
+
+        const update = this.getUpdate();
+        const logs = [];
+        const context = getContext();
+        const userId = context?.userId || 'anonymous';
+        const contextId = context?.contextId;
+
+        for (const field of auditConfig.fields) {
+            const hasChanged =
+                update?.$set?.hasOwnProperty(field) || update?.hasOwnProperty(field);
+
+            if (hasChanged) {
+                const newValue = update?.$set?.[field] ?? update?.[field];
+                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;
+                    }
+                    logs.push({
+                        name: `${collectionName}.${field}`,
+                        recordId: contextId || result._id,
+                        oldValue: resolvedOld,
+                        newValue: resolvedNew,
+                        createdBy: userId,
+                        externalData
+                    });
+                }
+            }
+        }
+
+        if (logs.length) {
+            await AuditLog.insertMany(logs);
+            await updateContextAuditCount(contextId, logs.length);
+            if (onAuditLogCreated) {
+                await onAuditLogCreated(logs, contextId);
+            }
+        }
+    });
+}
+
+async function updateContextAuditCount(contextId, count) {
+    count = Number(count);
+    if (!contextId || isNaN(count)) return;
+    const model = mongoose.models['Application'];
+    await model.findByIdAndUpdate(
+        { _id: contextId },
+        { $inc: { newAuditRecordsCount: count } },
+        { new: true, upsert: true }
+    );
+}
+
+export function registerAuditHook(callback) {
+    onAuditLogCreated = callback;
+}
+
+export default applyAuditMiddleware;

package/middlewares/index.js

@@ -1,2 +1,2 @@
-export {default as applyAuditMiddleware} from './audit.middleware.js';
-export { registerAuditHook } from './audit.middleware.js';
+export {default as applyAuditMiddleware} from './audit.middleware.js';
+export { registerAuditHook } from './audit.middleware.js';

package/models/audit-config.model.js

@@ -1,13 +1,13 @@
-import mongoose from 'mongoose';
-
-const auditConfigSchema = new mongoose.Schema({
-    collectionName: String,
-    fields: [String], 
-    trackCreation: { type: Boolean, default: false },
-    descriptionResolutorForExternalData: { type: String, default: null },
-});
-
-const AuditConfigModel = mongoose.models.AuditConfig || mongoose.model('AuditConfig', auditConfigSchema);
-
-
-export default AuditConfigModel;
+import mongoose from 'mongoose';
+
+const auditConfigSchema = new mongoose.Schema({
+    collectionName: String,
+    fields: [String], 
+    trackCreation: { type: Boolean, default: false },
+    descriptionResolutorForExternalData: { type: String, default: null },
+});
+
+const AuditConfigModel = mongoose.models.AuditConfig || mongoose.model('AuditConfig', auditConfigSchema);
+
+
+export default AuditConfigModel;

package/models/audit.model.js

@@ -1,16 +1,16 @@
-import mongoose from 'mongoose';
-
-const auditSchema = new mongoose.Schema({
-    name: String,
-    recordId: mongoose.Schema.Types.ObjectId,
-    contextId: mongoose.Schema.Types.ObjectId,
-    oldValue: mongoose.Schema.Types.Mixed,
-    newValue: mongoose.Schema.Types.Mixed,
-    timestamp: { type: Date, default: Date.now },
-    createdBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
-    externalData: mongoose.Schema.Types.Mixed
-});
-
-const AuditLog = mongoose.models.AuditLog || mongoose.model('AuditLog', auditSchema);
-
-export default AuditLog;
+import mongoose from 'mongoose';
+
+const auditSchema = new mongoose.Schema({
+    name: String,
+    recordId: mongoose.Schema.Types.ObjectId,
+    contextId: mongoose.Schema.Types.ObjectId,
+    oldValue: mongoose.Schema.Types.Mixed,
+    newValue: mongoose.Schema.Types.Mixed,
+    timestamp: { type: Date, default: Date.now },
+    createdBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
+    externalData: mongoose.Schema.Types.Mixed
+});
+
+const AuditLog = mongoose.models.AuditLog || mongoose.model('AuditLog', auditSchema);
+
+export default AuditLog;

package/models/form-configuration.model.js

@@ -1,269 +1,269 @@
-import mongoose from 'mongoose';
-
-const optionSchema = new mongoose.Schema({
-    label: { type: mongoose.Schema.Types.Mixed },
-    value: { type: mongoose.Schema.Types.Mixed },
-    text: { type: mongoose.Schema.Types.Mixed }
-
-}, { _id: false });
-
-const formfieldSchema = new mongoose.Schema({
-    isFutureDateBlocked: {
-        type: Boolean,
-    },
-    addToPayload: {
-        type: Boolean,
-        default: false
-    },
-    fieldName: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    isHidden: {
-        type: Boolean,
-        default: false
-    },
-    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: ['text-area', 'string', 'number', 'boolean-check', 'boolean-radio', 'percentage', 'date', 'array', 'object', 'select', 'radio', 'drop-down', 'sort-code', 'post-code', 'pound', 'lookup', 'multi-select', 'email', 'phone', 'internationalPhone'] // Added common form field types
-    },
-    isRequired: {
-        type: Boolean,
-        default: false
-    },
-    helpText: {
-        type: String,
-        default: null
-    },
-    isForceUpdate: {
-        type: Boolean,
-        default: false
-    },
-    isShowClearIcon: {
-        type: Boolean,
-        default: true
-    },
-    requiredErrorMessage: {
-        type: String,
-        default: 'Field is required'
-    },
-    defaultValue: {
-        type: mongoose.Schema.Types.Mixed
-    },
-    validationRules: [{
-        type: mongoose.Schema.Types.Mixed,
-        default: {}
-    }],
-    visibilityCondition: { // (LendingType=='BTL' || ApplicationType=='Company')
-        type: mongoose.Schema.Types.Mixed,
-        default: null
-    },
-    options: [optionSchema],
-    section: {
-        type: String,
-        default: null
-    },
-    keyIconClass: {
-      type: String,
-      default: null
-    },
-    keyIconStyle: {
-        type: Object,
-        default: null
-    },
-    // Ex: sort-code, post-code, pound, drop-down, lookup
-    uiHint: {
-        type: String
-    },
-    list: {
-        name: { // Lookup.BusinessType, DocumentType(collection) 
-            type: String
-        },
-        label: { // name
-            type: String
-        },
-        value: { // _id
-            type: String
-        },
-        listFilterQuery: { // MongoDB query ex: applicationId:applicationId
-            type: mongoose.Schema.Types.Mixed,
-            default: null
-        },
-        dynamicSource: {
-            sourceMapping: [{
-                sourceField: {
-                    type: String,
-                    default: null
-                },
-                sourceValue: { type: mongoose.Schema.Types.Mixed },
-                listName: { type: String },  // The collection name to use when source field has this value
-                fixedValue: { type: mongoose.Schema.Types.Mixed } // It's not req , and it can be a number like 0 , or a string etc.
-            }]
-        }
-    },
-    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
-    },
-    syncMapping: mongoose.Schema.Types.Mixed, // Ex: {true:'Checked', false: ''}
-    order: {
-        type: Number,
-        default: 0
-    },
-    maxLength: {
-        type: Number,
-        default: null,
-        min: 0
-    },
-    maxValue: {  // this is not required used only when given else ignore ex- 100% max
-        type: mongoose.Schema.Types.Mixed
-    },
-    minValue: {  // this is not required used only when given else ignore ex- 0% min   
-        type: Number
-    },
-    isReadOnly: {
-        type: Boolean,
-        default: false
-    },
-    collectionName: { // name of collection for field if field doesnt belong to main collection
-        type: String,
-        default: null
-    },
-    foreignReferenceField: { // Ex: when field is from forieng collection then foreignReferenceField could be applicationId(which refers to the application)
-        type: String,
-        default: null
-    },
-    shouldfilterOptionsAfterAdd: {
-        type : Boolean,
-        default : false
-    },
-    shouldfilterOptionsAfterDelete: {
-        type : Boolean,
-        default : false
-    }
-}, { timestamps: true, _id: false });
-
-const formConfigurationSchema = new mongoose.Schema({
-    formName: {
-        type: String,
-        required: true,
-        trim: true,
-        unique: true // Consider making form names unique
-    },
-    collectionName: {
-        type: String,
-        required: true
-    },
-    sectionLayout: {
-        type: String,
-        trim: true
-    },
-    parentKey: String,
-    populations: [Object],
-    visibilityCondition: {
-        type: mongoose.Schema.Types.Mixed,
-        default: null
-    },
-    sections: [{
-        sectionName: {
-            type: String,
-            trim: true
-        },
-        sectionLabel: {
-            type: String,
-            trim: true
-        },
-        isArray: {
-            type: Boolean,
-            default: false
-        },
-        isTable: {
-            type: Boolean,
-            default: false
-        },
-        dataFromSectionName: {
-            type: Boolean,
-            default: false
-        },
-        fields: [formfieldSchema],
-        order: {
-            type: Number,
-            default: 0
-        },
-        visibilityCondition: {  // Added section-level visibility
-            type: mongoose.Schema.Types.Mixed,
-            default: null
-        },
-        sections: [{
-            sectionName: {
-                type: String,
-                trim: true
-            },
-            sectionLabel: {
-                type: String,
-                trim: true
-            },
-            fields: [formfieldSchema],
-            order: {
-                type: Number,
-                default: 0
-            },
-            isTable: {
-                type: Boolean,
-                default: false
-            },
-            visibilityCondition: {  // Added section-level visibility
-                type: mongoose.Schema.Types.Mixed,
-                default: null
-            }
-        }]
-    }],
-    isActive: {  // Consider adding status flag
-        type: Boolean,
-        default: true
-    },
-    isDeleteApprivoSync: {
-        type: Boolean,
-        default: true
-    },
-    isCreateApprivoSync: {
-        type: Boolean,
-        default: true
-    },
-    version: {  // Consider adding versioning
-        type: Number,
-        default: 1
-    }
-}, { timestamps: true });
-
-const FormConfigurationModel = mongoose.models.FormConfiguration || mongoose.model('FormConfiguration', formConfigurationSchema);
-
-export default FormConfigurationModel;
+import mongoose from 'mongoose';
+
+const optionSchema = new mongoose.Schema({
+    label: { type: mongoose.Schema.Types.Mixed },
+    value: { type: mongoose.Schema.Types.Mixed },
+    text: { type: mongoose.Schema.Types.Mixed }
+
+}, { _id: false });
+
+const formfieldSchema = new mongoose.Schema({
+    isFutureDateBlocked: {
+        type: Boolean,
+    },
+    addToPayload: {
+        type: Boolean,
+        default: false
+    },
+    fieldName: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    isHidden: {
+        type: Boolean,
+        default: false
+    },
+    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: ['text-area', 'string', 'number', 'boolean-check', 'boolean-radio', 'percentage', 'date', 'array', 'object', 'select', 'radio', 'drop-down', 'sort-code', 'post-code', 'pound', 'lookup', 'multi-select', 'email', 'phone', 'internationalPhone'] // Added common form field types
+    },
+    isRequired: {
+        type: Boolean,
+        default: false
+    },
+    helpText: {
+        type: String,
+        default: null
+    },
+    isForceUpdate: {
+        type: Boolean,
+        default: false
+    },
+    isShowClearIcon: {
+        type: Boolean,
+        default: true
+    },
+    requiredErrorMessage: {
+        type: String,
+        default: 'Field is required'
+    },
+    defaultValue: {
+        type: mongoose.Schema.Types.Mixed
+    },
+    validationRules: [{
+        type: mongoose.Schema.Types.Mixed,
+        default: {}
+    }],
+    visibilityCondition: { // (LendingType=='BTL' || ApplicationType=='Company')
+        type: mongoose.Schema.Types.Mixed,
+        default: null
+    },
+    options: [optionSchema],
+    section: {
+        type: String,
+        default: null
+    },
+    keyIconClass: {
+      type: String,
+      default: null
+    },
+    keyIconStyle: {
+        type: Object,
+        default: null
+    },
+    // Ex: sort-code, post-code, pound, drop-down, lookup
+    uiHint: {
+        type: String
+    },
+    list: {
+        name: { // Lookup.BusinessType, DocumentType(collection) 
+            type: String
+        },
+        label: { // name
+            type: String
+        },
+        value: { // _id
+            type: String
+        },
+        listFilterQuery: { // MongoDB query ex: applicationId:applicationId
+            type: mongoose.Schema.Types.Mixed,
+            default: null
+        },
+        dynamicSource: {
+            sourceMapping: [{
+                sourceField: {
+                    type: String,
+                    default: null
+                },
+                sourceValue: { type: mongoose.Schema.Types.Mixed },
+                listName: { type: String },  // The collection name to use when source field has this value
+                fixedValue: { type: mongoose.Schema.Types.Mixed } // It's not req , and it can be a number like 0 , or a string etc.
+            }]
+        }
+    },
+    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
+    },
+    syncMapping: mongoose.Schema.Types.Mixed, // Ex: {true:'Checked', false: ''}
+    order: {
+        type: Number,
+        default: 0
+    },
+    maxLength: {
+        type: Number,
+        default: null,
+        min: 0
+    },
+    maxValue: {  // this is not required used only when given else ignore ex- 100% max
+        type: mongoose.Schema.Types.Mixed
+    },
+    minValue: {  // this is not required used only when given else ignore ex- 0% min   
+        type: Number
+    },
+    isReadOnly: {
+        type: Boolean,
+        default: false
+    },
+    collectionName: { // name of collection for field if field doesnt belong to main collection
+        type: String,
+        default: null
+    },
+    foreignReferenceField: { // Ex: when field is from forieng collection then foreignReferenceField could be applicationId(which refers to the application)
+        type: String,
+        default: null
+    },
+    shouldfilterOptionsAfterAdd: {
+        type : Boolean,
+        default : false
+    },
+    shouldfilterOptionsAfterDelete: {
+        type : Boolean,
+        default : false
+    }
+}, { timestamps: true, _id: false });
+
+const formConfigurationSchema = new mongoose.Schema({
+    formName: {
+        type: String,
+        required: true,
+        trim: true,
+        unique: true // Consider making form names unique
+    },
+    collectionName: {
+        type: String,
+        required: true
+    },
+    sectionLayout: {
+        type: String,
+        trim: true
+    },
+    parentKey: String,
+    populations: [Object],
+    visibilityCondition: {
+        type: mongoose.Schema.Types.Mixed,
+        default: null
+    },
+    sections: [{
+        sectionName: {
+            type: String,
+            trim: true
+        },
+        sectionLabel: {
+            type: String,
+            trim: true
+        },
+        isArray: {
+            type: Boolean,
+            default: false
+        },
+        isTable: {
+            type: Boolean,
+            default: false
+        },
+        dataFromSectionName: {
+            type: Boolean,
+            default: false
+        },
+        fields: [formfieldSchema],
+        order: {
+            type: Number,
+            default: 0
+        },
+        visibilityCondition: {  // Added section-level visibility
+            type: mongoose.Schema.Types.Mixed,
+            default: null
+        },
+        sections: [{
+            sectionName: {
+                type: String,
+                trim: true
+            },
+            sectionLabel: {
+                type: String,
+                trim: true
+            },
+            fields: [formfieldSchema],
+            order: {
+                type: Number,
+                default: 0
+            },
+            isTable: {
+                type: Boolean,
+                default: false
+            },
+            visibilityCondition: {  // Added section-level visibility
+                type: mongoose.Schema.Types.Mixed,
+                default: null
+            }
+        }]
+    }],
+    isActive: {  // Consider adding status flag
+        type: Boolean,
+        default: true
+    },
+    isDeleteApprivoSync: {
+        type: Boolean,
+        default: true
+    },
+    isCreateApprivoSync: {
+        type: Boolean,
+        default: true
+    },
+    version: {  // Consider adding versioning
+        type: Number,
+        default: 1
+    }
+}, { timestamps: true });
+
+const FormConfigurationModel = mongoose.models.FormConfiguration || mongoose.model('FormConfiguration', formConfigurationSchema);
+
+export default FormConfigurationModel;

package/models/index.js

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

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

@@ -1,12 +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.models.ValueReferenceMap ||  mongoose.model('ValueReferenceMap', valueReferenceMapSchema);
-export default ValueReferenceMapModel;
+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.models.ValueReferenceMap ||  mongoose.model('ValueReferenceMap', valueReferenceMapSchema);
+export default ValueReferenceMapModel;

package/package.json

@@ -1,21 +1,21 @@
-{
-  "name": "@dynamatix/cat-shared",
-  "version": "0.0.79",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "",
-  "license": "ISC",
-  "type": "module",
-  "description": "",
-  "exports": {
-    "./models": "./models/index.js",
-    "./middlewares": "./middlewares/index.js",
-    "./services": "./services/index.js"
-  },
-  "dependencies": {
-    "dotenv": "^16.4.7",
-    "mongoose": "^8.13.1"
-  }
-}
+{
+  "name": "@dynamatix/cat-shared",
+  "version": "0.0.80",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "description": "",
+  "exports": {
+    "./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

@@ -1,66 +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', 'applicantId']
-    }
-];
-
-// 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();
+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', 'applicantId']
+    }
+];
+
+// 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();

package/services/audit-log.hook.js

@@ -1,2 +1,2 @@
-
-
+
+

package/services/index.js

@@ -1 +1 @@
-export { getContext, setContext } from './request-context.service.js';
+export { getContext, setContext } from './request-context.service.js';

package/services/request-context.service.js

@@ -1,8 +1,8 @@
-// utils/request-context.js
-import { AsyncLocalStorage } from 'node:async_hooks';
-
-const asyncLocalStorage = new AsyncLocalStorage();
-
-export const setContext = (data) => asyncLocalStorage.enterWith(data);
-
-export const getContext = () => asyncLocalStorage.getStore();
+// utils/request-context.js
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+const asyncLocalStorage = new AsyncLocalStorage();
+
+export const setContext = (data) => asyncLocalStorage.enterWith(data);
+
+export const getContext = () => asyncLocalStorage.getStore();