@open-mercato/core 0.4.2-canary-f821f89ef6 → 0.4.2-canary-3b5064ce72

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

@@ -12,6 +12,7 @@
 
 import { EntityManager } from '@mikro-orm/core'
 import type { AwilixContainer } from 'awilix'
+import type { EventBus } from '@open-mercato/events'
 import {
   WorkflowInstance,
   WorkflowDefinition,
@@ -19,6 +20,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 +195,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 +217,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 +234,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
@@ -310,6 +272,13 @@ export async function executeTransition(
   context: TransitionExecutionContext
 ): Promise<TransitionExecutionResult> {
   try {
+    let eventBus: Pick<EventBus, 'emitEvent'> | null = null
+    try {
+      eventBus = container.resolve('eventBus') as EventBus
+    } catch {
+      eventBus = null
+    }
+
     // First, evaluate if transition is valid
     const evaluation = await evaluateTransition(
       em,
@@ -333,7 +302,8 @@ export async function executeTransition(
       em,
       instance,
       transition,
-      context
+      context,
+      eventBus
     )
 
     if (!preConditionsResult.allowed) {
@@ -544,7 +514,8 @@ export async function executeTransition(
       em,
       instance,
       transition,
-      context
+      context,
+      eventBus
     )
 
     if (!postConditionsResult.allowed) {
@@ -688,10 +659,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
@@ -702,7 +669,8 @@ async function evaluatePreConditions(
   em: EntityManager,
   instance: WorkflowInstance,
   transition: any,
-  context: TransitionExecutionContext
+  context: TransitionExecutionContext,
+  eventBus: Pick<EventBus, 'emitEvent'> | null
 ): Promise<ruleEngine.RuleEngineResult> {
   try {
     // Load workflow definition to get workflow ID
@@ -718,88 +686,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, { eventBus })
+
+    return result
   } catch (error) {
     console.error('Error evaluating pre-conditions:', error)
     return {
@@ -817,9 +729,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
@@ -830,7 +739,8 @@ async function evaluatePostConditions(
   em: EntityManager,
   instance: WorkflowInstance,
   transition: any,
-  context: TransitionExecutionContext
+  context: TransitionExecutionContext,
+  eventBus: Pick<EventBus, 'emitEvent'> | null
 ): Promise<ruleEngine.RuleEngineResult> {
   try {
     // Load workflow definition to get workflow ID
@@ -846,83 +756,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, { eventBus })
+
+    return result
   } catch (error) {
     console.error('Error evaluating post-conditions:', error)
     return {

package/src/modules/workflows/notifications.ts

@@ -0,0 +1,25 @@
+import type { NotificationTypeDefinition } from '@open-mercato/shared/modules/notifications/types'
+
+export const notificationTypes: NotificationTypeDefinition[] = [
+  {
+    type: 'workflows.task.assigned',
+    module: 'workflows',
+    titleKey: 'workflows.notifications.task.assigned.title',
+    bodyKey: 'workflows.notifications.task.assigned.body',
+    icon: 'clipboard-list',
+    severity: 'info',
+    actions: [
+      {
+        id: 'view',
+        labelKey: 'common.view',
+        variant: 'outline',
+        href: '/backend/workflows/tasks/{sourceEntityId}',
+        icon: 'external-link',
+      },
+    ],
+    linkHref: '/backend/workflows/tasks/{sourceEntityId}',
+    expiresAfterHours: 168, // 7 days
+  },
+]
+
+export default notificationTypes

package/src/modules/workflows/subscribers/task-assigned-notification.ts

@@ -0,0 +1,53 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { resolveNotificationService } from '../../notifications/lib/notificationService'
+import { buildNotificationFromType } from '../../notifications/lib/notificationBuilder'
+import { notificationTypes } from '../notifications'
+
+export const metadata = {
+  event: 'workflows.task.assigned',
+  persistent: true,
+  id: 'workflows:task-assigned-notification',
+}
+
+type TaskAssignedPayload = {
+  taskId: string
+  taskName: string
+  workflowName: string
+  assignedUserId: string
+  dueDate?: string | null
+  tenantId: string
+  organizationId?: string | null
+}
+
+type ResolverContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+export default async function handle(payload: TaskAssignedPayload, ctx: ResolverContext) {
+  if (!payload.assignedUserId) return
+
+  try {
+    const notificationService = resolveNotificationService(ctx)
+    const typeDef = notificationTypes.find((type) => type.type === 'workflows.task.assigned')
+    if (!typeDef) return
+
+    const notificationInput = buildNotificationFromType(typeDef, {
+      recipientUserId: payload.assignedUserId,
+      bodyVariables: {
+        taskName: payload.taskName,
+        workflowName: payload.workflowName,
+        dueDate: payload.dueDate ?? '',
+      },
+      sourceEntityType: 'workflows:user_task',
+      sourceEntityId: payload.taskId,
+      linkHref: `/backend/workflows/tasks/${payload.taskId}`,
+    })
+
+    await notificationService.create(notificationInput, {
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    })
+  } catch (err) {
+    console.error('[workflows:task-assigned-notification] Failed to create notification:', err)
+  }
+}

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