@open-mercato/core 0.4.2-canary-ec4978dbb3 → 0.4.2-canary-d0a025141f

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/core",
-  "version": "0.4.2-canary-ec4978dbb3",
+  "version": "0.4.2-canary-d0a025141f",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -207,7 +207,7 @@
     }
   },
   "dependencies": {
-    "@open-mercato/shared": "0.4.2-canary-ec4978dbb3",
+    "@open-mercato/shared": "0.4.2-canary-d0a025141f",
     "@xyflow/react": "^12.6.0",
     "date-fns": "^4.1.0",
     "date-fns-tz": "^3.2.0"

package/src/modules/workflows/api/__tests__/instances.route.test.ts

@@ -194,11 +194,14 @@ describe('Workflow Instances API', () => {
       const request = new NextRequest('http://localhost/api/workflows/instances?entityType=order&entityId=order-123')
       await listInstances(request)
 
+      // The implementation uses JSONB $contains queries for metadata filtering
       expect(mockEm.findAndCount).toHaveBeenCalledWith(
         WorkflowInstance,
         expect.objectContaining({
-          'metadata.entityType': 'order',
-          'metadata.entityId': 'order-123',
+          $and: expect.arrayContaining([
+            { metadata: { $contains: { entityType: 'order' } } },
+            { metadata: { $contains: { entityId: 'order-123' } } },
+          ]),
         }),
         expect.any(Object)
       )

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({
@@ -751,26 +812,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)
 
@@ -783,11 +852,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',
         })
@@ -795,22 +864,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)
 
@@ -830,7 +910,7 @@ describe('Transition Handler (Unit Tests)', () => {
         }
       )
 
-      expect(ruleEngine.executeRules).toHaveBeenCalledWith(
+      expect(ruleEngine.executeRuleByRuleId).toHaveBeenCalledWith(
         mockEm,
         expect.objectContaining({
           data: expect.objectContaining({