@dynamatix/gb-schemas 2.0.68 → 2.3.4

package/dist/shared/workflow.plugin.js

@@ -0,0 +1,151 @@
+import mongoose from 'mongoose';
+import { WorkflowMiddleware } from './workflow.middleware.js';
+import { workflowLog, workflowError } from './workflow.logger.js';
+/**
+ * Workflow plugin that automatically applies workflow middleware to schemas
+ * This plugin reads the record type from schema options and applies the appropriate middleware
+ */
+export function workflowPlugin(schema, options) {
+    // For global plugins, we'll determine the record type when the middleware is triggered
+    // by looking at the document's constructor name
+    workflowLog(`🔌 Workflow plugin applied to schema`);
+    // Create workflow middleware instance
+    const middleware = new WorkflowMiddleware();
+    // Apply post-save middleware
+    schema.post('save', async function (doc, next) {
+        // Determine record type from document constructor name
+        const recordType = doc.constructor.modelName?.toLowerCase() || 'unknown';
+        workflowLog(`💾 Post-save middleware triggered for ${recordType}`);
+        workflowLog(`   Document ID: ${doc._id}`);
+        workflowLog(`   Is new: ${doc.isNew}`);
+        workflowLog(`   Trigger key: ${recordType}.${doc.isNew ? 'created' : 'updated'}`);
+        try {
+            await middleware.handleEvent({
+                recordType,
+                action: doc.isNew ? 'created' : 'updated',
+                triggerKey: `${recordType}.${doc.isNew ? 'created' : 'updated'}`
+            }, doc);
+        }
+        catch (error) {
+            workflowError('Workflow middleware error:', error);
+            // Don't throw error to avoid breaking the main operation
+        }
+        next();
+    });
+    // Apply post-findOneAndUpdate middleware
+    schema.post('findOneAndUpdate', async function (doc, next) {
+        const recordType = doc.constructor.modelName?.toLowerCase() || 'unknown';
+        workflowLog(`🔄 Post-findOneAndUpdate middleware triggered for ${recordType}`);
+        workflowLog(`   Document ID: ${doc._id}`);
+        workflowLog(`   Trigger key: ${recordType}.updated`);
+        try {
+            await middleware.handleEvent({
+                recordType,
+                action: 'updated',
+                triggerKey: `${recordType}.updated`
+            }, doc);
+        }
+        catch (error) {
+            workflowError('Workflow middleware error:', error);
+            // Don't throw error to avoid breaking the main operation
+        }
+        next();
+    });
+    // Apply post-remove middleware
+    schema.post(/^delete/, async function (result, next) {
+        // Try multiple methods to get model name since context differs in delete hooks
+        // For query hooks (model.deleteOne or doc.deleteOne), 'this' is the query
+        let recordType = 'unknown';
+        // Try from query context first (most reliable for deleteOne hooks)
+        // When doc.deleteOne() is called, 'this' refers to the query object
+        if (this?.model?.modelName) {
+            recordType = this.model.modelName.toLowerCase();
+        }
+        // Try from schema modelName
+        else if (schema?.modelName) {
+            recordType = schema.modelName.toLowerCase();
+        }
+        // Try from collection name as fallback
+        else if (this?.model?.collection?.name) {
+            recordType = this.model.collection.name.toLowerCase();
+        }
+        // Try from result if it's a document
+        else if (result?.constructor?.modelName) {
+            recordType = result.constructor.modelName.toLowerCase();
+        }
+        workflowLog(`🗑️  Post-delete middleware triggered for ${recordType}`);
+        try {
+            await middleware.handleEvent({
+                recordType,
+                action: 'deleted',
+                triggerKey: `${recordType}.deleted`
+            }, result);
+        }
+        catch (error) {
+            workflowError('Workflow middleware error:', error);
+            // Don't throw error to avoid breaking the main operation
+        }
+        next();
+    });
+    schema.post('findOneAndDelete', async function (doc, next) {
+        const recordType = doc.constructor.modelName?.toLowerCase() || 'unknown';
+        workflowLog(`🗑️  Post-findOneAndDelete middleware triggered for ${recordType}`);
+        try {
+            await middleware.handleEvent({
+                recordType,
+                action: 'deleted',
+                triggerKey: `${recordType}.deleted`
+            }, doc);
+        }
+        catch (error) {
+            workflowError('Workflow middleware error:', error);
+            // Don't throw error to avoid breaking the main operation
+        }
+        next();
+    });
+    // Apply post-find middleware (for findAll queries)
+    schema.post('find', async function (docs, next) {
+        const recordType = docs && docs.length > 0
+            ? docs[0]?.constructor?.modelName?.toLowerCase() || 'unknown'
+            : 'unknown';
+        // Only process for applicantcreditreport model
+        if (recordType === 'applicantcreditreport') {
+            workflowLog(`📚 Post-find (findAll) middleware triggered for ${recordType}`);
+            workflowLog(`   Documents found: ${docs?.length || 0}`);
+            workflowLog(`   Trigger key: ${recordType}.get`);
+            // Process each document in the results
+            if (docs && docs.length > 0) {
+                for (const doc of docs) {
+                    try {
+                        await middleware.handleEvent({
+                            recordType,
+                            action: 'get',
+                            triggerKey: `${recordType}.get`
+                        }, doc);
+                    }
+                    catch (error) {
+                        workflowError('Workflow middleware error:', error);
+                        // Don't throw error to avoid breaking the main operation
+                    }
+                }
+            }
+        }
+        next();
+    });
+}
+/**
+ * Utility function to register the workflow plugin globally
+ * This will apply workflow middleware to all schemas automatically
+ */
+export function registerWorkflowPlugin() {
+    // Register the plugin globally
+    mongoose.plugin(workflowPlugin);
+}
+/**
+ * Utility function to apply workflow plugin to a specific schema with custom record type
+ * @param schema - The Mongoose schema
+ * @param recordType - The record type (e.g., 'applications', 'applicants')
+ */
+export function applyWorkflowPlugin(schema, recordType) {
+    schema.plugin(workflowPlugin, { recordType });
+}

package/dist/shared/workflow.service.d.ts

@@ -0,0 +1,42 @@
+import { WorkflowApiPayload, WorkflowMiddlewareOptions } from './workflow-trigger.type';
+export declare class WorkflowService {
+    private options;
+    private token?;
+    constructor(options: WorkflowMiddlewareOptions, token?: string);
+    /**
+     * Triggers a workflow execution in the background
+     * @param payload - The workflow payload to send
+     * @param token - Optional token to use for this specific call (overrides instance token)
+     * @returns Promise that resolves when the request is initiated (not when it completes)
+     */
+    triggerWorkflow(payload: WorkflowApiPayload, token?: string): Promise<void>;
+    /**
+     * Executes the actual workflow API call with retry logic
+     * @param payload - The workflow payload to send
+     * @param token - Optional token from context (takes priority over env var)
+     */
+    private executeWorkflowCall;
+    /**
+     * Validates that required variables are present in the data
+     * @param requiredVariables - Array of required variable names
+     * @param data - The data object to validate
+     * @returns true if all required variables are present
+     */
+    validateRequiredVariables(requiredVariables: string[], data: Record<string, any>): boolean;
+    /**
+     * Extracts variables from document data based on required and optional variables
+     * @param requiredVariables - Array of required variable names
+     * @param optionalVariables - Array of optional variable names
+     * @param document - The document to extract variables from
+     * @returns Object containing extracted variables
+     */
+    extractVariables(requiredVariables: string[], optionalVariables: string[], document: any): Record<string, any>;
+    /**
+     * Gets a nested value from an object using dot notation
+     * @param obj - The object to extract from
+     * @param path - The dot notation path (e.g., 'user.id')
+     * @returns The value at the path or undefined
+     */
+    private getNestedValue;
+}
+//# sourceMappingURL=workflow.service.d.ts.map

package/dist/shared/workflow.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.service.d.ts","sourceRoot":"","sources":["../../shared/workflow.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAGxF,qBAAa,eAAe;IACxB,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,KAAK,CAAC,CAAS;gBAEX,OAAO,EAAE,yBAAyB,EAAE,KAAK,CAAC,EAAE,MAAM;IAU9D;;;;;OAKG;IACG,eAAe,CAAC,OAAO,EAAE,kBAAkB,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAajF;;;;OAIG;YACW,mBAAmB;IA6DjC;;;;;OAKG;IACH,yBAAyB,CAAC,iBAAiB,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO;IAO1F;;;;;;OAMG;IACH,gBAAgB,CACZ,iBAAiB,EAAE,MAAM,EAAE,EAC3B,iBAAiB,EAAE,MAAM,EAAE,EAC3B,QAAQ,EAAE,GAAG,GACd,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAmBtB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;CAKzB"}

package/dist/shared/workflow.service.js

@@ -0,0 +1,134 @@
+import { workflowLog, workflowWarn, workflowError } from './workflow.logger.js';
+export class WorkflowService {
+    constructor(options, token) {
+        this.options = {
+            timeout: 30000,
+            retryAttempts: 3,
+            retryDelay: 1000,
+            ...options
+        };
+        this.token = token;
+    }
+    /**
+     * Triggers a workflow execution in the background
+     * @param payload - The workflow payload to send
+     * @param token - Optional token to use for this specific call (overrides instance token)
+     * @returns Promise that resolves when the request is initiated (not when it completes)
+     */
+    async triggerWorkflow(payload, token) {
+        // Execute in background without waiting for completion
+        const tokenToUse = token || this.token;
+        setTimeout(async () => {
+            try {
+                await this.executeWorkflowCall(payload, tokenToUse);
+            }
+            catch (error) {
+                workflowError('Workflow execution failed:', error);
+                // Could implement retry logic or error reporting here
+            }
+        }, 1000);
+    }
+    /**
+     * Executes the actual workflow API call with retry logic
+     * @param payload - The workflow payload to send
+     * @param token - Optional token from context (takes priority over env var)
+     */
+    async executeWorkflowCall(payload, token) {
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-Solution-Key': process.env.SOLUTION_KEY || 'default'
+        };
+        // Priority: Context token > Environment variable
+        const workflowApiKey = token || process.env.WORKFLOW_API_KEY;
+        if (workflowApiKey) {
+            headers['Authorization'] = `Bearer ${workflowApiKey}`;
+        }
+        const requestOptions = {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(this.options.timeout)
+        };
+        let lastError = null;
+        for (let attempt = 1; attempt <= this.options.retryAttempts; attempt++) {
+            try {
+                workflowLog(`🚀 Workflow API call attempt ${attempt}:`);
+                workflowLog(`   URL: ${this.options.workflowApiUrl}`);
+                workflowLog(`   Payload: ${JSON.stringify(payload, null, 2)}`);
+                const response = await fetch(this.options.workflowApiUrl, requestOptions);
+                if (!response.ok) {
+                    // Try to get error details from response body
+                    let errorDetails = response.statusText;
+                    try {
+                        const errorBody = await response.text();
+                        if (errorBody) {
+                            errorDetails = errorBody;
+                        }
+                    }
+                    catch (e) {
+                        // Ignore if we can't read the body
+                    }
+                    throw new Error(`HTTP ${response.status}: ${errorDetails}`);
+                }
+                const result = await response.json();
+                workflowLog(`✅ Workflow ${payload.workflowKey} triggered successfully: ${JSON.stringify(result, null, 2)}`);
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                workflowWarn(`Workflow API call attempt ${attempt} failed:`, error);
+                if (attempt < this.options.retryAttempts) {
+                    // Wait before retrying
+                    await new Promise(resolve => setTimeout(resolve, this.options.retryDelay * attempt));
+                }
+            }
+        }
+        // All retry attempts failed
+        throw new Error(`Workflow API call failed after ${this.options.retryAttempts} attempts: ${lastError?.message}`);
+    }
+    /**
+     * Validates that required variables are present in the data
+     * @param requiredVariables - Array of required variable names
+     * @param data - The data object to validate
+     * @returns true if all required variables are present
+     */
+    validateRequiredVariables(requiredVariables, data) {
+        return requiredVariables.every(variable => {
+            const value = data[variable];
+            return value !== undefined && value !== null && value !== '';
+        });
+    }
+    /**
+     * Extracts variables from document data based on required and optional variables
+     * @param requiredVariables - Array of required variable names
+     * @param optionalVariables - Array of optional variable names
+     * @param document - The document to extract variables from
+     * @returns Object containing extracted variables
+     */
+    extractVariables(requiredVariables, optionalVariables, document) {
+        const variables = {};
+        // Extract required variables
+        requiredVariables.forEach(variable => {
+            variables[variable] = this.getNestedValue(document, variable);
+        });
+        // Extract optional variables
+        optionalVariables?.forEach(variable => {
+            const value = this.getNestedValue(document, variable);
+            if (value !== undefined && value !== null) {
+                variables[variable] = value;
+            }
+        });
+        return variables;
+    }
+    /**
+     * Gets a nested value from an object using dot notation
+     * @param obj - The object to extract from
+     * @param path - The dot notation path (e.g., 'user.id')
+     * @returns The value at the path or undefined
+     */
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => {
+            return current && current[key] !== undefined ? current[key] : undefined;
+        }, obj);
+    }
+}

package/dist/types/base.types.d.ts

@@ -0,0 +1,35 @@
+/// <reference path="../value-objects/pound.d.ts" />
+/// <reference path="../value-objects/account-number.d.ts" />
+/// <reference path="../value-objects/sort-code.d.ts" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import { Types } from "mongoose";
+export interface IBaseType {
+    _id: Types.ObjectId;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+//# sourceMappingURL=base.types.d.ts.map

package/dist/types/base.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.types.d.ts","sourceRoot":"","sources":["../../types/base.types.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,MAAM,WAAW,SAAS;IACtB,GAAG,EAAE,KAAK,CAAC,QAAQ,CAAC;IACpB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,SAAS,CAAC,EAAE,IAAI,CAAC;CACpB"}

package/dist/types/base.types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../types/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/types/index.js

@@ -0,0 +1 @@
+export * from './base.types';

package/dist/underwriter/underwriter.model.d.ts

@@ -1,3 +1,31 @@
+/// <reference path="../value-objects/pound.d.ts" />
+/// <reference path="../value-objects/account-number.d.ts" />
+/// <reference path="../value-objects/sort-code.d.ts" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
 import mongoose from "mongoose";
 declare const UnderwriterModel: mongoose.Model<{
     createdAt: NativeDate;
@@ -27,7 +55,7 @@ declare const UnderwriterModel: mongoose.Model<{
     bridgingPreOfferCaseCount: number;
     bridgingPostOfferCaseCount: number;
     bridgingMandateLevel: number;
-}> & {
+}, {}> & {
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
@@ -75,7 +103,7 @@ declare const UnderwriterModel: mongoose.Model<{
     bridgingPreOfferCaseCount: number;
     bridgingPostOfferCaseCount: number;
     bridgingMandateLevel: number;
-}>> & mongoose.FlatRecord<{
+}>, {}> & mongoose.FlatRecord<{
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {

package/dist/underwriter/underwriter.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"underwriter.model.d.ts","sourceRoot":"","sources":["../../underwriter/underwriter.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiBhC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmD,CAAC;AAC1E,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"underwriter.model.d.ts","sourceRoot":"","sources":["../../underwriter/underwriter.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiBhC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmD,CAAC;AAC1E,eAAe,gBAAgB,CAAC"}

package/dist/users/auth-log.model.d.ts

@@ -1,3 +1,31 @@
+/// <reference path="../value-objects/pound.d.ts" />
+/// <reference path="../value-objects/account-number.d.ts" />
+/// <reference path="../value-objects/sort-code.d.ts" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
 import mongoose from "mongoose";
 declare const AuthLogModel: mongoose.Model<{
     userEmail: string;
@@ -9,7 +37,7 @@ declare const AuthLogModel: mongoose.Model<{
     loggedInTimestamp: NativeDate;
     isSuccess: boolean;
     activity?: "LOGIN" | "LOGOUT" | "PASSWORD_RESET" | null | undefined;
-}> & {
+}, {}> & {
     userEmail: string;
     loggedInTimestamp: NativeDate;
     isSuccess: boolean;
@@ -28,7 +56,7 @@ declare const AuthLogModel: mongoose.Model<{
     loggedInTimestamp: NativeDate;
     isSuccess: boolean;
     activity?: "LOGIN" | "LOGOUT" | "PASSWORD_RESET" | null | undefined;
-}>> & mongoose.FlatRecord<{
+}>, {}> & mongoose.FlatRecord<{
     userEmail: string;
     loggedInTimestamp: NativeDate;
     isSuccess: boolean;

package/dist/users/auth-log.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth-log.model.d.ts","sourceRoot":"","sources":["../../users/auth-log.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAqBhC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2C,CAAC;AAE9D,eAAe,YAAY,CAAC"}
+{"version":3,"file":"auth-log.model.d.ts","sourceRoot":"","sources":["../../users/auth-log.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAyBhC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2C,CAAC;AAE9D,eAAe,YAAY,CAAC"}

package/dist/users/auth-log.model.js

@@ -17,5 +17,8 @@ const AuthLogSchema = new mongoose.Schema({
         enum: ["LOGIN", "LOGOUT", "PASSWORD_RESET"]
     }
 });
+// Indexes for query optimization
+AuthLogSchema.index({ userEmail: 1, loggedInTimestamp: -1 }); // Compound index for getByEmail queries with timestamp sort
+AuthLogSchema.index({ loggedInTimestamp: -1 }); // Index for getAll queries sorted by timestamp descending
 const AuthLogModel = mongoose.model("AuthLog", AuthLogSchema);
 export default AuthLogModel;

package/dist/users/permission.model.d.ts

@@ -1,3 +1,31 @@
+/// <reference path="../value-objects/pound.d.ts" />
+/// <reference path="../value-objects/account-number.d.ts" />
+/// <reference path="../value-objects/sort-code.d.ts" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
 import mongoose from "mongoose";
 declare const PermissionModel: mongoose.Model<{
     createdAt: NativeDate;
@@ -13,7 +41,7 @@ declare const PermissionModel: mongoose.Model<{
     name: string;
     controllerName: string;
     methodName: string;
-}> & {
+}, {}> & {
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
@@ -40,7 +68,7 @@ declare const PermissionModel: mongoose.Model<{
     name: string;
     controllerName: string;
     methodName: string;
-}>> & mongoose.FlatRecord<{
+}>, {}> & mongoose.FlatRecord<{
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {

package/dist/users/permission.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"permission.model.d.ts","sourceRoot":"","sources":["../../users/permission.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAWhC,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiD,CAAC;AAEvE,eAAe,eAAe,CAAC"}
+{"version":3,"file":"permission.model.d.ts","sourceRoot":"","sources":["../../users/permission.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAchC,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiD,CAAC;AAEvE,eAAe,eAAe,CAAC"}

package/dist/users/permission.model.js

@@ -6,5 +6,7 @@ const permissionSchema = new mongoose.Schema({
 }, {
     timestamps: true
 });
+// Add recommended indexes for query optimization
+permissionSchema.index({ name: 1 }); // Filter by permission name
 const PermissionModel = mongoose.model('Permission', permissionSchema);
 export default PermissionModel;

package/dist/users/role-group.model.d.ts

@@ -1,3 +1,31 @@
+/// <reference path="../value-objects/pound.d.ts" />
+/// <reference path="../value-objects/account-number.d.ts" />
+/// <reference path="../value-objects/sort-code.d.ts" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
 import mongoose from "mongoose";
 declare const RoleGroupModel: mongoose.Model<{
     createdAt: NativeDate;
@@ -15,7 +43,7 @@ declare const RoleGroupModel: mongoose.Model<{
     groupId: string;
     roles: mongoose.Types.ObjectId[];
     description?: string | null | undefined;
-}> & {
+}, {}> & {
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
@@ -45,7 +73,7 @@ declare const RoleGroupModel: mongoose.Model<{
     groupId: string;
     roles: mongoose.Types.ObjectId[];
     description?: string | null | undefined;
-}>> & mongoose.FlatRecord<{
+}>, {}> & mongoose.FlatRecord<{
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {

package/dist/users/role-group.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"role-group.model.d.ts","sourceRoot":"","sources":["../../users/role-group.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAehC,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AACpE,eAAe,cAAc,CAAC"}
+{"version":3,"file":"role-group.model.d.ts","sourceRoot":"","sources":["../../users/role-group.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAmBhC,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AACpE,eAAe,cAAc,CAAC"}

package/dist/users/role-group.model.js

@@ -10,5 +10,8 @@ const RoleGroupSchema = new mongoose.Schema({
 }, {
     timestamps: true
 });
+// Indexes for query optimization
+RoleGroupSchema.index({ name: 1 });
+RoleGroupSchema.index({ roles: 1 });
 const RoleGroupModel = mongoose.model('RoleGroup', RoleGroupSchema);
 export default RoleGroupModel;