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

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

@@ -1,14 +1,11 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
 import * as fs from 'fs'
 import * as path from 'path'
+import { fileURLToPath } from 'node:url'
 import { WorkflowDefinition, type WorkflowDefinitionData } from '../data/entities'
 import { BusinessRule, type RuleType } from '@open-mercato/core/modules/business_rules/data/entities'
-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'
+
+const __esmDirname = path.dirname(fileURLToPath(import.meta.url))
 
 export type WorkflowSeedScope = { tenantId: string; organizationId: string }
 
@@ -48,22 +45,9 @@ type GuardRuleSeed = {
   labelsJson?: Record<string, string>
 }
 
-const embeddedSeeds: Record<string, unknown> = {
-  'checkout-demo-definition.json': checkoutDemoDefinition,
-  '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 {
-  const embedded = embeddedSeeds[fileName]
-  if (embedded) {
-    return embedded as T
-  }
   const candidates = [
-    path.join(__dirname, '..', 'examples', fileName),
+    path.join(__esmDirname, '..', 'examples', fileName),
     path.join(process.cwd(), 'packages', 'core', 'src', 'modules', 'workflows', 'examples', fileName),
     path.join(process.cwd(), 'src', 'modules', 'workflows', 'examples', fileName),
   ]
@@ -94,35 +78,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 +160,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 {