@open-mercato/core 0.6.4-develop.4217.1.c9aa050183 → 0.6.4-develop.4236.1.9fa6806b34

package/src/modules/sales/commands/payments.ts

@@ -654,167 +654,170 @@ const updatePaymentCommand: CommandHandler<
     )
     ensureSameScope(payment, resolvedOrganizationId, resolvedTenantId)
     const previousOrder = payment.order as SalesOrder | null
-    if (input.orderId !== undefined) {
-      if (!input.orderId) {
-        payment.order = null
-      } else {
-        const order = assertFound(
-          await findOneWithDecryption(em, SalesOrder, { id: input.orderId }, {}, { tenantId: resolvedTenantId, organizationId: resolvedOrganizationId }),
-          'sales.payments.order_not_found'
-        )
-        ensureSameScope(order, resolvedOrganizationId, resolvedTenantId)
-        if (
-          order.currencyCode &&
-          input.currencyCode &&
-          order.currencyCode.toUpperCase() !== input.currencyCode.toUpperCase()
-        ) {
+    // Apply payment scalar fields, order/line status changes and the
+    // allocations rebuild in one transaction so a mid-write failure cannot
+    // leave the payment and its allocations partially committed (#2336).
+    await em.transactional(async (tx) => {
+      if (input.orderId !== undefined) {
+        if (!input.orderId) {
+          payment.order = null
+        } else {
+          const order = assertFound(
+            await findOneWithDecryption(tx, SalesOrder, { id: input.orderId }, {}, { tenantId: resolvedTenantId, organizationId: resolvedOrganizationId }),
+            'sales.payments.order_not_found'
+          )
+          ensureSameScope(order, resolvedOrganizationId, resolvedTenantId)
+          if (
+            order.currencyCode &&
+            input.currencyCode &&
+            order.currencyCode.toUpperCase() !== input.currencyCode.toUpperCase()
+          ) {
+            throw new CrudHttpError(400, {
+              error: translate('sales.payments.currency_mismatch', 'Payment currency must match the order currency.'),
+            })
+          }
+          payment.order = order
+        }
+      }
+      if (input.paymentMethodId !== undefined) {
+        if (!input.paymentMethodId) {
+          payment.paymentMethod = null
+        } else {
+          const method = assertFound(
+            await findOneWithDecryption(tx, SalesPaymentMethod, { id: input.paymentMethodId }, {}, { tenantId: resolvedTenantId, organizationId: resolvedOrganizationId }),
+            'sales.payments.method_not_found'
+          )
+          ensureSameScope(method, resolvedOrganizationId, resolvedTenantId)
+          payment.paymentMethod = method
+        }
+      }
+      const currentOrder = payment.order as SalesOrder | null
+      if ((input.documentStatusEntryId !== undefined || input.lineStatusEntryId !== undefined) && !currentOrder) {
+        throw new CrudHttpError(400, { error: translate('sales.payments.order_required', 'Order is required for payments.') })
+      }
+      if (currentOrder && input.documentStatusEntryId !== undefined) {
+        const orderStatus = await resolveDictionaryEntryValue(tx, input.documentStatusEntryId ?? null)
+        if (input.documentStatusEntryId && !orderStatus) {
           throw new CrudHttpError(400, {
-            error: translate('sales.payments.currency_mismatch', 'Payment currency must match the order currency.'),
+            error: translate('sales.documents.detail.statusInvalid', 'Selected status could not be found.'),
           })
         }
-        payment.order = order
+        currentOrder.statusEntryId = input.documentStatusEntryId ?? null
+        currentOrder.status = orderStatus
+        currentOrder.updatedAt = new Date()
+        tx.persist(currentOrder)
       }
-    }
-    if (input.paymentMethodId !== undefined) {
-      if (!input.paymentMethodId) {
-        payment.paymentMethod = null
-      } else {
-        const method = assertFound(
-          await findOneWithDecryption(em, SalesPaymentMethod, { id: input.paymentMethodId }, {}, { tenantId: resolvedTenantId, organizationId: resolvedOrganizationId }),
-          'sales.payments.method_not_found'
-        )
-        ensureSameScope(method, resolvedOrganizationId, resolvedTenantId)
-        payment.paymentMethod = method
-      }
-    }
-    const currentOrder = payment.order as SalesOrder | null
-    if ((input.documentStatusEntryId !== undefined || input.lineStatusEntryId !== undefined) && !currentOrder) {
-      throw new CrudHttpError(400, { error: translate('sales.payments.order_required', 'Order is required for payments.') })
-    }
-    if (currentOrder && input.documentStatusEntryId !== undefined) {
-      const orderStatus = await resolveDictionaryEntryValue(em, input.documentStatusEntryId ?? null)
-      if (input.documentStatusEntryId && !orderStatus) {
-        throw new CrudHttpError(400, {
-          error: translate('sales.documents.detail.statusInvalid', 'Selected status could not be found.'),
+      if (currentOrder && input.lineStatusEntryId !== undefined) {
+        const lineStatus = await resolveDictionaryEntryValue(tx, input.lineStatusEntryId ?? null)
+        if (input.lineStatusEntryId && !lineStatus) {
+          throw new CrudHttpError(400, {
+            error: translate('sales.documents.detail.statusInvalid', 'Selected status could not be found.'),
+          })
+        }
+        const orderLines = await findWithDecryption(tx, SalesOrderLine, { order: currentOrder }, {}, { tenantId: resolvedTenantId, organizationId: resolvedOrganizationId })
+        orderLines.forEach((line) => {
+          line.statusEntryId = input.lineStatusEntryId ?? null
+          line.status = lineStatus
+          line.updatedAt = new Date()
         })
+        orderLines.forEach((line) => tx.persist(line))
       }
-      currentOrder.statusEntryId = input.documentStatusEntryId ?? null
-      currentOrder.status = orderStatus
-      currentOrder.updatedAt = new Date()
-      em.persist(currentOrder)
-    }
-    if (currentOrder && input.lineStatusEntryId !== undefined) {
-      const lineStatus = await resolveDictionaryEntryValue(em, input.lineStatusEntryId ?? null)
-      if (input.lineStatusEntryId && !lineStatus) {
-        throw new CrudHttpError(400, {
-          error: translate('sales.documents.detail.statusInvalid', 'Selected status could not be found.'),
-        })
+      if (input.paymentReference !== undefined) payment.paymentReference = input.paymentReference ?? null
+      if (input.statusEntryId !== undefined) {
+        payment.statusEntryId = input.statusEntryId ?? null
+        payment.status = await resolveDictionaryEntryValue(tx, input.statusEntryId ?? null)
       }
-      const orderLines = await findWithDecryption(em, SalesOrderLine, { order: currentOrder }, {}, { tenantId: resolvedTenantId, organizationId: resolvedOrganizationId })
-      orderLines.forEach((line) => {
-        line.statusEntryId = input.lineStatusEntryId ?? null
-        line.status = lineStatus
-        line.updatedAt = new Date()
-      })
-      orderLines.forEach((line) => em.persist(line))
-    }
-    if (input.paymentReference !== undefined) payment.paymentReference = input.paymentReference ?? null
-    if (input.statusEntryId !== undefined) {
-      payment.statusEntryId = input.statusEntryId ?? null
-      payment.status = await resolveDictionaryEntryValue(em, input.statusEntryId ?? null)
-    }
-    if (input.amount !== undefined) payment.amount = toNumericString(input.amount) ?? '0'
-    if (input.currencyCode !== undefined) payment.currencyCode = input.currencyCode
-    if (input.capturedAmount !== undefined) {
-      payment.capturedAmount = toNumericString(input.capturedAmount) ?? '0'
-    }
-    if (input.refundedAmount !== undefined) {
-      payment.refundedAmount = toNumericString(input.refundedAmount) ?? '0'
-    }
-    if (input.receivedAt !== undefined) payment.receivedAt = input.receivedAt ?? null
-    if (input.capturedAt !== undefined) payment.capturedAt = input.capturedAt ?? null
-    if (input.metadata !== undefined) {
-      payment.metadata = input.metadata ? cloneJson(input.metadata) : null
-    }
-    if (input.customFieldSetId !== undefined) {
-      payment.customFieldSetId = input.customFieldSetId ?? null
-    }
-    if (input.customFields !== undefined) {
-      if (!payment.id) {
-        await em.flush()
+      if (input.amount !== undefined) payment.amount = toNumericString(input.amount) ?? '0'
+      if (input.currencyCode !== undefined) payment.currencyCode = input.currencyCode
+      if (input.capturedAmount !== undefined) {
+        payment.capturedAmount = toNumericString(input.capturedAmount) ?? '0'
       }
-      await setRecordCustomFields(em, {
-        entityId: E.sales.sales_payment,
-        recordId: payment.id,
-        organizationId: payment.organizationId,
-        tenantId: payment.tenantId,
-        values: normalizeCustomFieldsInput(input.customFields),
-      })
-    }
-    payment.updatedAt = new Date()
-    await em.flush()
-
-    if (input.allocations !== undefined) {
-      const existingAllocations = await findWithDecryption(em, SalesPaymentAllocation, { payment }, {}, { tenantId: payment.tenantId, organizationId: payment.organizationId })
-      existingAllocations.forEach((allocation) => em.remove(allocation))
-      const allocationInputs = Array.isArray(input.allocations) ? input.allocations : []
-      const paymentOrderId =
-        (typeof payment.order === 'string' ? payment.order : payment.order?.id) ?? null
-      const orderCache = new Map<string, SalesOrder>()
-      if (currentOrder) orderCache.set(currentOrder.id, currentOrder)
-      const invoiceCache = new Map<string, SalesInvoice>()
-      for (const allocation of allocationInputs) {
-        const orderId = allocation.orderId ?? paymentOrderId
-        let order: SalesOrder | null = null
-        if (orderId && typeof orderId === 'string') {
-          order = orderCache.get(orderId) ?? null
-          if (!order) {
-            order = assertFound(
-              await findOneWithDecryption(
-                em,
-                SalesOrder,
-                { id: orderId },
-                {},
-                { tenantId: payment.tenantId, organizationId: payment.organizationId },
-              ),
-              'sales.payments.order_not_found',
-            )
-            ensureSameScope(order, payment.organizationId, payment.tenantId)
-            orderCache.set(orderId, order)
-          }
-        }
-        let invoice: SalesInvoice | null = null
-        if (allocation.invoiceId) {
-          invoice = invoiceCache.get(allocation.invoiceId) ?? null
-          if (!invoice) {
-            invoice = assertFound(
-              await findOneWithDecryption(
-                em,
-                SalesInvoice,
-                { id: allocation.invoiceId },
-                {},
-                { tenantId: payment.tenantId, organizationId: payment.organizationId },
-              ),
-              'sales.payments.invoice_not_found',
-            )
-            ensureSameScope(invoice, payment.organizationId, payment.tenantId)
-            invoiceCache.set(allocation.invoiceId, invoice)
-          }
+      if (input.refundedAmount !== undefined) {
+        payment.refundedAmount = toNumericString(input.refundedAmount) ?? '0'
+      }
+      if (input.receivedAt !== undefined) payment.receivedAt = input.receivedAt ?? null
+      if (input.capturedAt !== undefined) payment.capturedAt = input.capturedAt ?? null
+      if (input.metadata !== undefined) {
+        payment.metadata = input.metadata ? cloneJson(input.metadata) : null
+      }
+      if (input.customFieldSetId !== undefined) {
+        payment.customFieldSetId = input.customFieldSetId ?? null
+      }
+      if (input.customFields !== undefined) {
+        if (!payment.id) {
+          await tx.flush()
         }
-        const entity = em.create(SalesPaymentAllocation, {
-          payment,
-          order,
-          invoice,
+        await setRecordCustomFields(tx, {
+          entityId: E.sales.sales_payment,
+          recordId: payment.id,
           organizationId: payment.organizationId,
           tenantId: payment.tenantId,
-          amount: toNumericString(allocation.amount) ?? '0',
-          currencyCode: allocation.currencyCode,
-          metadata: allocation.metadata ? cloneJson(allocation.metadata) : null,
+          values: normalizeCustomFieldsInput(input.customFields),
         })
-        em.persist(entity)
       }
-      await em.flush()
-    }
+      payment.updatedAt = new Date()
+
+      if (input.allocations !== undefined) {
+        const existingAllocations = await findWithDecryption(tx, SalesPaymentAllocation, { payment }, {}, { tenantId: payment.tenantId, organizationId: payment.organizationId })
+        existingAllocations.forEach((allocation) => tx.remove(allocation))
+        const allocationInputs = Array.isArray(input.allocations) ? input.allocations : []
+        const paymentOrderId =
+          (typeof payment.order === 'string' ? payment.order : payment.order?.id) ?? null
+        const orderCache = new Map<string, SalesOrder>()
+        if (currentOrder) orderCache.set(currentOrder.id, currentOrder)
+        const invoiceCache = new Map<string, SalesInvoice>()
+        for (const allocation of allocationInputs) {
+          const orderId = allocation.orderId ?? paymentOrderId
+          let order: SalesOrder | null = null
+          if (orderId && typeof orderId === 'string') {
+            order = orderCache.get(orderId) ?? null
+            if (!order) {
+              order = assertFound(
+                await findOneWithDecryption(
+                  tx,
+                  SalesOrder,
+                  { id: orderId },
+                  {},
+                  { tenantId: payment.tenantId, organizationId: payment.organizationId },
+                ),
+                'sales.payments.order_not_found',
+              )
+              ensureSameScope(order, payment.organizationId, payment.tenantId)
+              orderCache.set(orderId, order)
+            }
+          }
+          let invoice: SalesInvoice | null = null
+          if (allocation.invoiceId) {
+            invoice = invoiceCache.get(allocation.invoiceId) ?? null
+            if (!invoice) {
+              invoice = assertFound(
+                await findOneWithDecryption(
+                  tx,
+                  SalesInvoice,
+                  { id: allocation.invoiceId },
+                  {},
+                  { tenantId: payment.tenantId, organizationId: payment.organizationId },
+                ),
+                'sales.payments.invoice_not_found',
+              )
+              ensureSameScope(invoice, payment.organizationId, payment.tenantId)
+              invoiceCache.set(allocation.invoiceId, invoice)
+            }
+          }
+          const entity = tx.create(SalesPaymentAllocation, {
+            payment,
+            order,
+            invoice,
+            organizationId: payment.organizationId,
+            tenantId: payment.tenantId,
+            amount: toNumericString(allocation.amount) ?? '0',
+            currencyCode: allocation.currencyCode,
+            metadata: allocation.metadata ? cloneJson(allocation.metadata) : null,
+          })
+          tx.persist(entity)
+        }
+      }
+    })
 
     const nextOrderId =
       (payment.order as SalesOrder | null)?.id ??
@@ -941,10 +944,13 @@ const deletePaymentCommand: CommandHandler<
           : allocation.order?.id ?? null
       )
       .filter((value): value is string => typeof value === 'string' && value.length > 0)
-    allocations.forEach((allocation) => em.remove(allocation))
-    await em.flush()
-    em.remove(payment)
-    await em.flush()
+    // Remove the allocations and the payment in one transaction so a failure
+    // between the two deletes cannot leave orphaned allocations committed
+    // without their payment (#2336).
+    await em.transactional(async (tx) => {
+      allocations.forEach((allocation) => tx.remove(allocation))
+      tx.remove(payment)
+    })
     let totals: { paidTotalAmount: number; refundedTotalAmount: number; outstandingAmount: number } | undefined
     const orderIds = Array.from(
       new Set(

package/src/modules/sales/commands/returns.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from 'crypto'
 import { registerCommand, type CommandHandler } from '@open-mercato/shared/lib/commands'
+import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 import { LockMode } from '@mikro-orm/core'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
@@ -470,72 +471,82 @@ const createReturnCommand: CommandHandler<ReturnCreateInput, { returnId: string
     )
     if (!order) return
 
-    const lines = await findWithDecryption(
-      em,
-      SalesOrderLine,
-      { order: order.id, deletedAt: null },
-      {},
-      { tenantId: after.tenantId, organizationId: after.organizationId },
-    )
-    const lineMap = new Map(lines.map((line) => [line.id, line]))
-    after.lines.forEach((entry) => {
-      const line = lineMap.get(entry.orderLineId)
-      if (!line) return
-      const next = Math.max(0, toNumeric(line.returnedQuantity) - entry.quantityReturned)
-      line.returnedQuantity = next.toString()
-      line.updatedAt = new Date()
-      em.persist(line)
-    })
-
-    if (after.adjustmentIds.length) {
-      const adjustments = await findWithDecryption(
-        em,
-        SalesOrderAdjustment,
-        { id: { $in: after.adjustmentIds }, deletedAt: null },
-        {},
-        { tenantId: after.tenantId, organizationId: after.organizationId },
-      )
-      adjustments.forEach((adj) => em.remove(adj))
-    }
-
-    const header = await findOneWithDecryption(
-      em,
-      SalesReturn,
-      { id: after.id, deletedAt: null },
-      {},
-      { tenantId: after.tenantId, organizationId: after.organizationId },
-    )
-    const returnLines = await findWithDecryption(
-      em,
-      SalesReturnLine,
-      { salesReturn: after.id, deletedAt: null },
-      {},
-      { tenantId: after.tenantId, organizationId: after.organizationId },
-    )
-    returnLines.forEach((line) => em.remove(line))
-    if (header) em.remove(header)
+    const salesCalculationService = ctx.container.resolve<SalesCalculationService>('salesCalculationService')
 
-    const existingAdjustments = await findWithDecryption(
+    // Line reversals, adjustment/return removals, and the order-total recompute
+    // interleave queries on the same EntityManager with scalar mutations, so they
+    // must run inside an atomic flush to avoid lost updates and partial commits.
+    await withAtomicFlush(
       em,
-      SalesOrderAdjustment,
-      { order: order.id, deletedAt: null },
-      { orderBy: { position: 'asc' } },
-      { tenantId: after.tenantId, organizationId: after.organizationId },
+      [
+        async () => {
+          const lines = await findWithDecryption(
+            em,
+            SalesOrderLine,
+            { order: order.id, deletedAt: null },
+            {},
+            { tenantId: after.tenantId, organizationId: after.organizationId },
+          )
+          const lineMap = new Map(lines.map((line) => [line.id, line]))
+          after.lines.forEach((entry) => {
+            const line = lineMap.get(entry.orderLineId)
+            if (!line) return
+            const next = Math.max(0, toNumeric(line.returnedQuantity) - entry.quantityReturned)
+            line.returnedQuantity = next.toString()
+            line.updatedAt = new Date()
+            em.persist(line)
+          })
+
+          if (after.adjustmentIds.length) {
+            const adjustments = await findWithDecryption(
+              em,
+              SalesOrderAdjustment,
+              { id: { $in: after.adjustmentIds }, deletedAt: null },
+              {},
+              { tenantId: after.tenantId, organizationId: after.organizationId },
+            )
+            adjustments.forEach((adj) => em.remove(adj))
+          }
+
+          const header = await findOneWithDecryption(
+            em,
+            SalesReturn,
+            { id: after.id, deletedAt: null },
+            {},
+            { tenantId: after.tenantId, organizationId: after.organizationId },
+          )
+          const returnLines = await findWithDecryption(
+            em,
+            SalesReturnLine,
+            { salesReturn: after.id, deletedAt: null },
+            {},
+            { tenantId: after.tenantId, organizationId: after.organizationId },
+          )
+          returnLines.forEach((line) => em.remove(line))
+          if (header) em.remove(header)
+
+          const existingAdjustments = await findWithDecryption(
+            em,
+            SalesOrderAdjustment,
+            { order: order.id, deletedAt: null },
+            { orderBy: { position: 'asc' } },
+            { tenantId: after.tenantId, organizationId: after.organizationId },
+          )
+          const lineSnapshots: SalesLineSnapshot[] = lines.map(mapOrderLineEntityToSnapshot)
+          const adjustmentDrafts: SalesAdjustmentDraft[] = existingAdjustments.map(mapOrderAdjustmentToDraft)
+          const calculation = await salesCalculationService.calculateDocumentTotals({
+            documentKind: 'order',
+            lines: lineSnapshots,
+            adjustments: adjustmentDrafts,
+            context: buildCalculationContext(order),
+          })
+          applyOrderTotals(order, calculation.totals, calculation.lines.length)
+          order.updatedAt = new Date()
+          em.persist(order)
+        },
+      ],
+      { transaction: true },
     )
-    const salesCalculationService = ctx.container.resolve<SalesCalculationService>('salesCalculationService')
-    const lineSnapshots: SalesLineSnapshot[] = lines.map(mapOrderLineEntityToSnapshot)
-    const adjustmentDrafts: SalesAdjustmentDraft[] = existingAdjustments.map(mapOrderAdjustmentToDraft)
-    const calculation = await salesCalculationService.calculateDocumentTotals({
-      documentKind: 'order',
-      lines: lineSnapshots,
-      adjustments: adjustmentDrafts,
-      context: buildCalculationContext(order),
-    })
-    applyOrderTotals(order, calculation.totals, calculation.lines.length)
-    order.updatedAt = new Date()
-    em.persist(order)
-
-    await em.flush()
   },
 }
 

package/src/modules/staff/acl.ts

@@ -8,6 +8,17 @@ export const features = [
   { id: 'staff.my_availability.unavailability', title: 'Manage my unavailability', module: 'staff' },
   { id: 'staff.my_leave_requests.view', title: 'View my leave requests', module: 'staff' },
   { id: 'staff.my_leave_requests.send', title: 'Send my leave requests', module: 'staff' },
+
+  // Timesheets (Phase 1)
+  { id: 'staff.timesheets.view', title: 'View own time entries', module: 'staff' },
+  { id: 'staff.timesheets.manage_own', title: 'Create/edit/delete own entries', module: 'staff' },
+  { id: 'staff.timesheets.manage_all', title: 'Manage all employees entries', module: 'staff' },
+  { id: 'staff.timesheets.projects.view', title: 'View time projects', module: 'staff' },
+  { id: 'staff.timesheets.projects.manage', title: 'Manage time projects', module: 'staff' },
+
+  // Timesheets (Phase 2)
+  { id: 'staff.timesheets.approve', title: 'Approve reportee time', module: 'staff' },
+  { id: 'staff.timesheets.lock', title: 'Lock time periods', module: 'staff' },
 ]
 
 export default features

package/src/modules/staff/analytics.ts

@@ -0,0 +1,30 @@
+import type { AnalyticsModuleConfig } from '@open-mercato/shared/modules/analytics'
+
+export const analyticsConfig: AnalyticsModuleConfig = {
+  entities: [
+    {
+      entityId: 'staff:staff_time_entries',
+      requiredFeatures: ['staff.timesheets.view'],
+      entityConfig: {
+        tableName: 'staff_time_entries',
+        dateField: 'date',
+        defaultScopeFields: ['tenant_id', 'organization_id'],
+      },
+      fieldMappings: {
+        id: { dbColumn: 'id', type: 'uuid' },
+        durationMinutes: { dbColumn: 'duration_minutes', type: 'numeric' },
+        date: { dbColumn: 'date', type: 'timestamp' },
+        timeProjectId: { dbColumn: 'time_project_id', type: 'uuid' },
+        staffMemberId: { dbColumn: 'staff_member_id', type: 'uuid' },
+        source: { dbColumn: 'source', type: 'text' },
+      },
+      labelResolvers: {
+        timeProjectId: { table: 'staff_time_projects', idColumn: 'id', labelColumn: 'name' },
+        staffMemberId: { table: 'staff_team_members', idColumn: 'id', labelColumn: 'display_name' },
+      },
+    },
+  ],
+}
+
+export const config = analyticsConfig
+export default analyticsConfig

package/src/modules/staff/api/guards.ts

@@ -0,0 +1,59 @@
+import type { AwilixContainer } from 'awilix'
+import {
+  bridgeLegacyGuard,
+  runMutationGuards,
+  type MutationGuard,
+  type MutationGuardInput,
+} from '@open-mercato/shared/lib/crud/mutation-guard-registry'
+
+type GuardAfterCallback = {
+  guard: MutationGuard
+  metadata: Record<string, unknown> | null
+}
+
+export function resolveUserFeatures(auth: unknown): string[] {
+  const features = (auth as { features?: unknown })?.features
+  if (!Array.isArray(features)) return []
+  return features.filter((value): value is string => typeof value === 'string')
+}
+
+export async function runStaffMutationGuards(
+  container: AwilixContainer,
+  input: MutationGuardInput,
+  userFeatures: string[],
+): Promise<{
+  ok: boolean
+  errorBody?: Record<string, unknown>
+  errorStatus?: number
+  modifiedPayload?: Record<string, unknown>
+  afterSuccessCallbacks: GuardAfterCallback[]
+}> {
+  const legacyGuard = bridgeLegacyGuard(container)
+  if (!legacyGuard) {
+    return { ok: true, afterSuccessCallbacks: [] }
+  }
+
+  return runMutationGuards([legacyGuard], input, { userFeatures })
+}
+
+export async function runStaffMutationGuardAfterSuccess(
+  callbacks: GuardAfterCallback[],
+  input: {
+    tenantId: string
+    organizationId: string | null
+    userId: string
+    resourceKind: string
+    resourceId: string
+    operation: 'create' | 'update' | 'delete'
+    requestMethod: string
+    requestHeaders: Headers
+  },
+): Promise<void> {
+  for (const callback of callbacks) {
+    if (!callback.guard.afterSuccess) continue
+    await callback.guard.afterSuccess({
+      ...input,
+      metadata: callback.metadata ?? null,
+    })
+  }
+}