@open-mercato/core 0.9.1-develop.7519.1.38f51f8dbb → 0.9.1-develop.7536.1.f9a5776a07

package/src/modules/workflows/lib/async-activity-wait.ts

@@ -0,0 +1,71 @@
+/**
+ * Async-activity wait resolution, PURE.
+ *
+ * A transition that queues async activities parks its token (instance or
+ * branch) and records the queue job ids it is waiting for in
+ * `_pendingAsyncActivities`. The worker logs one `ACTIVITY_COMPLETED` /
+ * `ACTIVITY_FAILED` event per delivery attempt, keyed by `jobId`, and the event
+ * log keeps every earlier wait's events. The wait is therefore decided by the
+ * outcome of exactly the jobs it queued — one outcome per job — and never by
+ * events of an earlier wait, an earlier attempt of the run, or a duplicate
+ * delivery. A job with a completed attempt counts as completed; otherwise any
+ * logged failed attempt counts as its failure, whether or not the queue retries
+ * it later. `events` must be in log order: the last event per job and outcome
+ * is the one used.
+ */
+
+export const ASYNC_ACTIVITY_OUTCOME_EVENT_TYPES = ['ACTIVITY_COMPLETED', 'ACTIVITY_FAILED'] as const
+
+export type AsyncActivityOutcomeEvent = {
+  eventType: string
+  eventData: Record<string, unknown> | null | undefined
+}
+
+export type AsyncActivityWaitResolution<TEvent extends AsyncActivityOutcomeEvent> = {
+  settled: boolean
+  completed: TEvent[]
+  failed: TEvent[]
+}
+
+export function readPendingAsyncJobIds(pending: unknown): string[] {
+  if (!Array.isArray(pending)) return []
+  const jobIds: string[] = []
+  for (const entry of pending) {
+    const jobId = entry && typeof entry === 'object' ? (entry as { jobId?: unknown }).jobId : undefined
+    if (typeof jobId === 'string' && jobId.length > 0 && !jobIds.includes(jobId)) jobIds.push(jobId)
+  }
+  return jobIds
+}
+
+export function resolveAsyncActivityWait<TEvent extends AsyncActivityOutcomeEvent>(
+  pendingJobIds: readonly string[],
+  events: readonly TEvent[],
+): AsyncActivityWaitResolution<TEvent> {
+  const completedByJob = new Map<string, TEvent>()
+  const failedByJob = new Map<string, TEvent>()
+  for (const event of events) {
+    const jobId = event.eventData?.jobId
+    if (typeof jobId !== 'string') continue
+    if (event.eventType === 'ACTIVITY_COMPLETED') completedByJob.set(jobId, event)
+    else if (event.eventType === 'ACTIVITY_FAILED') failedByJob.set(jobId, event)
+  }
+
+  const completed: TEvent[] = []
+  const failed: TEvent[] = []
+  let settled = true
+  for (const jobId of pendingJobIds) {
+    const completion = completedByJob.get(jobId)
+    if (completion) {
+      completed.push(completion)
+      continue
+    }
+    const failure = failedByJob.get(jobId)
+    if (failure) {
+      failed.push(failure)
+      continue
+    }
+    settled = false
+  }
+
+  return { settled, completed, failed }
+}

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

@@ -30,6 +30,11 @@ import {
   WorkflowEvent,
 } from '../data/entities'
 import { logWorkflowEvent } from './event-logger'
+import {
+  ASYNC_ACTIVITY_OUTCOME_EVENT_TYPES,
+  readPendingAsyncJobIds,
+  resolveAsyncActivityWait,
+} from './async-activity-wait'
 import * as stepHandler from './step-handler'
 import { branchToken, mergeTokenContext, type ExecutionToken } from './execution-token'
 import { WORKFLOW_ERROR_CONTEXT_KEY, buildErrorContextEntry } from './error-routing'
@@ -202,26 +207,30 @@ export async function resumeBranchAfterActivities(
   }
 
   const namespace = branch.contextNamespace || {}
-  const pendingJobIds = (namespace._pendingAsyncActivities as any[]) || []
-
-  const completedEvents = await em.find(WorkflowEvent, {
-    workflowInstanceId: instanceId,
-    branchInstanceId,
-    eventType: 'ACTIVITY_COMPLETED',
-    eventData: { async: true },
-  })
-  const failedCount = await em.count(WorkflowEvent, {
-    workflowInstanceId: instanceId,
-    branchInstanceId,
-    eventType: 'ACTIVITY_FAILED',
-    eventData: { async: true },
-  })
+  const pendingJobIds = readPendingAsyncJobIds(namespace._pendingAsyncActivities)
+
+  const outcomeEvents = pendingJobIds.length === 0
+    ? []
+    : await em.find(
+      WorkflowEvent,
+      {
+        workflowInstanceId: instanceId,
+        branchInstanceId,
+        eventType: { $in: [...ASYNC_ACTIVITY_OUTCOME_EVENT_TYPES] },
+        eventData: { async: true, jobId: { $in: pendingJobIds } },
+      },
+      { orderBy: { occurredAt: 'asc', id: 'asc' } },
+    )
+  const wait = resolveAsyncActivityWait(pendingJobIds, outcomeEvents)
 
-  if (completedEvents.length + failedCount < pendingJobIds.length) {
+  if (!wait.settled) {
     // Still waiting on other branch activities.
     return { continueExecution: false }
   }
 
+  const completedEvents = wait.completed
+  const failedCount = wait.failed.length
+
   const now = new Date()
   if (failedCount > 0) {
     branch.status = 'FAILED'

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

@@ -22,6 +22,11 @@ import {
   type WorkflowInstanceErrorHandlerMetadata,
 } from '../data/entities'
 import { compensateWorkflow } from './compensation-handler'
+import {
+  ASYNC_ACTIVITY_OUTCOME_EVENT_TYPES,
+  readPendingAsyncJobIds,
+  resolveAsyncActivityWait,
+} from './async-activity-wait'
 import { WORKFLOW_ENGINE_VERSION, isEngineVersionSupported } from './engine-version'
 import {
   WORKFLOW_ERROR_CONTEXT_KEY,
@@ -1635,33 +1640,31 @@ export async function resumeWorkflowAfterActivities(
       throw new Error('Workflow instance not waiting for activities')
     }
 
-    const pendingJobIds = (instance.context._pendingAsyncActivities as any[]) || []
+    const pendingJobIds = readPendingAsyncJobIds(instance.context._pendingAsyncActivities)
 
-    const completedActivities = await trx.count(WorkflowEvent, {
-      workflowInstanceId: instanceId,
-      eventType: 'ACTIVITY_COMPLETED',
-      eventData: { async: true },
-    })
-
-    const failedActivities = await trx.count(WorkflowEvent, {
-      workflowInstanceId: instanceId,
-      eventType: 'ACTIVITY_FAILED',
-      eventData: { async: true },
-    })
-
-    const totalProcessed = completedActivities + failedActivities
+    const outcomeEvents = pendingJobIds.length === 0
+      ? []
+      : await trx.find(
+        WorkflowEvent,
+        {
+          workflowInstanceId: instanceId,
+          eventType: { $in: [...ASYNC_ACTIVITY_OUTCOME_EVENT_TYPES] },
+          eventData: { async: true, jobId: { $in: pendingJobIds } },
+        },
+        { orderBy: { occurredAt: 'asc', id: 'asc' } },
+      )
+    const wait = resolveAsyncActivityWait(pendingJobIds, outcomeEvents)
 
-    if (totalProcessed < pendingJobIds.length) {
+    if (!wait.settled) {
       throw new Error('Activities still pending')
     }
 
-    if (failedActivities > 0) {
-      const failedEvents = await trx.find(WorkflowEvent, {
-        workflowInstanceId: instanceId,
-        eventType: 'ACTIVITY_FAILED',
-        eventData: { async: true },
-      })
+    const completedEvents = wait.completed
+    const failedEvents = wait.failed
+    const completedActivities = completedEvents.length
+    const failedActivities = failedEvents.length
 
+    if (failedActivities > 0) {
       instance.status = 'FAILED'
       instance.errorMessage = `${failedActivities} async activities failed`
       instance.errorDetails = {
@@ -1688,12 +1691,6 @@ export async function resumeWorkflowAfterActivities(
       return { continueExecution: false }
     }
 
-    const completedEvents = await trx.find(WorkflowEvent, {
-      workflowInstanceId: instanceId,
-      eventType: 'ACTIVITY_COMPLETED',
-      eventData: { async: true },
-    })
-
     for (const event of completedEvents) {
       if (event.eventData.output) {
         instance.context = {