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

package/src/modules/workflows/data/entities.ts

@@ -46,63 +46,6 @@ export type UserTaskStatus =
   | 'CANCELLED'
   | 'ESCALATED'
 
-// ============================================================================
-// Event Trigger Types
-// ============================================================================
-
-export type TriggerFilterOperator =
-  | 'eq'
-  | 'neq'
-  | 'gt'
-  | 'gte'
-  | 'lt'
-  | 'lte'
-  | 'contains'
-  | 'startsWith'
-  | 'endsWith'
-  | 'in'
-  | 'notIn'
-  | 'exists'
-  | 'notExists'
-  | 'regex'
-
-export interface TriggerFilterCondition {
-  field: string // JSON path (e.g., "status", "metadata.type")
-  operator: TriggerFilterOperator
-  value: unknown
-}
-
-export interface TriggerContextMapping {
-  targetKey: string // Key in workflow initial context
-  sourceExpression: string // Path from event payload (supports dot notation)
-  defaultValue?: unknown
-}
-
-export interface WorkflowEventTriggerConfig {
-  filterConditions?: TriggerFilterCondition[]
-  contextMapping?: TriggerContextMapping[]
-  debounceMs?: number // Debounce rapid events
-  maxConcurrentInstances?: number // Limit concurrent instances
-  entityType?: string // Entity type for workflow instance metadata (e.g., "SalesOrder")
-}
-
-/**
- * WorkflowDefinitionTrigger - Embedded trigger configuration
- *
- * Triggers are now embedded directly in the workflow definition,
- * allowing users to configure event-based workflow starts during
- * workflow creation in the visual editor.
- */
-export interface WorkflowDefinitionTrigger {
-  triggerId: string
-  name: string
-  description?: string | null
-  eventPattern: string // e.g., "sales.orders.created", "customers.*"
-  config?: WorkflowEventTriggerConfig | null
-  enabled: boolean
-  priority: number
-}
-
 // ============================================================================
 // JSONB Structure Interfaces
 // ============================================================================
@@ -110,7 +53,6 @@ export interface WorkflowDefinitionTrigger {
 export interface WorkflowDefinitionData {
   steps: any[] // WorkflowStep[] - will define schema in validators.ts
   transitions: any[] // WorkflowTransition[] - will define schema in validators.ts
-  triggers?: WorkflowDefinitionTrigger[] // Event triggers for automatic workflow start
   activities?: any[] // ActivityDefinition[] - will define schema in validators.ts
   queries?: any[]
   signals?: any[]
@@ -487,71 +429,6 @@ export class WorkflowEvent {
   organizationId!: string
 }
 
-// ============================================================================
-// Entity: WorkflowEventTrigger
-// ============================================================================
-
-/**
- * WorkflowEventTrigger entity
- *
- * Maps event patterns to workflow definitions for automatic triggering.
- * When a matching event is emitted, the corresponding workflow is started
- * with context mapped from the event payload.
- */
-@Entity({ tableName: 'workflow_event_triggers' })
-@Index({ name: 'workflow_event_triggers_event_pattern_idx', properties: ['eventPattern', 'enabled'] })
-@Index({ name: 'workflow_event_triggers_definition_idx', properties: ['workflowDefinitionId'] })
-@Index({ name: 'workflow_event_triggers_tenant_org_idx', properties: ['tenantId', 'organizationId'] })
-@Index({ name: 'workflow_event_triggers_enabled_priority_idx', properties: ['enabled', 'priority'] })
-export class WorkflowEventTrigger {
-  [OptionalProps]?: 'enabled' | 'priority' | 'createdAt' | 'updatedAt' | 'deletedAt'
-
-  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
-  id!: string
-
-  @Property({ name: 'name', type: 'varchar', length: 255 })
-  name!: string
-
-  @Property({ name: 'description', type: 'text', nullable: true })
-  description?: string | null
-
-  @Property({ name: 'workflow_definition_id', type: 'uuid' })
-  workflowDefinitionId!: string
-
-  @Property({ name: 'event_pattern', type: 'varchar', length: 255 })
-  eventPattern!: string
-
-  @Property({ name: 'config', type: 'jsonb', nullable: true })
-  config?: WorkflowEventTriggerConfig | null
-
-  @Property({ name: 'enabled', type: 'boolean', default: true })
-  enabled: boolean = true
-
-  @Property({ name: 'priority', type: 'integer', default: 0 })
-  priority: number = 0
-
-  @Property({ name: 'tenant_id', type: 'uuid' })
-  tenantId!: string
-
-  @Property({ name: 'organization_id', type: 'uuid' })
-  organizationId!: string
-
-  @Property({ name: 'created_by', type: 'varchar', length: 255, nullable: true })
-  createdBy?: string | null
-
-  @Property({ name: 'updated_by', type: 'varchar', length: 255, nullable: true })
-  updatedBy?: string | null
-
-  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
-  createdAt: Date = new Date()
-
-  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
-  updatedAt: Date = new Date()
-
-  @Property({ name: 'deleted_at', type: Date, nullable: true })
-  deletedAt?: Date | null
-}
-
 // Export all entities as default for MikroORM discovery
 export default [
   WorkflowDefinition,
@@ -559,5 +436,4 @@ export default [
   StepInstance,
   UserTask,
   WorkflowEvent,
-  WorkflowEventTrigger,
 ]

package/src/modules/workflows/data/validators.ts

@@ -215,43 +215,10 @@ export const workflowTransitionSchema = z.object({
   priority: z.number().int().min(0).max(9999).default(0),
 })
 
-// Workflow definition trigger schema (embedded in definition)
-// Note: Uses forward reference pattern since eventPatternSchema and eventTriggerConfigSchema are defined later
-export const workflowDefinitionTriggerSchema = z.object({
-  triggerId: z.string().min(1).max(100).regex(/^[a-z0-9_-]+$/, 'Trigger ID must contain only lowercase letters, numbers, hyphens, and underscores'),
-  name: z.string().min(1).max(255),
-  description: z.string().max(2000).optional().nullable(),
-  eventPattern: z.string()
-    .min(1, 'Event pattern is required')
-    .max(255, 'Event pattern must be at most 255 characters')
-    .regex(
-      /^(\*|[a-z0-9_]+(\.[a-z0-9_*]+)*)$/i,
-      'Event pattern must be "*" or a dot-separated pattern with optional wildcards (e.g., "customers.people.created", "sales.orders.*")'
-    ),
-  config: z.object({
-    filterConditions: z.array(z.object({
-      field: z.string().min(1).max(255),
-      operator: z.enum(['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'in', 'notIn', 'exists', 'notExists', 'regex']),
-      value: z.any(),
-    })).max(20).optional(),
-    contextMapping: z.array(z.object({
-      targetKey: z.string().min(1).max(100),
-      sourceExpression: z.string().min(1).max(255),
-      defaultValue: z.any().optional(),
-    })).max(50).optional(),
-    debounceMs: z.number().int().min(0).max(3600000).optional(),
-    maxConcurrentInstances: z.number().int().min(1).max(1000).optional(),
-  }).optional().nullable(),
-  enabled: z.boolean().default(true),
-  priority: z.number().int().min(0).max(9999).default(0),
-})
-export type WorkflowDefinitionTrigger = z.infer<typeof workflowDefinitionTriggerSchema>
-
 // Workflow definition data (JSONB structure)
 export const workflowDefinitionDataSchema = z.object({
   steps: z.array(workflowStepSchema).min(2, 'Workflow must have at least START and END steps'),
   transitions: z.array(workflowTransitionSchema).min(1, 'Workflow must have at least one transition'),
-  triggers: z.array(workflowDefinitionTriggerSchema).optional(), // Event triggers for automatic workflow start
   queries: z.array(z.any()).optional(), // For Phase 7
   signals: z.array(z.any()).optional(), // For Phase 9
   timers: z.array(z.any()).optional(), // For Phase 9
@@ -521,108 +488,3 @@ export const startWorkflowInputSchema = z.object({
 })
 
 export type StartWorkflowApiInput = z.infer<typeof startWorkflowInputSchema>
-
-// ============================================================================
-// WorkflowEventTrigger Schemas
-// ============================================================================
-
-export const triggerFilterOperatorSchema = z.enum([
-  'eq',
-  'neq',
-  'gt',
-  'gte',
-  'lt',
-  'lte',
-  'contains',
-  'startsWith',
-  'endsWith',
-  'in',
-  'notIn',
-  'exists',
-  'notExists',
-  'regex',
-])
-export type TriggerFilterOperator = z.infer<typeof triggerFilterOperatorSchema>
-
-export const triggerFilterConditionSchema = z.object({
-  field: z.string().min(1).max(255, 'Field path must be at most 255 characters'),
-  operator: triggerFilterOperatorSchema,
-  value: z.any(),
-})
-export type TriggerFilterCondition = z.infer<typeof triggerFilterConditionSchema>
-
-export const triggerContextMappingSchema = z.object({
-  targetKey: z.string().min(1).max(100, 'Target key must be at most 100 characters'),
-  sourceExpression: z.string().min(1).max(255, 'Source expression must be at most 255 characters'),
-  defaultValue: z.any().optional(),
-})
-export type TriggerContextMapping = z.infer<typeof triggerContextMappingSchema>
-
-export const eventTriggerConfigSchema = z.object({
-  filterConditions: z.array(triggerFilterConditionSchema).max(20, 'Maximum 20 filter conditions allowed').optional(),
-  contextMapping: z.array(triggerContextMappingSchema).max(50, 'Maximum 50 context mappings allowed').optional(),
-  debounceMs: z.number().int().min(0).max(3600000, 'Debounce cannot exceed 1 hour').optional(),
-  maxConcurrentInstances: z.number().int().min(1).max(1000, 'Max concurrent instances must be between 1 and 1000').optional(),
-})
-export type EventTriggerConfig = z.infer<typeof eventTriggerConfigSchema>
-
-export const eventPatternSchema = z.string()
-  .min(1, 'Event pattern is required')
-  .max(255, 'Event pattern must be at most 255 characters')
-  .regex(
-    /^(\*|[a-z0-9_]+(\.[a-z0-9_*]+)*)$/i,
-    'Event pattern must be "*" or a dot-separated pattern with optional wildcards (e.g., "customers.people.created", "sales.orders.*")'
-  )
-
-export const createEventTriggerSchema = z.object({
-  name: z.string().min(1).max(255),
-  description: z.string().max(2000).optional().nullable(),
-  workflowDefinitionId: uuid,
-  eventPattern: eventPatternSchema,
-  config: eventTriggerConfigSchema.optional().nullable(),
-  enabled: z.boolean().default(true),
-  priority: z.number().int().min(0).max(9999).default(0),
-  tenantId: uuid,
-  organizationId: uuid,
-  createdBy: z.string().max(255).optional().nullable(),
-})
-export type CreateEventTriggerInput = z.infer<typeof createEventTriggerSchema>
-
-// API input schema (omits tenant fields - injected from auth context)
-export const createEventTriggerInputSchema = z.object({
-  name: z.string().min(1).max(255),
-  description: z.string().max(2000).optional().nullable(),
-  workflowDefinitionId: uuid,
-  eventPattern: eventPatternSchema,
-  config: eventTriggerConfigSchema.optional().nullable(),
-  enabled: z.boolean().default(true).optional(),
-  priority: z.number().int().min(0).max(9999).default(0).optional(),
-})
-export type CreateEventTriggerApiInput = z.infer<typeof createEventTriggerInputSchema>
-
-export const updateEventTriggerSchema = createEventTriggerSchema.partial().extend({
-  id: uuid,
-})
-export type UpdateEventTriggerInput = z.infer<typeof updateEventTriggerSchema>
-
-// API update schema (omits tenant fields and allows partial updates)
-export const updateEventTriggerInputSchema = z.object({
-  name: z.string().min(1).max(255).optional(),
-  description: z.string().max(2000).optional().nullable(),
-  workflowDefinitionId: uuid.optional(),
-  eventPattern: eventPatternSchema.optional(),
-  config: eventTriggerConfigSchema.optional().nullable(),
-  enabled: z.boolean().optional(),
-  priority: z.number().int().min(0).max(9999).optional(),
-}).strict()
-export type UpdateEventTriggerApiInput = z.infer<typeof updateEventTriggerInputSchema>
-
-export const eventTriggerFilterSchema = z.object({
-  name: z.string().optional(),
-  workflowDefinitionId: uuid.optional(),
-  eventPattern: z.string().optional(),
-  enabled: z.boolean().optional(),
-  tenantId: uuid.optional(),
-  organizationId: uuid.optional(),
-})
-export type EventTriggerFilter = z.infer<typeof eventTriggerFilterSchema>

package/src/modules/workflows/examples/checkout-demo-definition.json

@@ -137,7 +137,11 @@
         "priority": 100,
         "preConditions": [
           {
-            "ruleId": "workflow_checkout_cart_not_empty",
+            "ruleId": "cart_not_empty",
+            "required": true
+          },
+          {
+            "ruleId": "inventory_available",
             "required": true
           }
         ],

package/src/modules/workflows/i18n/en.json

@@ -161,7 +161,6 @@
       "title": "Workflow Instances",
       "singular": "Workflow Instance",
       "plural": "Workflow Instances",
-      "duration": "Duration",
       "fields": {
         "instanceId": "Instance ID",
         "workflowId": "Workflow ID",
@@ -564,55 +563,6 @@
         "CompensationCompleted": "Compensation Completed"
       }
     },
-    "triggers": {
-      "title": "Event Triggers",
-      "add": "Add Trigger",
-      "description": "Configure events that automatically start this workflow. When a matching event occurs in the system, a new workflow instance will be created with the mapped context.",
-      "empty": {
-        "title": "No triggers configured",
-        "description": "Click \"Add Trigger\" to create an event trigger that automatically starts this workflow."
-      },
-      "dialog": {
-        "create": {
-          "title": "Create Event Trigger"
-        },
-        "edit": {
-          "title": "Edit Event Trigger"
-        },
-        "description": "Configure when this workflow should be automatically started based on system events."
-      },
-      "delete": {
-        "title": "Delete Event Trigger?",
-        "description": "This will remove the event trigger. The change will take effect when you save the workflow definition."
-      },
-      "fields": {
-        "name": "Name",
-        "description": "Description",
-        "eventPattern": "Event Pattern",
-        "enabled": "Enabled",
-        "priority": "Priority",
-        "filterConditions": "Filter Conditions",
-        "contextMapping": "Context Mapping",
-        "debounceMs": "Debounce (ms)",
-        "maxConcurrent": "Max Concurrent Instances"
-      },
-      "placeholders": {
-        "name": "Order Created Trigger",
-        "description": "Describe when this trigger should fire...",
-        "quickSelect": "Quick select...",
-        "unlimited": "Unlimited"
-      },
-      "hints": {
-        "priority": "Higher priority triggers execute first",
-        "eventPattern": "Use * as wildcard: \"sales.orders.*\" matches any order event",
-        "filterConditions": "Only trigger when the event payload matches these conditions (all must match)",
-        "contextMapping": "Map values from the event payload to the workflow's initial context",
-        "debounce": "Delay to prevent rapid re-triggers",
-        "maxConcurrent": "Limit simultaneous workflow instances"
-      },
-      "addCondition": "Add Condition",
-      "addMapping": "Add Mapping"
-    },
     "common": {
       "save": "Save",
       "cancel": "Cancel",
@@ -679,27 +629,6 @@
       "duplicateNotYetImplemented": "Duplicate functionality is not yet implemented"
     }
   },
-  "orderApproval": {
-    "groupLabel": "Order Approval",
-    "groupDescription": "Review and approve or reject this order",
-    "pendingTitle": "Pending Approval",
-    "pendingDescription": "This order requires approval before processing",
-    "decisionLabel": "Decision",
-    "approveButton": "Approve",
-    "rejectButton": "Reject",
-    "commentsLabel": "Comments",
-    "commentsPlaceholder": "Add optional comments...",
-    "approvedStatus": "Approved",
-    "rejectedStatus": "Rejected",
-    "requestApproval": "Request Approval",
-    "submitDecision": "Submit Decision",
-    "noWorkflowActive": "No approval workflow is active for this order.",
-    "processing": "Workflow is processing...",
-    "completed": "Approval workflow completed.",
-    "startError": "Failed to start approval workflow",
-    "completeError": "Failed to complete approval task",
-    "missingStatuses": "Missing order status entries. Please ensure pending_approval, approved, and rejected statuses exist in the sales.order_status dictionary."
-  },
   "common": {
     "all": "All",
     "enabled": "Enabled",

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