@dynamatix/cat-shared 0.0.96 → 0.0.97

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,302 +1,302 @@
-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;
-
-// Optionally, define custom resolvers here
-const customResolvers = {
-    // Example:
-    // expenditureRationale: (doc) => `Rationale for ${doc.type}: ${doc.rationale}`
-};
-
-// 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 modelName = doc.constructor.modelName;
-    const config = await ValueReferenceMap.findOne({ field, model: modelName });
-    if (!config) return field;
-
-    if (config.descriptionField && config.descriptionField.includes('${')) {
-        return await resolveExpressionDescription(doc, config.descriptionField, config.descriptionResolverType);
-    }
-
-    switch (config.descriptionResolverType) {
-        case 'lookup': {
-            const lookupId = doc[config.descriptionField];
-            if (!lookupId) return '';
-            const lookupDoc = await mongoose.models['Lookup'].findById(lookupId).lean();
-            return lookupDoc?.name || '';
-        }
-        case 'direct':
-            return doc[config.descriptionField] || '';
-        case 'composite':
-            return (config.descriptionFields || [])
-                .map(f => doc[f])
-                .filter(Boolean)
-                .join(' ');
-        case 'custom':
-            if (typeof customResolvers?.[config.descriptionFunction] === 'function') {
-                return await customResolvers[config.descriptionFunction](doc);
-            }
-            return '';
-        default:
-            return '';
-    }
-}
-
-// 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;
-}
-
-// Add new function to resolve deletion description
-async function resolveDeletionDescription(doc, auditConfig) {
-    if (!auditConfig.descriptionResolutorForDeletion) return '';
-    const expression = auditConfig.descriptionResolutorForDeletion;
-    return await resolveExpressionDescription(doc, expression, 'direct');
-}
-
-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 entityDescription = await resolveEntityDescription(doc, auditConfig);
-        let logs = [];
-
-        // Per-field logs
-        if (auditConfig.fields?.length) {
-            for (const field of auditConfig.fields) {
-                let lookupName;
-                const newValue = doc[field];
-                if (field.endsWith('Lid')) {
-                    const newlookupDoc = await mongoose.models['Lookup'].findById(newValue).lean();
-                    if (newlookupDoc) {
-                        lookupName = newlookupDoc.name;
-                    } else {
-                        lookupName = '';
-                    }
-                }
-                const fieldDescription = await resolveDescription(field, doc);
-                logs.push({
-                    name: fieldDescription,
-                    entity: entityDescription,
-                    recordId: contextId || doc._id,
-                    oldValue: null,
-                    newValue: lookupName || newValue,
-                    createdBy: userId,
-                    externalData: {
-                        description: entityDescription,
-                        contextId
-                    }
-                });
-            }
-        }
-        logs = logs.filter(log => {
-            // Convert null/undefined to empty string for comparison
-            const oldVal = log.oldValue ?? '';
-            const newVal = log.newValue ?? '';
-            return oldVal !== newVal;
-        });
-        if (logs.length) {
-            await AuditLog.insertMany(logs);
-            await updateContextAuditCount(contextId, logs.length);
-            if (onAuditLogCreated) {
-                await onAuditLogCreated(logs, 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();
-        let logs = [];
-        const context = getContext();
-        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);
-
-            if (hasChanged) {
-                const newValue = update?.$set?.[field] ?? update?.[field];
-                const oldValue = this._originalDoc ? this._originalDoc[field] : '';
-                let lookupOldName;
-                let lookupNewName;
-                if (field.endsWith('Lid')) {
-                    const newlookupDoc = await mongoose.models['Lookup'].findById(newValue).lean();
-                    if (newlookupDoc) {
-                        lookupOldName = newlookupDoc.name;
-                    } else {
-                        lookupOldName = '';
-                    }
-                    const oldlookupDoc = await mongoose.models['Lookup'].findById(oldValue).lean();
-                    if (oldlookupDoc) {
-                        lookupNewName = oldlookupDoc.name;
-                    } else {
-                        lookupNewName = '';
-                    }
-                }
-
-                // Convert null/undefined to empty string for comparison
-                const oldVal = lookupOldName ?? oldValue ?? '';
-                const newVal = lookupNewName ?? newValue ?? '';
-                if (oldVal !== newVal) {
-                    const fieldDescription = await resolveDescription(field, result);
-                    logs.push({
-                        name: fieldDescription,
-                        entity: entityDescription,
-                        recordId: contextId || result._id,
-                        oldValue: oldVal,
-                        newValue: newVal,
-                        createdBy: userId,
-                        externalData: {
-                            description: entityDescription,
-                            contextId: contextId || result._id
-                        }
-                    });
-                }
-            }
-        }
-        logs = logs.filter(log => {
-            // Convert null/undefined to empty string for comparison
-            const oldVal = log.oldValue ?? '';
-            const newVal = log.newValue ?? '';
-            return oldVal !== newVal;
-        });
-        if (logs.length) {
-            await AuditLog.insertMany(logs);
-            await updateContextAuditCount(contextId, logs.length);
-            if (onAuditLogCreated) {
-                await onAuditLogCreated(logs, contextId);
-            }
-        }
-    });
-
-    // Handle delete audits
-    schema.pre(['findOneAndDelete', 'findByIdAndDelete', 'deleteOne', 'deleteMany'], async function (next) {
-        try {
-            // Fetch the document before deletion
-            const docToDelete = await this.model.findOne(this.getQuery()).lean();
-            if (docToDelete) {
-                // Store the document for use in post middleware
-                this._docToDelete = docToDelete;
-            }
-            next();
-        } catch (error) {
-            next(error);
-        }
-    });
-
-    schema.post(['findOneAndDelete', 'findByIdAndDelete', 'deleteOne', 'deleteMany'], async function (result) {
-        if (!result) return;
-
-        const auditConfig = await AuditConfigModel.findOne({ collectionName });
-        if (!auditConfig?.trackDeletion) return;
-
-        const context = getContext();
-        const userId = context?.userId || 'anonymous';
-        const contextId = context?.contextId;
-
-        const entityDescription = await resolveEntityDescription(this._docToDelete, auditConfig);
-        const deletionDescription = await resolveDeletionDescription(this._docToDelete, auditConfig);
-
-        const log = {
-            name: deletionDescription || 'Entity Deletion',
-            entity: entityDescription,
-            recordId: contextId || deletedDoc._id,
-            oldValue: '',
-            newValue: 'Deleted',
-            createdBy: userId,
-            externalData: {
-                description: entityDescription,
-                contextId: contextId || deletedDoc._id
-            }
-        };
-        const oldVal = log.oldValue ?? '';
-        const newVal = log.newValue ?? '';
-        if (oldVal === newVal) {
-            return;
-        }
-        await AuditLog.create(log);
-        await updateContextAuditCount(contextId, 1);
-        if (onAuditLogCreated) {
-            await onAuditLogCreated([log], 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;
-}
-
+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;
+
+// Optionally, define custom resolvers here
+const customResolvers = {
+    // Example:
+    // expenditureRationale: (doc) => `Rationale for ${doc.type}: ${doc.rationale}`
+};
+
+// 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 modelName = doc.constructor.modelName;
+    const config = await ValueReferenceMap.findOne({ field, model: modelName });
+    if (!config) return field;
+
+    if (config.descriptionField && config.descriptionField.includes('${')) {
+        return await resolveExpressionDescription(doc, config.descriptionField, config.descriptionResolverType);
+    }
+
+    switch (config.descriptionResolverType) {
+        case 'lookup': {
+            const lookupId = doc[config.descriptionField];
+            if (!lookupId) return '';
+            const lookupDoc = await mongoose.models['Lookup'].findById(lookupId).lean();
+            return lookupDoc?.name || '';
+        }
+        case 'direct':
+            return doc[config.descriptionField] || '';
+        case 'composite':
+            return (config.descriptionFields || [])
+                .map(f => doc[f])
+                .filter(Boolean)
+                .join(' ');
+        case 'custom':
+            if (typeof customResolvers?.[config.descriptionFunction] === 'function') {
+                return await customResolvers[config.descriptionFunction](doc);
+            }
+            return '';
+        default:
+            return '';
+    }
+}
+
+// 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;
+}
+
+// Add new function to resolve deletion description
+async function resolveDeletionDescription(doc, auditConfig) {
+    if (!auditConfig.descriptionResolutorForDeletion) return '';
+    const expression = auditConfig.descriptionResolutorForDeletion;
+    return await resolveExpressionDescription(doc, expression, 'direct');
+}
+
+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 entityDescription = await resolveEntityDescription(doc, auditConfig);
+        let logs = [];
+
+        // Per-field logs
+        if (auditConfig.fields?.length) {
+            for (const field of auditConfig.fields) {
+                let lookupName;
+                const newValue = doc[field];
+                if (field.endsWith('Lid')) {
+                    const newlookupDoc = await mongoose.models['Lookup'].findById(newValue).lean();
+                    if (newlookupDoc) {
+                        lookupName = newlookupDoc.name;
+                    } else {
+                        lookupName = '';
+                    }
+                }
+                const fieldDescription = await resolveDescription(field, doc);
+                logs.push({
+                    name: fieldDescription,
+                    entity: entityDescription,
+                    recordId: contextId || doc._id,
+                    oldValue: null,
+                    newValue: lookupName || newValue,
+                    createdBy: userId,
+                    externalData: {
+                        description: entityDescription,
+                        contextId
+                    }
+                });
+            }
+        }
+        logs = logs.filter(log => {
+            // Convert null/undefined to empty string for comparison
+            const oldVal = log.oldValue ?? '';
+            const newVal = log.newValue ?? '';
+            return oldVal !== newVal;
+        });
+        if (logs.length) {
+            await AuditLog.insertMany(logs);
+            await updateContextAuditCount(contextId, logs.length);
+            if (onAuditLogCreated) {
+                await onAuditLogCreated(logs, 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();
+        let logs = [];
+        const context = getContext();
+        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);
+
+            if (hasChanged) {
+                const newValue = update?.$set?.[field] ?? update?.[field];
+                const oldValue = this._originalDoc ? this._originalDoc[field] : '';
+                let lookupOldName;
+                let lookupNewName;
+                if (field.endsWith('Lid')) {
+                    const newlookupDoc = await mongoose.models['Lookup'].findById(newValue).lean();
+                    if (newlookupDoc) {
+                        lookupNewName = newlookupDoc.name;
+                    } else {
+                        lookupNewName = '';
+                    }
+                    const oldlookupDoc = await mongoose.models['Lookup'].findById(oldValue).lean();
+                    if (oldlookupDoc) {
+                        lookupOldName = oldlookupDoc.name;
+                    } else {
+                        lookupOldName = '';
+                    }
+                }
+
+                // Convert null/undefined to empty string for comparison
+                const oldVal = lookupOldName ?? oldValue ?? '';
+                const newVal = lookupNewName ?? newValue ?? '';
+                if (oldVal !== newVal) {
+                    const fieldDescription = await resolveDescription(field, result);
+                    logs.push({
+                        name: fieldDescription,
+                        entity: entityDescription,
+                        recordId: contextId || result._id,
+                        oldValue: oldVal,
+                        newValue: newVal,
+                        createdBy: userId,
+                        externalData: {
+                            description: entityDescription,
+                            contextId: contextId || result._id
+                        }
+                    });
+                }
+            }
+        }
+        logs = logs.filter(log => {
+            // Convert null/undefined to empty string for comparison
+            const oldVal = log.oldValue ?? '';
+            const newVal = log.newValue ?? '';
+            return oldVal !== newVal;
+        });
+        if (logs.length) {
+            await AuditLog.insertMany(logs);
+            await updateContextAuditCount(contextId, logs.length);
+            if (onAuditLogCreated) {
+                await onAuditLogCreated(logs, contextId);
+            }
+        }
+    });
+
+    // Handle delete audits
+    schema.pre(['findOneAndDelete', 'findByIdAndDelete', 'deleteOne', 'deleteMany'], async function (next) {
+        try {
+            // Fetch the document before deletion
+            const docToDelete = await this.model.findOne(this.getQuery()).lean();
+            if (docToDelete) {
+                // Store the document for use in post middleware
+                this._docToDelete = docToDelete;
+            }
+            next();
+        } catch (error) {
+            next(error);
+        }
+    });
+
+    schema.post(['findOneAndDelete', 'findByIdAndDelete', 'deleteOne', 'deleteMany'], async function (result) {
+        if (!result) return;
+
+        const auditConfig = await AuditConfigModel.findOne({ collectionName });
+        if (!auditConfig?.trackDeletion) return;
+
+        const context = getContext();
+        const userId = context?.userId || 'anonymous';
+        const contextId = context?.contextId;
+
+        const entityDescription = await resolveEntityDescription(this._docToDelete, auditConfig);
+        const deletionDescription = await resolveDeletionDescription(this._docToDelete, auditConfig);
+
+        const log = {
+            name: deletionDescription || 'Entity Deletion',
+            entity: entityDescription,
+            recordId: contextId || deletedDoc._id,
+            oldValue: '',
+            newValue: 'Deleted',
+            createdBy: userId,
+            externalData: {
+                description: entityDescription,
+                contextId: contextId || deletedDoc._id
+            }
+        };
+        const oldVal = log.oldValue ?? '';
+        const newVal = log.newValue ?? '';
+        if (oldVal === newVal) {
+            return;
+        }
+        await AuditLog.create(log);
+        await updateContextAuditCount(contextId, 1);
+        if (onAuditLogCreated) {
+            await onAuditLogCreated([log], 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,15 +1,15 @@
-import mongoose from 'mongoose';
-
-const auditConfigSchema = new mongoose.Schema({
-    collectionName: String,
-    fields: [String],
-    trackCreation: { type: Boolean, default: false },
-    trackDeletion: { type: Boolean, default: false },
-    descriptionResolutorForExternalData: { type: String, default: null },
-    descriptionResolutorForDeletion: { 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 },
+    trackDeletion: { type: Boolean, default: false },
+    descriptionResolutorForExternalData: { type: String, default: null },
+    descriptionResolutorForDeletion: { type: String, default: null },
+});
+
+const AuditConfigModel = mongoose.models.AuditConfig || mongoose.model('AuditConfig', auditConfigSchema);
+
+
+export default AuditConfigModel;