cry-synced-db-client 0.1.112 → 0.1.113

package/dist/index.js

@@ -599,6 +599,10 @@ var LeaderElectionManager = class {
 var CrossTabSyncManager = class {
   constructor(config) {
     this.pendingBroadcasts = /* @__PURE__ */ new Map();
+    /** True while a full server sync is in progress — suppresses delta broadcasts. */
+    this.serverSyncInProgress = false;
+    /** Collections that received updates while serverSyncInProgress was true. */
+    this.syncAffectedCollections = /* @__PURE__ */ new Set();
     this.tenant = config.tenant;
     this.instanceId = config.instanceId;
     this.windowId = config.windowId;
@@ -631,10 +635,18 @@ var CrossTabSyncManager = class {
   /**
    * Broadcast updated IDs to other tabs (debounced).
    * Only the leader should broadcast.
+   * While a server sync is in progress, suppresses delta broadcasts and only
+   * records which collections were affected (for the post-sync reload broadcast).
    */
   broadcastMetaUpdate(updates) {
     if (!this.metaUpdateChannel) return;
     if (!this.deps.isLeader()) return;
+    if (this.serverSyncInProgress) {
+      for (const collection of Object.keys(updates)) {
+        this.syncAffectedCollections.add(collection);
+      }
+      return;
+    }
     for (const [collection, ids] of Object.entries(updates)) {
       let existing = this.pendingBroadcasts.get(collection);
       if (!existing) {
@@ -652,6 +664,31 @@ var CrossTabSyncManager = class {
       this.flushBroadcasts();
     }, this.debounceMs);
   }
+  /**
+   * Called when a full server sync starts.
+   * Cancels any pending incremental broadcasts and enables suppression mode.
+   */
+  startServerSync() {
+    this.serverSyncInProgress = true;
+    this.syncAffectedCollections.clear();
+    if (this.broadcastDebounceTimer) {
+      clearTimeout(this.broadcastDebounceTimer);
+      this.broadcastDebounceTimer = void 0;
+    }
+    this.pendingBroadcasts.clear();
+  }
+  /**
+   * Called when a full server sync ends.
+   * Emits a single reload broadcast for all collections touched during the sync,
+   * replacing the many incremental delta broadcasts that were suppressed.
+   */
+  endServerSync() {
+    this.serverSyncInProgress = false;
+    if (this.syncAffectedCollections.size === 0) return;
+    const collections = Array.from(this.syncAffectedCollections);
+    this.syncAffectedCollections.clear();
+    this.broadcastReload(collections);
+  }
   /**
    * Flush pending broadcasts immediately.
    */
@@ -667,6 +704,7 @@ var CrossTabSyncManager = class {
     }
     if (Object.keys(updates).length > 0) {
       const payload = {
+        type: "delta",
         updates,
         instanceId: this.instanceId,
         isLeader: this.deps.isLeader(),
@@ -705,23 +743,32 @@ var CrossTabSyncManager = class {
   // Private Methods
   // ============================================================
   async handleCrossTabMetaUpdate(payload) {
-    if (!this.deps.isInitialized()) {
-      return;
+    if (!this.deps.isInitialized()) return;
+    if (payload.instanceId === this.instanceId) return;
+    if (payload.type === "reload") {
+      await this.handleReloadBroadcast(payload);
+    } else {
+      await this.handleDeltaBroadcast(payload);
     }
-    if (payload.instanceId === this.instanceId) {
-      return;
+  }
+  async handleReloadBroadcast(payload) {
+    const collections = this.deps.getCollections();
+    for (const collection of payload.collections) {
+      if (!collections.has(collection)) continue;
+      if (!this.deps.isSyncAllowed(collection)) continue;
+      try {
+        await this.deps.reloadCollectionFromDexie(collection);
+      } catch (err) {
+        console.error(`Error reloading collection ${collection} from Dexie:`, err);
+      }
     }
+  }
+  async handleDeltaBroadcast(payload) {
     const collections = this.deps.getCollections();
     for (const [collection, ids] of Object.entries(payload.updates)) {
-      if (!collections.has(collection)) {
-        continue;
-      }
-      if (!this.deps.isSyncAllowed(collection)) {
-        continue;
-      }
-      if (ids.length === 0) {
-        continue;
-      }
+      if (!collections.has(collection)) continue;
+      if (!this.deps.isSyncAllowed(collection)) continue;
+      if (ids.length === 0) continue;
       try {
         const items = await this.deps.dexieDb.getByIds(collection, ids);
         const upsertBatch = [];
@@ -764,10 +811,25 @@ var CrossTabSyncManager = class {
           }
         }
       } catch (err) {
-        console.error(`Error handling cross-tab meta update for ${collection}:`, err);
+        console.error(`Error handling cross-tab delta update for ${collection}:`, err);
       }
     }
   }
+  broadcastReload(collections) {
+    if (!this.metaUpdateChannel) return;
+    const payload = {
+      type: "reload",
+      collections,
+      instanceId: this.instanceId,
+      isLeader: this.deps.isLeader(),
+      windowId: this.windowId
+    };
+    try {
+      this.metaUpdateChannel.postMessage(payload);
+    } catch (err) {
+      console.error("Failed to broadcast reload:", err);
+    }
+  }
   callOnInfrastructureError(type, message, error) {
     if (this.callbacks.onInfrastructureError) {
       try {
@@ -3435,7 +3497,8 @@ var SyncedDb = class _SyncedDb {
         writeToInMemBatch: (collection, items, operation) => {
           this.inMemManager.writeBatch(collection, items, operation);
         },
-        isSyncAllowed: (collection) => this.isSyncAllowed(collection)
+        isSyncAllowed: (collection) => this.isSyncAllowed(collection),
+        reloadCollectionFromDexie: (collection) => this.loadCollectionToInMem(collection).then(() => void 0)
       }
     });
     this.connectionManager = new ConnectionManager({
@@ -4264,6 +4327,7 @@ var SyncedDb = class _SyncedDb {
     if (this.syncLock) return;
     this.syncLock = true;
     this.syncing = true;
+    this.crossTabSync.startServerSync();
     try {
       await this.syncEngine.sync(calledFrom);
       if (!this.syncOnlyCollections) {
@@ -4280,6 +4344,7 @@ var SyncedDb = class _SyncedDb {
     } finally {
       this.syncing = false;
       this.syncLock = false;
+      this.crossTabSync.endServerSync();
       await this.processQueuedWsUpdates();
     }
   }

package/dist/src/db/managers/CrossTabSyncManager.d.ts

@@ -16,6 +16,10 @@ export declare class CrossTabSyncManager implements I_CrossTabSyncManager {
     private metaUpdateChannel?;
     private pendingBroadcasts;
     private broadcastDebounceTimer?;
+    /** True while a full server sync is in progress — suppresses delta broadcasts. */
+    private serverSyncInProgress;
+    /** Collections that received updates while serverSyncInProgress was true. */
+    private syncAffectedCollections;
     constructor(config: CrossTabSyncConfig);
     /**
      * Get debounce time in ms.
@@ -28,8 +32,21 @@ export declare class CrossTabSyncManager implements I_CrossTabSyncManager {
     /**
      * Broadcast updated IDs to other tabs (debounced).
      * Only the leader should broadcast.
+     * While a server sync is in progress, suppresses delta broadcasts and only
+     * records which collections were affected (for the post-sync reload broadcast).
      */
     broadcastMetaUpdate(updates: Record<string, string[]>): void;
+    /**
+     * Called when a full server sync starts.
+     * Cancels any pending incremental broadcasts and enables suppression mode.
+     */
+    startServerSync(): void;
+    /**
+     * Called when a full server sync ends.
+     * Emits a single reload broadcast for all collections touched during the sync,
+     * replacing the many incremental delta broadcasts that were suppressed.
+     */
+    endServerSync(): void;
     /**
      * Flush pending broadcasts immediately.
      */
@@ -43,5 +60,8 @@ export declare class CrossTabSyncManager implements I_CrossTabSyncManager {
      */
     handleExternalBroadcast(payload: MetaUpdateBroadcast): void;
     private handleCrossTabMetaUpdate;
+    private handleReloadBroadcast;
+    private handleDeltaBroadcast;
+    private broadcastReload;
     private callOnInfrastructureError;
 }

package/dist/src/db/types/managers.d.ts

@@ -52,6 +52,8 @@ export interface CrossTabSyncDeps {
     writeToInMemBatch: <T extends DbEntity>(collection: string, items: T[], operation: "upsert" | "delete") => void;
     /** Whether a collection participates in sync (not writeOnly, not filtered out). */
     isSyncAllowed: (collection: string) => boolean;
+    /** Reload a collection fully from Dexie into in-mem (called on reload broadcast). */
+    reloadCollectionFromDexie: (collection: string) => Promise<void>;
 }
 export interface CrossTabSyncConfig {
     tenant: string;
@@ -70,6 +72,16 @@ export interface I_CrossTabSyncManager {
     broadcastMetaUpdate(updates: Record<string, string[]>): void;
     /** Flush pending broadcasts immediately. */
     flushBroadcasts(): void;
+    /**
+     * Called when a full server sync starts.
+     * Suppresses incremental delta broadcasts and accumulates affected collections.
+     */
+    startServerSync(): void;
+    /**
+     * Called when a full server sync ends.
+     * Emits a single reload broadcast for all collections touched during the sync.
+     */
+    endServerSync(): void;
     /** Cleanup resources. */
     dispose(): void;
     /** Handle external broadcast (for testing). */

package/dist/src/types/I_DexieDb.d.ts

@@ -27,13 +27,8 @@ export interface DirtyChange {
     /** When last change was accumulated */
     updatedAt: number;
 }
-/**
- * Payload for cross-tab meta update broadcasts
- * Maps collection names to arrays of _id strings that were updated
- */
-export interface MetaUpdateBroadcast {
-    /** Map of collection name -> array of _id strings that were updated */
-    updates: Record<string, string[]>;
+/** Shared fields for all cross-tab broadcast messages */
+interface BroadcastBase {
     /** Unique ID of the SyncedDb instance that sent this broadcast */
     instanceId: string;
     /** Whether the sender is the leader tab */
@@ -41,6 +36,27 @@ export interface MetaUpdateBroadcast {
     /** Window ID of the sender (for debugging) */
     windowId: string;
 }
+/**
+ * Incremental cross-tab broadcast: specific IDs updated per collection.
+ * Sent after individual writes (user edits, WebSocket updates).
+ */
+export interface DeltaBroadcast extends BroadcastBase {
+    type: "delta";
+    /** Map of collection name -> array of _id strings that were updated */
+    updates: Record<string, string[]>;
+}
+/**
+ * Full-reload cross-tab broadcast: receiving tab must reload listed collections
+ * from Dexie into in-mem. Sent once after a full server sync completes instead
+ * of emitting many incremental delta broadcasts during the sync.
+ */
+export interface ReloadBroadcast extends BroadcastBase {
+    type: "reload";
+    /** Collections that were affected by the sync and need a full reload */
+    collections: string[];
+}
+/** Discriminated union of all cross-tab broadcast message types */
+export type MetaUpdateBroadcast = DeltaBroadcast | ReloadBroadcast;
 /**
  * Interface za Dexie (IndexedDB) bazo podatkov
  * Vse metode so async ker IndexedDB je asinhrona
@@ -101,3 +117,4 @@ export interface I_DexieDb {
     /** Vrne tenant */
     getTenant(): string;
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cry-synced-db-client",
-  "version": "0.1.112",
+  "version": "0.1.113",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",