@open-mercato/core 0.6.8-develop.6987.1.02f619470c → 0.6.8-develop.6992.1.00c90fecff

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

@@ -26,6 +26,25 @@ type SyncScope = {
   tenantId: string
 }
 
+export type CursorCommitOptions = {
+  /**
+   * Mirror the committed cursor into the shared `sync_cursors` row. Defaults to
+   * `true`; the engine passes the adapter's `persistsSharedCursor(entityType)`
+   * verdict. `false` keeps the cursor on the run row alone.
+   */
+  persistSharedCursor?: boolean
+  /**
+   * Fences the write against a concurrent delivery: the run must still be
+   * `running` and still sit on this batch count, or the commit throws
+   * {@link SyncRunOwnershipConflictError} and rolls back. Omit to keep the
+   * unguarded write for callers outside the engine.
+   */
+  expectedBatchesCompleted?: number
+}
+
+/** {@link CursorCommitOptions} minus the fence, which `updateCursor` does not apply. */
+export type SharedCursorOption = Pick<CursorCommitOptions, 'persistSharedCursor'>
+
 /**
  * Raised when a batch commit loses the ownership compare-and-swap, meaning
  * another delivery of the same job advanced the run while this worker was
@@ -64,8 +83,15 @@ export function createSyncRunService(em: EntityManager) {
     )
   }
 
-  function applyCursorMutation(run: SyncRun, cursorRow: SyncCursor | null, cursor: string, scope: SyncScope): void {
+  function applyCursorMutation(
+    run: SyncRun,
+    cursorRow: SyncCursor | null,
+    cursor: string,
+    scope: SyncScope,
+    persistSharedCursor: boolean,
+  ): void {
     run.cursor = cursor
+    if (!persistSharedCursor) return
     if (cursorRow) {
       cursorRow.cursor = cursor
     } else {
@@ -230,25 +256,37 @@ export function createSyncRunService(em: EntityManager) {
      * @deprecated Use {@link commitBatchProgress}. This method advances the
      * cursor without the ownership fence, so a stale delivery can move the
      * cursor of a run another worker owns. Kept for external callers only.
+     *
+     * It still takes `persistSharedCursor` despite being deprecated: an external
+     * caller advancing the cursor of an opted-out entity type would otherwise
+     * create the very `sync_cursors` row the opt-out exists to avoid, and a
+     * later incremental run would read it as a start position. The deprecated
+     * path has to honour the opt-out for as long as it exists.
      */
-    async updateCursor(runId: string, cursor: string, scope: SyncScope): Promise<void> {
+    async updateCursor(runId: string, cursor: string, scope: SyncScope, options?: SharedCursorOption): Promise<void> {
       const run = await this.getRun(runId, scope)
       if (!run) return
-      const cursorRow = await resolveCursorRow(run, scope)
+      const persistSharedCursor = options?.persistSharedCursor ?? true
+      const cursorRow = persistSharedCursor ? await resolveCursorRow(run, scope) : null
       await withAtomicFlush(em, [
-        () => applyCursorMutation(run, cursorRow, cursor, scope),
+        () => applyCursorMutation(run, cursorRow, cursor, scope, persistSharedCursor),
       ], { transaction: true })
     },
 
     /**
      * Commits one batch's counters and cursor in a single transaction.
      *
-     * Passing `expectedBatchesCompleted` fences the write: the run must still be
-     * `running` and still sit on that batch count, or another delivery of the
-     * same BullMQ job owns the run and this commit throws
+     * Passing `options.expectedBatchesCompleted` fences the write: the run must
+     * still be `running` and still sit on that batch count, or another delivery
+     * of the same BullMQ job owns the run and this commit throws
      * `SyncRunOwnershipConflictError` and rolls back. Omitting it keeps the
      * legacy unguarded write for callers outside the engine.
      *
+     * `options.persistSharedCursor` is orthogonal to the fence: it decides
+     * whether the committed cursor is mirrored into the shared `sync_cursors`
+     * row, and the two compose freely — a fenced commit for an opted-out entity
+     * type advances the run row alone and still throws on a stale fence.
+     *
      * The fence token is `batchesCompleted` rather than `cursor` because it
      * advances by construction on every commit. A cursor is a free-form adapter
      * string that an adapter may legitimately repeat between batches — the
@@ -268,11 +306,13 @@ export function createSyncRunService(em: EntityManager) {
       delta: Partial<Pick<SyncRun, 'createdCount' | 'updatedCount' | 'skippedCount' | 'failedCount' | 'batchesCompleted'>>,
       cursor: string,
       scope: SyncScope,
-      expectedBatchesCompleted?: number,
+      options?: CursorCommitOptions,
     ): Promise<SyncRun | null> {
       const run = await this.getRun(runId, scope)
       if (!run) return null
-      const cursorRow = await resolveCursorRow(run, scope)
+      const { expectedBatchesCompleted } = options ?? {}
+      const persistSharedCursor = options?.persistSharedCursor ?? true
+      const cursorRow = persistSharedCursor ? await resolveCursorRow(run, scope) : null
       const claimRunOwnership = async () => {
         if ((delta.batchesCompleted ?? 0) < 1) {
           throw new Error(`[internal] A fenced commit for sync run ${runId} must advance batchesCompleted`)
@@ -301,7 +341,7 @@ export function createSyncRunService(em: EntityManager) {
           run.skippedCount += delta.skippedCount ?? 0
           run.failedCount += delta.failedCount ?? 0
           run.batchesCompleted += delta.batchesCompleted ?? 0
-          applyCursorMutation(run, cursorRow, cursor, scope)
+          applyCursorMutation(run, cursorRow, cursor, scope, persistSharedCursor)
         },
       ], { transaction: true })
       return run
@@ -324,6 +364,74 @@ export function createSyncRunService(em: EntityManager) {
       return row?.cursor ?? null
     },
 
+    /**
+     * Resume position for an entity type whose adapter opted out of the shared
+     * `sync_cursors` row: the cursor of the most recent run, unless that run
+     * reached `completed`. A finished walk resumes from `null` so the next run
+     * starts over rather than skipping everything an older interrupted run had
+     * already passed.
+     */
+    async resolveResumeCursor(integrationId: string, entityType: string, direction: 'import' | 'export', scope: SyncScope): Promise<string | null> {
+      const [run] = await findWithDecryption(
+        em,
+        SyncRun,
+        {
+          integrationId,
+          entityType,
+          direction,
+          organizationId: scope.organizationId,
+          tenantId: scope.tenantId,
+          deletedAt: null,
+        },
+        { orderBy: { createdAt: 'DESC' }, limit: 1 },
+        scope,
+      )
+      if (!run || run.status === 'completed') return null
+      return run.cursor ?? null
+    },
+
+    /**
+     * Clears the run-scoped resume position for an entity type, so the next
+     * non-`fullSync` run starts from the beginning. Returns how many runs were
+     * cleared.
+     *
+     * This is the opt-out's equivalent of deleting the shared `sync_cursors`
+     * row. An entity type whose adapter returns `false` from
+     * `persistsSharedCursor` has no such row, so a reset flow that only deletes
+     * `SyncCursor` would leave {@link resolveResumeCursor} returning the cursor
+     * of the interrupted run it just reset against — re-importing the tail of a
+     * walk instead of the whole thing. Reset flows MUST call this alongside
+     * their `SyncCursor` delete; it is a no-op when nothing is interrupted.
+     *
+     * The `status` filter here selects which rows to clear. It is deliberately
+     * NOT the read-side filter {@link resolveResumeCursor} avoids: that method
+     * reads the single most recent run whatever its status, precisely so an
+     * older interrupted run cannot outlive a later completed walk. Clearing
+     * every interrupted run is enough to start fresh either way — if the latest
+     * run was interrupted its cursor is now null, and if it completed the resume
+     * path already returns null.
+     */
+    async resetResumePosition(
+      integrationId: string,
+      entityType: string,
+      direction: 'import' | 'export',
+      scope: SyncScope,
+    ): Promise<number> {
+      return em.nativeUpdate(
+        SyncRun,
+        {
+          integrationId,
+          entityType,
+          direction,
+          status: { $ne: 'completed' },
+          organizationId: scope.organizationId,
+          tenantId: scope.tenantId,
+          deletedAt: null,
+        },
+        { cursor: null, updatedAt: new Date() },
+      )
+    },
+
     async findRunningOverlap(integrationId: string, entityType: string, direction: 'import' | 'export', scope: SyncScope): Promise<SyncRun | null> {
       const [run] = await findWithDecryption(
         em,

package/src/modules/data_sync/workers/sync-scheduled.ts

@@ -6,6 +6,7 @@ import type { ProgressService } from '../../progress/lib/progressService'
 import type { SyncRunService } from '../lib/sync-run-service'
 import { SyncSchedule } from '../data/entities'
 import { startDataSyncRun } from '../lib/start-run'
+import { resolveAdapterForIntegration, resolveStartCursor } from '../lib/start-cursor'
 
 type ScheduledSyncPayload = {
   scheduleId: string
@@ -65,12 +66,14 @@ export default async function handle(job: QueuedJob<ScheduledSyncPayload>, ctx:
 
   const cursor = schedule.fullSync
     ? null
-    : await syncRunService.resolveCursor(
-        schedule.integrationId,
-        schedule.entityType,
-        schedule.direction,
-        job.payload.scope,
-      )
+    : await resolveStartCursor({
+        syncRunService,
+        adapter: resolveAdapterForIntegration(schedule.integrationId),
+        integrationId: schedule.integrationId,
+        entityType: schedule.entityType,
+        direction: schedule.direction,
+        scope: job.payload.scope,
+      })
 
   schedule.lastRunAt = new Date()
   await em.flush()

package/src/modules/sales/api/channels/route.ts

@@ -38,7 +38,7 @@ const listSchema = z
   .passthrough()
 
 const routeMetadata = {
-  GET: { requireAuth: true, requireFeatures: ['sales.channels.manage'] },
+  GET: { requireAuth: true, requireFeatures: ['sales.channels.view'] },
   POST: { requireAuth: true, requireFeatures: ['sales.channels.manage'] },
   PUT: { requireAuth: true, requireFeatures: ['sales.channels.manage'] },
   DELETE: { requireAuth: true, requireFeatures: ['sales.channels.manage'] },