@open-mercato/core 0.4.2-canary-51881f6bf3 → 0.4.2-canary-5f415b8a44

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

@@ -7,6 +7,8 @@ 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 }
 
@@ -51,6 +53,8 @@ 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 {
@@ -90,16 +94,35 @@ async function seedWorkflowDefinition(
   })
 
   if (existing) {
-    // Check if the definition needs to be updated (e.g., missing preConditions on START step)
+    // 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
     const seedStartStep = seed.definition.steps.find((s: any) => s.stepType === 'START')
     const existingStartStep = existing.definition.steps.find((s: any) => s.stepType === 'START')
-
-    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`)
+    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})`)
       existing.definition = seed.definition
       await em.flush()
       return true
@@ -172,4 +195,7 @@ 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,59 +128,69 @@ export async function validateWorkflowStart(
   const validatedRules: ValidatedRule[] = []
 
   for (const condition of preConditions) {
-    const ruleContext: ruleEngine.RuleEngineContext = {
-      entityType: `workflow:${workflowId}:start`,
-      entityId: 'pre_start_validation',
-      eventType: 'validate_start',
+    // Execute rule directly by string rule_id
+    const result = await ruleEngine.executeRuleByRuleId(em, {
+      ruleId: condition.ruleId,  // String identifier like "workflow_checkout_inventory_available"
       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
-    }
-
-    // Find applicable rules for this context
-    const rules = await ruleEngine.findApplicableRules(em, {
-      entityType: ruleContext.entityType,
-      eventType: ruleContext.eventType,
-      tenantId,
-      organizationId,
-      ruleType: 'GUARD',
     })
 
-    const rule = rules.find(r => r.ruleId === condition.ruleId)
+    validatedRules.push({
+      ruleId: condition.ruleId,
+      passed: result.conditionResult,
+      executionTime: result.executionTime,
+    })
 
-    if (!rule) {
-      // Rule not found - if required, this is an error
+    // Handle rule not found
+    if (result.error === 'Rule not found') {
       if (condition.required) {
         errors.push({
           ruleId: condition.ruleId,
-          message: getLocalizedMessage(condition, null, locale, `Business rule '${condition.ruleId}' not found`),
+          message: getLocalizedMessage(condition, null, locale, `Business rule not found: ${condition.ruleId}`),
           code: 'RULE_NOT_FOUND',
         })
-        validatedRules.push({ ruleId: condition.ruleId, passed: false })
       }
       continue
     }
 
-    // Execute the single rule
-    const result = await ruleEngine.executeSingleRule(em, rule, ruleContext)
+    // 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
+    }
 
-    validatedRules.push({
-      ruleId: condition.ruleId,
-      passed: result.conditionResult,
-      executionTime: result.executionTime,
-    })
+    // 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
+    }
 
+    // Handle condition failure
     if (!result.conditionResult && condition.required) {
-      // Get localized message from condition, rule failure actions, or default
+      // Get localized message from condition or use default with rule name
       const message = getLocalizedMessage(
         condition,
-        rule,
+        null,
         locale,
-        `Pre-condition '${rule.ruleName || condition.ruleId}' failed`
+        `Pre-condition '${result.ruleName || condition.ruleId}' failed`
       )
       errors.push({
         ruleId: condition.ruleId,

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

@@ -19,7 +19,6 @@ 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'
@@ -194,11 +193,15 @@ 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
+ * @returns Array of evaluation results for all transitions, sorted by priority (desc)
  */
 export async function findValidTransitions(
   em: EntityManager,
@@ -216,16 +219,17 @@ export async function findValidTransitions(
       return []
     }
 
-    // Find all transitions from current step
-    const transitions = (definition.definition.transitions || []).filter(
-      (t: any) => t.fromStepId === fromStepId
-    )
+    // 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))
 
-    // Evaluate each transition
+    // Evaluate each transition including preConditions
     const results: TransitionEvaluationResult[] = []
 
     for (const transition of transitions) {
-      const result = await evaluateTransition(
+      // First check inline condition
+      const conditionResult = await evaluateTransition(
         em,
         instance,
         fromStepId,
@@ -233,7 +237,42 @@ export async function findValidTransitions(
         context
       )
 
-      results.push(result)
+      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,
+      })
     }
 
     return results
@@ -649,6 +688,10 @@ 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
@@ -675,32 +718,88 @@ async function evaluatePreConditions(
       }
     }
 
-    // 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,
-        },
-        triggerData: context.triggerData,
-      },
-      user: context.userId ? { id: context.userId } : undefined,
-      tenantId: instance.tenantId,
-      organizationId: instance.organizationId,
-      executedBy: context.userId,
+    // 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 rules - only GUARD rules will affect the 'allowed' status
-    const result = await ruleEngine.executeRules(em, ruleContext)
+    // Execute each pre-condition rule directly by ruleId
+    const startTime = Date.now()
+    const executedRules: ruleEngine.RuleExecutionResult[] = []
+    const errors: string[] = []
+    let allowed = true
 
-    return result
+    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,
+        },
+        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`)
+      }
+    }
+
+    return {
+      allowed,
+      executedRules,
+      totalExecutionTime: Date.now() - startTime,
+      errors: errors.length > 0 ? errors : undefined,
+    }
   } catch (error) {
     console.error('Error evaluating pre-conditions:', error)
     return {
@@ -718,6 +817,9 @@ 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
@@ -744,32 +846,83 @@ async function evaluatePostConditions(
       }
     }
 
-    // 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,
-        },
-        triggerData: context.triggerData,
-      },
-      user: context.userId ? { id: context.userId } : undefined,
-      tenantId: instance.tenantId,
-      organizationId: instance.organizationId,
-      executedBy: context.userId,
+    // 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 rules
-    const result = await ruleEngine.executeRules(em, ruleContext)
+    // Execute each post-condition rule directly by ruleId
+    const startTime = Date.now()
+    const executedRules: ruleEngine.RuleExecutionResult[] = []
+    const errors: string[] = []
+    let allowed = true
 
-    return result
+    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,
+        },
+        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`)
+      }
+    }
+
+    return {
+      allowed,
+      executedRules,
+      totalExecutionTime: Date.now() - startTime,
+      errors: errors.length > 0 ? errors : undefined,
+    }
   } catch (error) {
     console.error('Error evaluating post-conditions:', error)
     return {

package/src/modules/workflows/migrations/Migration20260123143500.ts

@@ -0,0 +1,38 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260123143500 extends Migration {
+
+  override async up(): Promise<void> {
+    // Create workflow_event_triggers table
+    this.addSql(`
+      create table "workflow_event_triggers" (
+        "id" uuid not null default gen_random_uuid(),
+        "name" varchar(255) not null,
+        "description" text null,
+        "workflow_definition_id" uuid not null,
+        "event_pattern" varchar(255) not null,
+        "config" jsonb null,
+        "enabled" bool not null default true,
+        "priority" int4 not null default 0,
+        "tenant_id" uuid not null,
+        "organization_id" uuid not null,
+        "created_by" varchar(255) null,
+        "updated_by" varchar(255) null,
+        "created_at" timestamptz(6) not null,
+        "updated_at" timestamptz(6) not null,
+        "deleted_at" timestamptz(6) null,
+        constraint "workflow_event_triggers_pkey" primary key ("id")
+      );
+    `);
+
+    // Create indexes
+    this.addSql(`create index "workflow_event_triggers_event_pattern_idx" on "workflow_event_triggers" ("event_pattern", "enabled");`);
+    this.addSql(`create index "workflow_event_triggers_definition_idx" on "workflow_event_triggers" ("workflow_definition_id");`);
+    this.addSql(`create index "workflow_event_triggers_tenant_org_idx" on "workflow_event_triggers" ("tenant_id", "organization_id");`);
+    this.addSql(`create index "workflow_event_triggers_enabled_priority_idx" on "workflow_event_triggers" ("enabled", "priority");`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`drop table if exists "workflow_event_triggers" cascade;`);
+  }
+}

package/src/modules/workflows/subscribers/event-trigger.ts

@@ -0,0 +1,109 @@
+/**
+ * Workflows Module - Event Trigger Subscriber
+ *
+ * Wildcard subscriber that listens to all events and evaluates
+ * workflow event triggers. When a matching trigger is found,
+ * the corresponding workflow is started with mapped context.
+ */
+
+import type { EntityManager } from '@mikro-orm/core'
+import type { AwilixContainer } from 'awilix'
+
+export const metadata = {
+  event: '*', // Subscribe to ALL events
+  persistent: true, // Ensure reliability
+  id: 'workflows:event-trigger',
+}
+
+// Events that should never trigger workflows (internal/system events)
+const EXCLUDED_EVENT_PREFIXES = [
+  'query_index.', // Internal indexing events
+  'search.', // Internal search events
+  'workflows.', // Workflow internal events (avoid recursion)
+  'cache.', // Cache events
+  'queue.', // Queue events
+]
+
+/**
+ * Check if an event should be excluded from trigger processing.
+ */
+function isExcludedEvent(eventName: string): boolean {
+  return EXCLUDED_EVENT_PREFIXES.some(prefix => eventName.startsWith(prefix))
+}
+
+export default async function handle(
+  payload: unknown,
+  ctx: { resolve: <T = unknown>(name: string) => T; eventName?: string }
+): Promise<void> {
+  const eventName = ctx.eventName
+  if (!eventName) {
+    // Skip if no event name (shouldn't happen, but be safe)
+    return
+  }
+
+  // Skip excluded events
+  if (isExcludedEvent(eventName)) {
+    return
+  }
+
+  // Ensure payload is an object
+  const eventPayload = (payload && typeof payload === 'object' ? payload : {}) as Record<string, unknown>
+
+  // Extract tenant/org from payload
+  const tenantId = eventPayload?.tenantId as string | undefined
+  const organizationId = eventPayload?.organizationId as string | undefined
+
+  // Skip events without tenant context
+  if (!tenantId || !organizationId) {
+    return
+  }
+
+  // Get dependencies from container
+  let em: EntityManager
+  let container: AwilixContainer
+
+  try {
+    em = ctx.resolve<EntityManager>('em')
+    // Create a minimal container wrapper using the resolve function
+    // This avoids the need to register 'container' as a self-reference in DI
+    container = {
+      resolve: ctx.resolve,
+      // Provide minimal AwilixContainer interface for type compatibility
+      cradle: new Proxy({}, {
+        get: (_target, prop: string) => ctx.resolve(prop),
+      }),
+    } as unknown as AwilixContainer
+  } catch (error) {
+    // DI not available - skip
+    console.warn(`[workflow-trigger] Cannot resolve dependencies for event "${eventName}":`, error)
+    return
+  }
+
+  // Import service dynamically to avoid circular dependencies
+  const { processEventTriggers } = await import('../lib/event-trigger-service')
+
+  try {
+    const result = await processEventTriggers(em, container, {
+      eventName,
+      payload: eventPayload,
+      tenantId,
+      organizationId,
+    })
+
+    if (result.triggered > 0) {
+      console.log(
+        `[workflow-trigger] Triggered ${result.triggered} workflow(s) for "${eventName}"` +
+        (result.skipped > 0 ? ` (${result.skipped} skipped)` : '') +
+        (result.errors.length > 0 ? ` (${result.errors.length} errors)` : '')
+      )
+    }
+
+    if (result.errors.length > 0) {
+      for (const err of result.errors) {
+        console.error(`[workflow-trigger] Trigger ${err.triggerId} failed:`, err.error)
+      }
+    }
+  } catch (error) {
+    console.error(`[workflow-trigger] Error processing triggers for "${eventName}":`, error)
+  }
+}