@open-mercato/core 0.8.1-develop.7296.1.2111d779db → 0.8.1-develop.7441.1.b42958b98c

package/src/modules/workflows/api/tasks/[id]/reassign/route.ts

@@ -22,6 +22,7 @@ import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { resolveSingleOrganizationIdOrDeny } from '@open-mercato/core/modules/directory/utils/organizationScopeFilter'
 import { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import { enforceCommandOptimisticLock } from '@open-mercato/shared/lib/crud/optimistic-lock-command'
 import { createLogger } from '@open-mercato/shared/lib/logger'
@@ -67,7 +68,7 @@ export async function POST(
 
     const scope = await resolveOrganizationScopeForRequest({ container, auth, request })
     const tenantId = auth.tenantId
-    const organizationId = scope?.selectedId ?? auth.orgId
+    const organizationId = resolveSingleOrganizationIdOrDeny(scope, auth)
 
     if (!tenantId || !organizationId) {
       return NextResponse.json(

package/src/modules/workflows/api/tasks/[id]/unclaim/route.ts

@@ -17,6 +17,7 @@ import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { resolveSingleOrganizationIdOrDeny } from '@open-mercato/core/modules/directory/utils/organizationScopeFilter'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 import type { TaskHandlerService } from '../../../../lib/task-handler'
 import { gateTaskAction } from '../../../../lib/task-visibility-request'
@@ -27,6 +28,7 @@ import {
   userTaskClaimResponseSchema,
   workflowErrorSchema,
 } from '../../../openapi'
+import { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 
 const logger = createLogger('workflows')
 
@@ -50,7 +52,7 @@ export async function POST(
 
     const scope = await resolveOrganizationScopeForRequest({ container, auth, request })
     const tenantId = auth.tenantId
-    const organizationId = scope?.selectedId ?? auth.orgId
+    const organizationId = resolveSingleOrganizationIdOrDeny(scope, auth)
 
     if (!tenantId || !organizationId) {
       return NextResponse.json(
@@ -88,6 +90,7 @@ export async function POST(
       message: 'Task released successfully',
     })
   } catch (error) {
+    if (isCrudHttpError(error)) return NextResponse.json(error.body, { status: error.status })
     logger.error('Error releasing user task', { err: error })
 
     const code = (error as { code?: unknown } | null)?.code

package/src/modules/workflows/api/templates/route.ts

@@ -10,9 +10,11 @@ import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { resolveSingleOrganizationIdOrDeny } from '@open-mercato/core/modules/directory/utils/organizationScopeFilter'
 import { loadWorkflowTemplates } from '../../lib/workflow-templates'
 import { workflowsTag, workflowErrorSchema, workflowTemplateListResponseSchema } from '../openapi'
 import { createLogger } from '@open-mercato/shared/lib/logger'
+import { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 
 const logger = createLogger('workflows')
 
@@ -37,7 +39,7 @@ export async function GET(request: NextRequest) {
 
     const scope = await resolveOrganizationScopeForRequest({ container, auth, request })
     const tenantId = auth.tenantId
-    const organizationId = scope?.selectedId ?? auth.orgId
+    const organizationId = resolveSingleOrganizationIdOrDeny(scope, auth)
 
     if (!tenantId) {
       return NextResponse.json({ error: 'Missing tenant context' }, { status: 400 })
@@ -58,6 +60,7 @@ export async function GET(request: NextRequest) {
 
     return NextResponse.json({ items })
   } catch (error) {
+    if (isCrudHttpError(error)) return NextResponse.json(error.body, { status: error.status })
     logger.error('Error listing workflow templates', { err: error })
     return NextResponse.json(
       { error: 'Failed to list workflow templates' },

package/src/modules/workflows/api/work-inbox/next/route.ts

@@ -25,6 +25,7 @@ import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { resolveSingleOrganizationIdOrDeny } from '@open-mercato/core/modules/directory/utils/organizationScopeFilter'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 import { USER_TASK_INBOX_KIND } from '../../tasks/serialize'
 import { serializeWorkInboxRow } from '../../../lib/work-inbox/provider'
@@ -42,6 +43,7 @@ import {
   workInboxClaimNextResponseSchema,
   workflowErrorSchema,
 } from '../../openapi'
+import { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 
 const logger = createLogger('workflows')
 
@@ -71,7 +73,7 @@ export async function POST(request: NextRequest) {
 
     const organizationScope = await resolveOrganizationScopeForRequest({ container, auth, request })
     const tenantId = auth.tenantId
-    const organizationId = organizationScope?.selectedId ?? auth.orgId
+    const organizationId = resolveSingleOrganizationIdOrDeny(organizationScope, auth)
 
     if (!tenantId || !organizationId) {
       return NextResponse.json(
@@ -138,6 +140,7 @@ export async function POST(request: NextRequest) {
 
     return NextResponse.json({ data: null, message: 'No claimable work available' })
   } catch (error) {
+    if (isCrudHttpError(error)) return NextResponse.json(error.body, { status: error.status })
     logger.error('Error claiming the next work item', { err: error })
     return NextResponse.json(
       {

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

@@ -858,11 +858,14 @@ async function executeActivityByType(
  * Sends via the DI-registered emailService when available; without one it
  * reports an honest stub result ({ sent: false, simulated: true, reason: 'no-email-service' }).
  * A real send() failure propagates so the activity retry loop handles it.
+ * When a timeout AbortSignal is provided it is forwarded on the send payload and
+ * the await is raced against abort (#5148).
  */
 export async function executeSendEmail(
   config: any,
   context: ActivityContext,
-  container: AwilixContainer
+  container: AwilixContainer,
+  signal?: AbortSignal
 ): Promise<any> {
   const { to, subject, template, templateData, body } = config
 
@@ -870,6 +873,8 @@ export async function executeSendEmail(
     throw new Error('SEND_EMAIL requires "to" and "subject" fields')
   }
 
+  throwIfAborted(signal)
+
   logger.info('Send email activity invoked', { component: 'SEND_EMAIL', subject })
 
   let emailService: { send: (input: unknown) => Promise<unknown> | unknown } | undefined
@@ -880,13 +885,20 @@ export async function executeSendEmail(
   }
 
   if (emailService && typeof emailService.send === 'function') {
-    await emailService.send({
-      to,
-      subject,
-      template,
-      templateData,
-      body,
-    })
+    await raceAbortable(
+      Promise.resolve(
+        emailService.send({
+          to,
+          subject,
+          template,
+          templateData,
+          body,
+          signal,
+        })
+      ),
+      signal
+    )
+    throwIfAborted(signal)
     return { sent: true, to, subject, via: 'emailService' }
   }
 
@@ -897,12 +909,17 @@ export async function executeSendEmail(
 /**
  * EMIT_EVENT activity handler
  *
- * Publishes a domain event to the event bus
+ * Publishes a domain event to the event bus.
+ * Honours an activity-timeout AbortSignal by refusing to dispatch after abort
+ * (throwIfAborted guard) and by racing the await against the signal via
+ * raceAbortable (#5148). The event bus does not declare a signal parameter, so
+ * an emit that has already begun cannot be cancelled — same contract as UPDATE_ENTITY.
  */
 export async function executeEmitEvent(
   config: any,
   context: ActivityContext,
-  container: AwilixContainer
+  container: AwilixContainer,
+  signal?: AbortSignal
 ): Promise<any> {
   const { eventName, payload } = config
 
@@ -929,6 +946,8 @@ export async function executeEmitEvent(
     )
   }
 
+  throwIfAborted(signal)
+
   // Get event bus from container
   const eventBus = container.resolve<{ emitEvent: (event: string, payload: unknown, options?: unknown) => Promise<unknown> | unknown }>('eventBus')
 
@@ -947,10 +966,16 @@ export async function executeEmitEvent(
     },
   }
 
-  await eventBus.emitEvent(eventName, enrichedPayload, {
-    tenantId: context.workflowInstance.tenantId,
-    organizationId: context.workflowInstance.organizationId,
-  })
+  await raceAbortable(
+    Promise.resolve(
+      eventBus.emitEvent(eventName, enrichedPayload, {
+        tenantId: context.workflowInstance.tenantId,
+        organizationId: context.workflowInstance.organizationId,
+      })
+    ),
+    signal
+  )
+  throwIfAborted(signal)
 
   return { emitted: true, eventName, payload: enrichedPayload }
 }
@@ -1007,7 +1032,8 @@ export async function executeUpdateEntity(
   em: EntityManager,
   config: any,
   context: ActivityContext,
-  container: AwilixContainer
+  container: AwilixContainer,
+  signal?: AbortSignal
 ): Promise<any> {
   const { commandId, input, statusDictionary } = config
 
@@ -1028,6 +1054,7 @@ export async function executeUpdateEntity(
     container,
     context.workflowInstance.tenantId,
   )
+  throwIfAborted(signal)
   if (!isWorkflowCommandEnabled(workflowSafeCommand, commandPolicy)) {
     throw new Error('UPDATE_ENTITY command is not enabled for this tenant')
   }
@@ -1048,6 +1075,7 @@ export async function executeUpdateEntity(
     context.workflowInstance.tenantId,
     context.workflowInstance.organizationId
   )
+  throwIfAborted(signal)
   if (!authorized) {
     throw new Error('UPDATE_ENTITY command is not authorized')
   }
@@ -1079,6 +1107,7 @@ export async function executeUpdateEntity(
       context.workflowInstance.tenantId,
       context.workflowInstance.organizationId
     )
+    throwIfAborted(signal)
     if (statusEntryId) {
       finalInput.statusEntryId = statusEntryId
     }
@@ -1101,11 +1130,20 @@ export async function executeUpdateEntity(
       : null,
   }
 
-  // Execute the command
-  const { result, logEntry } = await commandBus.execute(commandId, {
-    input: finalInput,
-    ctx,
-  })
+  // Execute the command. A timeout AbortSignal refuses a start (throwIfAborted
+  // guard) and races the await via raceAbortable (#5148). CommandBus.execute
+  // does not accept a signal, so a write that has already begun cannot be rolled back.
+  throwIfAborted(signal)
+  const { result, logEntry } = await raceAbortable(
+    Promise.resolve(
+      commandBus.execute(commandId, {
+        input: finalInput,
+        ctx,
+      })
+    ),
+    signal
+  )
+  throwIfAborted(signal)
 
   return {
     executed: true,
@@ -1260,12 +1298,15 @@ export async function executeCallWebhook(
 /**
  * EXECUTE_FUNCTION activity handler
  *
- * Calls a registered function from DI container
+ * Calls a registered function from DI container.
+ * Forwards the activity-timeout AbortSignal as the third argument so registered
+ * functions can cancel cooperative work (#5148).
  */
 export async function executeFunction(
   config: any,
   context: ActivityContext,
-  container: AwilixContainer
+  container: AwilixContainer,
+  signal?: AbortSignal
 ): Promise<any> {
   const { functionName, args = {} } = config
 
@@ -1273,6 +1314,8 @@ export async function executeFunction(
     throw new Error('EXECUTE_FUNCTION requires "functionName" field')
   }
 
+  throwIfAborted(signal)
+
   // Look up function in container
   const fnKey = `workflowFunction:${functionName}`
 
@@ -1283,8 +1326,13 @@ export async function executeFunction(
       throw new Error(`Registered workflow function "${functionName}" is not a function`)
     }
 
-    // Call function with args and context
-    const result = await fn(args, context)
+    // Call function with args, context, and optional abort signal (additive —
+    // existing two-arg functions ignore the third parameter).
+    const result = await raceAbortable(
+      Promise.resolve(fn(args, context, signal)),
+      signal
+    )
+    throwIfAborted(signal)
 
     return { executed: true, functionName, result }
   } catch (error) {
@@ -2137,10 +2185,14 @@ function sleep(ms: number): Promise<void> {
 /**
  * Execute a promise with timeout
  *
- * Only CALL_API and CALL_WEBHOOK honour the abort signal today — they forward
- * it to `fetch`. SEND_EMAIL, EMIT_EVENT, UPDATE_ENTITY and EXECUTE_FUNCTION
- * still run to completion after the timeout has been recorded. Tracked in
- * #5148.
+ * AbortController.signal is threaded into every activity handler on both the
+ * synchronous (`executeActivity`) and asynchronous worker (`activity-worker-handler`)
+ * paths. CALL_API / CALL_WEBHOOK forward it to `fetch`. SEND_EMAIL forwards it to
+ * `emailService.send` (honouring is optional per implementation). EMIT_EVENT and
+ * UPDATE_ENTITY check it before dispatch and race their awaits against it via
+ * `raceAbortable` — neither the event bus nor the command bus declare a `signal`
+ * parameter, so a write/emit that has already begun cannot be rolled back.
+ * EXECUTE_FUNCTION forwards it as its third argument (#5148 / #4918).
  */
 async function executeWithTimeout<T>(
   executor: (signal: AbortSignal) => Promise<T>,
@@ -2163,6 +2215,51 @@ async function executeWithTimeout<T>(
   }
 }
 
+function createActivityAbortError(signal?: AbortSignal): Error {
+  if (signal?.reason instanceof Error) return signal.reason
+  try {
+    return new DOMException('The operation was aborted', 'AbortError')
+  } catch {
+    const error = new Error('The operation was aborted')
+    error.name = 'AbortError'
+    return error
+  }
+}
+
+function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) {
+    throw createActivityAbortError(signal)
+  }
+}
+
+/**
+ * Reject when `signal` aborts while `promise` is still pending. Does not cancel
+ * an underlying effect that cannot honour AbortSignal — callers must pass the
+ * signal into that effect when it can.
+ */
+function raceAbortable<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {
+  if (!signal) return promise
+  if (signal.aborted) {
+    return Promise.reject(createActivityAbortError(signal))
+  }
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => {
+      reject(createActivityAbortError(signal))
+    }
+    signal.addEventListener('abort', onAbort, { once: true })
+    promise.then(
+      (value) => {
+        signal.removeEventListener('abort', onAbort)
+        resolve(value)
+      },
+      (error) => {
+        signal.removeEventListener('abort', onAbort)
+        reject(error)
+      }
+    )
+  })
+}
+
 bindActivityExecutor({
   executeSendEmail,
   executeEmitEvent,

package/src/modules/workflows/lib/activity-types.ts

@@ -233,7 +233,8 @@ export function registerBuiltinActivityTypes(): void {
       { id: 'template', component: 'text' },
       { id: 'body', component: 'textarea' },
     ],
-    execute: async (config, ctx, deps) => (await loadExecutor()).executeSendEmail(config, ctx, deps.container),
+    execute: async (config, ctx, deps) =>
+      (await loadExecutor()).executeSendEmail(config, ctx, deps.container, deps.signal),
     async: { capable: true },
     mock: (config) => {
       const record = asConfigRecord(config)
@@ -250,7 +251,8 @@ export function registerBuiltinActivityTypes(): void {
       { id: 'eventName', component: 'eventName', required: true },
       { id: 'payload', component: 'json' },
     ],
-    execute: async (config, ctx, deps) => (await loadExecutor()).executeEmitEvent(config, ctx, deps.container),
+    execute: async (config, ctx, deps) =>
+      (await loadExecutor()).executeEmitEvent(config, ctx, deps.container, deps.signal),
     async: { capable: true },
     mock: (config) => {
       const record = asConfigRecord(config)
@@ -273,7 +275,8 @@ export function registerBuiltinActivityTypes(): void {
       { id: 'input', component: 'json', required: true },
       { id: 'statusDictionary', component: 'text' },
     ],
-    execute: async (config, ctx, deps) => (await loadExecutor()).executeUpdateEntity(deps.em, config, ctx, deps.container),
+    execute: async (config, ctx, deps) =>
+      (await loadExecutor()).executeUpdateEntity(deps.em, config, ctx, deps.container, deps.signal),
     async: { capable: true },
     outputContract: resolveCommandOutputContract,
     mock: (config) => {
@@ -320,7 +323,8 @@ export function registerBuiltinActivityTypes(): void {
       },
       { id: 'args', component: 'json' },
     ],
-    execute: async (config, ctx, deps) => (await loadExecutor()).executeFunction(config, ctx, deps.container),
+    execute: async (config, ctx, deps) =>
+      (await loadExecutor()).executeFunction(config, ctx, deps.container, deps.signal),
     async: { capable: true },
     mock: 'refuse',
   })

package/src/modules/workflows/lib/activity-worker-handler.ts

@@ -218,26 +218,30 @@ export function createActivityWorkerHandler(
         userId: payload.userId,
       }
 
-      // Execute activity by type (with timeout if specified)
+      // Execute activity by type (with timeout and abort signal if specified)
       let result: any
 
-      const executeActivityByType = async () =>
+      const executeActivityByType = (signal?: AbortSignal) =>
         executeRegistryActivity(payload, activityContext, {
           em: em as PostgreSqlEntityManager,
           container,
+          signal,
         })
 
-      // Apply timeout if specified
       if (payload.timeoutMs) {
-        result = await Promise.race([
-          executeActivityByType(),
-          new Promise((_, reject) =>
-            setTimeout(
-              () => reject(new Error(`Activity timeout after ${payload.timeoutMs}ms`)),
-              payload.timeoutMs
-            )
-          ),
-        ])
+        const ac = new AbortController()
+        let timerId: NodeJS.Timeout
+        const timeoutPromise = new Promise<never>((_, reject) => {
+          timerId = setTimeout(() => {
+            ac.abort()
+            reject(new Error(`Activity timeout after ${payload.timeoutMs}ms`))
+          }, payload.timeoutMs)
+        })
+        try {
+          result = await Promise.race([executeActivityByType(ac.signal), timeoutPromise])
+        } finally {
+          clearTimeout(timerId!)
+        }
       } else {
         result = await executeActivityByType()
       }

package/src/modules/workflows/lib/event-trigger-service.ts

@@ -420,6 +420,13 @@ async function loadLegacyTriggers(
  * those with no triggers — so the caller can let a materialized (customized)
  * definition suppress its code-registry counterpart regardless of whether the
  * customization kept any triggers (#4425).
+ *
+ * Versions of a workflow coexist as separate rows, and publishing copies the
+ * triggers into the new row while the previous one stays enabled for the
+ * instances and pinned callers still running it. Triggers are therefore taken
+ * only from the database row an unpinned start resolves to
+ * (`findWorkflowDefinition`): the highest enabled, published version. Projecting every enabled row would
+ * start one instance per version for a single event.
  */
 async function loadEmbeddedTriggers(
   em: EntityManager,
@@ -428,7 +435,8 @@ async function loadEmbeddedTriggers(
 ): Promise<{ triggers: UnifiedTrigger[]; workflowIds: Set<string> }> {
   const postgresEm = em as unknown as PostgreSqlEntityManager
   // Load all definitions so disabled customizations still shadow their code
-  // counterpart. Only enabled definitions contribute embedded triggers below.
+  // counterpart. Only the resolved version of each workflow contributes
+  // embedded triggers below.
   const definitions = await findWithDecryption(
     postgresEm,
     WorkflowDefinition,
@@ -443,11 +451,19 @@ async function loadEmbeddedTriggers(
 
   const triggers: UnifiedTrigger[] = []
   const workflowIds = new Set<string>()
+  const resolvedVersions = new Map<string, WorkflowDefinition>()
 
   for (const def of definitions) {
     workflowIds.add(def.workflowId)
-    if (!def.enabled) continue
+    if (!def.enabled || def.lifecycle !== 'published') continue
+
+    const resolved = resolvedVersions.get(def.workflowId)
+    if (!resolved || def.version > resolved.version) {
+      resolvedVersions.set(def.workflowId, def)
+    }
+  }
 
+  for (const def of resolvedVersions.values()) {
     const embeddedTriggers = def.definition?.triggers as WorkflowDefinitionTrigger[] | undefined
     if (!embeddedTriggers || embeddedTriggers.length === 0) continue
 

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

@@ -1716,10 +1716,15 @@ function mapOutputData(
 }
 
 /**
- * Map a completed sub-workflow's child context to parent output and validate it
- * against the child's declared output ports. Shared by the synchronous
- * (inline) completion branch in `handleSubWorkflowStep` and the async parent
- * resume path so both apply identical mapping/validation rules. Returns the
+ * Validate a completed sub-workflow's child context against the child's
+ * declared output ports, then map it to parent output. Shared by the
+ * synchronous (inline) completion branch in `handleSubWorkflowStep` and the
+ * async parent resume path so both apply identical mapping/validation rules.
+ *
+ * Output ports are named in the CHILD's vocabulary, while `outputMapping` is
+ * `{ parentKey: childPath }`, so validation and coercion run on the child
+ * context before mapping — validating the mapped result would look ports up
+ * under caller-chosen parent keys and reject any renamed mapping. Returns the
  * mapped `outputData` on success or an `error` message on port-validation
  * failure (never throws).
  */
@@ -1728,15 +1733,15 @@ export function mapSubWorkflowOutput(
   outputMapping: Record<string, string>,
   ioContract?: WorkflowIoContract
 ): { outputData: Record<string, any>; error?: undefined } | { outputData?: undefined; error: string } {
-  let outputData = mapOutputData(childContext, outputMapping || {})
+  let childOutput = childContext
 
   if (ioContract?.outputs?.length) {
-    const { coerced, errors } = validateAgainstPorts(outputData, ioContract.outputs)
+    const { coerced, errors } = validateAgainstPorts(childContext, ioContract.outputs)
     if (errors.length > 0) {
       return { error: `Sub-workflow output validation failed: ${errors.map((e) => e.message).join('; ')}` }
     }
-    outputData = coerced
+    childOutput = coerced
   }
 
-  return { outputData }
+  return { outputData: mapOutputData(childOutput, outputMapping || {}) }
 }

package/src/test-utils/transactionalEntityManagerDouble.ts

@@ -0,0 +1,51 @@
+type EntityManagerOperations = Record<string, unknown>
+
+export type TransactionalEntityManagerDouble = EntityManagerOperations & {
+  begin: () => Promise<void>
+  commit: () => Promise<void>
+  rollback: () => Promise<void>
+  isInTransaction: () => boolean
+  transactional: <Result>(
+    callback: (entityManager: TransactionalEntityManagerDouble) => Promise<Result> | Result,
+  ) => Promise<Result>
+  fork: () => TransactionalEntityManagerDouble
+}
+
+export function createTransactionalEntityManagerDouble<Operations extends EntityManagerOperations>(
+  operations: Operations,
+): Operations & TransactionalEntityManagerDouble {
+  const createManager = (): Operations & TransactionalEntityManagerDouble => {
+    let transactionActive = false
+    const manager = {
+      ...operations,
+      begin: async () => {
+        transactionActive = true
+      },
+      commit: async () => {
+        transactionActive = false
+      },
+      rollback: async () => {
+        transactionActive = false
+      },
+      isInTransaction: () => transactionActive,
+      transactional: async <Result>(
+        callback: (entityManager: TransactionalEntityManagerDouble) => Promise<Result> | Result,
+      ): Promise<Result> => {
+        const transactionalManager = createManager()
+        await transactionalManager.begin()
+        try {
+          const result = await callback(transactionalManager)
+          await transactionalManager.commit()
+          return result
+        } catch (error) {
+          await transactionalManager.rollback()
+          throw error
+        }
+      },
+      fork: () => createManager(),
+    }
+    return manager
+  }
+
+  return createManager()
+}