@dynamatix/gb-schemas 1.3.334 → 1.3.336

package/README.md

@@ -20,6 +20,7 @@ This package contains all the schemas and data models used in Gatehouse Bank's b
 - **TypeScript Support**: Full TypeScript definitions and type safety
 - **Mongoose Integration**: Built on Mongoose ODM for MongoDB
 - **Audit Middleware**: Built-in audit trail support via `@dynamatix/cat-shared`
+- **Workflow Middleware**: Automatic workflow triggering based on database events
 - **Custom Value Objects**: Specialized types for financial data (Pound, Account Number, Sort Code)
 - **Modular Architecture**: Organized into logical domains (applications, applicants, properties, etc.)
 - **Migration Scripts**: Comprehensive data migration and maintenance tools
@@ -88,6 +89,26 @@ const newIncome = new ApplicantIncomeModel({
 const savedIncome = await newIncome.save();
 ```
 
+### Workflow Middleware
+
+The library includes a powerful workflow middleware system that automatically triggers workflows based on database events.
+
+```typescript
+import { initializeWorkflowMiddlewareWithCheck } from '@dynamatix/gb-schemas';
+
+// Initialize workflow middleware for ALL schemas with one call
+initializeWorkflowMiddlewareWithCheck();
+```
+
+**Environment Variables:**
+- `WORKFLOW_API_KEY`: Required API key for workflow service authentication
+- `WORKFLOW_API_URL`: Optional workflow API URL (default: https://your-workflow-api.com/api/v1/workflows/execute)
+- `WORKFLOW_TIMEOUT`: Optional timeout in milliseconds (default: 30000)
+- `WORKFLOW_RETRY_ATTEMPTS`: Optional retry attempts (default: 3)
+- `WORKFLOW_RETRY_DELAY`: Optional retry delay in milliseconds (default: 1000)
+
+For detailed documentation, see [Workflow Middleware Guide](./docs/WORKFLOW_MIDDLEWARE.md).
+
 ## 🏛️ Core Schemas
 
 ### Applicants
@@ -118,6 +139,7 @@ const savedIncome = await newIncome.save();
 - **System Parameters**: Configuration and system settings
 - **Tasks**: Workflow task management
 - **Alerts**: System notification system
+- **Workflow Triggers**: Configuration for automatic workflow execution
 
 ## 💰 Custom Value Objects
 

package/dist/applications/application-note.model.d.ts

@@ -37,7 +37,6 @@ declare const ApplictionNoteModel: mongoose.Model<{
     subject: string;
     note: string;
     reminderDate: string;
-    attachmentDocumentId: string;
     assignedOperation: string;
     autoCreated: string;
     additionalData: any;
@@ -49,6 +48,8 @@ declare const ApplictionNoteModel: mongoose.Model<{
     createdByUserId?: mongoose.Types.ObjectId | null | undefined;
     noteTypeLid?: mongoose.Types.ObjectId | null | undefined;
     noteSubTypeLid?: mongoose.Types.ObjectId | null | undefined;
+    attachmentDocumentId?: string | null | undefined;
+    documentName?: string | null | undefined;
     assignedByUserId?: mongoose.Types.ObjectId | null | undefined;
 }, {}, {}, {}, mongoose.Document<unknown, {}, {
     comment: string;
@@ -60,7 +61,6 @@ declare const ApplictionNoteModel: mongoose.Model<{
     subject: string;
     note: string;
     reminderDate: string;
-    attachmentDocumentId: string;
     assignedOperation: string;
     autoCreated: string;
     additionalData: any;
@@ -72,6 +72,8 @@ declare const ApplictionNoteModel: mongoose.Model<{
     createdByUserId?: mongoose.Types.ObjectId | null | undefined;
     noteTypeLid?: mongoose.Types.ObjectId | null | undefined;
     noteSubTypeLid?: mongoose.Types.ObjectId | null | undefined;
+    attachmentDocumentId?: string | null | undefined;
+    documentName?: string | null | undefined;
     assignedByUserId?: mongoose.Types.ObjectId | null | undefined;
 }, {}> & {
     comment: string;
@@ -83,7 +85,6 @@ declare const ApplictionNoteModel: mongoose.Model<{
     subject: string;
     note: string;
     reminderDate: string;
-    attachmentDocumentId: string;
     assignedOperation: string;
     autoCreated: string;
     additionalData: any;
@@ -95,6 +96,8 @@ declare const ApplictionNoteModel: mongoose.Model<{
     createdByUserId?: mongoose.Types.ObjectId | null | undefined;
     noteTypeLid?: mongoose.Types.ObjectId | null | undefined;
     noteSubTypeLid?: mongoose.Types.ObjectId | null | undefined;
+    attachmentDocumentId?: string | null | undefined;
+    documentName?: string | null | undefined;
     assignedByUserId?: mongoose.Types.ObjectId | null | undefined;
 } & {
     _id: mongoose.Types.ObjectId;
@@ -110,7 +113,6 @@ declare const ApplictionNoteModel: mongoose.Model<{
     subject: string;
     note: string;
     reminderDate: string;
-    attachmentDocumentId: string;
     assignedOperation: string;
     autoCreated: string;
     additionalData: any;
@@ -122,6 +124,8 @@ declare const ApplictionNoteModel: mongoose.Model<{
     createdByUserId?: mongoose.Types.ObjectId | null | undefined;
     noteTypeLid?: mongoose.Types.ObjectId | null | undefined;
     noteSubTypeLid?: mongoose.Types.ObjectId | null | undefined;
+    attachmentDocumentId?: string | null | undefined;
+    documentName?: string | null | undefined;
     assignedByUserId?: mongoose.Types.ObjectId | null | undefined;
 }, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
     comment: string;
@@ -133,7 +137,6 @@ declare const ApplictionNoteModel: mongoose.Model<{
     subject: string;
     note: string;
     reminderDate: string;
-    attachmentDocumentId: string;
     assignedOperation: string;
     autoCreated: string;
     additionalData: any;
@@ -145,6 +148,8 @@ declare const ApplictionNoteModel: mongoose.Model<{
     createdByUserId?: mongoose.Types.ObjectId | null | undefined;
     noteTypeLid?: mongoose.Types.ObjectId | null | undefined;
     noteSubTypeLid?: mongoose.Types.ObjectId | null | undefined;
+    attachmentDocumentId?: string | null | undefined;
+    documentName?: string | null | undefined;
     assignedByUserId?: mongoose.Types.ObjectId | null | undefined;
 }>, {}> & mongoose.FlatRecord<{
     comment: string;
@@ -156,7 +161,6 @@ declare const ApplictionNoteModel: mongoose.Model<{
     subject: string;
     note: string;
     reminderDate: string;
-    attachmentDocumentId: string;
     assignedOperation: string;
     autoCreated: string;
     additionalData: any;
@@ -168,6 +172,8 @@ declare const ApplictionNoteModel: mongoose.Model<{
     createdByUserId?: mongoose.Types.ObjectId | null | undefined;
     noteTypeLid?: mongoose.Types.ObjectId | null | undefined;
     noteSubTypeLid?: mongoose.Types.ObjectId | null | undefined;
+    attachmentDocumentId?: string | null | undefined;
+    documentName?: string | null | undefined;
     assignedByUserId?: mongoose.Types.ObjectId | null | undefined;
 }> & {
     _id: mongoose.Types.ObjectId;

package/dist/applications/application-note.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application-note.model.d.ts","sourceRoot":"","sources":["../../applications/application-note.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAmFhC,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AACzE,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"application-note.model.d.ts","sourceRoot":"","sources":["../../applications/application-note.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAqFhC,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AACzE,eAAe,mBAAmB,CAAC"}

package/dist/applications/application-note.model.js

@@ -36,7 +36,9 @@ const noteSchema = new mongoose.Schema({
     },
     attachmentDocumentId: {
         type: String,
-        default: null
+    },
+    documentName: {
+        type: String,
     },
     assignedOperation: {
         type: String,

package/dist/applications/application-note.type.d.ts

@@ -40,7 +40,8 @@ export default interface IApplicationNoteType extends IBaseType {
     subject?: string | null;
     note: string;
     reminderDate?: string | null;
-    attachmentDocumentId?: string | null;
+    attachmentDocumentId?: string;
+    documentName?: string;
     assignedOperation?: string;
     autoCreated?: boolean;
     additionalData?: any;

package/dist/applications/application-note.type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application-note.type.d.ts","sourceRoot":"","sources":["../../applications/application-note.type.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD,MAAM,CAAC,OAAO,WAAW,oBAAqB,SAAQ,SAAS;IAC3D,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,eAAe,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IACxC,WAAW,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IACpC,cAAc,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IACvC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,GAAG,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,gBAAgB,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IACzC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B"}
+{"version":3,"file":"application-note.type.d.ts","sourceRoot":"","sources":["../../applications/application-note.type.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD,MAAM,CAAC,OAAO,WAAW,oBAAqB,SAAQ,SAAS;IAC3D,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,eAAe,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IACxC,WAAW,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IACpC,cAAc,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IACvC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,GAAG,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,gBAAgB,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IACzC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B"}

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export * from './applicants/index.js';
 export * from './users/index.js';
 export * from './product-catalogues/index.js';
 export * from './underwriter/index.js';
+export { initializeWorkflowMiddleware, initializeWorkflowMiddlewareWithCheck, isWorkflowMiddlewareConfigured } from './shared/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AAGvC,OAAO,EACH,4BAA4B,EAC5B,qCAAqC,EACrC,8BAA8B,EACjC,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -5,3 +5,5 @@ export * from './applicants/index.js';
 export * from './users/index.js';
 export * from './product-catalogues/index.js';
 export * from './underwriter/index.js';
+// Re-export workflow middleware initialization for easy access
+export { initializeWorkflowMiddleware, initializeWorkflowMiddlewareWithCheck, isWorkflowMiddlewareConfigured } from './shared/index.js';

package/dist/shared/index.d.ts

@@ -13,4 +13,5 @@ export { default as TaskDocumentTypeModel } from './task-document.model';
 export { default as SchemaDocModel } from './schema-doc.model';
 export { default as ApiLogModel } from './api-log.model';
 export { default as IWebhookEvent } from './webhook-event.type';
+export { initializeWorkflowMiddleware, initializeWorkflowMiddlewareWithCheck, isWorkflowMiddlewareConfigured } from './workflow.init';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../shared/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAC7D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAChE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../shared/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAC7D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAChE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGhE,OAAO,EAAE,4BAA4B,EAAE,qCAAqC,EAAE,8BAA8B,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/shared/index.js

@@ -11,3 +11,5 @@ export { default as WebhookEventModel } from './webhook-event.model';
 export { default as TaskDocumentTypeModel } from './task-document.model';
 export { default as SchemaDocModel } from './schema-doc.model';
 export { default as ApiLogModel } from './api-log.model';
+// Workflow middleware initialization exports
+export { initializeWorkflowMiddleware, initializeWorkflowMiddlewareWithCheck, isWorkflowMiddlewareConfigured } from './workflow.init';

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

@@ -0,0 +1,32 @@
+/// <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 _default: mongoose.Model<any, {}, {}, {}, any, any>;
+export default _default;
+//# sourceMappingURL=workflow-trigger.model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-trigger.model.d.ts","sourceRoot":"","sources":["../../shared/workflow-trigger.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAoB,MAAM,UAAU,CAAC;;AAmD5C,wBAA6H"}

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

@@ -0,0 +1,45 @@
+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
+        }],
+    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,59 @@
+/// <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[];
+    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,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":"AAGA;;;;;;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,38 @@
+import { registerWorkflowPlugin } from './workflow.plugin';
+/**
+ * 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() {
+    console.log('Initializing workflow middleware for all schemas...');
+    registerWorkflowPlugin();
+    console.log('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) {
+        console.warn(`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()) {
+        console.warn('Workflow middleware configuration incomplete. Middleware will be disabled.');
+        return false;
+    }
+    initializeWorkflowMiddleware();
+    return true;
+}

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

@@ -0,0 +1,100 @@
+/// <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';
+import { WorkflowTriggerEvent, WorkflowMiddlewareOptions } from './workflow-trigger.type';
+export declare class WorkflowMiddleware {
+    private workflowService;
+    private options;
+    constructor(options?: Partial<WorkflowMiddlewareOptions>);
+    /**
+     * Safely gets the WorkflowTrigger model, handling potential registration issues
+     */
+    private getWorkflowTriggerModel;
+    /**
+     * 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,yBAAyB,CAAC;AAEjC,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;;;;OAIG;IACH,gBAAgB,CAAC,UAAU,EAAE,MAAM;yBAGK,GAAG,OAAO,GAAG,QAAQ,QAAQ;2BAgB3B,GAAG,OAAO,GAAG,QAAQ,QAAQ;;IAiBvE;;;;OAIG;IACG,WAAW,CAAC,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB5E;;;;;OAKG;YACW,cAAc;IA4C5B;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAkBzB;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAUvB;;;;;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,209 @@
+import WorkflowTriggerModel from './workflow-trigger.model';
+import { WorkflowService } from './workflow.service';
+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) {
+            console.error('Error accessing WorkflowTrigger model:', error);
+            throw new Error('WorkflowTrigger model is not properly registered');
+        }
+    }
+    /**
+     * 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 {
+                    const middleware = new WorkflowMiddleware(this.options || {});
+                    await middleware.handleEvent({
+                        recordType,
+                        action: doc.isNew ? 'created' : 'updated',
+                        triggerKey: `${recordType}.${doc.isNew ? 'created' : 'updated'}`
+                    }, doc);
+                }
+                catch (error) {
+                    console.error('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 {
+                    const middleware = new WorkflowMiddleware(this.options || {});
+                    await middleware.handleEvent({
+                        recordType,
+                        action: 'deleted',
+                        triggerKey: `${recordType}.deleted`
+                    }, doc);
+                }
+                catch (error) {
+                    console.error('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
+            const WorkflowTrigger = this.getWorkflowTriggerModel();
+            const triggers = await WorkflowTrigger.find({
+                triggerKey: event.triggerKey,
+                isActive: true
+            });
+            if (triggers.length === 0) {
+                console.log(`No active triggers found for ${event.triggerKey}`);
+                return;
+            }
+            // Process each trigger
+            for (const trigger of triggers) {
+                await this.processTrigger(trigger, document, event);
+            }
+        }
+        catch (error) {
+            console.error(`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 {
+            // Check if condition is met (if specified)
+            if (trigger.condition && !this.evaluateCondition(trigger.condition, document)) {
+                console.log(`Condition not met for trigger ${trigger.triggerKey}`);
+                return;
+            }
+            // Extract variables from document
+            const variables = this.workflowService.extractVariables(trigger.requiredVariables, trigger.optionalVariables || [], document);
+            // Validate required variables
+            if (!this.workflowService.validateRequiredVariables(trigger.requiredVariables, variables)) {
+                console.warn(`Required variables missing for trigger ${trigger.triggerKey}`);
+                return;
+            }
+            // Add metadata
+            const enrichedVariables = {
+                ...variables,
+                ...this.extractMetadata(document, event)
+            };
+            // Create workflow payload
+            const payload = {
+                workflowKey: trigger.workflowKey,
+                version: 1, // Default version, could be made configurable
+                variables: enrichedVariables
+            };
+            // Trigger workflow in background
+            await this.workflowService.triggerWorkflow(payload);
+            console.log(`Workflow ${trigger.workflowKey} triggered for ${event.triggerKey}`);
+        }
+        catch (error) {
+            console.error(`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) {
+            console.error('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) {
+        return {
+            recordType: event.recordType,
+            action: event.action,
+            triggerKey: event.triggerKey,
+            documentId: document._id?.toString(),
+            timestamp: new Date().toISOString()
+        };
+    }
+    /**
+     * 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" />
+/// <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';
+/**
+ * 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;AAGhC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,QAkDnE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,SAGrC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,QAE9E"}

package/dist/shared/workflow.plugin.js

@@ -0,0 +1,72 @@
+import mongoose from 'mongoose';
+import { WorkflowMiddleware } from './workflow.middleware';
+/**
+ * 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) {
+    // Get record type from schema options or infer from model name
+    const recordType = options.recordType || options.modelName?.toLowerCase() || 'unknown';
+    // Create workflow middleware instance
+    const middleware = new WorkflowMiddleware();
+    // Apply post-save middleware
+    schema.post('save', async function (doc, next) {
+        try {
+            await middleware.handleEvent({
+                recordType,
+                action: doc.isNew ? 'created' : 'updated',
+                triggerKey: `${recordType}.${doc.isNew ? 'created' : 'updated'}`
+            }, doc);
+        }
+        catch (error) {
+            console.error('Workflow middleware error:', error);
+            // Don't throw error to avoid breaking the main operation
+        }
+        next();
+    });
+    // Apply post-remove middleware
+    schema.post(/^delete/, async function (doc, next) {
+        try {
+            await middleware.handleEvent({
+                recordType,
+                action: 'deleted',
+                triggerKey: `${recordType}.deleted`
+            }, doc);
+        }
+        catch (error) {
+            console.error('Workflow middleware error:', error);
+            // Don't throw error to avoid breaking the main operation
+        }
+        next();
+    });
+    schema.post('findOneAndDelete', async function (doc, next) {
+        try {
+            await middleware.handleEvent({
+                recordType,
+                action: 'deleted',
+                triggerKey: `${recordType}.deleted`
+            }, doc);
+        }
+        catch (error) {
+            console.error('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,39 @@
+import { WorkflowApiPayload, WorkflowMiddlewareOptions } from './workflow-trigger.type';
+export declare class WorkflowService {
+    private options;
+    constructor(options: WorkflowMiddlewareOptions);
+    /**
+     * Triggers a workflow execution in the background
+     * @param payload - The workflow payload to send
+     * @returns Promise that resolves when the request is initiated (not when it completes)
+     */
+    triggerWorkflow(payload: WorkflowApiPayload): Promise<void>;
+    /**
+     * Executes the actual workflow API call with retry logic
+     * @param payload - The workflow payload to send
+     */
+    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;AAExF,qBAAa,eAAe;IACxB,OAAO,CAAC,OAAO,CAA4B;gBAE/B,OAAO,EAAE,yBAAyB;IAS9C;;;;OAIG;IACG,eAAe,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjE;;;OAGG;YACW,mBAAmB;IA+CjC;;;;;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,114 @@
+export class WorkflowService {
+    constructor(options) {
+        this.options = {
+            timeout: 30000,
+            retryAttempts: 3,
+            retryDelay: 1000,
+            ...options
+        };
+    }
+    /**
+     * Triggers a workflow execution in the background
+     * @param payload - The workflow payload to send
+     * @returns Promise that resolves when the request is initiated (not when it completes)
+     */
+    async triggerWorkflow(payload) {
+        // Execute in background without waiting for completion
+        setImmediate(async () => {
+            try {
+                await this.executeWorkflowCall(payload);
+            }
+            catch (error) {
+                console.error('Workflow execution failed:', error);
+                // Could implement retry logic or error reporting here
+            }
+        });
+    }
+    /**
+     * Executes the actual workflow API call with retry logic
+     * @param payload - The workflow payload to send
+     */
+    async executeWorkflowCall(payload) {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        // Get API key from environment variable
+        const workflowApiKey = 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 {
+                const response = await fetch(this.options.workflowApiUrl, requestOptions);
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                const result = await response.json();
+                console.log(`Workflow ${payload.workflowKey} triggered successfully:`, result);
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                console.warn(`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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamatix/gb-schemas",
-  "version": "1.3.334",
+  "version": "1.3.336",
   "description": "All the schemas for gatehouse bank back-end",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",