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

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

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

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

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

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,