@open-mercato/core 0.4.2-canary-d0a025141f → 0.4.2-canary-3efa759f5c

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({

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

@@ -448,30 +448,7 @@ export async function executeEmitEvent(
 /**
  * UPDATE_ENTITY activity handler
  *
- * Updates an entity via CommandBus for proper audit logging, undo support, and side effects.
- *
- * Config format:
- * ```json
- * {
- *   "commandId": "sales.documents.update",
- *   "input": {
- *     "id": "{{context.orderId}}",
- *     "statusEntryId": "{{context.approvedStatusId}}"
- *   }
- * }
- * ```
- *
- * Alternative format with statusValue (auto-resolves to statusEntryId):
- * ```json
- * {
- *   "commandId": "sales.orders.update",
- *   "statusDictionary": "sales.order_status",
- *   "input": {
- *     "id": "{{context.id}}",
- *     "statusValue": "pending_approval"
- *   }
- * }
- * ```
+ * Updates an entity via query engine
  */
 export async function executeUpdateEntity(
   em: EntityManager,
@@ -479,119 +456,29 @@ export async function executeUpdateEntity(
   context: ActivityContext,
   container: AwilixContainer
 ): Promise<any> {
-  const { commandId, input, statusDictionary } = config
-
-  if (!commandId) {
-    throw new Error('UPDATE_ENTITY requires "commandId" field (e.g., "sales.documents.update")')
-  }
+  const { entityType, entityId, updates } = config
 
-  if (!input || typeof input !== 'object') {
-    throw new Error('UPDATE_ENTITY requires "input" object with entity data')
+  if (!entityType || !entityId || !updates) {
+    throw new Error('UPDATE_ENTITY requires "entityType", "entityId", and "updates" fields')
   }
 
-  // Resolve CommandBus from container
-  const commandBus = container.resolve('commandBus') as any
-
-  if (!commandBus || typeof commandBus.execute !== 'function') {
-    throw new Error('CommandBus not available in container')
-  }
-
-  // Prepare final input, resolving statusValue if provided
-  let finalInput = { ...input }
-
-  // If statusValue is provided with a statusDictionary, resolve it to statusEntryId
-  if (finalInput.statusValue && statusDictionary) {
-    const statusEntryId = await resolveDictionaryEntryId(
-      em,
-      statusDictionary,
-      finalInput.statusValue,
-      context.workflowInstance.tenantId,
-      context.workflowInstance.organizationId
-    )
-    if (statusEntryId) {
-      finalInput.statusEntryId = statusEntryId
-    }
-    delete finalInput.statusValue
-  }
+  // Get query engine from container
+  const queryEngine = container.resolve('queryEngine')
 
-  // Build synthetic CommandRuntimeContext for workflow execution
-  // Use nil UUID for system actions when no user context is available
-  const SYSTEM_USER_ID = '00000000-0000-0000-0000-000000000000'
-  const ctx = {
-    container,
-    auth: {
-      sub: context.userId || SYSTEM_USER_ID,
-      tenantId: context.workflowInstance.tenantId,
-      orgId: context.workflowInstance.organizationId,
-      isSuperAdmin: false,
-    },
-    organizationScope: null,
-    selectedOrganizationId: context.workflowInstance.organizationId,
-    organizationIds: context.workflowInstance.organizationId
-      ? [context.workflowInstance.organizationId]
-      : null,
+  if (!queryEngine || typeof queryEngine.update !== 'function') {
+    throw new Error('Query engine not available in container')
   }
 
-  // Execute the command
-  const { result, logEntry } = await commandBus.execute(commandId, {
-    input: finalInput,
-    ctx,
+  // Execute update with tenant scoping
+  await queryEngine.update({
+    entity: entityType,
+    where: { id: entityId },
+    data: updates,
+    tenantId: context.workflowInstance.tenantId,
+    organizationId: context.workflowInstance.organizationId,
   })
 
-  return {
-    executed: true,
-    commandId,
-    result,
-    logEntryId: logEntry?.id,
-  }
-}
-
-/**
- * Helper to resolve dictionary entry ID by value
- */
-async function resolveDictionaryEntryId(
-  em: EntityManager,
-  dictionaryKey: string,
-  value: string,
-  tenantId: string,
-  organizationId: string
-): Promise<string | null> {
-  try {
-    // Import here to avoid circular dependencies
-    const { Dictionary, DictionaryEntry } = await import('@open-mercato/core/modules/dictionaries/data/entities')
-
-    // Find the dictionary
-    const dictionary = await em.findOne(Dictionary, {
-      key: dictionaryKey,
-      tenantId,
-      organizationId,
-      deletedAt: null,
-    })
-
-    if (!dictionary) {
-      console.warn(`[UPDATE_ENTITY] Dictionary not found: ${dictionaryKey}`)
-      return null
-    }
-
-    // Find the entry by normalized value
-    const normalizedValue = value.toLowerCase().trim()
-    const entry = await em.findOne(DictionaryEntry, {
-      dictionary: dictionary.id,
-      tenantId,
-      organizationId,
-      normalizedValue,
-    })
-
-    if (!entry) {
-      console.warn(`[UPDATE_ENTITY] Dictionary entry not found: ${dictionaryKey}/${value}`)
-      return null
-    }
-
-    return entry.id
-  } catch (error) {
-    console.error(`[UPDATE_ENTITY] Error resolving dictionary entry:`, error)
-    return null
-  }
+  return { updated: true, entityType, entityId, updates }
 }
 
 /**

package/src/modules/workflows/lib/graph-utils.ts

@@ -205,20 +205,12 @@ export function definitionToGraph(
   definition: WorkflowDefinition['definition'],
   options: DefinitionToGraphOptions = {}
 ): { nodes: Node[]; edges: Edge[] } {
-  const { autoLayout = true, layoutSpacing = { vertical: 200, horizontal: 300 } } = options
-
-  // Build step map for quick lookup
-  const stepMap = new Map(definition.steps.map(step => [step.stepId, step]))
-
-  // Calculate smart layout positions if autoLayout is enabled
-  const positions = autoLayout
-    ? calculateSmartLayout(definition.steps, definition.transitions, layoutSpacing)
-    : null
+  const { autoLayout = true, layoutSpacing = { vertical: 250, horizontal: 100 } } = options
 
   // Convert steps to nodes
   const nodes: Node[] = definition.steps.map((step, index) => {
     // Determine position
-    let position = positions?.get(step.stepId) || { x: 250, y: 50 + index * layoutSpacing.vertical }
+    let position = { x: 250, y: 50 + index * layoutSpacing.vertical }
 
     // Use stored position if available and not auto-layouting
     if (!autoLayout && (step as any)._editorPosition) {
@@ -334,113 +326,6 @@ export function definitionToGraph(
   return { nodes, edges }
 }
 
-/**
- * Calculate smart layout positions for workflow nodes
- * Uses a layered/hierarchical layout algorithm that:
- * 1. Assigns levels (ranks) to nodes based on graph topology
- * 2. Spreads sibling nodes horizontally at the same level
- * 3. Centers merge points below their incoming nodes
- */
-function calculateSmartLayout(
-  steps: any[],
-  transitions: any[],
-  spacing: { vertical: number; horizontal: number }
-): Map<string, { x: number; y: number }> {
-  const positions = new Map<string, { x: number; y: number }>()
-
-  if (steps.length === 0) return positions
-
-  // Build adjacency lists
-  const outgoing = new Map<string, string[]>() // node -> children
-  const incoming = new Map<string, string[]>() // node -> parents
-
-  for (const step of steps) {
-    outgoing.set(step.stepId, [])
-    incoming.set(step.stepId, [])
-  }
-
-  for (const t of transitions) {
-    const children = outgoing.get(t.fromStepId) || []
-    children.push(t.toStepId)
-    outgoing.set(t.fromStepId, children)
-
-    const parents = incoming.get(t.toStepId) || []
-    parents.push(t.fromStepId)
-    incoming.set(t.toStepId, parents)
-  }
-
-  // Find start node(s) - nodes with no incoming edges
-  const startNodes = steps.filter(s => (incoming.get(s.stepId) || []).length === 0)
-  if (startNodes.length === 0) {
-    // Fallback: use first step as start
-    startNodes.push(steps[0])
-  }
-
-  // Assign levels using BFS (longest path from start)
-  const levels = new Map<string, number>()
-  const queue: Array<{ id: string; level: number }> = []
-
-  for (const start of startNodes) {
-    queue.push({ id: start.stepId, level: 0 })
-  }
-
-  while (queue.length > 0) {
-    const { id, level } = queue.shift()!
-    const currentLevel = levels.get(id)
-
-    // Take the maximum level (longest path)
-    if (currentLevel === undefined || level > currentLevel) {
-      levels.set(id, level)
-    }
-
-    const children = outgoing.get(id) || []
-    for (const child of children) {
-      queue.push({ id: child, level: level + 1 })
-    }
-  }
-
-  // Group nodes by level
-  const nodesByLevel = new Map<number, string[]>()
-  for (const [nodeId, level] of levels) {
-    const nodesAtLevel = nodesByLevel.get(level) || []
-    nodesAtLevel.push(nodeId)
-    nodesByLevel.set(level, nodesAtLevel)
-  }
-
-  // Calculate positions
-  const centerX = 400 // Center line for the graph
-  const startY = 50
-
-  for (const [level, nodeIds] of nodesByLevel) {
-    const count = nodeIds.length
-    const y = startY + level * spacing.vertical
-
-    if (count === 1) {
-      // Single node at this level - center it
-      positions.set(nodeIds[0], { x: centerX, y })
-    } else {
-      // Multiple nodes at this level - spread them horizontally
-      const totalWidth = (count - 1) * spacing.horizontal
-      const startX = centerX - totalWidth / 2
-
-      // Sort nodes by their parent's position for consistent ordering
-      nodeIds.sort((a, b) => {
-        const parentsA = incoming.get(a) || []
-        const parentsB = incoming.get(b) || []
-        const parentPosA = parentsA.length > 0 ? (positions.get(parentsA[0])?.x || 0) : 0
-        const parentPosB = parentsB.length > 0 ? (positions.get(parentsB[0])?.x || 0) : 0
-        return parentPosA - parentPosB
-      })
-
-      nodeIds.forEach((nodeId, idx) => {
-        positions.set(nodeId, { x: startX + idx * spacing.horizontal, y })
-      })
-    }
-  }
-
-  return positions
-}
-
 /**
  * Map node type to step type (for graph → definition)
  */