@open-mercato/core 0.4.2-canary-5d2c419a9b → 0.4.2-canary-9e0237de8e

package/src/modules/workflows/i18n/en.json

@@ -161,6 +161,7 @@
       "title": "Workflow Instances",
       "singular": "Workflow Instance",
       "plural": "Workflow Instances",
+      "duration": "Duration",
       "fields": {
         "instanceId": "Instance ID",
         "workflowId": "Workflow ID",
@@ -563,6 +564,55 @@
         "CompensationCompleted": "Compensation Completed"
       }
     },
+    "triggers": {
+      "title": "Event Triggers",
+      "add": "Add Trigger",
+      "description": "Configure events that automatically start this workflow. When a matching event occurs in the system, a new workflow instance will be created with the mapped context.",
+      "empty": {
+        "title": "No triggers configured",
+        "description": "Click \"Add Trigger\" to create an event trigger that automatically starts this workflow."
+      },
+      "dialog": {
+        "create": {
+          "title": "Create Event Trigger"
+        },
+        "edit": {
+          "title": "Edit Event Trigger"
+        },
+        "description": "Configure when this workflow should be automatically started based on system events."
+      },
+      "delete": {
+        "title": "Delete Event Trigger?",
+        "description": "This will remove the event trigger. The change will take effect when you save the workflow definition."
+      },
+      "fields": {
+        "name": "Name",
+        "description": "Description",
+        "eventPattern": "Event Pattern",
+        "enabled": "Enabled",
+        "priority": "Priority",
+        "filterConditions": "Filter Conditions",
+        "contextMapping": "Context Mapping",
+        "debounceMs": "Debounce (ms)",
+        "maxConcurrent": "Max Concurrent Instances"
+      },
+      "placeholders": {
+        "name": "Order Created Trigger",
+        "description": "Describe when this trigger should fire...",
+        "quickSelect": "Quick select...",
+        "unlimited": "Unlimited"
+      },
+      "hints": {
+        "priority": "Higher priority triggers execute first",
+        "eventPattern": "Use * as wildcard: \"sales.orders.*\" matches any order event",
+        "filterConditions": "Only trigger when the event payload matches these conditions (all must match)",
+        "contextMapping": "Map values from the event payload to the workflow's initial context",
+        "debounce": "Delay to prevent rapid re-triggers",
+        "maxConcurrent": "Limit simultaneous workflow instances"
+      },
+      "addCondition": "Add Condition",
+      "addMapping": "Add Mapping"
+    },
     "common": {
       "save": "Save",
       "cancel": "Cancel",
@@ -629,6 +679,27 @@
       "duplicateNotYetImplemented": "Duplicate functionality is not yet implemented"
     }
   },
+  "orderApproval": {
+    "groupLabel": "Order Approval",
+    "groupDescription": "Review and approve or reject this order",
+    "pendingTitle": "Pending Approval",
+    "pendingDescription": "This order requires approval before processing",
+    "decisionLabel": "Decision",
+    "approveButton": "Approve",
+    "rejectButton": "Reject",
+    "commentsLabel": "Comments",
+    "commentsPlaceholder": "Add optional comments...",
+    "approvedStatus": "Approved",
+    "rejectedStatus": "Rejected",
+    "requestApproval": "Request Approval",
+    "submitDecision": "Submit Decision",
+    "noWorkflowActive": "No approval workflow is active for this order.",
+    "processing": "Workflow is processing...",
+    "completed": "Approval workflow completed.",
+    "startError": "Failed to start approval workflow",
+    "completeError": "Failed to complete approval task",
+    "missingStatuses": "Missing order status entries. Please ensure pending_approval, approved, and rejected statuses exist in the sales.order_status dictionary."
+  },
   "common": {
     "all": "All",
     "enabled": "Enabled",

package/src/modules/workflows/lib/__tests__/activity-executor.test.ts

@@ -318,22 +318,24 @@ describe('Activity Executor (Unit Tests)', () => {
 
   describe('UPDATE_ENTITY activity', () => {
     test('should execute UPDATE_ENTITY activity successfully', async () => {
-      const mockQueryEngine = {
-        update: jest.fn().mockResolvedValue({ updated: 1 }),
+      const mockCommandBus = {
+        execute: jest.fn().mockResolvedValue({
+          result: { id: 'order-123', status: 'confirmed' },
+          logEntry: { id: 'log-123' },
+        }),
       }
 
-      mockContainer.resolve.mockReturnValue(mockQueryEngine)
+      mockContainer.resolve.mockReturnValue(mockCommandBus)
 
       const activity: ActivityDefinition = {
         activityId: 'activity-8',
         activityName: 'Update Order Status',
         activityType: 'UPDATE_ENTITY',
         config: {
-          entityType: 'orders',
-          entityId: 'order-123',
-          updates: {
-            status: 'confirmed',
-            confirmedAt: new Date().toISOString(),
+          commandId: 'sales.orders.update',
+          input: {
+            id: 'order-123',
+            statusEntryId: 'status-confirmed-id',
           },
         },
       }
@@ -346,21 +348,22 @@ describe('Activity Executor (Unit Tests)', () => {
       )
 
       expect(result.success).toBe(true)
-      expect(result.output.updated).toBe(true)
-      expect(mockQueryEngine.update).toHaveBeenCalledWith({
-        entity: 'orders',
-        where: { id: 'order-123' },
-        data: expect.objectContaining({
-          status: 'confirmed',
-        }),
-        tenantId: testTenantId,
-        organizationId: testOrgId,
-      })
+      expect(result.output.executed).toBe(true)
+      expect(result.output.commandId).toBe('sales.orders.update')
+      expect(mockCommandBus.execute).toHaveBeenCalledWith(
+        'sales.orders.update',
+        expect.objectContaining({
+          input: expect.objectContaining({
+            id: 'order-123',
+            statusEntryId: 'status-confirmed-id',
+          }),
+        })
+      )
     })
 
-    test('should fail UPDATE_ENTITY if query engine not available', async () => {
+    test('should fail UPDATE_ENTITY if command bus not available', async () => {
       mockContainer.resolve.mockImplementation(() => {
-        throw new Error('queryEngine not registered')
+        throw new Error('commandBus not registered')
       })
 
       const activity: ActivityDefinition = {
@@ -368,9 +371,8 @@ describe('Activity Executor (Unit Tests)', () => {
         activityName: 'Test Update',
         activityType: 'UPDATE_ENTITY',
         config: {
-          entityType: 'orders',
-          entityId: 'order-123',
-          updates: { status: 'confirmed' },
+          commandId: 'sales.orders.update',
+          input: { id: 'order-123', status: 'confirmed' },
         },
       }
 
@@ -382,23 +384,23 @@ describe('Activity Executor (Unit Tests)', () => {
       )
 
       expect(result.success).toBe(false)
-      expect(result.error).toContain('queryEngine not registered')
+      expect(result.error).toContain('commandBus not registered')
     })
 
     test('should fail UPDATE_ENTITY if missing required fields', async () => {
-      const mockQueryEngine = {
-        update: jest.fn().mockResolvedValue({ updated: 1 }),
+      const mockCommandBus = {
+        execute: jest.fn().mockResolvedValue({ result: {} }),
       }
 
-      mockContainer.resolve.mockReturnValue(mockQueryEngine)
+      mockContainer.resolve.mockReturnValue(mockCommandBus)
 
       const activity: ActivityDefinition = {
         activityId: 'activity-10',
         activityName: 'Invalid Update',
         activityType: 'UPDATE_ENTITY',
         config: {
-          entityType: 'orders',
-          // Missing entityId and updates
+          // Missing commandId
+          input: { id: 'order-123' },
         },
       }
 
@@ -410,7 +412,7 @@ describe('Activity Executor (Unit Tests)', () => {
       )
 
       expect(result.success).toBe(false)
-      expect(result.error).toContain('requires "entityType", "entityId", and "updates"')
+      expect(result.error).toContain('requires "commandId"')
     })
   })
 
@@ -1095,13 +1097,16 @@ describe('Activity Executor (Unit Tests)', () => {
         emitEvent: jest.fn().mockResolvedValue(undefined),
       }
 
-      const mockQueryEngine = {
-        update: jest.fn().mockResolvedValue({ updated: 1 }),
+      const mockCommandBus = {
+        execute: jest.fn().mockResolvedValue({
+          result: { id: 'order-123', status: 'confirmed' },
+          logEntry: { id: 'log-123' },
+        }),
       }
 
       mockContainer.resolve
         .mockReturnValueOnce(mockEventBus) // First activity
-        .mockReturnValueOnce(mockQueryEngine) // Second activity
+        .mockReturnValueOnce(mockCommandBus) // Second activity
 
       const activities: ActivityDefinition[] = [
         {
@@ -1118,9 +1123,11 @@ describe('Activity Executor (Unit Tests)', () => {
           activityName: 'Update Entity',
           activityType: 'UPDATE_ENTITY',
           config: {
-            entityType: 'orders',
-            entityId: 'order-123',
-            updates: { status: 'confirmed' },
+            commandId: 'sales.orders.update',
+            input: {
+              id: 'order-123',
+              statusEntryId: 'status-confirmed-id',
+            },
           },
         },
       ]

package/src/modules/workflows/lib/__tests__/transition-handler.test.ts

@@ -462,15 +462,35 @@ describe('Transition Handler (Unit Tests)', () => {
     })
 
     test('should reject transition if pre-conditions fail', async () => {
+      // Create a definition with preConditions
+      const definitionWithPreConditions = {
+        ...mockDefinition,
+        definition: {
+          ...mockDefinition.definition,
+          transitions: [
+            { fromStepId: 'start', toStepId: 'step-1' },
+            {
+              fromStepId: 'step-1',
+              toStepId: 'step-2',
+              preConditions: [{ ruleId: 'test-guard-rule', required: true }],
+            },
+            { fromStepId: 'step-2', toStepId: 'end' },
+          ],
+        },
+      }
+
       mockEm.findOne
-        .mockResolvedValueOnce(mockDefinition) // evaluateTransition
-        .mockResolvedValueOnce(mockDefinition) // evaluatePreConditions
-
-      ;(ruleEngine.executeRules as jest.Mock).mockResolvedValueOnce({
-        allowed: false,
-        executedRules: [],
-        totalExecutionTime: 10,
-        errors: ['Pre-condition rule failed'],
+        .mockResolvedValueOnce(definitionWithPreConditions) // evaluateTransition
+        .mockResolvedValueOnce(definitionWithPreConditions) // evaluatePreConditions
+
+      ;(ruleEngine.executeRuleByRuleId as jest.Mock).mockResolvedValueOnce({
+        success: false,
+        ruleId: 'test-guard-rule',
+        ruleName: 'Test Guard Rule',
+        conditionResult: false,
+        actionsExecuted: null,
+        executionTime: 10,
+        error: undefined,
       })
 
       mockEm.create.mockReturnValue({} as any)
@@ -491,15 +511,35 @@ describe('Transition Handler (Unit Tests)', () => {
     })
 
     test('should log transition rejection event', async () => {
-      mockEm.findOne
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
+      // Create a definition with preConditions
+      const definitionWithPreConditions = {
+        ...mockDefinition,
+        definition: {
+          ...mockDefinition.definition,
+          transitions: [
+            { fromStepId: 'start', toStepId: 'step-1' },
+            {
+              fromStepId: 'step-1',
+              toStepId: 'step-2',
+              preConditions: [{ ruleId: 'test-guard-rule', required: true }],
+            },
+            { fromStepId: 'step-2', toStepId: 'end' },
+          ],
+        },
+      }
 
-      ;(ruleEngine.executeRules as jest.Mock).mockResolvedValueOnce({
-        allowed: false,
-        executedRules: [],
-        totalExecutionTime: 10,
-        errors: ['Rule XYZ failed'],
+      mockEm.findOne
+        .mockResolvedValueOnce(definitionWithPreConditions)
+        .mockResolvedValueOnce(definitionWithPreConditions)
+
+      ;(ruleEngine.executeRuleByRuleId as jest.Mock).mockResolvedValueOnce({
+        success: false,
+        ruleId: 'test-guard-rule',
+        ruleName: 'Test Guard Rule',
+        conditionResult: false,
+        actionsExecuted: null,
+        executionTime: 10,
+        error: undefined,
       })
 
       mockEm.create.mockReturnValue({} as any)
@@ -527,27 +567,36 @@ describe('Transition Handler (Unit Tests)', () => {
     })
 
     test('should execute transition even if post-conditions fail (warning only)', async () => {
-      mockEm.findOne.mockReset()
-      mockEm.findOne
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValue(mockDefinition)
+      // Create a definition with postConditions
+      const definitionWithPostConditions = {
+        ...mockDefinition,
+        definition: {
+          ...mockDefinition.definition,
+          transitions: [
+            { fromStepId: 'start', toStepId: 'step-1' },
+            {
+              fromStepId: 'step-1',
+              toStepId: 'step-2',
+              postConditions: [{ ruleId: 'test-post-rule', required: true }],
+            },
+            { fromStepId: 'step-2', toStepId: 'end' },
+          ],
+        },
+      }
 
-      ;(ruleEngine.executeRules as jest.Mock)
-        .mockResolvedValueOnce({
-          allowed: true,
-          executedRules: [],
-          totalExecutionTime: 10,
-        })
-        .mockResolvedValueOnce({
-          allowed: false, // Post-condition failed
-          executedRules: [],
-          totalExecutionTime: 5,
-          errors: ['Post-condition rule failed'],
-        })
+      mockEm.findOne.mockReset()
+      mockEm.findOne.mockResolvedValue(definitionWithPostConditions)
+
+      // Post-condition fails
+      ;(ruleEngine.executeRuleByRuleId as jest.Mock).mockResolvedValueOnce({
+        success: false,
+        ruleId: 'test-post-rule',
+        ruleName: 'Test Post Rule',
+        conditionResult: false,
+        actionsExecuted: null,
+        executionTime: 5,
+        error: undefined,
+      })
 
       mockEm.create.mockReturnValue({} as any)
 
@@ -709,22 +758,33 @@ describe('Transition Handler (Unit Tests)', () => {
 
   describe('Business Rules Integration', () => {
     test('should call rule engine for pre-conditions with correct entityType', async () => {
-      mockEm.findOne
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
+      // Create a definition with preConditions
+      const definitionWithPreConditions = {
+        ...mockDefinition,
+        definition: {
+          ...mockDefinition.definition,
+          transitions: [
+            { fromStepId: 'start', toStepId: 'step-1' },
+            {
+              fromStepId: 'step-1',
+              toStepId: 'step-2',
+              preConditions: [{ ruleId: 'test-guard-rule', required: true }],
+            },
+            { fromStepId: 'step-2', toStepId: 'end' },
+          ],
+        },
+      }
 
-      ;(ruleEngine.executeRules as jest.Mock)
-        .mockResolvedValueOnce({
-          allowed: true,
-          executedRules: [],
-          totalExecutionTime: 10,
-        })
-        .mockResolvedValueOnce({
-          allowed: true,
-          executedRules: [],
-          totalExecutionTime: 5,
-        })
+      mockEm.findOne.mockResolvedValue(definitionWithPreConditions)
+
+      ;(ruleEngine.executeRuleByRuleId as jest.Mock).mockResolvedValueOnce({
+        success: true,
+        ruleId: 'test-guard-rule',
+        ruleName: 'Test Guard Rule',
+        conditionResult: true,
+        actionsExecuted: null,
+        executionTime: 10,
+      })
 
       mockEm.create.mockReturnValue({} as any)
 
@@ -737,9 +797,10 @@ describe('Transition Handler (Unit Tests)', () => {
         { workflowContext: {} }
       )
 
-      expect(ruleEngine.executeRules).toHaveBeenCalledWith(
+      expect(ruleEngine.executeRuleByRuleId).toHaveBeenCalledWith(
         mockEm,
         expect.objectContaining({
+          ruleId: 'test-guard-rule',
           entityType: 'workflow:simple-approval:transition',
           eventType: 'pre_transition',
           data: expect.objectContaining({
@@ -752,26 +813,34 @@ describe('Transition Handler (Unit Tests)', () => {
     })
 
     test('should call rule engine for post-conditions with correct eventType', async () => {
-      mockEm.findOne.mockReset()
-      mockEm.findOne
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValue(mockDefinition)
+      // Create a definition with postConditions
+      const definitionWithPostConditions = {
+        ...mockDefinition,
+        definition: {
+          ...mockDefinition.definition,
+          transitions: [
+            { fromStepId: 'start', toStepId: 'step-1' },
+            {
+              fromStepId: 'step-1',
+              toStepId: 'step-2',
+              postConditions: [{ ruleId: 'test-post-rule', required: true }],
+            },
+            { fromStepId: 'step-2', toStepId: 'end' },
+          ],
+        },
+      }
 
-      ;(ruleEngine.executeRules as jest.Mock)
-        .mockResolvedValueOnce({
-          allowed: true,
-          executedRules: [],
-          totalExecutionTime: 10,
-        })
-        .mockResolvedValueOnce({
-          allowed: true,
-          executedRules: [],
-          totalExecutionTime: 5,
-        })
+      mockEm.findOne.mockReset()
+      mockEm.findOne.mockResolvedValue(definitionWithPostConditions)
+
+      ;(ruleEngine.executeRuleByRuleId as jest.Mock).mockResolvedValueOnce({
+        success: true,
+        ruleId: 'test-post-rule',
+        ruleName: 'Test Post Rule',
+        conditionResult: true,
+        actionsExecuted: null,
+        executionTime: 5,
+      })
 
       mockEm.create.mockReturnValue({} as any)
 
@@ -784,11 +853,11 @@ describe('Transition Handler (Unit Tests)', () => {
         { workflowContext: {} }
       )
 
-      // Check second call to executeRules (post-conditions)
-      expect(ruleEngine.executeRules).toHaveBeenNthCalledWith(
-        2,
+      // Check call to executeRuleByRuleId for post-conditions
+      expect(ruleEngine.executeRuleByRuleId).toHaveBeenCalledWith(
         mockEm,
         expect.objectContaining({
+          ruleId: 'test-post-rule',
           entityType: 'workflow:simple-approval:transition',
           eventType: 'post_transition',
         }),
@@ -797,22 +866,33 @@ describe('Transition Handler (Unit Tests)', () => {
     })
 
     test('should pass workflow context and trigger data to rule engine', async () => {
-      mockEm.findOne
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
-        .mockResolvedValueOnce(mockDefinition)
+      // Create a definition with preConditions
+      const definitionWithPreConditions = {
+        ...mockDefinition,
+        definition: {
+          ...mockDefinition.definition,
+          transitions: [
+            { fromStepId: 'start', toStepId: 'step-1' },
+            {
+              fromStepId: 'step-1',
+              toStepId: 'step-2',
+              preConditions: [{ ruleId: 'test-guard-rule', required: true }],
+            },
+            { fromStepId: 'step-2', toStepId: 'end' },
+          ],
+        },
+      }
 
-      ;(ruleEngine.executeRules as jest.Mock)
-        .mockResolvedValueOnce({
-          allowed: true,
-          executedRules: [],
-          totalExecutionTime: 10,
-        })
-        .mockResolvedValueOnce({
-          allowed: true,
-          executedRules: [],
-          totalExecutionTime: 5,
-        })
+      mockEm.findOne.mockResolvedValue(definitionWithPreConditions)
+
+      ;(ruleEngine.executeRuleByRuleId as jest.Mock).mockResolvedValueOnce({
+        success: true,
+        ruleId: 'test-guard-rule',
+        ruleName: 'Test Guard Rule',
+        conditionResult: true,
+        actionsExecuted: null,
+        executionTime: 10,
+      })
 
       mockEm.create.mockReturnValue({} as any)
 
@@ -832,7 +912,7 @@ describe('Transition Handler (Unit Tests)', () => {
         }
       )
 
-      expect(ruleEngine.executeRules).toHaveBeenCalledWith(
+      expect(ruleEngine.executeRuleByRuleId).toHaveBeenCalledWith(
         mockEm,
         expect.objectContaining({
           data: expect.objectContaining({