@dynamatix/cat-shared 0.0.65 → 0.0.67

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,111 +1,111 @@
-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 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: doc._id,
-            oldValue: null,
-            newValue: 'Document created',
-            createdBy: userId,
-            contextId
-        };
-
-        await AuditLog.create(log);
-
-        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 || !this._originalDoc) 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[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: resolvedOld,
-                        newValue: resolvedNew,
-                        createdBy: userId,
-                        contextId
-                    });
-                }
-            }
-        }
-
-        if (logs.length) {
-            await AuditLog.insertMany(logs);
-            if (onAuditLogCreated) {
-                await onAuditLogCreated(logs, contextId);
-            }
-        }
-    });
-}
-
-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
+    };
+}
+
+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: doc._id,
+            oldValue: null,
+            newValue: 'Document created',
+            createdBy: userId,
+            contextId
+        };
+
+        await AuditLog.create(log);
+
+        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 || !this._originalDoc) 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[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: resolvedOld,
+                        newValue: resolvedNew,
+                        createdBy: userId,
+                        contextId
+                    });
+                }
+            }
+        }
+
+        if (logs.length) {
+            await AuditLog.insertMany(logs);
+            if (onAuditLogCreated) {
+                await onAuditLogCreated(logs, contextId);
+            }
+        }
+    });
+}
+
+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,11 +1,12 @@
-import mongoose from 'mongoose';
-
-const auditConfigSchema = new mongoose.Schema({
-    collectionName: String,
-    fields: [String], 
-    trackCreation: { type: Boolean, default: false }
-});
-
-const AuditConfigModel = 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.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.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.model('AuditLog', auditSchema);
+
+export default AuditLog;

package/models/form-configuration.model.js

@@ -1,255 +1,257 @@
-import mongoose from 'mongoose';
-
-const optionSchema = new mongoose.Schema({
-    label: { type: mongoose.Schema.Types.Mixed },
-    value: { 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
-    },
-    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
-    },
-    // 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.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
+    },
+    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
+    },
+    // 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.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.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.model('ValueReferenceMap', valueReferenceMapSchema);
+export default ValueReferenceMapModel;

package/package.json

@@ -1,21 +1,21 @@
-{
-  "name": "@dynamatix/cat-shared",
-  "version": "0.0.65",
-  "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.67",
+  "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']
-    }
-];
-
-// 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();