@open-mercato/core 0.6.3-develop.3876.1.d40fe4ec2d → 0.6.3-develop.3881.1.0b590ac4eb

package/src/modules/workflows/lib/node-type-icons.ts

@@ -1,6 +1,6 @@
-import { CircleDot, CircleStop, User, Zap, Workflow, Clock, LucideIcon } from 'lucide-react'
+import { CircleDot, CircleStop, User, Zap, Workflow, Clock, Timer, LucideIcon } from 'lucide-react'
 
-export type NodeType = 'start' | 'end' | 'userTask' | 'automated' | 'subWorkflow' | 'waitForSignal'
+export type NodeType = 'start' | 'end' | 'userTask' | 'automated' | 'subWorkflow' | 'waitForSignal' | 'waitForTimer'
 
 export const NODE_TYPE_ICONS: Record<NodeType, LucideIcon> = {
   start: CircleDot,
@@ -9,6 +9,7 @@ export const NODE_TYPE_ICONS: Record<NodeType, LucideIcon> = {
   automated: Zap,
   subWorkflow: Workflow,
   waitForSignal: Clock,
+  waitForTimer: Timer,
 }
 
 export const NODE_TYPE_COLORS: Record<NodeType, string> = {
@@ -18,6 +19,7 @@ export const NODE_TYPE_COLORS: Record<NodeType, string> = {
   automated: 'text-amber-500',
   subWorkflow: 'text-purple-500',
   waitForSignal: 'text-purple-500',
+  waitForTimer: 'text-cyan-500',
 }
 
 export const NODE_TYPE_LABELS: Record<NodeType, { title: string; description: string }> = {
@@ -27,6 +29,7 @@ export const NODE_TYPE_LABELS: Record<NodeType, { title: string; description: st
   automated: { title: 'AUTOMATED', description: 'System task' },
   subWorkflow: { title: 'SUB-WORKFLOW', description: 'Invoke workflow' },
   waitForSignal: { title: 'WAIT FOR SIGNAL', description: 'Pause for external event' },
+  waitForTimer: { title: 'WAIT FOR TIMER', description: 'Pause for a duration' },
 }
 
 const STEP_TYPE_TO_NODE_TYPE: Record<string, NodeType> = {
@@ -36,6 +39,7 @@ const STEP_TYPE_TO_NODE_TYPE: Record<string, NodeType> = {
   AUTOMATED: 'automated',
   SUB_WORKFLOW: 'subWorkflow',
   WAIT_FOR_SIGNAL: 'waitForSignal',
+  WAIT_FOR_TIMER: 'waitForTimer',
 }
 
 export function stepTypeToNodeType(stepType: string): NodeType {

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

@@ -5,12 +5,14 @@
  */
 
 import { EntityManager } from '@mikro-orm/core'
+import type { EntityManager as PostgreSqlEntityManager } from '@mikro-orm/postgresql'
 import type { AwilixContainer } from 'awilix'
+import { findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { WorkflowInstance, WorkflowDefinition, StepInstance } from '../data/entities'
-import { logWorkflowEvent } from './event-logger'
-import { executeWorkflow } from './workflow-executor'
-import * as stepHandler from './step-handler'
-import * as transitionHandler from './transition-handler'
+import type * as eventLoggerModule from './event-logger'
+import type * as stepHandlerModule from './step-handler'
+import type * as transitionHandlerModule from './transition-handler'
+import type * as workflowExecutorModule from './workflow-executor'
 
 export interface SendSignalOptions {
   /**
@@ -61,12 +63,23 @@ export async function sendSignal(
 ): Promise<void> {
   const { instanceId, signalName, payload, userId, tenantId, organizationId } = options
 
+  const eventLogger = container.resolve<typeof eventLoggerModule>('eventLogger')
+  const stepHandler = container.resolve<typeof stepHandlerModule>('stepHandler')
+  const transitionHandler = container.resolve<typeof transitionHandlerModule>('transitionHandler')
+  const workflowExecutor = container.resolve<typeof workflowExecutorModule>('workflowExecutor')
+
   // Fetch workflow instance
-  const instance = await em.findOne(WorkflowInstance, {
-    id: instanceId,
-    tenantId,
-    organizationId,
-  })
+  const instance = await findOneWithDecryption(
+    em as PostgreSqlEntityManager,
+    WorkflowInstance,
+    {
+      id: instanceId,
+      tenantId,
+      organizationId,
+    },
+    undefined,
+    { tenantId, organizationId },
+  )
 
   if (!instance) {
     throw new SignalError(
@@ -85,8 +98,19 @@ export async function sendSignal(
     )
   }
 
-  // Load workflow definition to check current step
-  const definition = await em.findOne(WorkflowDefinition, instance.definitionId)
+  // Load workflow definition with tenant/org scope to check current step
+  const definition = await findOneWithDecryption(
+    em as PostgreSqlEntityManager,
+    WorkflowDefinition,
+    {
+      id: instance.definitionId,
+      tenantId: instance.tenantId,
+      organizationId: instance.organizationId,
+      deletedAt: null,
+    },
+    undefined,
+    { tenantId: instance.tenantId, organizationId: instance.organizationId },
+  )
   if (!definition) {
     throw new SignalError(
       'Workflow definition not found',
@@ -133,7 +157,7 @@ export async function sendSignal(
   instance.updatedAt = now
 
   // Log signal received event
-  await logWorkflowEvent(em, {
+  await eventLogger.logWorkflowEvent(em, {
     workflowInstanceId: instance.id,
     eventType: 'SIGNAL_RECEIVED',
     eventData: {
@@ -146,11 +170,19 @@ export async function sendSignal(
   })
 
   // Find active step instance and exit it
-  const stepInstance = await em.findOne(StepInstance, {
-    workflowInstanceId: instance.id,
-    stepId: instance.currentStepId,
-    status: 'ACTIVE',
-  })
+  const stepInstance = await findOneWithDecryption(
+    em as PostgreSqlEntityManager,
+    StepInstance,
+    {
+      workflowInstanceId: instance.id,
+      stepId: instance.currentStepId,
+      status: 'ACTIVE',
+      tenantId: instance.tenantId,
+      organizationId: instance.organizationId,
+    },
+    undefined,
+    { tenantId: instance.tenantId, organizationId: instance.organizationId },
+  )
 
   if (stepInstance) {
     await stepHandler.exitStep(em, stepInstance, {
@@ -212,7 +244,7 @@ export async function sendSignal(
   }
 
   // Resume workflow execution
-  await executeWorkflow(em, container, instance.id, { userId })
+  await workflowExecutor.executeWorkflow(em, container, instance.id, { userId })
 }
 
 /**
@@ -226,12 +258,18 @@ export async function sendSignalByCorrelationKey(
   const { correlationKey, signalName, payload, userId, tenantId, organizationId } = options
 
   // Find all paused instances with this correlation key
-  const instances = await em.find(WorkflowInstance, {
-    correlationKey,
-    status: 'PAUSED',
-    tenantId,
-    organizationId,
-  })
+  const instances = await findWithDecryption(
+    em as PostgreSqlEntityManager,
+    WorkflowInstance,
+    {
+      correlationKey,
+      status: 'PAUSED',
+      tenantId,
+      organizationId,
+    },
+    undefined,
+    { tenantId, organizationId },
+  )
 
   let signalsProcessed = 0
 

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

@@ -19,6 +19,8 @@ import {
   type StepInstanceStatus,
   type WorkflowStepType,
 } from '../data/entities'
+import { parseDuration } from './duration'
+import { logWorkflowEvent } from './event-logger'
 
 // ============================================================================
 // Types and Interfaces
@@ -333,9 +335,11 @@ async function executeStepByType(
     case 'WAIT_FOR_SIGNAL':
       return await handleWaitForSignalStep(em, instance, stepInstance, stepDef, context)
 
+    case 'WAIT_FOR_TIMER':
+      return await handleWaitForTimerStep(em, instance, stepInstance, stepDef, context)
+
     case 'PARALLEL_FORK':
     case 'PARALLEL_JOIN':
-    case 'WAIT_FOR_TIMER':
       // These will be implemented in later phases
       throw new StepExecutionError(
         `Step type not yet implemented: ${stepType}`,
@@ -756,66 +760,119 @@ async function handleWaitForSignalStep(
   }
 }
 
-// ============================================================================
-// Helper Functions
-// ============================================================================
-
 /**
- * Parse ISO 8601 duration to milliseconds
- *
- * Supports:
- * - ISO 8601: PT5M (5 minutes), PT1H (1 hour), P1D (1 day), P3D (3 days)
- * - Simple formats: 5m, 1h, 3d, 30s
+ * Handle WAIT_FOR_TIMER step - pause workflow until a timer fires.
  *
- * @param duration - Duration string
- * @returns Duration in milliseconds
+ * Reads `duration` (relative, e.g. "PT5M") or `until` (ISO 8601 datetime) from
+ * `stepDef.config` (preferred — matches StepsEditor) or `stepDef.timerConfig`.
+ * Enqueues a delayed timer job on the workflow-activities queue; when the job
+ * is processed by the activity worker, it calls `timerHandler.fireTimer` to
+ * resume the workflow.
  */
-function parseDuration(duration: string): number {
-  // Try ISO 8601 format first: P[n]DT[n]H[n]M[n]S
-  const iso8601Regex = /P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?/
-  const iso8601Match = duration.match(iso8601Regex)
-
-  if (iso8601Match && iso8601Match[0] === duration) {
-    const days = parseInt(iso8601Match[1] || '0')
-    const hours = parseInt(iso8601Match[2] || '0')
-    const minutes = parseInt(iso8601Match[3] || '0')
-    const seconds = parseInt(iso8601Match[4] || '0')
-
-    return (
-      days * 24 * 60 * 60 * 1000 +
-      hours * 60 * 60 * 1000 +
-      minutes * 60 * 1000 +
-      seconds * 1000
+async function handleWaitForTimerStep(
+  em: EntityManager,
+  instance: WorkflowInstance,
+  stepInstance: StepInstance,
+  stepDef: any,
+  context: StepExecutionContext
+): Promise<StepExecutionResult> {
+  const timerConfig = stepDef.config || stepDef.timerConfig || {}
+  const duration: string | undefined = timerConfig.duration
+  const until: string | undefined = timerConfig.until
+
+  if (!duration && !until) {
+    throw new StepExecutionError(
+      'WAIT_FOR_TIMER requires either "duration" (e.g., "PT5M") or "until" (ISO 8601 datetime)',
+      'TIMER_CONFIG_MISSING',
+      { stepId: stepDef.stepId }
     )
   }
 
-  // Try simple format: 1d, 5h, 30m, 45s
-  const simpleRegex = /^(\d+)(d|h|m|s)$/
-  const simpleMatch = duration.match(simpleRegex)
-
-  if (simpleMatch) {
-    const value = parseInt(simpleMatch[1])
-    const unit = simpleMatch[2]
-
-    switch (unit) {
-      case 'd':
-        return value * 24 * 60 * 60 * 1000
-      case 'h':
-        return value * 60 * 60 * 1000
-      case 'm':
-        return value * 60 * 1000
-      case 's':
-        return value * 1000
+  let fireAtMs: number
+  if (until) {
+    const targetDate = new Date(until)
+    if (isNaN(targetDate.getTime())) {
+      throw new StepExecutionError(
+        `WAIT_FOR_TIMER invalid "until" datetime: ${until}`,
+        'TIMER_CONFIG_INVALID',
+        { until }
+      )
     }
+    fireAtMs = targetDate.getTime()
+  } else {
+    fireAtMs = Date.now() + parseDuration(duration as string)
   }
 
-  throw new StepExecutionError(
-    `Invalid duration format: ${duration}`,
-    'INVALID_DURATION',
-    { duration }
-  )
+  const delayMs = fireAtMs - Date.now()
+  const fireAt = new Date(fireAtMs)
+
+  // Immediate-fire path: skip the queue round-trip if the timer is in the past
+  if (delayMs <= 0) {
+    return {
+      status: 'COMPLETED',
+      outputData: {
+        stepType: 'WAIT_FOR_TIMER',
+        timerFiredImmediately: true,
+        fireAt,
+        duration,
+        until,
+      },
+    }
+  }
+
+  const now = new Date()
+
+  // Enqueue delayed timer job via the shared activity queue.
+  // Imported here to avoid a top-level cycle between step-handler and activity-executor.
+  const { enqueueTimerJob } = await import('./activity-executor')
+  const jobId = await enqueueTimerJob({
+    workflowInstanceId: instance.id,
+    stepInstanceId: stepInstance.id,
+    tenantId: instance.tenantId,
+    organizationId: instance.organizationId,
+    userId: context.userId,
+    fireAt: fireAt.toISOString(),
+    delayMs,
+  })
+
+  await logWorkflowEvent(em, {
+    workflowInstanceId: instance.id,
+    stepInstanceId: stepInstance.id,
+    eventType: 'TIMER_AWAITING',
+    eventData: {
+      fireAt: fireAt.toISOString(),
+      duration: duration || null,
+      until: until || null,
+      jobId,
+    },
+    userId: context.userId,
+    tenantId: instance.tenantId,
+    organizationId: instance.organizationId,
+  })
+
+  instance.status = 'PAUSED'
+  instance.pausedAt = now
+  instance.updatedAt = now
+  await em.flush()
+
+  return {
+    status: 'WAITING',
+    waitReason: 'TIMER',
+    outputData: {
+      fireAt,
+      duration,
+      until,
+      jobId,
+    },
+  }
 }
 
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+// parseDuration is imported from ./duration
+
 /**
  * Log step-related event to event sourcing table
  */

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

@@ -0,0 +1,213 @@
+/**
+ * Timer Handler Service
+ *
+ * Fires timers for WAIT_FOR_TIMER steps: resumes a paused workflow instance
+ * when its scheduled timer job is processed by the activity worker.
+ */
+
+import { EntityManager } from '@mikro-orm/core'
+import type { EntityManager as PostgreSqlEntityManager } from '@mikro-orm/postgresql'
+import type { AwilixContainer } from 'awilix'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { WorkflowInstance, WorkflowDefinition, StepInstance } from '../data/entities'
+import type * as eventLoggerModule from './event-logger'
+import type * as stepHandlerModule from './step-handler'
+import type * as transitionHandlerModule from './transition-handler'
+import type * as workflowExecutorModule from './workflow-executor'
+
+export interface FireTimerOptions {
+  instanceId: string
+  stepInstanceId?: string
+  userId?: string
+  tenantId: string
+  organizationId: string
+}
+
+export class TimerError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public details?: any
+  ) {
+    super(message)
+    this.name = 'TimerError'
+  }
+}
+
+/**
+ * Fire a timer and resume workflow execution.
+ *
+ * Mirrors `sendSignal` from signal-handler.ts — verifies the instance is
+ * paused at a WAIT_FOR_TIMER step, logs TIMER_FIRED, exits the step, then
+ * executes auto transitions and resumes the workflow.
+ */
+export async function fireTimer(
+  em: EntityManager,
+  container: AwilixContainer,
+  options: FireTimerOptions
+): Promise<void> {
+  const { instanceId, stepInstanceId, userId, tenantId, organizationId } = options
+
+  const eventLogger = container.resolve<typeof eventLoggerModule>('eventLogger')
+  const stepHandler = container.resolve<typeof stepHandlerModule>('stepHandler')
+  const transitionHandler = container.resolve<typeof transitionHandlerModule>('transitionHandler')
+  const workflowExecutor = container.resolve<typeof workflowExecutorModule>('workflowExecutor')
+
+  const instance = await findOneWithDecryption(
+    em as PostgreSqlEntityManager,
+    WorkflowInstance,
+    {
+      id: instanceId,
+      tenantId,
+      organizationId,
+    },
+    undefined,
+    { tenantId, organizationId },
+  )
+
+  if (!instance) {
+    throw new TimerError(
+      'Workflow instance not found',
+      'INSTANCE_NOT_FOUND',
+      { instanceId }
+    )
+  }
+
+  if (instance.status !== 'PAUSED') {
+    throw new TimerError(
+      'Workflow is not paused',
+      'WORKFLOW_NOT_PAUSED',
+      { instanceId, status: instance.status }
+    )
+  }
+
+  const definition = await findOneWithDecryption(
+    em as PostgreSqlEntityManager,
+    WorkflowDefinition,
+    {
+      id: instance.definitionId,
+      tenantId: instance.tenantId,
+      organizationId: instance.organizationId,
+      deletedAt: null,
+    },
+    undefined,
+    { tenantId: instance.tenantId, organizationId: instance.organizationId },
+  )
+  if (!definition) {
+    throw new TimerError(
+      'Workflow definition not found',
+      'DEFINITION_NOT_FOUND',
+      { definitionId: instance.definitionId }
+    )
+  }
+
+  const currentStep = definition.definition.steps.find(
+    (s: any) => s.stepId === instance.currentStepId
+  )
+
+  if (!currentStep || currentStep.stepType !== 'WAIT_FOR_TIMER') {
+    throw new TimerError(
+      'Workflow is not waiting for timer',
+      'NOT_WAITING_FOR_TIMER',
+      { instanceId, currentStepId: instance.currentStepId }
+    )
+  }
+
+  const now = new Date()
+  instance.updatedAt = now
+
+  await eventLogger.logWorkflowEvent(em, {
+    workflowInstanceId: instance.id,
+    stepInstanceId,
+    eventType: 'TIMER_FIRED',
+    eventData: {
+      stepId: instance.currentStepId,
+      firedAt: now.toISOString(),
+    },
+    userId,
+    tenantId: instance.tenantId,
+    organizationId: instance.organizationId,
+  })
+
+  const stepInstance = stepInstanceId
+    ? await findOneWithDecryption(
+        em as PostgreSqlEntityManager,
+        StepInstance,
+        {
+          id: stepInstanceId,
+          workflowInstanceId: instance.id,
+          tenantId: instance.tenantId,
+          organizationId: instance.organizationId,
+        },
+        undefined,
+        { tenantId: instance.tenantId, organizationId: instance.organizationId },
+      )
+    : await findOneWithDecryption(
+        em as PostgreSqlEntityManager,
+        StepInstance,
+        {
+          workflowInstanceId: instance.id,
+          stepId: instance.currentStepId,
+          status: 'ACTIVE',
+          tenantId: instance.tenantId,
+          organizationId: instance.organizationId,
+        },
+        undefined,
+        { tenantId: instance.tenantId, organizationId: instance.organizationId },
+      )
+
+  if (stepInstance) {
+    await stepHandler.exitStep(em, stepInstance, {
+      firedAt: now.toISOString(),
+    })
+  }
+
+  const autoTransitions = (definition.definition.transitions || []).filter(
+    (t: any) => t.fromStepId === instance.currentStepId && t.trigger === 'auto'
+  )
+
+  if (autoTransitions.length === 0) {
+    instance.status = 'RUNNING'
+    await em.flush()
+    return
+  }
+
+  const transitionContext = {
+    workflowContext: instance.context,
+    userId,
+  }
+
+  const validTransitions = await transitionHandler.findValidTransitions(
+    em,
+    instance,
+    instance.currentStepId,
+    transitionContext
+  )
+
+  const firstValidTransition = validTransitions.find((t) => t.isValid)
+
+  if (!firstValidTransition || !firstValidTransition.transition) {
+    instance.status = 'RUNNING'
+    await em.flush()
+    return
+  }
+
+  const transitionResult = await transitionHandler.executeTransition(
+    em,
+    container,
+    instance,
+    instance.currentStepId,
+    firstValidTransition.transition.toStepId,
+    transitionContext
+  )
+
+  if (!transitionResult.success) {
+    throw new TimerError(
+      'Transition failed after timer fired',
+      'TRANSITION_FAILED',
+      { error: transitionResult.error }
+    )
+  }
+
+  await workflowExecutor.executeWorkflow(em, container, instance.id, { userId })
+}

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

@@ -325,7 +325,7 @@ export async function executeWorkflow(
         if (
           currentStep?.stepType === 'USER_TASK' ||
           currentStep?.stepType === 'WAIT_FOR_SIGNAL' ||
-          currentStep?.stepType === 'TIMER'
+          currentStep?.stepType === 'WAIT_FOR_TIMER'
         ) {
           return {
             status: 'RUNNING',

package/src/modules/workflows/workers/workflow-activities.worker.ts

@@ -9,7 +9,7 @@
  */
 
 import type { QueuedJob, JobContext, WorkerMeta } from '@open-mercato/queue'
-import { WORKFLOW_ACTIVITIES_QUEUE_NAME, type WorkflowActivityJob } from '../lib/activity-queue-types'
+import type { WorkflowActivityJob } from '../lib/activity-queue-types'
 import type { EntityManager } from '@mikro-orm/core'
 import type { AwilixContainer } from 'awilix'
 import { WorkflowInstance } from '../data/entities'
@@ -23,12 +23,18 @@ import {
   executeFunction,
 } from '../lib/activity-executor'
 
-// Worker metadata for auto-discovery
+// Worker metadata for auto-discovery.
+// NOTE: `queue` MUST be a string literal (or locally-declared const) so the
+// generator's AST-based extractor can resolve it when Node cannot import the
+// .ts source file directly. Importing `WORKFLOW_ACTIVITIES_QUEUE_NAME` from
+// another module breaks auto-discovery and silently drops the worker from
+// `modules.generated.ts`.
+const WORKFLOW_ACTIVITIES_QUEUE = 'workflow-activities'
 const DEFAULT_CONCURRENCY = 1
 const envConcurrency = process.env.WORKERS_WORKFLOW_ACTIVITIES_CONCURRENCY
 
 export const metadata: WorkerMeta = {
-  queue: WORKFLOW_ACTIVITIES_QUEUE_NAME,
+  queue: WORKFLOW_ACTIVITIES_QUEUE,
   id: 'workflows:workflow-activities',
   concurrency: envConcurrency ? parseInt(envConcurrency, 10) : DEFAULT_CONCURRENCY,
 }
@@ -54,10 +60,6 @@ export default async function handle(
   const { payload } = job
   const startTime = Date.now()
 
-  console.log(
-    `[workflows:activity-worker] Processing activity ${payload.activityId} (${payload.activityType}) for workflow instance ${payload.workflowInstanceId} (job ${ctx.jobId}, attempt ${ctx.attemptNumber})`
-  )
-
   // Resolve services from DI container
   const em = ctx.resolve<EntityManager>('em')
 
@@ -65,6 +67,27 @@ export default async function handle(
   // The ctx already has the resolve method we need, we just need to cast it
   const container = ctx as unknown as AwilixContainer
 
+  // Timer jobs (kind: 'timer') are a distinct flow — they resume a paused
+  // workflow at a WAIT_FOR_TIMER step rather than running an activity.
+  if (payload.kind === 'timer') {
+    console.log(
+      `[workflows:activity-worker] Firing timer for instance ${payload.workflowInstanceId} (job ${ctx.jobId})`
+    )
+    const { fireTimer } = await import('../lib/timer-handler')
+    await fireTimer(em, container, {
+      instanceId: payload.workflowInstanceId,
+      stepInstanceId: payload.stepInstanceId,
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId,
+      userId: payload.userId,
+    })
+    return
+  }
+
+  console.log(
+    `[workflows:activity-worker] Processing activity ${payload.activityId} (${payload.activityType}) for workflow instance ${payload.workflowInstanceId} (job ${ctx.jobId}, attempt ${ctx.attemptNumber})`
+  )
+
   try {
     // Fetch workflow instance with tenant/org scoping
     const instance = await em.findOne(WorkflowInstance, {
@@ -114,6 +137,9 @@ export default async function handle(
           return await executeCallWebhook(payload.activityConfig, activityContext, { signal })
         case 'EXECUTE_FUNCTION':
           return await executeFunction(payload.activityConfig, activityContext, container)
+        case 'WAIT':
+          // Delay already handled by queue's delayMs — return success immediately
+          return { waited: true }
         default:
           throw new Error(`Unsupported activity type: ${payload.activityType}`)
       }