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

package/src/modules/customers/commands/personCompanyLinks.ts

@@ -294,35 +294,36 @@ const createPersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkCreateInpu
     )
     if (!link) return
 
-    link.isPrimary = false
-    link.deletedAt = new Date()
-    await em.flush()
-
-    const person = await findOneWithDecryption(
-      em,
-      CustomerEntity,
-      { id: after.personEntityId, kind: 'person', tenantId: after.tenantId, organizationId: after.organizationId, deletedAt: null },
-      undefined,
-      { tenantId: after.tenantId, organizationId: after.organizationId },
-    )
-    if (person) {
-      const profile = await findOneWithDecryption(
-        em,
-        CustomerPersonProfile,
-        { entity: person },
-        { populate: ['company'] },
-        { tenantId: person.tenantId, organizationId: person.organizationId },
-      )
-      if (profile) {
-        const remainingLinks = await loadPersonCompanyLinks(em, person)
-        if (after.isPrimary) {
-          await promoteFallbackPrimaryLink(em, person, profile, remainingLinks, after.companyEntityId)
-        } else if (profile.company && typeof profile.company !== 'string' && profile.company.id === after.companyEntityId) {
-          profile.company = null
+    await withAtomicFlush(em, [
+      async () => {
+        link.isPrimary = false
+        link.deletedAt = new Date()
+        const person = await findOneWithDecryption(
+          em,
+          CustomerEntity,
+          { id: after.personEntityId, kind: 'person', tenantId: after.tenantId, organizationId: after.organizationId, deletedAt: null },
+          undefined,
+          { tenantId: after.tenantId, organizationId: after.organizationId },
+        )
+        if (person) {
+          const profile = await findOneWithDecryption(
+            em,
+            CustomerPersonProfile,
+            { entity: person },
+            { populate: ['company'] },
+            { tenantId: person.tenantId, organizationId: person.organizationId },
+          )
+          if (profile) {
+            const remainingLinks = await loadPersonCompanyLinks(em, person)
+            if (after.isPrimary) {
+              await promoteFallbackPrimaryLink(em, person, profile, remainingLinks, after.companyEntityId)
+            } else if (profile.company && typeof profile.company !== 'string' && profile.company.id === after.companyEntityId) {
+              profile.company = null
+            }
+          }
         }
-        await em.flush()
-      }
-    }
+      },
+    ], { transaction: true })
 
     const dataEngine = ctx.container.resolve('dataEngine') as DataEngine
     await emitCrudUndoSideEffects({
@@ -376,21 +377,24 @@ const updatePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkUpdateInpu
     const profile = await requirePersonProfile(em, person)
     const linkedCompany = await requireCompanyEntity(em, companyId, parsed.tenantId, parsed.organizationId)
 
-    if (parsed.isPrimary) {
-      await clearPrimaryFlagsForPerson(em, person)
-      link.isPrimary = true
-      profile.company = linkedCompany
-    } else if (!parsed.isPrimary) {
-      const linkWasPrimary = link.isPrimary
-      link.isPrimary = false
-      if (linkWasPrimary) {
-        const remainingLinks = (await loadPersonCompanyLinks(em, person)).filter((entry) => entry.id !== link.id)
-        await promoteFallbackPrimaryLink(em, person, profile, remainingLinks, companyId)
-      } else if (profile.company && typeof profile.company !== 'string' && profile.company.id === companyId) {
-        profile.company = null
-      }
-    }
-    await em.flush()
+    await withAtomicFlush(em, [
+      async () => {
+        if (parsed.isPrimary) {
+          await clearPrimaryFlagsForPerson(em, person)
+          link.isPrimary = true
+          profile.company = linkedCompany
+        } else if (!parsed.isPrimary) {
+          const linkWasPrimary = link.isPrimary
+          link.isPrimary = false
+          if (linkWasPrimary) {
+            const remainingLinks = (await loadPersonCompanyLinks(em, person)).filter((entry) => entry.id !== link.id)
+            await promoteFallbackPrimaryLink(em, person, profile, remainingLinks, companyId)
+          } else if (profile.company && typeof profile.company !== 'string' && profile.company.id === companyId) {
+            profile.company = null
+          }
+        }
+      },
+    ], { transaction: true })
 
     const dataEngine = ctx.container.resolve('dataEngine') as DataEngine
     await emitCrudSideEffects({
@@ -449,39 +453,42 @@ const updatePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkUpdateInpu
     )
     if (!link) return
 
-    const person = await findOneWithDecryption(
-      em,
-      CustomerEntity,
-      { id: before.personEntityId, kind: 'person', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
-      undefined,
-      { tenantId: before.tenantId, organizationId: before.organizationId },
-    )
-    if (person) {
-      const profile = await findOneWithDecryption(
-        em,
-        CustomerPersonProfile,
-        { entity: person },
-        { populate: ['company'] },
-        { tenantId: person.tenantId, organizationId: person.organizationId },
-      )
-      if (profile) {
-        if (before.isPrimary) {
-          await clearPrimaryFlagsForPerson(em, person)
-          link.isPrimary = true
-          const company = await findOneWithDecryption(
+    await withAtomicFlush(em, [
+      async () => {
+        const person = await findOneWithDecryption(
+          em,
+          CustomerEntity,
+          { id: before.personEntityId, kind: 'person', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
+          undefined,
+          { tenantId: before.tenantId, organizationId: before.organizationId },
+        )
+        if (person) {
+          const profile = await findOneWithDecryption(
             em,
-            CustomerEntity,
-            { id: before.companyEntityId, kind: 'company', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
-            undefined,
-            { tenantId: before.tenantId, organizationId: before.organizationId },
+            CustomerPersonProfile,
+            { entity: person },
+            { populate: ['company'] },
+            { tenantId: person.tenantId, organizationId: person.organizationId },
           )
-          if (company) profile.company = company
-        } else {
-          link.isPrimary = false
+          if (profile) {
+            if (before.isPrimary) {
+              await clearPrimaryFlagsForPerson(em, person)
+              link.isPrimary = true
+              const company = await findOneWithDecryption(
+                em,
+                CustomerEntity,
+                { id: before.companyEntityId, kind: 'company', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
+                undefined,
+                { tenantId: before.tenantId, organizationId: before.organizationId },
+              )
+              if (company) profile.company = company
+            } else {
+              link.isPrimary = false
+            }
+          }
         }
-      }
-    }
-    await em.flush()
+      },
+    ], { transaction: true })
 
     const dataEngine = ctx.container.resolve('dataEngine') as DataEngine
     await emitCrudUndoSideEffects({
@@ -603,39 +610,41 @@ const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInpu
     )
     if (!link) return
 
-    link.deletedAt = null
-    link.isPrimary = before.isPrimary
+    await withAtomicFlush(em, [
+      async () => {
+        link.deletedAt = null
+        link.isPrimary = before.isPrimary
 
-    const person = await findOneWithDecryption(
-      em,
-      CustomerEntity,
-      { id: before.personEntityId, kind: 'person', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
-      undefined,
-      { tenantId: before.tenantId, organizationId: before.organizationId },
-    )
-    if (person && before.isPrimary) {
-      await clearPrimaryFlagsForPerson(em, person)
-      link.isPrimary = true
-      const profile = await findOneWithDecryption(
-        em,
-        CustomerPersonProfile,
-        { entity: person },
-        { populate: ['company'] },
-        { tenantId: person.tenantId, organizationId: person.organizationId },
-      )
-      if (profile) {
-        const company = await findOneWithDecryption(
+        const person = await findOneWithDecryption(
           em,
           CustomerEntity,
-          { id: before.companyEntityId, kind: 'company', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
+          { id: before.personEntityId, kind: 'person', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
           undefined,
           { tenantId: before.tenantId, organizationId: before.organizationId },
         )
-        if (company) profile.company = company
-      }
-    }
-
-    await em.flush()
+        if (person && before.isPrimary) {
+          await clearPrimaryFlagsForPerson(em, person)
+          link.isPrimary = true
+          const profile = await findOneWithDecryption(
+            em,
+            CustomerPersonProfile,
+            { entity: person },
+            { populate: ['company'] },
+            { tenantId: person.tenantId, organizationId: person.organizationId },
+          )
+          if (profile) {
+            const company = await findOneWithDecryption(
+              em,
+              CustomerEntity,
+              { id: before.companyEntityId, kind: 'company', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
+              undefined,
+              { tenantId: before.tenantId, organizationId: before.organizationId },
+            )
+            if (company) profile.company = company
+          }
+        }
+      },
+    ], { transaction: true })
 
     const dataEngine = ctx.container.resolve('dataEngine') as DataEngine
     await emitCrudUndoSideEffects({

package/src/modules/customers/commands/pipeline-stages.ts

@@ -15,6 +15,7 @@ import {
 } from '../data/validators'
 import { ensureOrganizationScope, ensureTenantScope, ensureDictionaryEntry } from './shared'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 
 const createPipelineStageCommand: CommandHandler<PipelineStageCreateInput, { stageId: string }> = {
   id: 'customers.pipeline-stages.create',
@@ -48,9 +49,7 @@ const createPipelineStageCommand: CommandHandler<PipelineStageCreateInput, { sta
         ? existingStages.length
         : Math.max(0, Math.min(requestedOrder, existingStages.length))
 
-    // Shift the order of every stage at or after the insert position. We use the
-    // already-forked EM so the shifts and the new INSERT land in a single `flush()`
-    // (one transaction by default with MikroORM's `forceTransactions` config). Skipping
+    // Shift the order of every stage at or after the insert position. Skipping
     // this step would either duplicate `order` values (silently corrupting kanban
     // ordering) or push the new stage to the wrong spot when re-sorting.
     if (requestedOrder !== undefined) {
@@ -71,18 +70,22 @@ const createPipelineStageCommand: CommandHandler<PipelineStageCreateInput, { sta
       createdAt: new Date(),
       updatedAt: new Date(),
     })
-    em.persist(stage)
-    await em.flush()
 
-    await ensureDictionaryEntry(em, {
-      tenantId: parsed.tenantId,
-      organizationId: parsed.organizationId,
-      kind: 'pipeline_stage',
-      value: stage.label,
-      color: parsed.color,
-      icon: parsed.icon,
-    })
-    await em.flush()
+    await withAtomicFlush(em, [
+      () => {
+        em.persist(stage)
+      },
+      async () => {
+        await ensureDictionaryEntry(em, {
+          tenantId: parsed.tenantId,
+          organizationId: parsed.organizationId,
+          kind: 'pipeline_stage',
+          value: stage.label,
+          color: parsed.color,
+          icon: parsed.icon,
+        })
+      },
+    ], { transaction: true })
 
     return { stageId: stage.id }
   },
@@ -113,19 +116,20 @@ const updatePipelineStageCommand: CommandHandler<PipelineStageUpdateInput, void>
     if (parsed.order !== undefined) stage.order = parsed.order
     stage.updatedAt = new Date()
 
-    await em.flush()
-
-    if (parsed.label !== undefined || parsed.color !== undefined || parsed.icon !== undefined) {
-      await ensureDictionaryEntry(em, {
-        tenantId: stage.tenantId,
-        organizationId: stage.organizationId,
-        kind: 'pipeline_stage',
-        value: stage.label,
-        color: parsed.color,
-        icon: parsed.icon,
-      })
-      await em.flush()
-    }
+    await withAtomicFlush(em, [
+      async () => {
+        if (parsed.label !== undefined || parsed.color !== undefined || parsed.icon !== undefined) {
+          await ensureDictionaryEntry(em, {
+            tenantId: stage.tenantId,
+            organizationId: stage.organizationId,
+            kind: 'pipeline_stage',
+            value: stage.label,
+            color: parsed.color,
+            icon: parsed.icon,
+          })
+        }
+      },
+    ], { transaction: true })
   },
 }
 

package/src/modules/customers/commands/pipelines.ts

@@ -12,6 +12,7 @@ import {
 } from '../data/validators'
 import { ensureOrganizationScope, ensureTenantScope } from './shared'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 
 const createPipelineCommand: CommandHandler<PipelineCreateInput, { pipelineId: string }> = {
   id: 'customers.pipelines.create',
@@ -22,14 +23,6 @@ const createPipelineCommand: CommandHandler<PipelineCreateInput, { pipelineId: s
 
     const em = (ctx.container.resolve('em') as EntityManager).fork()
 
-    if (parsed.isDefault) {
-      await em.nativeUpdate(
-        CustomerPipeline,
-        { organizationId: parsed.organizationId, tenantId: parsed.tenantId, isDefault: true },
-        { isDefault: false }
-      )
-    }
-
     const pipeline = em.create(CustomerPipeline, {
       organizationId: parsed.organizationId,
       tenantId: parsed.tenantId,
@@ -38,8 +31,19 @@ const createPipelineCommand: CommandHandler<PipelineCreateInput, { pipelineId: s
       createdAt: new Date(),
       updatedAt: new Date(),
     })
-    em.persist(pipeline)
-    await em.flush()
+
+    await withAtomicFlush(em, [
+      async () => {
+        if (parsed.isDefault) {
+          await em.nativeUpdate(
+            CustomerPipeline,
+            { organizationId: parsed.organizationId, tenantId: parsed.tenantId, isDefault: true },
+            { isDefault: false }
+          )
+        }
+        em.persist(pipeline)
+      },
+    ], { transaction: true })
 
     return { pipelineId: pipeline.id }
   },
@@ -57,19 +61,21 @@ const updatePipelineCommand: CommandHandler<PipelineUpdateInput, void> = {
     ensureTenantScope(ctx, pipeline.tenantId)
     ensureOrganizationScope(ctx, pipeline.organizationId)
 
-    if (parsed.isDefault && !pipeline.isDefault) {
-      await em.nativeUpdate(
-        CustomerPipeline,
-        { organizationId: pipeline.organizationId, tenantId: pipeline.tenantId, isDefault: true },
-        { isDefault: false }
-      )
-    }
-
-    if (parsed.name !== undefined) pipeline.name = parsed.name
-    if (parsed.isDefault !== undefined) pipeline.isDefault = parsed.isDefault
-    pipeline.updatedAt = new Date()
-
-    await em.flush()
+    await withAtomicFlush(em, [
+      async () => {
+        if (parsed.isDefault && !pipeline.isDefault) {
+          await em.nativeUpdate(
+            CustomerPipeline,
+            { organizationId: pipeline.organizationId, tenantId: pipeline.tenantId, isDefault: true },
+            { isDefault: false }
+          )
+        }
+
+        if (parsed.name !== undefined) pipeline.name = parsed.name
+        if (parsed.isDefault !== undefined) pipeline.isDefault = parsed.isDefault
+        pipeline.updatedAt = new Date()
+      },
+    ], { transaction: true })
   },
 }
 

package/src/modules/customers/commands/tags.ts

@@ -25,6 +25,7 @@ import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import type { CrudEventsConfig } from '@open-mercato/shared/lib/crud/types'
 import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { emitCustomersEvent } from '../events'
+import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 
 const tagCrudEvents: CrudEventsConfig = {
   module: 'customers',
@@ -286,9 +287,12 @@ const deleteTagCommand: CommandHandler<{ body?: Record<string, unknown>; query?:
     if (!tag) throw new CrudHttpError(404, { error: 'Tag not found' })
     ensureTenantScope(ctx, tag.tenantId)
     ensureOrganizationScope(ctx, tag.organizationId)
-    await em.nativeDelete(CustomerTagAssignment, { tag })
-    em.remove(tag)
-    await em.flush()
+    await withAtomicFlush(em, [
+      async () => {
+        await em.nativeDelete(CustomerTagAssignment, { tag })
+        em.remove(tag)
+      },
+    ], { transaction: true })
 
     const de = (ctx.container.resolve('dataEngine') as DataEngine)
     await emitCrudSideEffects({
@@ -345,7 +349,12 @@ const deleteTagCommand: CommandHandler<{ body?: Record<string, unknown>; query?:
       tag.color = before.color
       tag.description = before.description
     }
-    await em.flush()
+    const restoredTag = tag
+    await withAtomicFlush(em, [
+      () => {
+        em.persist(restoredTag)
+      },
+    ], { transaction: true })
 
     const de = (ctx.container.resolve('dataEngine') as DataEngine)
     await emitCrudUndoSideEffects({
@@ -471,7 +480,6 @@ const unassignTagCommand: CommandHandler<TagAssignmentInput, { assignmentId: str
     })
     if (!existing) throw new CrudHttpError(404, { error: 'Tag assignment not found' })
     await em.remove(existing).flush()
-    await em.flush()
 
     const de = (ctx.container.resolve('dataEngine') as DataEngine)
     await emitCrudSideEffects({

package/src/modules/dashboards/api/users/widgets/route.ts

@@ -129,7 +129,6 @@ export async function PUT(req: Request) {
   if (parsed.data.mode === 'inherit') {
     if (record) {
       await em.remove(record).flush()
-      await em.flush()
     }
     return NextResponse.json({ ok: true, mode: 'inherit', widgetIds: [] })
   }

package/src/modules/dashboards/api/widgets/data/route.ts

@@ -10,6 +10,7 @@ import {
   WidgetDataValidationError,
 } from '../../../services/widgetDataService'
 import type { AnalyticsRegistry } from '../../../services/analyticsRegistry'
+import { runApiInterceptorsBefore } from '@open-mercato/shared/lib/crud/interceptor-runner'
 import type { OpenApiMethodDoc, OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { dashboardsTag, dashboardsErrorSchema } from '../../openapi'
 import { widgetDataRequestSchema, widgetDataResponseSchema } from './schema'
@@ -81,10 +82,44 @@ export async function POST(req: Request) {
     return undefined
   })()
 
+  const userFeatures = Array.isArray(auth.features)
+    ? auth.features.filter((value): value is string => typeof value === 'string')
+    : []
+
+  const headers: Record<string, string> = {}
+  req.headers.forEach((value, key) => {
+    headers[key] = value
+  })
+
+  const interceptorResult = await runApiInterceptorsBefore({
+    routePath: 'dashboards/widgets/data',
+    method: 'POST',
+    request: {
+      method: 'POST',
+      url: req.url,
+      headers,
+      body: parsed.data as unknown as Record<string, unknown>,
+    },
+    context: {
+      em,
+      container,
+      userId: auth.sub ?? '',
+      tenantId,
+      organizationId: organizationIds?.[0] ?? auth.orgId ?? '',
+      userFeatures,
+    },
+  })
+
+  if (!interceptorResult.ok) {
+    return NextResponse.json(interceptorResult.body, { status: interceptorResult.statusCode })
+  }
+
+  const requestData = (interceptorResult.request.body ?? parsed.data) as WidgetDataRequest
+
   try {
     const cache = container.resolve<CacheStrategy>('cache')
     const service = createWidgetDataService(em, { tenantId, organizationIds }, analyticsRegistry, cache)
-    const result = await service.fetchWidgetData(parsed.data as WidgetDataRequest)
+    const result = await service.fetchWidgetData(requestData)
     return NextResponse.json(result)
   } catch (err) {
     console.error('[widgets/data] Error:', err)

package/src/modules/data_sync/lib/sync-engine.ts

@@ -445,15 +445,15 @@ export function createSyncEngine(deps: EngineDeps) {
           processedCount += processedBatchCount
           totalCount = batch.totalEstimate ?? totalCount
 
-          await syncRunService.updateCounts(
+          await syncRunService.commitBatchProgress(
             run.id,
             {
               ...delta,
               batchesCompleted: 1,
             },
+            batch.cursor,
             scope,
           )
-          await syncRunService.updateCursor(run.id, batch.cursor, scope)
 
           await updateProgress(run.progressJobId, processedCount, totalCount, scope)
           await refreshCoverageSnapshots(batch.refreshCoverageEntityTypes, scope)
@@ -587,7 +587,7 @@ export function createSyncEngine(deps: EngineDeps) {
           const delta = applyExportCounters(batch)
           processedCount += delta.processedCount
 
-          await syncRunService.updateCounts(
+          await syncRunService.commitBatchProgress(
             run.id,
             {
               createdCount: 0,
@@ -596,10 +596,9 @@ export function createSyncEngine(deps: EngineDeps) {
               failedCount: delta.failedCount,
               batchesCompleted: 1,
             },
+            batch.cursor,
             scope,
           )
-
-          await syncRunService.updateCursor(run.id, batch.cursor, scope)
           await updateProgress(run.progressJobId, processedCount, null, scope)
 
           await writeOperationalLog({

package/src/modules/data_sync/lib/sync-run-service.ts

@@ -1,5 +1,6 @@
 import type { EntityManager, FilterQuery } from '@mikro-orm/postgresql'
 import { findAndCountWithDecryption, findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 import { SyncCursor, SyncRun } from '../data/entities'
 
 type SyncScope = {
@@ -8,6 +9,38 @@ type SyncScope = {
 }
 
 export function createSyncRunService(em: EntityManager) {
+  async function resolveCursorRow(run: SyncRun, scope: SyncScope): Promise<SyncCursor | null> {
+    return findOneWithDecryption(
+      em,
+      SyncCursor,
+      {
+        integrationId: run.integrationId,
+        entityType: run.entityType,
+        direction: run.direction,
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+      },
+      undefined,
+      scope,
+    )
+  }
+
+  function applyCursorMutation(run: SyncRun, cursorRow: SyncCursor | null, cursor: string, scope: SyncScope): void {
+    run.cursor = cursor
+    if (cursorRow) {
+      cursorRow.cursor = cursor
+    } else {
+      em.create(SyncCursor, {
+        integrationId: run.integrationId,
+        entityType: run.entityType,
+        direction: run.direction,
+        cursor,
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+      })
+    }
+  }
+
   return {
     async createRun(input: {
       integrationId: string
@@ -142,36 +175,32 @@ export function createSyncRunService(em: EntityManager) {
     async updateCursor(runId: string, cursor: string, scope: SyncScope): Promise<void> {
       const run = await this.getRun(runId, scope)
       if (!run) return
-      run.cursor = cursor
+      const cursorRow = await resolveCursorRow(run, scope)
+      await withAtomicFlush(em, [
+        () => applyCursorMutation(run, cursorRow, cursor, scope),
+      ], { transaction: true })
+    },
 
-      const cursorRow = await findOneWithDecryption(
-        em,
-        SyncCursor,
-        {
-        integrationId: run.integrationId,
-        entityType: run.entityType,
-        direction: run.direction,
-        organizationId: scope.organizationId,
-        tenantId: scope.tenantId,
+    async commitBatchProgress(
+      runId: string,
+      delta: Partial<Pick<SyncRun, 'createdCount' | 'updatedCount' | 'skippedCount' | 'failedCount' | 'batchesCompleted'>>,
+      cursor: string,
+      scope: SyncScope,
+    ): Promise<SyncRun | null> {
+      const run = await this.getRun(runId, scope)
+      if (!run) return null
+      const cursorRow = await resolveCursorRow(run, scope)
+      await withAtomicFlush(em, [
+        () => {
+          run.createdCount += delta.createdCount ?? 0
+          run.updatedCount += delta.updatedCount ?? 0
+          run.skippedCount += delta.skippedCount ?? 0
+          run.failedCount += delta.failedCount ?? 0
+          run.batchesCompleted += delta.batchesCompleted ?? 0
+          applyCursorMutation(run, cursorRow, cursor, scope)
         },
-        undefined,
-        scope,
-      )
-
-      if (cursorRow) {
-        cursorRow.cursor = cursor
-      } else {
-        em.create(SyncCursor, {
-          integrationId: run.integrationId,
-          entityType: run.entityType,
-          direction: run.direction,
-          cursor,
-          organizationId: scope.organizationId,
-          tenantId: scope.tenantId,
-        })
-      }
-
-      await em.flush()
+      ], { transaction: true })
+      return run
     },
 
     async resolveCursor(integrationId: string, entityType: string, direction: 'import' | 'export', scope: SyncScope): Promise<string | null> {