cry-synced-db-client 0.1.47 → 0.1.50

package/dist/index.js

@@ -1097,8 +1097,7 @@ class SyncedDb {
   onWsNotification;
   onOnlineStatusChange;
   crossTabSyncDebounceMs;
-  onExternalSync;
-  onStaleMetaConflict;
+  onCrossTabSync;
   onBecameLeader;
   onLostLeadership;
   onInfrastructureError;
@@ -1117,8 +1116,9 @@ class SyncedDb {
   updaterId;
   syncedDbInstanceId;
   syncMetaCache = new Map;
-  lastSeenRevCache = new Map;
-  unsubscribeMetaUpdates;
+  metaUpdateChannel;
+  pendingBroadcasts = new Map;
+  broadcastDebounceTimer;
   isLeader = false;
   releaseLeaderLockResolve;
   leaderReelectionChannel;
@@ -1154,8 +1154,7 @@ class SyncedDb {
     this.onWsNotification = config.onWsNotification;
     this.onOnlineStatusChange = config.onOnlineStatusChange;
     this.crossTabSyncDebounceMs = config.crossTabSyncDebounceMs ?? DEFAULT_CROSS_TAB_SYNC_DEBOUNCE_MS;
-    this.onExternalSync = config.onExternalSync;
-    this.onStaleMetaConflict = config.onStaleMetaConflict;
+    this.onCrossTabSync = config.onCrossTabSync;
     this.onBecameLeader = config.onBecameLeader;
     this.onLostLeadership = config.onLostLeadership;
     this.onInfrastructureError = config.onInfrastructureError;
@@ -1174,6 +1173,9 @@ class SyncedDb {
   isLeaderTab() {
     return this.isLeader;
   }
+  simulateExternalBroadcast(payload) {
+    this.handleCrossTabMetaUpdate(payload);
+  }
   tryBecomeLeader() {
     if (this.closing) {
       return Promise.resolve();
@@ -1343,9 +1345,6 @@ class SyncedDb {
         this.syncMetaCache.set(name, meta);
       }
     }
-    this.unsubscribeMetaUpdates = this.dexieDb.onMetaUpdated((payload) => {
-      this.handleCrossTabMetaUpdate(payload);
-    });
     if (typeof BroadcastChannel !== "undefined") {
       this.leaderReelectionChannel = new BroadcastChannel(`synced-db-leader-reelection-${this.tenant}`);
       this.leaderReelectionChannel.onmessage = (event) => {
@@ -1353,6 +1352,10 @@ class SyncedDb {
           this.handleLeaderReelection();
         }
       };
+      this.metaUpdateChannel = new BroadcastChannel(`synced-db-meta-${this.tenant}`);
+      this.metaUpdateChannel.onmessage = (event) => {
+        this.handleCrossTabMetaUpdate(event.data);
+      };
     }
     if (typeof document === "undefined" || document.visibilityState === "visible") {
       this.tryBecomeLeader();
@@ -1402,9 +1405,10 @@ class SyncedDb {
     }
     this.stopAutoSync();
     await this.flushAllPendingChanges();
-    if (this.unsubscribeMetaUpdates) {
-      this.unsubscribeMetaUpdates();
-      this.unsubscribeMetaUpdates = undefined;
+    this.flushBroadcasts();
+    if (this.metaUpdateChannel) {
+      this.metaUpdateChannel.close();
+      this.metaUpdateChannel = undefined;
     }
     this.releaseLeaderLock();
     if (this.leaderReelectionChannel) {
@@ -1803,7 +1807,7 @@ class SyncedDb {
       const syncSpecs = [];
       const configMap = new Map;
       for (const [collectionName, config] of this.collections) {
-        const meta = await this.dexieDb.getSyncMeta(collectionName);
+        const meta = this.syncMetaCache.get(collectionName);
         syncSpecs.push({
           collection: collectionName,
           timestamp: meta?.lastSyncTs || 0,
@@ -1944,59 +1948,68 @@ class SyncedDb {
     }
     return result;
   }
-  async deleteCollectionData(collection, force = false) {
+  async dropCollection(collection, force = false) {
     this.assertCollection(collection);
+    if (!force && (this.forcedOffline || !this.online)) {
+      throw new Error(`Cannot drop collection "${collection}": database is offline. Use force=true to drop anyway.`);
+    }
     await this.flushPendingChangesForCollection(collection);
-    let sendSuccess = true;
-    if (this.isOnline()) {
-      try {
-        await this.uploadDirtyItemsForCollection(collection);
-      } catch (err) {
-        console.error(`Failed to send dirty data for ${collection}:`, err);
-        sendSuccess = false;
+    const dirtyItems = await this.dexieDb.getDirty(collection);
+    if (dirtyItems.length > 0) {
+      if (!force && (this.forcedOffline || !this.online)) {
+        throw new Error(`Cannot drop collection "${collection}": ${dirtyItems.length} unsynchronized items would be lost. Use force=true to drop anyway.`);
       }
-    } else {
-      const dirtyItems = await this.dexieDb.getDirty(collection);
-      if (dirtyItems.length > 0) {
-        sendSuccess = false;
+      if (this.online && !this.forcedOffline) {
+        try {
+          await this.uploadDirtyItemsForCollection(collection);
+        } catch (err) {
+          if (!force) {
+            throw new Error(`Cannot drop collection "${collection}": failed to sync dirty items to server. Use force=true to drop anyway. Original error: ${err}`);
+          }
+        }
       }
     }
-    if (!sendSuccess && !force) {
-      return false;
-    }
     await this.dexieDb.deleteCollection(collection);
     this.inMemDb.deleteCollection(collection);
     await this.dexieDb.deleteSyncMeta(collection);
-    return true;
+    await this.dexieDb.clearDirtyChanges(collection);
+    this.syncMetaCache.delete(collection);
   }
-  async deleteAllCollectionsData(force = false) {
+  async dropDatabase(force = false) {
+    if (!force && (this.forcedOffline || !this.online)) {
+      throw new Error("Cannot drop database: database is offline. Use force=true to drop anyway.");
+    }
     await this.flushAllPendingChanges();
-    let sendSuccess = true;
-    if (this.isOnline()) {
-      try {
-        await this.uploadDirtyItems();
-      } catch (err) {
-        console.error("Failed to send dirty data:", err);
-        sendSuccess = false;
+    const collectionNames = Array.from(this.collections.keys());
+    const dirtyCollections = [];
+    for (const collectionName of collectionNames) {
+      const dirtyItems = await this.dexieDb.getDirty(collectionName);
+      if (dirtyItems.length > 0) {
+        dirtyCollections.push({ name: collectionName, count: dirtyItems.length });
       }
-    } else {
-      for (const [collectionName] of this.collections) {
-        const dirtyItems = await this.dexieDb.getDirty(collectionName);
-        if (dirtyItems.length > 0) {
-          sendSuccess = false;
-          break;
+    }
+    if (dirtyCollections.length > 0) {
+      const totalDirty = dirtyCollections.reduce((sum, c) => sum + c.count, 0);
+      if (!force && (this.forcedOffline || !this.online)) {
+        throw new Error(`Cannot drop database: ${totalDirty} unsynchronized items in ${dirtyCollections.length} collections would be lost. Use force=true to drop anyway.`);
+      }
+      if (this.online && !this.forcedOffline) {
+        try {
+          await this.uploadDirtyItems();
+        } catch (err) {
+          if (!force) {
+            throw new Error(`Cannot drop database: failed to sync dirty items to server. Use force=true to drop anyway. Original error: ${err}`);
+          }
         }
       }
     }
-    if (!sendSuccess && !force) {
-      return false;
-    }
-    for (const [collectionName] of this.collections) {
+    for (const collectionName of collectionNames) {
       await this.dexieDb.deleteCollection(collectionName);
       this.inMemDb.deleteCollection(collectionName);
       await this.dexieDb.deleteSyncMeta(collectionName);
+      await this.dexieDb.clearDirtyChanges(collectionName);
     }
-    return true;
+    this.syncMetaCache.clear();
   }
   assertCollection(name) {
     if (!this.collections.has(name)) {
@@ -2245,6 +2258,27 @@ class SyncedDb {
         this.inMemDb.deleteManyByIds(collection, deleteIds);
         sentCount += deleted.length;
       }
+      const allItems = [...inserted, ...updated, ...deleted];
+      let maxTs = undefined;
+      for (const item of allItems) {
+        if (item._ts) {
+          if (!maxTs || this.compareTimestamps(item._ts, maxTs) > 0) {
+            maxTs = item._ts;
+          }
+        }
+      }
+      if (maxTs) {
+        const currentMeta = this.syncMetaCache.get(collection);
+        const currentTs = currentMeta?.lastSyncTs;
+        if (!currentTs || this.compareTimestamps(maxTs, currentTs) > 0) {
+          await this.dexieDb.setSyncMeta(collection, maxTs);
+          this.syncMetaCache.set(collection, {
+            tenant: this.tenant,
+            collection,
+            lastSyncTs: maxTs
+          });
+        }
+      }
     }
     return { sentCount };
   }
@@ -2497,6 +2531,27 @@ class SyncedDb {
         this.inMemDb.deleteManyByIds(collection, deleteIds);
         sentCount += deleted.length;
       }
+      const allItems = [...inserted, ...updated, ...deleted];
+      let maxTs = undefined;
+      for (const item of allItems) {
+        if (item._ts) {
+          if (!maxTs || this.compareTimestamps(item._ts, maxTs) > 0) {
+            maxTs = item._ts;
+          }
+        }
+      }
+      if (maxTs) {
+        const currentMeta = this.syncMetaCache.get(collection);
+        const currentTs = currentMeta?.lastSyncTs;
+        if (!currentTs || this.compareTimestamps(maxTs, currentTs) > 0) {
+          await this.dexieDb.setSyncMeta(collection, maxTs);
+          this.syncMetaCache.set(collection, {
+            tenant: this.tenant,
+            collection,
+            lastSyncTs: maxTs
+          });
+        }
+      }
       if (errors) {
         console.error(`Sync errors for ${collection}:`, errors);
       }
@@ -2547,74 +2602,83 @@ class SyncedDb {
     }
     return false;
   }
-  normalizeTimestamp(ts) {
-    if (ts === null || ts === undefined)
-      return 0;
-    if (typeof ts === "number")
-      return ts;
-    if (ts instanceof Date)
-      return ts.getTime();
-    if (typeof ts === "object" && "t" in ts)
-      return ts.t;
-    if (typeof ts.toNumber === "function")
-      return ts.toNumber();
-    if (typeof ts.valueOf === "function")
-      return ts.valueOf();
-    return 0;
-  }
-  async broadcastMetaUpdate(collection, timestamp) {
-    const cachedMeta = this.syncMetaCache.get(collection);
-    const cachedTs = this.normalizeTimestamp(cachedMeta?.lastSyncTs);
-    const newTs = this.normalizeTimestamp(timestamp);
-    if (newTs > cachedTs) {
-      await this.dexieDb.setSyncMeta(collection, timestamp);
-      this.syncMetaCache.set(collection, {
-        tenant: this.tenant,
-        collection,
-        lastSyncTs: timestamp
-      });
+  broadcastMetaUpdate(updates) {
+    if (!this.metaUpdateChannel)
+      return;
+    for (const [collection, ids] of Object.entries(updates)) {
+      let existing = this.pendingBroadcasts.get(collection);
+      if (!existing) {
+        existing = new Set;
+        this.pendingBroadcasts.set(collection, existing);
+      }
+      for (const id of ids) {
+        existing.add(id);
+      }
+    }
+    if (this.broadcastDebounceTimer) {
+      clearTimeout(this.broadcastDebounceTimer);
+    }
+    this.broadcastDebounceTimer = setTimeout(() => {
+      this.flushBroadcasts();
+    }, this.crossTabSyncDebounceMs);
+  }
+  flushBroadcasts() {
+    if (!this.metaUpdateChannel)
+      return;
+    if (this.broadcastDebounceTimer) {
+      clearTimeout(this.broadcastDebounceTimer);
+      this.broadcastDebounceTimer = undefined;
+    }
+    const updates = {};
+    for (const [collection, ids] of this.pendingBroadcasts) {
+      updates[collection] = Array.from(ids);
     }
+    if (Object.keys(updates).length > 0) {
+      const payload = {
+        updates,
+        instanceId: this.syncedDbInstanceId
+      };
+      this.metaUpdateChannel.postMessage(payload);
+    }
+    this.pendingBroadcasts.clear();
   }
   async handleCrossTabMetaUpdate(payload) {
-    if (payload.instanceId === this.dexieDb.getInstanceId()) {
+    if (!this.initialized) {
       return;
     }
-    const collection = payload.collection;
-    if (!this.collections.has(collection)) {
+    if (payload.instanceId === this.syncedDbInstanceId) {
       return;
     }
-    const lastSeenRev = this.lastSeenRevCache.get(collection) ?? 0;
-    try {
-      const newMeta = await this.dexieDb.getSyncMeta(collection);
-      if (newMeta) {
-        this.syncMetaCache.set(collection, newMeta);
-      }
-      const newerItems = await this.dexieDb.getNewerThan(collection, lastSeenRev);
-      let newItemsCount = 0;
-      let maxRev = lastSeenRev;
-      for (const item of newerItems) {
-        if (item._rev !== undefined && item._rev > maxRev) {
-          maxRev = item._rev;
-        }
-        if (item._deleted) {
-          this.inMemDb.deleteOne(collection, item._id);
-        } else {
-          this.inMemDb.save(collection, item._id, this.stripLocalFields(item));
-        }
-        newItemsCount++;
+    for (const [collection, ids] of Object.entries(payload.updates)) {
+      if (!this.collections.has(collection)) {
+        continue;
       }
-      if (maxRev > lastSeenRev) {
-        this.lastSeenRevCache.set(collection, maxRev);
+      if (ids.length === 0) {
+        continue;
       }
-      if (this.onExternalSync) {
-        try {
-          this.onExternalSync(collection, newItemsCount);
-        } catch (err) {
-          console.error("onExternalSync callback failed:", err);
+      try {
+        const items = await this.dexieDb.getByIds(collection, ids);
+        let newItemsCount = 0;
+        for (const item of items) {
+          if (!item)
+            continue;
+          if (item._deleted) {
+            this.inMemDb.deleteOne(collection, item._id);
+          } else {
+            this.inMemDb.save(collection, item._id, this.stripLocalFields(item));
+          }
+          newItemsCount++;
         }
+        if (this.onCrossTabSync && newItemsCount > 0) {
+          try {
+            this.onCrossTabSync(collection, newItemsCount);
+          } catch (err) {
+            console.error("onCrossTabSync callback failed:", err);
+          }
+        }
+      } catch (err) {
+        console.error(`Error handling cross-tab meta update for ${collection}:`, err);
       }
-    } catch (err) {
-      console.error(`Error handling cross-tab meta update for ${collection}:`, err);
     }
   }
   async handleServerUpdate(payload) {
@@ -2626,14 +2690,13 @@ class SyncedDb {
     const collectionName = payload.collection;
     if (!this.collections.has(collectionName))
       return;
+    const updatedIds = [];
     switch (payload.operation) {
       case "insert": {
         const serverItem = payload.data;
         if (serverItem) {
           await this.handleServerItemInsert(collectionName, serverItem);
-          if (serverItem._ts) {
-            await this.broadcastMetaUpdate(collectionName, serverItem._ts);
-          }
+          updatedIds.push(String(serverItem._id));
         }
         break;
       }
@@ -2643,16 +2706,12 @@ class SyncedDb {
           const localItem = await this.dexieDb.getById(collectionName, deltaData._id);
           if (localItem) {
             await this.handleServerItemUpdate(collectionName, localItem, deltaData);
-            if (deltaData._ts) {
-              await this.broadcastMetaUpdate(collectionName, deltaData._ts);
-            }
+            updatedIds.push(String(deltaData._id));
           } else {
             const fullItem = await this.restInterface.findById(collectionName, deltaData._id);
             if (fullItem) {
               await this.handleServerItemInsert(collectionName, fullItem);
-              if (fullItem._ts) {
-                await this.broadcastMetaUpdate(collectionName, fullItem._ts);
-              }
+              updatedIds.push(String(fullItem._id));
             }
           }
         }
@@ -2661,7 +2720,7 @@ class SyncedDb {
       case "delete": {
         const deleteData = payload.data;
         await this.handleServerItemDelete(collectionName, deleteData._id);
-        await this.broadcastMetaUpdate(collectionName, Date.now());
+        updatedIds.push(String(deleteData._id));
         break;
       }
       case "batch": {
@@ -2679,6 +2738,7 @@ class SyncedDb {
         }
         for (const serverItem of inserts) {
           await this.handleServerItemInsert(collectionName, serverItem);
+          updatedIds.push(String(serverItem._id));
         }
         if (updates.length > 0) {
           const updateIds = updates.map((u) => u._id);
@@ -2688,21 +2748,26 @@ class SyncedDb {
             const localItem = localItems[i];
             if (localItem) {
               await this.handleServerItemUpdate(collectionName, localItem, deltaData);
+              updatedIds.push(String(deltaData._id));
             } else {
               const fullItem = await this.restInterface.findById(collectionName, deltaData._id);
               if (fullItem) {
                 await this.handleServerItemInsert(collectionName, fullItem);
+                updatedIds.push(String(fullItem._id));
               }
             }
           }
         }
         for (const deleteData of deletes) {
           await this.handleServerItemDelete(collectionName, deleteData._id);
+          updatedIds.push(String(deleteData._id));
         }
-        await this.broadcastMetaUpdate(collectionName, Date.now());
         break;
       }
     }
+    if (updatedIds.length > 0) {
+      this.broadcastMetaUpdate({ [collectionName]: updatedIds });
+    }
   }
   async handleServerItemInsert(collectionName, serverItem) {
     const localItem = await this.dexieDb.getById(collectionName, serverItem._id);
@@ -2824,27 +2889,17 @@ var DIRTY_CHANGES_TABLE = "_dirty_changes";
 
 class DexieDb extends Dexie {
   tenant;
-  instanceId;
-  crossTabSyncDebounceMs;
   collections = new Map;
   syncMeta;
   dirtyChanges;
-  broadcastChannel = null;
-  pendingBroadcasts = new Map;
-  debounceTimer = null;
-  metaUpdateCallbacks = new Set;
-  constructor(tenant, collectionConfigs, options) {
+  constructor(tenant, collectionConfigs) {
     super(`synced-db-${tenant}`);
     this.tenant = tenant;
-    this.instanceId = options?.instanceId ?? `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-    this.crossTabSyncDebounceMs = options?.crossTabSyncDebounceMs ?? 100;
     const schema = {};
     schema[SYNC_META_TABLE] = "[tenant+collection]";
     schema[DIRTY_CHANGES_TABLE] = "[collection+id]";
     for (const config of collectionConfigs) {
-      const additionalIndexes = config.indexes || [];
-      const indexes = ["_id", "_rev", ...additionalIndexes.map(String)];
-      schema[config.name] = indexes.join(", ");
+      schema[config.name] = "_id";
     }
     this.version(1).stores(schema);
     this.syncMeta = this.table(SYNC_META_TABLE);
@@ -2852,48 +2907,6 @@ class DexieDb extends Dexie {
     for (const config of collectionConfigs) {
       this.collections.set(config.name, this.table(config.name));
     }
-    this.setupBroadcastChannel();
-  }
-  setupBroadcastChannel() {
-    if (typeof BroadcastChannel === "undefined") {
-      return;
-    }
-    this.broadcastChannel = new BroadcastChannel(`synced-db-meta-${this.tenant}`);
-    this.broadcastChannel.onmessage = (event) => {
-      const payload = event.data;
-      for (const callback of this.metaUpdateCallbacks) {
-        try {
-          callback(payload);
-        } catch (err) {
-          console.error("Error in metaUpdate callback:", err);
-        }
-      }
-    };
-  }
-  queueBroadcast(collection, lastSyncTs) {
-    if (!this.broadcastChannel)
-      return;
-    this.pendingBroadcasts.set(collection, lastSyncTs);
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-    }
-    this.debounceTimer = setTimeout(() => {
-      this.flushBroadcasts();
-    }, this.crossTabSyncDebounceMs);
-  }
-  flushBroadcasts() {
-    if (!this.broadcastChannel)
-      return;
-    for (const [collection, lastSyncTs] of this.pendingBroadcasts) {
-      const payload = {
-        collection,
-        lastSyncTs,
-        instanceId: this.instanceId
-      };
-      this.broadcastChannel.postMessage(payload);
-    }
-    this.pendingBroadcasts.clear();
-    this.debounceTimer = null;
   }
   getTable(collection) {
     const table = this.collections.get(collection);
@@ -3073,7 +3086,6 @@ class DexieDb extends Dexie {
       collection,
       lastSyncTs
     });
-    this.queueBroadcast(collection, lastSyncTs);
   }
   async deleteSyncMeta(collection) {
     await this.syncMeta.delete([this.tenant, collection]);
@@ -3081,30 +3093,6 @@ class DexieDb extends Dexie {
   getTenant() {
     return this.tenant;
   }
-  getInstanceId() {
-    return this.instanceId;
-  }
-  async getNewerThan(collection, rev) {
-    const table = this.getTable(collection);
-    return await table.where("_rev").above(rev).toArray();
-  }
-  onMetaUpdated(callback) {
-    this.metaUpdateCallbacks.add(callback);
-    return () => {
-      this.metaUpdateCallbacks.delete(callback);
-    };
-  }
-  closeBroadcastChannel() {
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-      this.flushBroadcasts();
-    }
-    if (this.broadcastChannel) {
-      this.broadcastChannel.close();
-      this.broadcastChannel = null;
-    }
-    this.metaUpdateCallbacks.clear();
-  }
 }
 // node_modules/msgpackr/unpack.js
 var decoder;

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

@@ -1,26 +1,18 @@
 import Dexie from "dexie";
-import type { DexieDbOptions, DirtyChange, I_DexieDb, MetaUpdateBroadcast, SyncMeta } from "../types/I_DexieDb";
+import type { DirtyChange, I_DexieDb, SyncMeta } from "../types/I_DexieDb";
 import type { CollectionConfig } from "../types/CollectionConfig";
 import type { Id, LocalDbEntity } from "../types/DbEntity";
 /**
  * Implementacija DexieDb interface
  * Uporablja Dexie za dostop do IndexedDB
+ * Note: This is pure storage - cross-tab sync is handled by SyncedDb
  */
 export declare class DexieDb extends Dexie implements I_DexieDb {
     private tenant;
-    private instanceId;
-    private crossTabSyncDebounceMs;
     private collections;
     private syncMeta;
     private dirtyChanges;
-    private broadcastChannel;
-    private pendingBroadcasts;
-    private debounceTimer;
-    private metaUpdateCallbacks;
-    constructor(tenant: string, collectionConfigs: CollectionConfig<any>[], options?: Partial<DexieDbOptions>);
-    private setupBroadcastChannel;
-    private queueBroadcast;
-    private flushBroadcasts;
+    constructor(tenant: string, collectionConfigs: CollectionConfig<any>[]);
     private getTable;
     private idToString;
     save<T extends LocalDbEntity>(collection: string, id: Id, data: Partial<T>): Promise<void>;
@@ -56,9 +48,4 @@ export declare class DexieDb extends Dexie implements I_DexieDb {
     setSyncMeta(collection: string, lastSyncTs: any): Promise<void>;
     deleteSyncMeta(collection: string): Promise<void>;
     getTenant(): string;
-    getInstanceId(): string;
-    getNewerThan<T extends LocalDbEntity>(collection: string, rev: number): Promise<T[]>;
-    onMetaUpdated(callback: (payload: MetaUpdateBroadcast) => void): () => void;
-    /** Close the broadcast channel when done */
-    closeBroadcastChannel(): void;
 }

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

@@ -1,5 +1,6 @@
 import type { AggregateOptions } from "mongodb";
 import type { I_SyncedDb, SyncedDbConfig, WsNotificationInfo } from "../types/I_SyncedDb";
+import type { MetaUpdateBroadcast } from "../types/I_DexieDb";
 import type { QuerySpec, UpdateSpec, InsertSpec, BatchSpec } from "../types/I_RestInterface";
 import type { Id, DbEntity } from "../types/DbEntity";
 /**
@@ -33,8 +34,7 @@ export declare class SyncedDb implements I_SyncedDb {
     private onWsNotification?;
     private onOnlineStatusChange?;
     private crossTabSyncDebounceMs;
-    private onExternalSync?;
-    private onStaleMetaConflict?;
+    private onCrossTabSync?;
     private onBecameLeader?;
     private onLostLeadership?;
     private onInfrastructureError?;
@@ -60,10 +60,12 @@ export declare class SyncedDb implements I_SyncedDb {
     private readonly syncedDbInstanceId;
     /** In-memory cache of sync metadata per collection */
     private syncMetaCache;
-    /** In-memory cache of max _rev seen per collection (for cross-tab sync) */
-    private lastSeenRevCache;
-    /** Unsubscribe function for cross-tab meta updates */
-    private unsubscribeMetaUpdates?;
+    /** BroadcastChannel for cross-tab meta updates */
+    private metaUpdateChannel?;
+    /** Pending broadcasts to be sent (debounced) */
+    private pendingBroadcasts;
+    /** Debounce timer for broadcasts */
+    private broadcastDebounceTimer?;
     /** Whether this instance is the leader tab */
     private isLeader;
     /** Resolve function to release the leader lock */
@@ -86,6 +88,11 @@ export declare class SyncedDb implements I_SyncedDb {
     getCrossTabSyncDebounceMs(): number;
     /** Check if this instance is the leader tab */
     isLeaderTab(): boolean;
+    /**
+     * Test helper: simulate receiving a cross-tab broadcast from another instance.
+     * This is used in tests where BroadcastChannel is not available.
+     */
+    simulateExternalBroadcast(payload: MetaUpdateBroadcast): void;
     /**
      * Try to become the leader tab using Web Locks API.
      * Only the leader processes server notifications.
@@ -170,8 +177,8 @@ export declare class SyncedDb implements I_SyncedDb {
     getOnWsReconnect(): ((attempt: number) => void) | undefined;
     getOnWsNotification(): ((info: WsNotificationInfo) => void) | undefined;
     getDirty<T extends DbEntity>(): Promise<Readonly<Record<string, readonly T[]>>>;
-    deleteCollectionData(collection: string, force?: boolean): Promise<boolean>;
-    deleteAllCollectionsData(force?: boolean): Promise<boolean>;
+    dropCollection(collection: string, force?: boolean): Promise<void>;
+    dropDatabase(force?: boolean): Promise<void>;
     private assertCollection;
     private stripLocalFields;
     private getPendingKey;
@@ -210,16 +217,18 @@ export declare class SyncedDb implements I_SyncedDb {
      */
     private timestampsEqual;
     /**
-     * Normalize timestamp to number for comparison
+     * Notify other tabs about updated records via BroadcastChannel.
+     * Does NOT write to Dexie - just sends a broadcast with the updated _ids.
+     * Broadcasts are debounced to reduce message frequency.
      */
-    private normalizeTimestamp;
+    private broadcastMetaUpdate;
     /**
-     * Broadcast metadata update to other tabs.
-     * Updates both Dexie sync meta and the in-memory cache.
+     * Flush pending broadcasts immediately.
      */
-    private broadcastMetaUpdate;
+    private flushBroadcasts;
     /**
-     * Handle cross-tab sync metadata updates from BroadcastChannel
+     * Handle cross-tab sync metadata updates from BroadcastChannel.
+     * Copies the specified objects from Dexie to in-memory and removes deleted records.
      */
     private handleCrossTabMetaUpdate;
     private handleServerUpdate;

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

@@ -1,7 +1,6 @@
 import type { QuerySpec } from ".";
-export interface CollectionConfig<T> {
+export interface CollectionConfig<T = any> {
     name: string;
     query?: QuerySpec<T>;
-    indexes?: (keyof T)[];
     resolveSyncConflict?(local: T, external: T): T;
 }

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

@@ -29,20 +29,12 @@ export interface DirtyChange {
 }
 /**
  * Payload for cross-tab meta update broadcasts
+ * Maps collection names to arrays of _id strings that were updated
  */
 export interface MetaUpdateBroadcast {
-    collection: string;
-    lastSyncTs: any;
-    instanceId: string;
-}
-/**
- * Options for DexieDb constructor
- */
-export interface DexieDbOptions {
-    /** Unique identifier for this SyncedDb instance */
+    /** Map of collection name -> array of _id strings that were updated */
+    updates: Record<string, string[]>;
     instanceId: string;
-    /** Debounce interval for cross-tab sync broadcasts (ms) */
-    crossTabSyncDebounceMs: number;
 }
 /**
  * Interface za Dexie (IndexedDB) bazo podatkov
@@ -105,10 +97,4 @@ export interface I_DexieDb {
     deleteSyncMeta(collection: string): Promise<void>;
     /** Vrne tenant */
     getTenant(): string;
-    /** Get records newer than revision (uses _rev index) */
-    getNewerThan<T extends LocalDbEntity>(collection: string, rev: number): Promise<T[]>;
-    /** Subscribe to metadata updates from other tabs. Returns unsubscribe function. */
-    onMetaUpdated(callback: (payload: MetaUpdateBroadcast) => void): () => void;
-    /** Get the instance ID */
-    getInstanceId(): string;
 }

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

@@ -201,15 +201,13 @@ export interface SyncInfo {
 /**
  * Konfiguracija za posamezno kolekcijo
  */
-export interface CollectionConfig {
+export interface CollectionConfig<T extends DbEntity = any> {
     /** Ime kolekcije */
     name: string;
     /** Opcijski filter za velike tabele - omeji obseg sinhronizacije */
     query?: QuerySpec<any>;
-    /** Dodatni indexi poleg _id */
-    indexes?: string[];
     /** Opcijska funkcija za razreševanje konfliktov */
-    resolveSyncConflict?<T extends DbEntity>(local: T, external: T): T;
+    resolveSyncConflict?(local: T, external: T): T;
 }
 /**
  * Konfiguracija za SyncedDb - dependencies so podani kot parametri (DI)
@@ -275,9 +273,7 @@ export interface SyncedDbConfig {
     /** Debounce interval for cross-tab sync broadcasts in ms (default: 100) */
     crossTabSyncDebounceMs?: number;
     /** Callback when another tab synced data and local in-memory cache was updated */
-    onExternalSync?: (collection: string, newItemsCount: number) => void;
-    /** Callback when received metadata is older than in-memory (indicates conflict/issue) */
-    onStaleMetaConflict?: (collection: string, inMemoryTs: any, receivedTs: any) => void;
+    onCrossTabSync?: (collection: string, newItemsCount: number) => void;
     /** Callback when this instance becomes the leader tab */
     onBecameLeader?: () => void;
     /** Callback when this instance loses leadership (e.g., another tab took over) */
@@ -410,20 +406,28 @@ export interface I_SyncedDb {
     /** Vrne vse dirty objekte iz vseh kolekcij */
     getDirty<T extends DbEntity>(): Promise<Readonly<Record<string, readonly T[]>>>;
     /**
-     * Deletes all data for a single collection from Dexie and in-memory.
-     * First sends all dirty data to the server.
-     * @param collection Name of the collection to delete
-     * @param force If true, deletes data even if sending dirty data fails
-     * @returns true if successful, false if sending failed and force was false
+     * Drops a collection, ensuring no data loss.
+     * - Throws if offline or forcedOffline (unless force=true)
+     * - Flushes pending in-memory changes to Dexie
+     * - Syncs all dirty items to the server
+     * - Throws if sync fails (unless force=true)
+     * - Then deletes collection data, metadata, and dirty changes from Dexie and in-memory
+     * @param collection Name of the collection to drop
+     * @param force If true, drops even if offline or sync fails (may lose data)
+     * @throws Error if offline, forcedOffline, or sync fails (unless force=true)
      */
-    deleteCollectionData(collection: string, force?: boolean): Promise<boolean>;
+    dropCollection(collection: string, force?: boolean): Promise<void>;
     /**
-     * Deletes all data for all collections from Dexie and in-memory.
-     * First sends all dirty data to the server.
-     * @param force If true, deletes data even if sending dirty data fails
-     * @returns true if successful, false if sending failed and force was false
+     * Drops all collections (the entire database), ensuring no data loss.
+     * - Throws if offline or forcedOffline (unless force=true)
+     * - Flushes pending in-memory changes to Dexie
+     * - Syncs all dirty items to the server
+     * - Throws if sync fails (unless force=true)
+     * - Then deletes all collection data, metadata, and dirty changes from Dexie and in-memory
+     * @param force If true, drops even if offline or sync fails (may lose data)
+     * @throws Error if offline, forcedOffline, or sync fails (unless force=true)
      */
-    deleteAllCollectionsData(force?: boolean): Promise<boolean>;
+    dropDatabase(force?: boolean): Promise<void>;
     /**
      * Check if this instance is the leader tab.
      * Only the leader processes server notifications and writes to Dexie from server updates.

package/package.json

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