@mindline/sync 1.0.110 → 1.0.111

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindline/sync",
-  "version": "1.0.110",
+  "version": "1.0.111",
   "description": "sync is a node.js package encapsulating JavaScript classes required for configuring Mindline sync service.",
   "main": "dist/sync.es.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -929,13 +929,6 @@ export class BatchArray {
     private pollAuthorizedUser: User | null = null;
     private pollBatchIdArray: Array<any> = [];
 
-    // Last known backend queues (strongest completion signal)
-    private lastQueues: { main: number | null; writer: number | null; deferred: number | null } = {
-        main: null,
-        writer: null,
-        deferred: null
-    };
-    private hasQueueInfo: boolean = false;
 
     // Store UI callbacks so we can update the UI from poll/completion events.
     private setIdleText: ((idleText: string) => void) | null = null;
@@ -1049,10 +1042,6 @@ export class BatchArray {
         // Save callback so completion/polling can update the idle text too.
         this.setIdleText = setIdleText;
 
-        // IMPORTANT: reset completion signals between sync runs.
-        // Otherwise a previous run that ended with queues=0 could make the next run immediately "Complete".
-        this.hasQueueInfo = false;
-        this.lastQueues = { main: null, writer: null, deferred: null };
 
         this.pb_startTS = Date.now();
         this.pb_progress = 0;
@@ -1061,35 +1050,14 @@ export class BatchArray {
         setSyncProgress(this.pb_progress);
         setIdleText("Starting sync...");
         this.pb_timer = setInterval(() => {
-            // If backend indicates completion (prefer queue-empty when available), stop the timer
+            // Completion check is now handled by the SignalR handler via isSyncCompleted()
+            // This timer only increments elapsed time; actual completion logic lives in the handler.
             console.log("this.tenantNodes", this.tenantNodes)
-            let isCompletedOrNothingToSync = this.tenantNodes.every((tn: TenantNode) =>
-                tn.nothingtosync || tn.targets.every((ta) => ta.status === "complete" || ta.status === "failed")
-            );
 
-            const queuesEmpty = this.hasQueueInfo &&
-                this.lastQueues.main === 0 &&
-                this.lastQueues.writer === 0 &&
-                this.lastQueues.deferred === 0;
+            this.pb_total = this.pb_total + 1;
+            this.pb_idle = this.pb_idle + 1;
 
-            // If we have queue info, trust it for completion. Otherwise fall back to node terminal states.
-            const isCompleted = queuesEmpty || (!this.hasQueueInfo && isCompletedOrNothingToSync);
-
-            if (isCompleted) {
-                clearInterval(this.pb_timer!);
-                this.pb_timer = null;
-                this.pb_progress = 100;
-                setSyncProgress(this.pb_progress);
-                setIdleText(`Complete.`);
-                this.stopPolling();
-                this.clearStoredBatchIds();
-            }
-            else {
-                this.pb_total = this.pb_total + 1;
-                this.pb_idle = this.pb_idle + 1;
-
-                setIdleText(`${this.pb_total} seconds elapsed. Last update ${this.pb_idle} seconds ago.`);
-            }
+            setIdleText(`${this.pb_total} seconds elapsed. Last update ${this.pb_idle} seconds ago.`);
         }, 1000);
         this.milestoneArray.start(setMilestones);
     }
@@ -1202,9 +1170,6 @@ export class BatchArray {
         bClearLocalStorage = bClearLocalStorage;
         message = message;
 
-        // Starting a new SignalR session for a (potentially new) run: reset queue-based completion signals.
-        this.hasQueueInfo = false;
-        this.lastQueues = { main: null, writer: null, deferred: null };
 
         // we have just completed a successful POST to startSync
         this.milestoneArray.post(setMilestones);
@@ -1235,10 +1200,6 @@ export class BatchArray {
             // does this tenantnode/batch have nothing to sync?
             let bTotalCountZero: boolean = false;
             let bCurrentCountZero: boolean = false;
-            // queue stats (better completion signal than only written/total)
-            let totalInMainQueue: number | null = null;
-            let totalInWriterQueue: number | null = null;
-            let totalInDeferredQueue: number | null = null;
             for (let j = 0; j < statskeys.length; j++) {
                 let bTotalCount = statskeys[j].endsWith("TotalCount");
                 let bCurrentCount = statskeys[j].endsWith("CurrentCount");
@@ -1292,16 +1253,6 @@ export class BatchArray {
                 }
                 tenantNode.nothingtosync = bTotalCountZero && bCurrentCountZero;
 
-                // queue stats are global for the batch
-                if (statskeys[j] === "TotalInMainQueue") {
-                    totalInMainQueue = Number(statsvalues[j]);
-                }
-                if (statskeys[j] === "TotalInWriterQueue") {
-                    totalInWriterQueue = Number(statsvalues[j]);
-                }
-                if (statskeys[j] === "TotalInDeferredQueue") {
-                    totalInDeferredQueue = Number(statsvalues[j]);
-                }
 
                 if (statskeys[j].startsWith("Writer")) {
                     // parse tid from Writer key
@@ -1379,23 +1330,17 @@ export class BatchArray {
                 readerExcluded += sourceTenantNode.excluded;
             });
 
-            // If queue stats are available, they are a stronger indicator of write completion.
-            // When all queues are empty, the backend has finished processing this batch and may stop emitting updates.
-            if (totalInMainQueue != null) this.lastQueues.main = totalInMainQueue;
-            if (totalInWriterQueue != null) this.lastQueues.writer = totalInWriterQueue;
-            if (totalInDeferredQueue != null) this.lastQueues.deferred = totalInDeferredQueue;
-            this.hasQueueInfo = this.lastQueues.main != null && this.lastQueues.writer != null && this.lastQueues.deferred != null;
-
-            const queuesEmpty = this.hasQueueInfo &&
-                this.lastQueues.main === 0 &&
-                this.lastQueues.writer === 0 &&
-                this.lastQueues.deferred === 0;
+            // New completion condition: sync is complete when:
+            // (Reader/TotalCount - Reader/ExtCount) === (Writer/CurrentCount + Writer/DeferredCount)
+            // This means all users that should be written (total minus excluded) have been processed.
+            const usersToSync = readerTotal - readerExcluded;
+            const usersProcessed = writerCurrent + writerDeferred;
+            const isSyncCompleted = usersToSync > 0 && usersToSync === usersProcessed;
 
-            if (queuesEmpty) {
+            if (isSyncCompleted) {
                 bWritingComplete = true;
 
-                // Ensure the UI can reach a terminal state even if writer CurrentCount never reaches TotalCount.
-                // We trust the backend queues more than client-side totals in this scenario.
+                // Mark all nodes as complete since sync condition is satisfied.
                 this.tenantNodes.forEach((src) => {
                     src.targets.forEach((t) => {
                         if (t.status !== "failed") t.status = "complete";
@@ -1450,8 +1395,8 @@ export class BatchArray {
                     setRefreshDeltaTrigger(config!.workspaceId);
                 }
                 // with that out of the way, is writing complete?
-                // Only allow terminal completion when backend queues are empty (if we have queue info).
-                if (bWritingComplete && (queuesEmpty || !this.hasQueueInfo)) {
+                // Completion is determined by the new formula: usersToSync === usersProcessed
+                if (bWritingComplete && isSyncCompleted) {
                     this.milestoneArray.write(setMilestones);
                     this.stopPolling();
                     setConfigSyncResult("sync complete");