cry-synced-db-client 0.1.112 → 0.1.114

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 {
@@ -3376,6 +3438,7 @@ var SyncedDb = class _SyncedDb {
     const windowId = (_a = config._testWindowId) != null ? _a : this.getOrCreateWindowId();
     this.defaultReturnDeleted = (_b = config.returnDeleted) != null ? _b : false;
     this.defaultReturnArchived = (_c = config.returnArchived) != null ? _c : false;
+    this.onDatabaseCreated = config.onDatabaseCreated;
     this.onSyncStart = config.onSyncStart;
     this.onSyncEnd = config.onSyncEnd;
     this.onDexieSyncStart = config.onDexieSyncStart;
@@ -3435,7 +3498,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({
@@ -3651,6 +3715,13 @@ var SyncedDb = class _SyncedDb {
     }
     await this._loadLastFullSync();
     await this._loadLastInitialSync();
+    if (this.dexieDb.isNewDatabase() && this.onDatabaseCreated) {
+      try {
+        this.onDatabaseCreated();
+      } catch (err) {
+        console.error("onDatabaseCreated callback failed:", err);
+      }
+    }
     await this.pendingChanges.recoverPendingWrites();
     const allowedColls = [...this.collections.keys()].filter((n) => this.isSyncAllowed(n));
     const dexieStart = Date.now();
@@ -4264,6 +4335,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 +4352,7 @@ var SyncedDb = class _SyncedDb {
     } finally {
       this.syncing = false;
       this.syncLock = false;
+      this.crossTabSync.endServerSync();
       await this.processQueuedWsUpdates();
     }
   }
@@ -4512,7 +4585,7 @@ var SyncedDb = class _SyncedDb {
   }
   assertCollection(name) {
     if (!this.collections.has(name)) {
-      throw new Error(`Collection "${name}" not configured`);
+      throw new Error(`SyncedDb: Collection "${(name == null ? void 0 : name.toString()) || "?"}" not configured`);
     }
   }
   /** Stringify an Id parameter (ObjectId → hex string). */
@@ -4593,6 +4666,7 @@ var DexieDb = class extends Dexie {
   constructor(tenant, collectionConfigs) {
     super(`synced-db-${tenant}`);
     this.collections = /* @__PURE__ */ new Map();
+    this._isNewDatabase = false;
     this.tenant = tenant;
     const schema = {};
     schema[SYNC_META_TABLE] = "[tenant+collection]";
@@ -4601,6 +4675,9 @@ var DexieDb = class extends Dexie {
       schema[config.name] = "_id";
     }
     this.version(1).stores(schema);
+    this.on("populate", () => {
+      this._isNewDatabase = true;
+    });
     this.syncMeta = this.table(SYNC_META_TABLE);
     this.dirtyChanges = this.table(DIRTY_CHANGES_TABLE);
     for (const config of collectionConfigs) {
@@ -4610,7 +4687,7 @@ var DexieDb = class extends Dexie {
   getTable(collection) {
     const table = this.collections.get(collection);
     if (!table) {
-      throw new Error(`Collection "${collection}" not configured`);
+      throw new Error(`DexieDb: Collection "${(collection == null ? void 0 : collection.toString()) || "?"}" not configured`);
     }
     return table;
   }
@@ -4809,6 +4886,9 @@ var DexieDb = class extends Dexie {
   getTenant() {
     return this.tenant;
   }
+  isNewDatabase() {
+    return this._isNewDatabase;
+  }
 };
 
 // node_modules/msgpackr/unpack.js

package/dist/src/db/DexieDb.d.ts

@@ -12,6 +12,7 @@ export declare class DexieDb extends Dexie implements I_DexieDb {
     private collections;
     private syncMeta;
     private dirtyChanges;
+    private _isNewDatabase;
     constructor(tenant: string, collectionConfigs: CollectionConfig<any>[]);
     private getTable;
     private idToString;
@@ -51,4 +52,5 @@ export declare class DexieDb extends Dexie implements I_DexieDb {
     setSyncMeta(collection: string, lastSyncTs: any): Promise<void>;
     deleteSyncMeta(collection: string): Promise<void>;
     getTenant(): string;
+    isNewDatabase(): boolean;
 }

package/dist/src/db/SyncedDb.d.ts

@@ -37,6 +37,7 @@ export declare class SyncedDb implements I_SyncedDb {
     private beforeUnloadHandler?;
     private readonly defaultReturnDeleted;
     private readonly defaultReturnArchived;
+    private readonly onDatabaseCreated?;
     private readonly onSyncStart?;
     private readonly onSyncEnd?;
     private readonly onDexieSyncStart?;

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
@@ -100,4 +116,7 @@ export interface I_DexieDb {
     deleteSyncMeta(collection: string): Promise<void>;
     /** Vrne tenant */
     getTenant(): string;
+    /** Returns true if the IndexedDB database was created fresh during this session (first ever open). */
+    isNewDatabase(): boolean;
 }
+export {};

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

@@ -293,6 +293,8 @@ export interface SyncedDbConfig {
     debounceRestWritesMs?: number;
     /** Callback ki se pokliče, ko SyncedDb sam preide v offline stanje (npr. ob sync napaki) */
     onForcedOffline?: (reason: string) => void;
+    /** Callback fired once during init() when the IndexedDB database was created fresh (first ever open). */
+    onDatabaseCreated?: () => void;
     /** Callback at the start of each sync cycle. initialSync=true if no full sync has completed yet. */
     onSyncStart?: (info: {
         calledFrom?: string;

package/package.json

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