@dynamatix/gb-schemas 2.0.67 → 2.3.4

package/dist/shared/workflow-trigger.model.js

@@ -0,0 +1,49 @@
+import mongoose, { Schema } from 'mongoose';
+const WorkflowTriggerSchema = new Schema({
+    triggerKey: {
+        type: String,
+        required: true,
+        unique: true,
+        index: true
+    },
+    description: {
+        type: String,
+        required: true
+    },
+    isActive: {
+        type: Boolean,
+        default: true,
+        index: true
+    },
+    condition: {
+        type: String,
+        required: true
+    },
+    workflowKey: {
+        type: String,
+        required: true,
+        index: true
+    },
+    requiredVariables: [{
+            type: String,
+            required: true
+        }],
+    optionalVariables: [{
+            type: String
+        }],
+    parentKey: {
+        type: String,
+        required: false
+    },
+    validationRules: {
+        type: Schema.Types.Mixed
+    },
+    metadata: {
+        type: Schema.Types.Mixed
+    }
+}, { timestamps: true });
+// Index for efficient querying
+WorkflowTriggerSchema.index({ triggerKey: 1, isActive: 1 });
+WorkflowTriggerSchema.index({ workflowKey: 1, isActive: 1 });
+// Conditional model registration to avoid "Cannot overwrite model" errors
+export default mongoose.models.WorkflowTrigger || mongoose.model('WorkflowTrigger', WorkflowTriggerSchema);

package/dist/shared/workflow-trigger.type.d.ts

@@ -0,0 +1,60 @@
+/// <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 { Document } from 'mongoose';
+export default interface IWorkflowTrigger extends Document {
+    triggerKey: string;
+    description: string;
+    isActive: boolean;
+    condition: string;
+    workflowKey: string;
+    requiredVariables: string[];
+    optionalVariables?: string[];
+    parentKey?: string;
+    validationRules?: any;
+    metadata?: any;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface WorkflowTriggerEvent {
+    recordType: string;
+    action: string;
+    triggerKey: string;
+}
+export interface WorkflowApiPayload {
+    workflowKey: string;
+    version: number;
+    variables: Record<string, any>;
+}
+export interface WorkflowMiddlewareOptions {
+    workflowApiUrl: string;
+    timeout?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+//# sourceMappingURL=workflow-trigger.type.d.ts.map

package/dist/shared/workflow-trigger.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-trigger.type.d.ts","sourceRoot":"","sources":["../../shared/workflow-trigger.type.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,MAAM,CAAC,OAAO,WAAW,gBAAiB,SAAQ,QAAQ;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,yBAAyB;IACtC,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB"}

package/dist/shared/workflow-trigger.type.js

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

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

@@ -0,0 +1,21 @@
+/**
+ * Initialize workflow middleware for all schemas
+ * Call this function once in your application startup to enable workflow middleware globally
+ *
+ * This will automatically apply workflow middleware to all Mongoose schemas
+ * The record type will be inferred from the model name (e.g., 'Application' -> 'applications')
+ */
+export declare function initializeWorkflowMiddleware(): void;
+/**
+ * Check if workflow middleware is properly configured
+ * @returns true if all required environment variables are set
+ */
+export declare function isWorkflowMiddlewareConfigured(): boolean;
+/**
+ * Initialize workflow middleware with configuration check
+ * @param options - Optional configuration options
+ */
+export declare function initializeWorkflowMiddlewareWithCheck(options?: {
+    skipConfigCheck?: boolean;
+}): boolean;
+//# sourceMappingURL=workflow.init.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.init.d.ts","sourceRoot":"","sources":["../../shared/workflow.init.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,wBAAgB,4BAA4B,SAI3C;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,IAAI,OAAO,CAUxD;AAED;;;GAGG;AACH,wBAAgB,qCAAqC,CAAC,OAAO,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,WAQ5F"}

package/dist/shared/workflow.init.js

@@ -0,0 +1,42 @@
+import dotenv from 'dotenv';
+import { registerWorkflowPlugin } from './workflow.plugin.js';
+import { workflowLog, workflowWarn } from './workflow.logger.js';
+// Load environment variables from .env file
+dotenv.config();
+/**
+ * Initialize workflow middleware for all schemas
+ * Call this function once in your application startup to enable workflow middleware globally
+ *
+ * This will automatically apply workflow middleware to all Mongoose schemas
+ * The record type will be inferred from the model name (e.g., 'Application' -> 'applications')
+ */
+export function initializeWorkflowMiddleware() {
+    workflowLog('Initializing workflow middleware for all schemas...');
+    registerWorkflowPlugin();
+    workflowLog('Workflow middleware initialized successfully');
+}
+/**
+ * Check if workflow middleware is properly configured
+ * @returns true if all required environment variables are set
+ */
+export function isWorkflowMiddlewareConfigured() {
+    const requiredEnvVars = ['WORKFLOW_API_KEY'];
+    const missingVars = requiredEnvVars.filter(varName => !process.env[varName]);
+    if (missingVars.length > 0) {
+        workflowWarn(`Missing required environment variables for workflow middleware: ${missingVars.join(', ')}`);
+        return false;
+    }
+    return true;
+}
+/**
+ * Initialize workflow middleware with configuration check
+ * @param options - Optional configuration options
+ */
+export function initializeWorkflowMiddlewareWithCheck(options) {
+    if (!options?.skipConfigCheck && !isWorkflowMiddlewareConfigured()) {
+        workflowWarn('Workflow middleware configuration incomplete. Middleware will be disabled.');
+        return false;
+    }
+    initializeWorkflowMiddleware();
+    return true;
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Utility functions for workflow engine logging
+ * Logs are controlled by the SHOW_WORKFLOW_ENGINE_LOGS environment variable
+ */
+/**
+ * Conditional console.log that only logs if SHOW_WORKFLOW_ENGINE_LOGS is enabled
+ */
+export declare function workflowLog(...args: any[]): void;
+/**
+ * Conditional console.warn that only logs if SHOW_WORKFLOW_ENGINE_LOGS is enabled
+ */
+export declare function workflowWarn(...args: any[]): void;
+/**
+ * Conditional console.error that only logs if SHOW_WORKFLOW_ENGINE_LOGS is enabled
+ * Note: Error logs might be important, but we'll respect the flag for consistency
+ */
+export declare function workflowError(...args: any[]): void;
+//# sourceMappingURL=workflow.logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.logger.d.ts","sourceRoot":"","sources":["../../shared/workflow.logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAeH;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAIhD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAIjD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAIlD"}

package/dist/shared/workflow.logger.js

@@ -0,0 +1,41 @@
+/**
+ * Utility functions for workflow engine logging
+ * Logs are controlled by the SHOW_WORKFLOW_ENGINE_LOGS environment variable
+ */
+/**
+ * Checks if workflow engine logs should be displayed
+ * @returns true if SHOW_WORKFLOW_ENGINE_LOGS is set to a truthy value
+ */
+function shouldShowLogs() {
+    const envValue = process.env.SHOW_WORKFLOW_ENGINE_LOGS;
+    if (!envValue)
+        return false;
+    // Check for truthy string values
+    const normalizedValue = envValue.toLowerCase().trim();
+    return normalizedValue === 'true' || normalizedValue === '1' || normalizedValue === 'yes';
+}
+/**
+ * Conditional console.log that only logs if SHOW_WORKFLOW_ENGINE_LOGS is enabled
+ */
+export function workflowLog(...args) {
+    if (shouldShowLogs()) {
+        console.log(...args);
+    }
+}
+/**
+ * Conditional console.warn that only logs if SHOW_WORKFLOW_ENGINE_LOGS is enabled
+ */
+export function workflowWarn(...args) {
+    if (shouldShowLogs()) {
+        console.warn(...args);
+    }
+}
+/**
+ * Conditional console.error that only logs if SHOW_WORKFLOW_ENGINE_LOGS is enabled
+ * Note: Error logs might be important, but we'll respect the flag for consistency
+ */
+export function workflowError(...args) {
+    if (shouldShowLogs()) {
+        console.error(...args);
+    }
+}

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

@@ -0,0 +1,108 @@
+/// <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.js" />
+/// <reference types="mongoose/types/callback.js" />
+/// <reference types="mongoose/types/collection.js" />
+/// <reference types="mongoose/types/connection.js" />
+/// <reference types="mongoose/types/cursor.js" />
+/// <reference types="mongoose/types/document.js" />
+/// <reference types="mongoose/types/error.js" />
+/// <reference types="mongoose/types/expressions.js" />
+/// <reference types="mongoose/types/helpers.js" />
+/// <reference types="mongoose/types/middlewares.js" />
+/// <reference types="mongoose/types/indexes.js" />
+/// <reference types="mongoose/types/models.js" />
+/// <reference types="mongoose/types/mongooseoptions.js" />
+/// <reference types="mongoose/types/pipelinestage.js" />
+/// <reference types="mongoose/types/populate.js" />
+/// <reference types="mongoose/types/query.js" />
+/// <reference types="mongoose/types/schemaoptions.js" />
+/// <reference types="mongoose/types/session.js" />
+/// <reference types="mongoose/types/types.js" />
+/// <reference types="mongoose/types/utility.js" />
+/// <reference types="mongoose/types/validation.js" />
+/// <reference types="mongoose/types/virtuals.js" />
+/// <reference types="mongoose/types/schematypes.js" />
+/// <reference types="mongoose/types/inferschematype.js" />
+/// <reference types="mongoose/types/inferrawdoctype.js" />
+import mongoose from 'mongoose';
+import { WorkflowTriggerEvent, WorkflowMiddlewareOptions } from './workflow-trigger.type.js';
+export declare class WorkflowMiddleware {
+    private workflowService;
+    private options;
+    constructor(options?: Partial<WorkflowMiddlewareOptions>);
+    /**
+     * Safely gets the WorkflowTrigger model, handling potential registration issues
+     */
+    private getWorkflowTriggerModel;
+    /**
+     * Gets the current request context including application_id and token
+     * @returns The current context object or null if not available
+     */
+    getContext(): {
+        contextId: any;
+        token: any;
+    } | null;
+    /**
+     * Creates a Mongoose middleware function for a specific model
+     * @param recordType - The type of record (e.g., 'applications', 'products', 'tasks')
+     * @returns Mongoose middleware function
+     */
+    createMiddleware(recordType: string): {
+        postSave: (this: any, doc: any, next: Function) => Promise<void>;
+        postRemove: (this: any, doc: any, next: Function) => Promise<void>;
+    };
+    /**
+     * Handles a workflow trigger event
+     * @param event - The workflow trigger event
+     * @param document - The document that triggered the event
+     */
+    handleEvent(event: WorkflowTriggerEvent, document: any): Promise<void>;
+    /**
+     * Processes a single workflow trigger
+     * @param trigger - The workflow trigger configuration
+     * @param document - The document that triggered the event
+     * @param event - The workflow trigger event
+     */
+    private processTrigger;
+    /**
+     * Evaluates a condition against a document
+     * @param condition - The condition string to evaluate
+     * @param document - The document to evaluate against
+     * @returns true if condition is met
+     */
+    private evaluateCondition;
+    /**
+     * Extracts metadata from document and event
+     * @param document - The document
+     * @param event - The event
+     * @returns Metadata object
+     */
+    private extractMetadata;
+    /**
+     * Manually trigger a workflow for a specific document
+     * @param triggerKey - The trigger key to use
+     * @param document - The document to process
+     * @param recordType - The record type
+     */
+    manualTrigger(triggerKey: string, document: any, recordType: string): Promise<void>;
+}
+/**
+ * Factory function to create workflow middleware for a model
+ * @param recordType - The type of record (e.g., 'applications', 'products', 'tasks')
+ * @param options - Optional workflow middleware options (overrides env vars)
+ * @returns Mongoose middleware functions
+ */
+export declare function createWorkflowMiddleware(recordType: string, options?: Partial<WorkflowMiddlewareOptions>): {
+    postSave: (this: any, doc: any, next: Function) => Promise<void>;
+    postRemove: (this: any, doc: any, next: Function) => Promise<void>;
+};
+/**
+ * Utility function to apply workflow middleware to a Mongoose schema
+ * @param schema - The Mongoose schema
+ * @param recordType - The type of record
+ * @param options - Optional workflow middleware options (overrides env vars)
+ */
+export declare function applyWorkflowMiddleware(schema: mongoose.Schema, recordType: string, options?: Partial<WorkflowMiddlewareOptions>): void;
+//# sourceMappingURL=workflow.middleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.middleware.d.ts","sourceRoot":"","sources":["../../shared/workflow.middleware.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAGhC,OAAO,EACH,oBAAoB,EAEpB,yBAAyB,EAC5B,MAAM,4BAA4B,CAAC;AAIpC,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,OAAO,CAA4B;gBAE/B,OAAO,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC;IAYxD;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAS/B;;;OAGG;IACH,UAAU;;;;IAWV;;;;OAIG;IACH,gBAAgB,CAAC,UAAU,EAAE,MAAM;yBAGK,GAAG,OAAO,GAAG,QAAQ,QAAQ;2BAiB3B,GAAG,OAAO,GAAG,QAAQ,QAAQ;;IAkBvE;;;;OAIG;IACG,WAAW,CAAC,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B5E;;;;;OAKG;YACW,cAAc;IA0D5B;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAkBzB;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAavB;;;;;OAKG;IACG,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAS5F;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC;;;EAGxG;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC,QAShI"}

package/dist/shared/workflow.middleware.js

@@ -0,0 +1,246 @@
+import WorkflowTriggerModel from './workflow-trigger.model.js';
+import { WorkflowService } from './workflow.service.js';
+// @ts-ignore - No type declarations available for @dynamatix/cat-shared/services
+import { getContext as getSharedContext } from '@dynamatix/cat-shared/services';
+import { workflowLog, workflowWarn, workflowError } from './workflow.logger.js';
+export class WorkflowMiddleware {
+    constructor(options) {
+        // Read configuration from environment variables with fallbacks
+        this.options = {
+            workflowApiUrl: process.env.WORKFLOW_API_URL || 'https://your-workflow-api.com/api/v1/workflows/execute',
+            timeout: parseInt(process.env.WORKFLOW_TIMEOUT || '30000'),
+            retryAttempts: parseInt(process.env.WORKFLOW_RETRY_ATTEMPTS || '3'),
+            retryDelay: parseInt(process.env.WORKFLOW_RETRY_DELAY || '1000'),
+            ...options // Allow override of specific options
+        };
+        this.workflowService = new WorkflowService(this.options);
+    }
+    /**
+     * Safely gets the WorkflowTrigger model, handling potential registration issues
+     */
+    getWorkflowTriggerModel() {
+        try {
+            return WorkflowTriggerModel;
+        }
+        catch (error) {
+            workflowError('Error accessing WorkflowTrigger model:', error);
+            throw new Error('WorkflowTrigger model is not properly registered');
+        }
+    }
+    /**
+     * Gets the current request context including application_id and token
+     * @returns The current context object or null if not available
+     */
+    getContext() {
+        const context = getSharedContext();
+        if (context) {
+            return {
+                contextId: context.contextId,
+                token: context.token
+            };
+        }
+        return null;
+    }
+    /**
+     * Creates a Mongoose middleware function for a specific model
+     * @param recordType - The type of record (e.g., 'applications', 'products', 'tasks')
+     * @returns Mongoose middleware function
+     */
+    createMiddleware(recordType) {
+        return {
+            // Post-save middleware for create and update operations
+            postSave: async function (doc, next) {
+                try {
+                    workflowLog('Post-save middleware for create and update operations');
+                    const middleware = new WorkflowMiddleware(this.options || {});
+                    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();
+            }.bind(this),
+            // Post-remove middleware for delete operations
+            postRemove: async function (doc, next) {
+                try {
+                    workflowLog('Post-remove middleware for delete operations');
+                    const middleware = new WorkflowMiddleware(this.options || {});
+                    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();
+            }.bind(this)
+        };
+    }
+    /**
+     * Handles a workflow trigger event
+     * @param event - The workflow trigger event
+     * @param document - The document that triggered the event
+     */
+    async handleEvent(event, document) {
+        try {
+            // Find active triggers for this event
+            workflowLog('Finding active triggers for this event');
+            const WorkflowTrigger = this.getWorkflowTriggerModel();
+            const triggers = await WorkflowTrigger.find({
+                triggerKey: event.triggerKey,
+                isActive: true
+            });
+            if (triggers.length === 0) {
+                workflowLog(`No active triggers found for ${event.triggerKey}`);
+                return;
+            }
+            // Process each trigger
+            workflowLog('Processing each trigger');
+            for (const trigger of triggers) {
+                await this.processTrigger(trigger, document, event);
+            }
+        }
+        catch (error) {
+            workflowError(`Error handling workflow event ${event.triggerKey}:`, error);
+        }
+    }
+    /**
+     * Processes a single workflow trigger
+     * @param trigger - The workflow trigger configuration
+     * @param document - The document that triggered the event
+     * @param event - The workflow trigger event
+     */
+    async processTrigger(trigger, document, event) {
+        try {
+            workflowLog('Processing trigger');
+            // Check if condition is met (if specified)
+            if (trigger.condition && !this.evaluateCondition(trigger.condition, document)) {
+                workflowLog(`Condition not met for trigger ${trigger.triggerKey}`);
+                return;
+            }
+            // Extract variables from document
+            workflowLog('Extracting variables from document');
+            workflowLog(`   Required variables: ${JSON.stringify(trigger.requiredVariables)}`);
+            workflowLog(`   Optional variables: ${JSON.stringify(trigger.optionalVariables || [])}`);
+            const variables = this.workflowService.extractVariables(trigger.requiredVariables, trigger.optionalVariables || [], document);
+            workflowLog(`   Extracted variables: ${JSON.stringify(variables, null, 2)}`);
+            // Validate required variables
+            if (!this.workflowService.validateRequiredVariables(trigger.requiredVariables, variables)) {
+                workflowWarn(`❌ Required variables missing for trigger ${trigger.triggerKey}`);
+                workflowWarn(`   Required: ${JSON.stringify(trigger.requiredVariables)}`);
+                workflowWarn(`   Got: ${JSON.stringify(variables)}`);
+                return;
+            }
+            // Add metadata
+            const metadata = this.extractMetadata(document, event, trigger.parentKey);
+            workflowLog(`   Metadata: ${JSON.stringify(metadata, null, 2)}`);
+            const enrichedVariables = {
+                ...variables,
+                ...metadata
+            };
+            // Create workflow payload
+            const payload = {
+                workflowKey: trigger.workflowKey,
+                version: 1, // Default version, could be made configurable
+                variables: enrichedVariables
+            };
+            workflowLog('📦 Workflow payload:', JSON.stringify(payload, null, 2));
+            // Get token from context
+            const context = this.getContext();
+            const token = context?.token;
+            // Trigger workflow in background
+            await this.workflowService.triggerWorkflow(payload, token);
+            workflowLog(`Workflow ${trigger.workflowKey} triggered for ${event.triggerKey}`);
+        }
+        catch (error) {
+            workflowError(`Error processing trigger ${trigger.triggerKey}:`, error);
+        }
+    }
+    /**
+     * Evaluates a condition against a document
+     * @param condition - The condition string to evaluate
+     * @param document - The document to evaluate against
+     * @returns true if condition is met
+     */
+    evaluateCondition(condition, document) {
+        try {
+            // Simple condition evaluation - could be enhanced with a proper expression parser
+            // For now, supporting basic field checks like "status === 'active'"
+            if (condition.includes('===')) {
+                const [field, value] = condition.split('===').map(s => s.trim());
+                const fieldValue = this.workflowService['getNestedValue'](document, field);
+                return fieldValue === value.replace(/['"]/g, '');
+            }
+            // Default to true if condition format is not recognized
+            return true;
+        }
+        catch (error) {
+            workflowError('Error evaluating condition:', error);
+            return false;
+        }
+    }
+    /**
+     * Extracts metadata from document and event
+     * @param document - The document
+     * @param event - The event
+     * @returns Metadata object
+     */
+    extractMetadata(document, event, parentKey) {
+        const context = this.getContext();
+        return {
+            source: event.recordType,
+            action: event.action,
+            triggerKey: event.triggerKey,
+            sourceId: document._id?.toString(),
+            parentSourceId: parentKey ? document[parentKey] : null,
+            timestamp: new Date().toISOString(),
+            contextId: context?.contextId,
+        };
+    }
+    /**
+     * Manually trigger a workflow for a specific document
+     * @param triggerKey - The trigger key to use
+     * @param document - The document to process
+     * @param recordType - The record type
+     */
+    async manualTrigger(triggerKey, document, recordType) {
+        const event = {
+            recordType,
+            action: 'manual',
+            triggerKey
+        };
+        await this.handleEvent(event, document);
+    }
+}
+/**
+ * Factory function to create workflow middleware for a model
+ * @param recordType - The type of record (e.g., 'applications', 'products', 'tasks')
+ * @param options - Optional workflow middleware options (overrides env vars)
+ * @returns Mongoose middleware functions
+ */
+export function createWorkflowMiddleware(recordType, options) {
+    const middleware = new WorkflowMiddleware(options);
+    return middleware.createMiddleware(recordType);
+}
+/**
+ * Utility function to apply workflow middleware to a Mongoose schema
+ * @param schema - The Mongoose schema
+ * @param recordType - The type of record
+ * @param options - Optional workflow middleware options (overrides env vars)
+ */
+export function applyWorkflowMiddleware(schema, recordType, options) {
+    const middleware = createWorkflowMiddleware(recordType, options);
+    // Apply post-save middleware
+    schema.post('save', middleware.postSave);
+    // Apply post-remove middleware
+    schema.post(/^delete/, middleware.postRemove);
+    schema.post('findOneAndDelete', middleware.postRemove);
+}

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

@@ -0,0 +1,46 @@
+/// <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.js" />
+/// <reference types="mongoose/types/callback.js" />
+/// <reference types="mongoose/types/collection.js" />
+/// <reference types="mongoose/types/connection.js" />
+/// <reference types="mongoose/types/cursor.js" />
+/// <reference types="mongoose/types/document.js" />
+/// <reference types="mongoose/types/error.js" />
+/// <reference types="mongoose/types/expressions.js" />
+/// <reference types="mongoose/types/helpers.js" />
+/// <reference types="mongoose/types/middlewares.js" />
+/// <reference types="mongoose/types/indexes.js" />
+/// <reference types="mongoose/types/models.js" />
+/// <reference types="mongoose/types/mongooseoptions.js" />
+/// <reference types="mongoose/types/pipelinestage.js" />
+/// <reference types="mongoose/types/populate.js" />
+/// <reference types="mongoose/types/query.js" />
+/// <reference types="mongoose/types/schemaoptions.js" />
+/// <reference types="mongoose/types/session.js" />
+/// <reference types="mongoose/types/types.js" />
+/// <reference types="mongoose/types/utility.js" />
+/// <reference types="mongoose/types/validation.js" />
+/// <reference types="mongoose/types/virtuals.js" />
+/// <reference types="mongoose/types/schematypes.js" />
+/// <reference types="mongoose/types/inferschematype.js" />
+/// <reference types="mongoose/types/inferrawdoctype.js" />
+import mongoose from 'mongoose';
+/**
+ * Workflow plugin that automatically applies workflow middleware to schemas
+ * This plugin reads the record type from schema options and applies the appropriate middleware
+ */
+export declare function workflowPlugin(schema: mongoose.Schema, options: any): void;
+/**
+ * Utility function to register the workflow plugin globally
+ * This will apply workflow middleware to all schemas automatically
+ */
+export declare function registerWorkflowPlugin(): void;
+/**
+ * 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 declare function applyWorkflowPlugin(schema: mongoose.Schema, recordType: string): void;
+//# sourceMappingURL=workflow.plugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.plugin.d.ts","sourceRoot":"","sources":["../../shared/workflow.plugin.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAIhC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,QAyInE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,SAGrC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,QAE9E"}