@open-mercato/core 0.4.2-canary-ec4978dbb3 → 0.4.2-canary-9074fd41ce

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)
  */

package/src/modules/workflows/lib/seeds.ts

@@ -7,8 +7,6 @@ import checkoutDemoDefinition from '../examples/checkout-demo-definition.json'
 import guardRulesExample from '../examples/guard-rules-example.json'
 import salesPipelineDefinition from '../examples/sales-pipeline-definition.json'
 import simpleApprovalDefinition from '../examples/simple-approval-definition.json'
-import orderApprovalDefinition from '../examples/order-approval-definition.json'
-import orderApprovalGuardRules from '../examples/order-approval-guard-rules.json'
 
 export type WorkflowSeedScope = { tenantId: string; organizationId: string }
 
@@ -53,8 +51,6 @@ const embeddedSeeds: Record<string, unknown> = {
   'guard-rules-example.json': guardRulesExample,
   'sales-pipeline-definition.json': salesPipelineDefinition,
   'simple-approval-definition.json': simpleApprovalDefinition,
-  'order-approval-definition.json': orderApprovalDefinition,
-  'order-approval-guard-rules.json': orderApprovalGuardRules,
 }
 
 function readExampleJson<T>(fileName: string): T {
@@ -94,35 +90,16 @@ async function seedWorkflowDefinition(
   })
 
   if (existing) {
-    // Check if the definition needs to be updated by comparing steps and transitions
-    const seedStepCount = seed.definition.steps.length
-    const existingStepCount = existing.definition.steps.length
-    const seedTransitionCount = seed.definition.transitions.length
-    const existingTransitionCount = existing.definition.transitions.length
-
-    // Check for preConditions on transitions
-    const seedHasTransitionPreConditions = seed.definition.transitions.some(
-      (t: any) => t.preConditions && t.preConditions.length > 0
-    )
-    const existingHasTransitionPreConditions = existing.definition.transitions.some(
-      (t: any) => t.preConditions && t.preConditions.length > 0
-    )
-
-    // Check for preConditions on START step
+    // Check if the definition needs to be updated (e.g., missing preConditions on START step)
     const seedStartStep = seed.definition.steps.find((s: any) => s.stepType === 'START')
     const existingStartStep = existing.definition.steps.find((s: any) => s.stepType === 'START')
-    const seedHasStartPreConditions = seedStartStep?.preConditions && seedStartStep.preConditions.length > 0
-    const existingHasStartPreConditions = existingStartStep?.preConditions && existingStartStep.preConditions.length > 0
-
-    // Update if structure has changed
-    const needsUpdate =
-      seedStepCount !== existingStepCount ||
-      seedTransitionCount !== existingTransitionCount ||
-      (seedHasStartPreConditions && !existingHasStartPreConditions) ||
-      (seedHasTransitionPreConditions && !existingHasTransitionPreConditions)
-
-    if (needsUpdate) {
-      console.log(`[seed] Updating workflow ${workflowId} (steps: ${existingStepCount}→${seedStepCount}, transitions: ${existingTransitionCount}→${seedTransitionCount})`)
+
+    const seedHasPreConditions = seedStartStep?.preConditions && seedStartStep.preConditions.length > 0
+    const existingHasPreConditions = existingStartStep?.preConditions && existingStartStep.preConditions.length > 0
+
+    // Update if seed has preConditions but existing doesn't
+    if (seedHasPreConditions && !existingHasPreConditions) {
+      console.log(`[seed] Updating workflow ${workflowId} with preConditions`)
       existing.definition = seed.definition
       await em.flush()
       return true
@@ -195,7 +172,4 @@ export async function seedExampleWorkflows(em: EntityManager, scope: WorkflowSee
   await seedGuardRules(em, scope, 'guard-rules-example.json')
   await seedWorkflowDefinition(em, scope, 'sales-pipeline-definition.json')
   await seedWorkflowDefinition(em, scope, 'simple-approval-definition.json')
-  // Seed order approval guard rules before the workflow definition
-  await seedGuardRules(em, scope, 'order-approval-guard-rules.json')
-  await seedWorkflowDefinition(em, scope, 'order-approval-definition.json')
 }

package/src/modules/workflows/lib/start-validator.ts

@@ -128,69 +128,59 @@ export async function validateWorkflowStart(
   const validatedRules: ValidatedRule[] = []
 
   for (const condition of preConditions) {
-    // Execute rule directly by string rule_id
-    const result = await ruleEngine.executeRuleByRuleId(em, {
-      ruleId: condition.ruleId,  // String identifier like "workflow_checkout_inventory_available"
+    const ruleContext: ruleEngine.RuleEngineContext = {
+      entityType: `workflow:${workflowId}:start`,
+      entityId: 'pre_start_validation',
+      eventType: 'validate_start',
       data: {
         workflowId,
         workflowContext: context,
       },
       tenantId,
       organizationId,
-      entityType: `workflow:${workflowId}:start`,
-      entityId: 'pre_start_validation',
-      eventType: 'validate_start',
       dryRun: true, // Don't log execution during validation
-    })
+    }
 
-    validatedRules.push({
-      ruleId: condition.ruleId,
-      passed: result.conditionResult,
-      executionTime: result.executionTime,
+    // Find applicable rules for this context
+    const rules = await ruleEngine.findApplicableRules(em, {
+      entityType: ruleContext.entityType,
+      eventType: ruleContext.eventType,
+      tenantId,
+      organizationId,
+      ruleType: 'GUARD',
     })
 
-    // Handle rule not found
-    if (result.error === 'Rule not found') {
+    const rule = rules.find(r => r.ruleId === condition.ruleId)
+
+    if (!rule) {
+      // Rule not found - if required, this is an error
       if (condition.required) {
         errors.push({
           ruleId: condition.ruleId,
-          message: getLocalizedMessage(condition, null, locale, `Business rule not found: ${condition.ruleId}`),
+          message: getLocalizedMessage(condition, null, locale, `Business rule '${condition.ruleId}' not found`),
           code: 'RULE_NOT_FOUND',
         })
+        validatedRules.push({ ruleId: condition.ruleId, passed: false })
       }
       continue
     }
 
-    // Handle disabled rule
-    if (result.error === 'Rule is disabled') {
-      if (condition.required) {
-        errors.push({
-          ruleId: condition.ruleId,
-          message: getLocalizedMessage(condition, null, locale, `Business rule is disabled: ${result.ruleName}`),
-          code: 'RULE_DISABLED',
-        })
-      }
-      continue
-    }
+    // Execute the single rule
+    const result = await ruleEngine.executeSingleRule(em, rule, ruleContext)
 
-    // Handle other errors (not yet effective, expired, etc.)
-    if (result.error && condition.required) {
-      errors.push({
-        ruleId: condition.ruleId,
-        message: getLocalizedMessage(condition, null, locale, `Rule error: ${result.error}`),
-        code: 'RULE_ERROR',
-      })
-      continue
-    }
+    validatedRules.push({
+      ruleId: condition.ruleId,
+      passed: result.conditionResult,
+      executionTime: result.executionTime,
+    })
 
-    // Handle condition failure
     if (!result.conditionResult && condition.required) {
-      // Get localized message from condition or use default with rule name
+      // Get localized message from condition, rule failure actions, or default
       const message = getLocalizedMessage(
         condition,
-        null,
+        rule,
         locale,
-        `Pre-condition '${result.ruleName || condition.ruleId}' failed`
+        `Pre-condition '${rule.ruleName || condition.ruleId}' failed`
       )
       errors.push({
         ruleId: condition.ruleId,

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

@@ -19,6 +19,7 @@ import {
 } from '../data/entities'
 import * as ruleEvaluator from '../../business_rules/lib/rule-evaluator'
 import * as ruleEngine from '../../business_rules/lib/rule-engine'
+import type { RuleEngineContext } from '../../business_rules/lib/rule-engine'
 import * as activityExecutor from './activity-executor'
 import type { ActivityDefinition } from './activity-executor'
 import * as stepHandler from './step-handler'
@@ -193,15 +194,11 @@ export async function evaluateTransition(
 /**
  * Find all valid transitions from current step
  *
- * This function evaluates both inline conditions AND preConditions (business rules)
- * to determine which transitions are truly valid. This is important for decision
- * branching where multiple transitions exist with different preConditions.
- *
  * @param em - Entity manager
  * @param instance - Workflow instance
  * @param fromStepId - Current step ID
  * @param context - Evaluation context
- * @returns Array of evaluation results for all transitions, sorted by priority (desc)
+ * @returns Array of evaluation results for all transitions
  */
 export async function findValidTransitions(
   em: EntityManager,
@@ -219,17 +216,16 @@ export async function findValidTransitions(
       return []
     }
 
-    // Find all transitions from current step, sorted by priority (highest first)
-    const transitions = (definition.definition.transitions || [])
-      .filter((t: any) => t.fromStepId === fromStepId)
-      .sort((a: any, b: any) => (b.priority || 0) - (a.priority || 0))
+    // Find all transitions from current step
+    const transitions = (definition.definition.transitions || []).filter(
+      (t: any) => t.fromStepId === fromStepId
+    )
 
-    // Evaluate each transition including preConditions
+    // Evaluate each transition
     const results: TransitionEvaluationResult[] = []
 
     for (const transition of transitions) {
-      // First check inline condition
-      const conditionResult = await evaluateTransition(
+      const result = await evaluateTransition(
         em,
         instance,
         fromStepId,
@@ -237,42 +233,7 @@ export async function findValidTransitions(
         context
       )
 
-      if (!conditionResult.isValid) {
-        results.push(conditionResult)
-        continue
-      }
-
-      // Also evaluate preConditions if they exist
-      const preConditions = transition.preConditions || []
-      if (preConditions.length > 0) {
-        const preConditionsResult = await evaluatePreConditions(
-          em,
-          instance,
-          transition,
-          context as TransitionExecutionContext
-        )
-
-        if (!preConditionsResult.allowed) {
-          // Transition is invalid due to preConditions
-          const failedRules = preConditionsResult.executedRules
-            .filter((r) => !r.conditionResult)
-            .map((r) => r.rule.ruleId || r.rule.ruleName)
-
-          results.push({
-            isValid: false,
-            transition,
-            reason: `Pre-conditions failed: ${failedRules.join(', ')}`,
-            failedConditions: failedRules,
-          })
-          continue
-        }
-      }
-
-      // Transition is valid (both condition and preConditions passed)
-      results.push({
-        ...conditionResult,
-        transition,
-      })
+      results.push(result)
     }
 
     return results
@@ -688,10 +649,6 @@ async function evaluateTransitionConditions(
  * Pre-conditions are GUARD rules that must pass before transition can execute.
  * If any GUARD rule fails, the transition is blocked.
  *
- * If the transition defines specific preConditions with ruleIds, those are
- * executed directly via executeRuleByRuleId. Otherwise, falls back to
- * discovery-based execution via executeRules.
- *
  * @param em - Entity manager
  * @param instance - Workflow instance
  * @param transition - Transition definition
@@ -718,88 +675,32 @@ async function evaluatePreConditions(
       }
     }
 
-    // Check if transition has specific preConditions defined
-    const preConditions = transition.preConditions || []
-
-    // If no pre-conditions defined, allow transition
-    if (preConditions.length === 0) {
-      return {
-        allowed: true,
-        executedRules: [],
-        totalExecutionTime: 0,
-      }
-    }
-
-    // Execute each pre-condition rule directly by ruleId
-    const startTime = Date.now()
-    const executedRules: ruleEngine.RuleExecutionResult[] = []
-    const errors: string[] = []
-    let allowed = true
-
-    for (const condition of preConditions) {
-      const result = await ruleEngine.executeRuleByRuleId(em, {
-        ruleId: condition.ruleId,  // String identifier
-        data: {
-          workflowInstanceId: instance.id,
-          workflowId: definition.workflowId,
-          fromStepId: transition.fromStepId,
-          toStepId: transition.toStepId,
-          workflowContext: {
-            ...instance.context,
-            ...context.workflowContext,
-          },
-          triggerData: context.triggerData,
+    // Build rule engine context
+    const ruleContext: RuleEngineContext = {
+      entityType: `workflow:${definition.workflowId}:transition`,
+      entityId: transition.transitionId || `${transition.fromStepId}->${transition.toStepId}`,
+      eventType: 'pre_transition',
+      data: {
+        workflowInstanceId: instance.id,
+        workflowId: definition.workflowId,
+        fromStepId: transition.fromStepId,
+        toStepId: transition.toStepId,
+        workflowContext: {
+          ...instance.context,
+          ...context.workflowContext,
         },
-        user: context.userId ? { id: context.userId } : undefined,
-        tenantId: instance.tenantId,
-        organizationId: instance.organizationId,
-        executedBy: context.userId,
-        entityType: `workflow:${definition.workflowId}:transition`,
-        entityId: transition.transitionId || `${transition.fromStepId}->${transition.toStepId}`,
-        eventType: 'pre_transition',
-      })
-
-      // Create a compatible RuleExecutionResult for tracking
-      // We don't have the full BusinessRule entity, but we can create a partial result
-      const ruleResult: ruleEngine.RuleExecutionResult = {
-        rule: {
-          ruleId: result.ruleId,
-          ruleName: result.ruleName,
-          ruleType: 'GUARD',
-        } as any,
-        conditionResult: result.conditionResult,
-        actionsExecuted: result.actionsExecuted,
-        executionTime: result.executionTime,
-        error: result.error,
-        logId: result.logId,
-      }
-      executedRules.push(ruleResult)
-
-      // Handle rule errors
-      if (result.error) {
-        // Rule not found, disabled, or other errors
-        const isRequired = condition.required !== false  // Default to required
-        if (isRequired) {
-          allowed = false
-          errors.push(`Rule '${result.ruleId}': ${result.error}`)
-        }
-        continue
-      }
-
-      // If required and condition failed, block transition
-      const isRequired = condition.required !== false  // Default to required
-      if (isRequired && !result.conditionResult) {
-        allowed = false
-        errors.push(`Pre-condition '${result.ruleName || result.ruleId}' failed`)
-      }
+        triggerData: context.triggerData,
+      },
+      user: context.userId ? { id: context.userId } : undefined,
+      tenantId: instance.tenantId,
+      organizationId: instance.organizationId,
+      executedBy: context.userId,
     }
 
-    return {
-      allowed,
-      executedRules,
-      totalExecutionTime: Date.now() - startTime,
-      errors: errors.length > 0 ? errors : undefined,
-    }
+    // Execute rules - only GUARD rules will affect the 'allowed' status
+    const result = await ruleEngine.executeRules(em, ruleContext)
+
+    return result
   } catch (error) {
     console.error('Error evaluating pre-conditions:', error)
     return {
@@ -817,9 +718,6 @@ async function evaluatePreConditions(
  * Post-conditions are GUARD rules that should pass after transition executes.
  * Unlike pre-conditions, post-condition failures are logged but don't block the transition.
  *
- * If the transition defines specific postConditions with ruleIds, those are
- * executed directly via executeRuleByRuleId. Otherwise, returns allowed: true.
- *
  * @param em - Entity manager
  * @param instance - Workflow instance
  * @param transition - Transition definition
@@ -846,83 +744,32 @@ async function evaluatePostConditions(
       }
     }
 
-    // Check if transition has specific postConditions defined
-    const postConditions = transition.postConditions || []
-
-    // If no post-conditions defined, allow
-    if (postConditions.length === 0) {
-      return {
-        allowed: true,
-        executedRules: [],
-        totalExecutionTime: 0,
-      }
-    }
-
-    // Execute each post-condition rule directly by ruleId
-    const startTime = Date.now()
-    const executedRules: ruleEngine.RuleExecutionResult[] = []
-    const errors: string[] = []
-    let allowed = true
-
-    for (const condition of postConditions) {
-      const result = await ruleEngine.executeRuleByRuleId(em, {
-        ruleId: condition.ruleId,  // String identifier
-        data: {
-          workflowInstanceId: instance.id,
-          workflowId: definition.workflowId,
-          fromStepId: transition.fromStepId,
-          toStepId: transition.toStepId,
-          workflowContext: {
-            ...instance.context,
-            ...context.workflowContext,
-          },
-          triggerData: context.triggerData,
+    // Build rule engine context
+    const ruleContext: RuleEngineContext = {
+      entityType: `workflow:${definition.workflowId}:transition`,
+      entityId: transition.transitionId || `${transition.fromStepId}->${transition.toStepId}`,
+      eventType: 'post_transition',
+      data: {
+        workflowInstanceId: instance.id,
+        workflowId: definition.workflowId,
+        fromStepId: transition.fromStepId,
+        toStepId: transition.toStepId,
+        workflowContext: {
+          ...instance.context,
+          ...context.workflowContext,
         },
-        user: context.userId ? { id: context.userId } : undefined,
-        tenantId: instance.tenantId,
-        organizationId: instance.organizationId,
-        executedBy: context.userId,
-        entityType: `workflow:${definition.workflowId}:transition`,
-        entityId: transition.transitionId || `${transition.fromStepId}->${transition.toStepId}`,
-        eventType: 'post_transition',
-      })
-
-      // Create a compatible RuleExecutionResult for tracking
-      const ruleResult: ruleEngine.RuleExecutionResult = {
-        rule: {
-          ruleId: result.ruleId,
-          ruleName: result.ruleName,
-          ruleType: 'GUARD',
-        } as any,
-        conditionResult: result.conditionResult,
-        actionsExecuted: result.actionsExecuted,
-        executionTime: result.executionTime,
-        error: result.error,
-        logId: result.logId,
-      }
-      executedRules.push(ruleResult)
-
-      // Handle rule errors
-      if (result.error) {
-        errors.push(`Rule '${result.ruleId}': ${result.error}`)
-        // Post-conditions don't block, but track the failure
-        allowed = false
-        continue
-      }
-
-      // Track condition failures (post-conditions are warnings, not blockers)
-      if (!result.conditionResult) {
-        allowed = false
-        errors.push(`Post-condition '${result.ruleName || result.ruleId}' failed`)
-      }
+        triggerData: context.triggerData,
+      },
+      user: context.userId ? { id: context.userId } : undefined,
+      tenantId: instance.tenantId,
+      organizationId: instance.organizationId,
+      executedBy: context.userId,
     }
 
-    return {
-      allowed,
-      executedRules,
-      totalExecutionTime: Date.now() - startTime,
-      errors: errors.length > 0 ? errors : undefined,
-    }
+    // Execute rules
+    const result = await ruleEngine.executeRules(em, ruleContext)
+
+    return result
   } catch (error) {
     console.error('Error evaluating post-conditions:', error)
     return {

package/dist/generated/entities/workflow_event_trigger/index.js

@@ -1,33 +0,0 @@
-const id = "id";
-const name = "name";
-const description = "description";
-const workflow_definition_id = "workflow_definition_id";
-const event_pattern = "event_pattern";
-const config = "config";
-const enabled = "enabled";
-const priority = "priority";
-const tenant_id = "tenant_id";
-const organization_id = "organization_id";
-const created_by = "created_by";
-const updated_by = "updated_by";
-const created_at = "created_at";
-const updated_at = "updated_at";
-const deleted_at = "deleted_at";
-export {
-  config,
-  created_at,
-  created_by,
-  deleted_at,
-  description,
-  enabled,
-  event_pattern,
-  id,
-  name,
-  organization_id,
-  priority,
-  tenant_id,
-  updated_at,
-  updated_by,
-  workflow_definition_id
-};
-//# sourceMappingURL=index.js.map