@open-mercato/core 0.9.1-develop.7519.1.38f51f8dbb → 0.9.1-develop.7532.1.8eac7e198f

package/src/modules/staff/commands/leave-requests.ts

@@ -12,7 +12,7 @@ import type { DataEngine } from '@open-mercato/shared/lib/data/engine'
 import { invalidateCrudCache } from '@open-mercato/shared/lib/crud/cache'
 import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { PlannerAvailabilityRule } from '@open-mercato/core/modules/planner/data/entities'
-import { StaffLeaveRequest, type StaffLeaveRequestStatus } from '../data/entities'
+import { StaffLeaveRequest, StaffTeamMember, type StaffLeaveRequestStatus } from '../data/entities'
 import {
   staffLeaveRequestCreateSchema,
   staffLeaveRequestDecisionSchema,
@@ -210,6 +210,36 @@ function ensurePendingStatus(request: StaffLeaveRequest): void {
   }
 }
 
+async function ensureUndoablePending(request: StaffLeaveRequest): Promise<void> {
+  if (request.status === 'pending') return
+  const { translate } = await resolveTranslations()
+  throw new CrudHttpError(409, {
+    error: translate(
+      'staff.leaveRequests.errors.undoAfterDecision',
+      'This leave request has already been approved or rejected and can no longer be undone. Undo the decision first.',
+    ),
+  })
+}
+
+async function requireUndoMember(em: EntityManager, snapshot: LeaveRequestSnapshot): Promise<StaffTeamMember> {
+  const scope = explicitStaffCommandScope(snapshot.tenantId, snapshot.organizationId)
+  const member = await findOneWithDecryption(
+    em,
+    StaffTeamMember,
+    applyScopeToWhere<StaffTeamMember>({ id: snapshot.memberId, deletedAt: null }, scope),
+    undefined,
+    scopeForDecryption(scope),
+  )
+  if (member) return member
+  const { translate } = await resolveTranslations()
+  throw new CrudHttpError(409, {
+    error: translate(
+      'staff.leaveRequests.errors.undoMemberMissing',
+      'The original team member of this leave request no longer exists, so the change cannot be undone.',
+    ),
+  })
+}
+
 async function createUnavailabilityRules(params: {
   em: EntityManager
   tenantId: string
@@ -388,25 +418,25 @@ const createLeaveRequestCommand: CommandHandler<StaffLeaveRequestCreateInput, {
     if (!after) return
     const em = (ctx.container.resolve('em') as EntityManager).fork()
     const request = await em.findOne(StaffLeaveRequest, scopedStaffSnapshotWhere(after.id, staffSnapshotScopeFromSnapshot(after)))
-    if (request) {
-      request.deletedAt = new Date()
-      request.updatedAt = new Date()
-      await em.flush()
+    if (!request || request.deletedAt) return
+    await ensureUndoablePending(request)
+    request.deletedAt = new Date()
+    request.updatedAt = new Date()
+    await em.flush()
 
-      const de = (ctx.container.resolve('dataEngine') as DataEngine)
-      await emitCrudUndoSideEffects({
-        dataEngine: de,
-        action: 'deleted',
-        entity: request,
-        identifiers: {
-          id: request.id,
-          organizationId: request.organizationId,
-          tenantId: request.tenantId,
-        },
-        events: staffLeaveRequestCrudEvents,
+    const de = (ctx.container.resolve('dataEngine') as DataEngine)
+    await emitCrudUndoSideEffects({
+      dataEngine: de,
+      action: 'deleted',
+      entity: request,
+      identifiers: {
+        id: request.id,
+        organizationId: request.organizationId,
+        tenantId: request.tenantId,
+      },
+      events: staffLeaveRequestCrudEvents,
       indexer: leaveRequestCrudIndexer,
-      })
-    }
+    })
   },
   redo: makeCreateRedo<StaffLeaveRequest, LeaveRequestSnapshot, StaffLeaveRequestCreateInput, { requestId: string }>({
     entityClass: StaffLeaveRequest,
@@ -517,17 +547,18 @@ const updateLeaveRequestCommand: CommandHandler<StaffLeaveRequestUpdateInput, {
     if (!before || !after) return
     const em = (ctx.container.resolve('em') as EntityManager).fork()
     const request = await em.findOne(StaffLeaveRequest, scopedStaffSnapshotWhere(after.id, staffSnapshotScopeFromSnapshot(after)))
-    if (!request) return
+    if (!request || request.deletedAt) return
+    await ensureUndoablePending(request)
+    const currentMemberId = typeof request.member === 'string' ? request.member : request.member.id
+    if (before.memberId !== currentMemberId) {
+      request.member = await requireUndoMember(em, before)
+    }
     request.startDate = new Date(before.startDate)
     request.endDate = new Date(before.endDate)
     request.timezone = before.timezone
-    request.status = before.status
     request.unavailabilityReasonEntryId = before.unavailabilityReasonEntryId
     request.unavailabilityReasonValue = before.unavailabilityReasonValue
     request.note = before.note
-    request.decisionComment = before.decisionComment
-    request.decidedByUserId = before.decidedByUserId
-    request.decidedAt = before.decidedAt ? new Date(before.decidedAt) : null
     request.updatedAt = new Date()
     await em.flush()
 

package/src/modules/staff/i18n/de.json

@@ -269,6 +269,8 @@
   "staff.leaveRequests.errors.profileLoad": "Profil konnte nicht geladen werden.",
   "staff.leaveRequests.errors.profileRequired": "Bitte zuerst dein Profil erstellen.",
   "staff.leaveRequests.errors.reject": "Urlaubsantrag konnte nicht abgelehnt werden.",
+  "staff.leaveRequests.errors.undoAfterDecision": "Dieser Urlaubsantrag wurde bereits genehmigt oder abgelehnt und kann nicht mehr rückgängig gemacht werden. Mache zuerst die Entscheidung rückgängig.",
+  "staff.leaveRequests.errors.undoMemberMissing": "Das ursprüngliche Teammitglied dieses Urlaubsantrags existiert nicht mehr, daher kann die Änderung nicht rückgängig gemacht werden.",
   "staff.leaveRequests.form.actions.create": "Erstellen",
   "staff.leaveRequests.form.actions.save": "Speichern",
   "staff.leaveRequests.form.createTitle": "Urlaubsantrag erstellen",

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

@@ -269,6 +269,8 @@
   "staff.leaveRequests.errors.profileLoad": "Failed to load your profile.",
   "staff.leaveRequests.errors.profileRequired": "Create your profile first.",
   "staff.leaveRequests.errors.reject": "Failed to reject leave request.",
+  "staff.leaveRequests.errors.undoAfterDecision": "This leave request has already been approved or rejected and can no longer be undone. Undo the decision first.",
+  "staff.leaveRequests.errors.undoMemberMissing": "The original team member of this leave request no longer exists, so the change cannot be undone.",
   "staff.leaveRequests.form.actions.create": "Create",
   "staff.leaveRequests.form.actions.save": "Save",
   "staff.leaveRequests.form.createTitle": "Create leave request",

package/src/modules/staff/i18n/es.json

@@ -269,6 +269,8 @@
   "staff.leaveRequests.errors.profileLoad": "No se pudo cargar tu perfil.",
   "staff.leaveRequests.errors.profileRequired": "Crea tu perfil primero.",
   "staff.leaveRequests.errors.reject": "No se pudo rechazar la solicitud de ausencia.",
+  "staff.leaveRequests.errors.undoAfterDecision": "Esta solicitud de ausencia ya fue aprobada o rechazada y ya no se puede deshacer. Deshaz primero la decisión.",
+  "staff.leaveRequests.errors.undoMemberMissing": "El miembro del equipo original de esta solicitud de ausencia ya no existe, por lo que el cambio no se puede deshacer.",
   "staff.leaveRequests.form.actions.create": "Crear",
   "staff.leaveRequests.form.actions.save": "Guardar",
   "staff.leaveRequests.form.createTitle": "Crear solicitud de ausencia",

package/src/modules/staff/i18n/ko.json

@@ -269,6 +269,8 @@
   "staff.leaveRequests.errors.profileLoad": "프로필을 불러오지 못했습니다.",
   "staff.leaveRequests.errors.profileRequired": "먼저 프로필을 생성하세요.",
   "staff.leaveRequests.errors.reject": "휴가 신청을 반려하지 못했습니다.",
+  "staff.leaveRequests.errors.undoAfterDecision": "이 휴가 신청은 이미 승인 또는 반려되어 더 이상 실행 취소할 수 없습니다. 먼저 결정을 실행 취소하세요.",
+  "staff.leaveRequests.errors.undoMemberMissing": "이 휴가 신청의 원래 팀원이 더 이상 존재하지 않아 변경 사항을 실행 취소할 수 없습니다.",
   "staff.leaveRequests.form.actions.create": "생성",
   "staff.leaveRequests.form.actions.save": "저장",
   "staff.leaveRequests.form.createTitle": "휴가 신청 생성",

package/src/modules/staff/i18n/pl.json

@@ -269,6 +269,8 @@
   "staff.leaveRequests.errors.profileLoad": "Nie udało się załadować profilu.",
   "staff.leaveRequests.errors.profileRequired": "Najpierw utwórz swój profil.",
   "staff.leaveRequests.errors.reject": "Nie udało się odrzucić wniosku urlopowego.",
+  "staff.leaveRequests.errors.undoAfterDecision": "Ten wniosek urlopowy został już zatwierdzony lub odrzucony i nie można go już cofnąć. Najpierw cofnij decyzję.",
+  "staff.leaveRequests.errors.undoMemberMissing": "Pierwotny członek zespołu tego wniosku urlopowego już nie istnieje, więc nie można cofnąć zmiany.",
   "staff.leaveRequests.form.actions.create": "Utwórz",
   "staff.leaveRequests.form.actions.save": "Zapisz",
   "staff.leaveRequests.form.createTitle": "Utwórz wniosek urlopowy",

package/src/modules/warranty_claims/api/portal/attachments/route.ts

@@ -17,7 +17,11 @@ import { checkAttachmentAccess } from '@open-mercato/core/modules/attachments/li
 import { attachmentCrudEvents, attachmentCrudIndexer } from '@open-mercato/core/modules/attachments/lib/crud'
 import { readAttachmentMetadata } from '@open-mercato/core/modules/attachments/lib/metadata'
 import { clearAttachmentThumbnailCache } from '@open-mercato/core/modules/attachments/lib/thumbnailCache'
-import { isMultipartRequestWithinUploadLimit } from '@open-mercato/core/modules/attachments/lib/upload-limits'
+import {
+  isMultipartUploadLimitError,
+  parseMultipartFormDataWithinUploadLimit,
+  resolveDefaultAttachmentMaxUploadBytes,
+} from '@open-mercato/core/modules/attachments/lib/upload-limits'
 import {
   isScopedAttachmentUploadError,
   type ScopedAttachmentUploadErrorCode,
@@ -341,6 +345,14 @@ export async function GET(req: Request) {
   })
 }
 
+function uploadTooLargeResponse(t: Awaited<ReturnType<typeof resolveTranslations>>['t']): Response {
+  return NextResponse.json({
+    ok: false,
+    error: t('attachments.errors.maxUploadSize', 'Attachment exceeds the maximum upload size.'),
+    code: 'max_upload_size',
+  }, { status: 413 })
+}
+
 async function handleUpload(req: Request, replacement: boolean): Promise<Response> {
   const contextOrResponse = await resolvePortalContext(req)
   if (contextOrResponse instanceof Response) return contextOrResponse
@@ -350,14 +362,13 @@ async function handleUpload(req: Request, replacement: boolean): Promise<Respons
   if (!contentType.toLowerCase().includes('multipart/form-data')) {
     return NextResponse.json({ ok: false, error: translate('warranty_claims.errors.invalidInput', 'Invalid input') }, { status: 400 })
   }
-  if (!isMultipartRequestWithinUploadLimit(req.headers.get('content-length'))) {
-    return NextResponse.json({
-      ok: false,
-      error: t('attachments.errors.maxUploadSize', 'Attachment exceeds the maximum upload size.'),
-    }, { status: 413 })
+  let form: FormData
+  try {
+    form = await parseMultipartFormDataWithinUploadLimit(req)
+  } catch (error) {
+    if (isMultipartUploadLimitError(error)) return uploadTooLargeResponse(t)
+    throw error
   }
-
-  const form = await req.formData()
   const parsed = uploadBodySchema.safeParse({
     claimId: form.get('claimId') ?? undefined,
     file: form.get('file') instanceof File ? (form.get('file') as File).name : '',
@@ -376,6 +387,7 @@ async function handleUpload(req: Request, replacement: boolean): Promise<Respons
   if (!(file instanceof File)) {
     return NextResponse.json({ ok: false, error: translate('warranty_claims.portal.detail.fileRequired', 'Choose a file before uploading.') }, { status: 400 })
   }
+  if (file.size > resolveDefaultAttachmentMaxUploadBytes()) return uploadTooLargeResponse(t)
   const buffer = Buffer.from(await file.arrayBuffer())
 
   const attachmentId = replacement && parsedAttachmentId?.success ? parsedAttachmentId.data : null

package/src/modules/warranty_claims/commands/claims.ts

@@ -269,7 +269,7 @@ function hasOwn(input: object, key: string): boolean {
 }
 
 function resolveScope(ctx: CommandRuntimeContext, input: ScopeInput): WarrantyClaimScope {
-  const tenantId = input.tenantId ?? ctx.auth?.tenantId ?? null
+  const tenantId = input.tenantId ?? ctx.auth?.tenantId ?? ctx.organizationScope?.tenantId ?? null
   const organizationId = input.organizationId ?? ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
   if (!tenantId) throw new CrudHttpError(400, { error: '[internal] tenant scope required for warranty claim command' })
   if (!organizationId) throw new CrudHttpError(400, { error: '[internal] organization scope required for warranty claim command' })

package/src/modules/warranty_claims/subscribers/return-shipment-tracking.ts

@@ -7,7 +7,6 @@ import { createLogger } from '@open-mercato/shared/lib/logger'
 import type { TransitionClaimInput } from '../data/validators'
 
 const logger = createLogger('warranty_claims')
-const SYSTEM_USER_ID = '00000000-0000-0000-0000-000000000000'
 
 export const metadata = {
   event: 'shipping_carriers.shipment.delivered',
@@ -182,12 +181,13 @@ export default async function handle(payload: unknown, ctx: SubscriberContext):
 
   const commandCtx: CommandRuntimeContext = {
     container: container as unknown as AwilixContainer,
-    auth: {
-      sub: SYSTEM_USER_ID,
+    auth: null,
+    organizationScope: {
+      selectedId: organizationId,
+      filterIds: null,
+      allowedIds: null,
       tenantId,
-      orgId: organizationId,
     },
-    organizationScope: null,
     selectedOrganizationId: organizationId,
     organizationIds: [organizationId],
     systemActor: true,

package/src/modules/wms/commands/inventory-actions.ts

@@ -734,19 +734,37 @@ async function findReservationBucketBalance(
   })
 }
 
+type BalanceBucketInput = {
+  warehouseId: string
+  locationId: string
+  catalogVariantId: string
+  lotId?: string
+  serialNumber?: string
+}
+
+const BALANCE_BUCKET_CREATE_LOCK_SQL = 'select pg_advisory_xact_lock(hashtextextended(?, 0))'
+
+function balanceBucketCreateLockKey(input: BalanceBucketInput): string {
+  return [
+    'wms:inventory-balance-bucket',
+    input.warehouseId.toLowerCase(),
+    input.locationId.toLowerCase(),
+    input.catalogVariantId.toLowerCase(),
+    input.lotId?.toLowerCase() ?? '',
+    input.serialNumber ?? '',
+  ].join(':')
+}
+
 async function upsertBalanceBucket(
   em: EntityManager,
   scope: Scope,
-  input: {
-    warehouseId: string
-    locationId: string
-    catalogVariantId: string
-    lotId?: string
-    serialNumber?: string
-  },
+  input: BalanceBucketInput,
 ): Promise<{ balance: InventoryBalance; created: boolean }> {
   const existing = await findExactBalanceForUpdate(em, scope, input)
   if (existing) return { balance: existing, created: false }
+  await em.execute(BALANCE_BUCKET_CREATE_LOCK_SQL, [balanceBucketCreateLockKey(input)])
+  const createdConcurrently = await findExactBalanceForUpdate(em, scope, input)
+  if (createdConcurrently) return { balance: createdConcurrently, created: false }
   const balance = em.create(InventoryBalance, {
     organizationId: scope.organizationId,
     tenantId: scope.tenantId,
@@ -1608,15 +1626,17 @@ const moveInventoryCommand: CommandHandler<InventoryMoveInput, { movementId: str
       if (sourceWarehouseId !== input.warehouseId || targetWarehouseId !== input.warehouseId) {
         throw new CrudHttpError(422, { error: 'invalid_location' })
       }
-      const sourceResult = await upsertBalanceBucket(trx, scope, {
+      const sourceBalance = await findExactBalanceForUpdate(trx, scope, {
         warehouseId: input.warehouseId,
         locationId: input.fromLocationId,
         catalogVariantId: input.catalogVariantId,
         lotId: input.lotId,
         serialNumber: input.serialNumber,
       })
-      const sourceBalance = sourceResult.balance
-      const sourceBalanceAction = sourceResult.created ? ('created' as const) : ('updated' as const)
+      if (!sourceBalance) {
+        throw new CrudHttpError(409, { error: 'insufficient_stock' })
+      }
+      const sourceBalanceAction = 'updated' as const
       const targetResult = await upsertBalanceBucket(trx, scope, {
         warehouseId: input.warehouseId,
         locationId: input.toLocationId,

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 = {