@open-mercato/core 0.4.2-canary-ed15f2e753 → 0.4.2-canary-e2aeb1a7bf

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

@@ -161,7 +161,6 @@
       "title": "Workflow Instances",
       "singular": "Workflow Instance",
       "plural": "Workflow Instances",
-      "duration": "Duration",
       "fields": {
         "instanceId": "Instance ID",
         "workflowId": "Workflow ID",
@@ -564,55 +563,6 @@
         "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",
@@ -679,27 +629,6 @@
       "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",
@@ -747,5 +676,7 @@
       "success": "Sub-workflow completed successfully",
       "failed": "Sub-workflow failed"
     }
-  }
+  },
+  "workflows.notifications.task.assigned.title": "Task Assigned",
+  "workflows.notifications.task.assigned.body": "You have been assigned to task \"{taskName}\" in workflow \"{workflowName}\"{dueDate, select, other { (due: {dueDate})}}"
 }

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

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

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

@@ -462,35 +462,15 @@ 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(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,
+        .mockResolvedValueOnce(mockDefinition) // evaluateTransition
+        .mockResolvedValueOnce(mockDefinition) // evaluatePreConditions
+
+      ;(ruleEngine.executeRules as jest.Mock).mockResolvedValueOnce({
+        allowed: false,
+        executedRules: [],
+        totalExecutionTime: 10,
+        errors: ['Pre-condition rule failed'],
       })
 
       mockEm.create.mockReturnValue({} as any)
@@ -511,35 +491,15 @@ describe('Transition Handler (Unit Tests)', () => {
     })
 
     test('should log transition rejection event', 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(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,
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
+
+      ;(ruleEngine.executeRules as jest.Mock).mockResolvedValueOnce({
+        allowed: false,
+        executedRules: [],
+        totalExecutionTime: 10,
+        errors: ['Rule XYZ failed'],
       })
 
       mockEm.create.mockReturnValue({} as any)
@@ -567,36 +527,27 @@ describe('Transition Handler (Unit Tests)', () => {
     })
 
     test('should execute transition even if post-conditions fail (warning only)', async () => {
-      // 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' },
-          ],
-        },
-      }
-
       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.findOne
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValue(mockDefinition)
+
+      ;(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.create.mockReturnValue({} as any)
 
@@ -758,33 +709,22 @@ describe('Transition Handler (Unit Tests)', () => {
 
   describe('Business Rules Integration', () => {
     test('should call rule engine for pre-conditions with correct entityType', 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.mockResolvedValue(definitionWithPreConditions)
+      mockEm.findOne
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
 
-      ;(ruleEngine.executeRuleByRuleId as jest.Mock).mockResolvedValueOnce({
-        success: true,
-        ruleId: 'test-guard-rule',
-        ruleName: 'Test Guard Rule',
-        conditionResult: true,
-        actionsExecuted: null,
-        executionTime: 10,
-      })
+      ;(ruleEngine.executeRules as jest.Mock)
+        .mockResolvedValueOnce({
+          allowed: true,
+          executedRules: [],
+          totalExecutionTime: 10,
+        })
+        .mockResolvedValueOnce({
+          allowed: true,
+          executedRules: [],
+          totalExecutionTime: 5,
+        })
 
       mockEm.create.mockReturnValue({} as any)
 
@@ -797,10 +737,9 @@ describe('Transition Handler (Unit Tests)', () => {
         { workflowContext: {} }
       )
 
-      expect(ruleEngine.executeRuleByRuleId).toHaveBeenCalledWith(
+      expect(ruleEngine.executeRules).toHaveBeenCalledWith(
         mockEm,
         expect.objectContaining({
-          ruleId: 'test-guard-rule',
           entityType: 'workflow:simple-approval:transition',
           eventType: 'pre_transition',
           data: expect.objectContaining({
@@ -812,34 +751,26 @@ describe('Transition Handler (Unit Tests)', () => {
     })
 
     test('should call rule engine for post-conditions with correct eventType', async () => {
-      // 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' },
-          ],
-        },
-      }
-
       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.findOne
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValue(mockDefinition)
+
+      ;(ruleEngine.executeRules as jest.Mock)
+        .mockResolvedValueOnce({
+          allowed: true,
+          executedRules: [],
+          totalExecutionTime: 10,
+        })
+        .mockResolvedValueOnce({
+          allowed: true,
+          executedRules: [],
+          totalExecutionTime: 5,
+        })
 
       mockEm.create.mockReturnValue({} as any)
 
@@ -852,11 +783,11 @@ describe('Transition Handler (Unit Tests)', () => {
         { workflowContext: {} }
       )
 
-      // Check call to executeRuleByRuleId for post-conditions
-      expect(ruleEngine.executeRuleByRuleId).toHaveBeenCalledWith(
+      // Check second call to executeRules (post-conditions)
+      expect(ruleEngine.executeRules).toHaveBeenNthCalledWith(
+        2,
         mockEm,
         expect.objectContaining({
-          ruleId: 'test-post-rule',
           entityType: 'workflow:simple-approval:transition',
           eventType: 'post_transition',
         })
@@ -864,33 +795,22 @@ describe('Transition Handler (Unit Tests)', () => {
     })
 
     test('should pass workflow context and trigger data to rule engine', 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.mockResolvedValue(definitionWithPreConditions)
+      mockEm.findOne
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
+        .mockResolvedValueOnce(mockDefinition)
 
-      ;(ruleEngine.executeRuleByRuleId as jest.Mock).mockResolvedValueOnce({
-        success: true,
-        ruleId: 'test-guard-rule',
-        ruleName: 'Test Guard Rule',
-        conditionResult: true,
-        actionsExecuted: null,
-        executionTime: 10,
-      })
+      ;(ruleEngine.executeRules as jest.Mock)
+        .mockResolvedValueOnce({
+          allowed: true,
+          executedRules: [],
+          totalExecutionTime: 10,
+        })
+        .mockResolvedValueOnce({
+          allowed: true,
+          executedRules: [],
+          totalExecutionTime: 5,
+        })
 
       mockEm.create.mockReturnValue({} as any)
 
@@ -910,7 +830,7 @@ describe('Transition Handler (Unit Tests)', () => {
         }
       )
 
-      expect(ruleEngine.executeRuleByRuleId).toHaveBeenCalledWith(
+      expect(ruleEngine.executeRules).toHaveBeenCalledWith(
         mockEm,
         expect.objectContaining({
           data: expect.objectContaining({