@open-mercato/core 0.6.3-develop.3876.1.d40fe4ec2d → 0.6.3-develop.3894.1.352abf4240

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}`)
       }