cry-synced-db-client 0.1.76 → 0.1.79

package/dist/index.js

@@ -705,7 +705,6 @@ var CrossTabSyncManager = class {
   // Private Methods
   // ============================================================
   async handleCrossTabMetaUpdate(payload) {
-    var _a;
     if (!this.deps.isInitialized()) {
       return;
     }
@@ -717,7 +716,7 @@ var CrossTabSyncManager = class {
       if (!collections.has(collection)) {
         continue;
       }
-      if ((_a = collections.get(collection)) == null ? void 0 : _a.writeOnly) {
+      if (!this.deps.isSyncAllowed(collection)) {
         continue;
       }
       if (ids.length === 0) {
@@ -1870,7 +1869,7 @@ dist_default.registerCustom(
   {
     isApplicable: (v) => v instanceof ObjectId,
     serialize: (v) => v.toHexString(),
-    deserialize: (v) => new ObjectId(v)
+    deserialize: (v) => v
   },
   "ObjectId"
 );
@@ -2062,9 +2061,16 @@ var PendingChangesManager = class {
           });
           if (existing) {
             Object.assign(existing, write.data);
+            if (existing._id && typeof existing._id === "object") {
+              existing._id = String(existing._id);
+            }
             saveBatch.push(existing);
           } else {
-            insertBatch.push(write.data);
+            const insertData = write.data;
+            if (insertData._id && typeof insertData._id === "object") {
+              insertData._id = String(insertData._id);
+            }
+            insertBatch.push(insertData);
           }
         }
         if (dirtyChangesBatch.length > 0) {
@@ -2344,7 +2350,7 @@ var _SyncEngine = class _SyncEngine {
       const syncSpecs = [];
       const configMap = /* @__PURE__ */ new Map();
       for (const [collectionName, config] of this.collections) {
-        if (config.writeOnly) continue;
+        if (!this.deps.isSyncAllowed(collectionName)) continue;
         const syncEnabled = (_a = config.syncConfig) == null ? void 0 : _a.enabled;
         const shouldSync = typeof syncEnabled === "function" ? syncEnabled() : syncEnabled;
         if (shouldSync === false) {
@@ -2873,13 +2879,12 @@ var ServerUpdateHandler = class {
    * Handle incoming server update (WebSocket notification).
    */
   async handleServerUpdate(payload) {
-    var _a;
     this.callOnWsNotification(payload);
     if (!this.deps.isLeader()) return;
     if (!this.deps.canReceiveServerUpdates()) return;
     const collectionName = payload.collection;
     if (!this.collections.has(collectionName)) return;
-    if ((_a = this.collections.get(collectionName)) == null ? void 0 : _a.writeOnly) return;
+    if (!this.deps.isSyncAllowed(collectionName)) return;
     const updatedIds = [];
     switch (payload.operation) {
       case "insert": {
@@ -3293,6 +3298,8 @@ var SyncedDb = class {
     this.syncing = false;
     this.syncLock = false;
     this.wsUpdateQueue = [];
+    /** When non-null, only these collections participate in sync/in-mem loading. */
+    this.syncOnlyCollections = null;
     // Sync metadata cache
     this.syncMetaCache = /* @__PURE__ */ new Map();
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
@@ -3358,7 +3365,8 @@ var SyncedDb = class {
         dexieDb: this.dexieDb,
         writeToInMemBatch: (collection, items, operation) => {
           this.inMemManager.writeBatch(collection, items, operation);
-        }
+        },
+        isSyncAllowed: (collection) => this.isSyncAllowed(collection)
       }
     });
     this.connectionManager = new ConnectionManager({
@@ -3438,7 +3446,8 @@ var SyncedDb = class {
         flushAllPendingChanges: () => this.pendingChanges.flushAll(),
         cancelRestUploadTimer: () => this.pendingChanges.cancelRestUploadTimer(),
         awaitRestUpload: () => this.pendingChanges.awaitRestUpload(),
-        broadcastUpdates: (updates) => this.crossTabSync.broadcastMetaUpdate(updates)
+        broadcastUpdates: (updates) => this.crossTabSync.broadcastMetaUpdate(updates),
+        isSyncAllowed: (collection) => this.isSyncAllowed(collection)
       }
     });
     this.serverUpdateHandler = new ServerUpdateHandler({
@@ -3457,7 +3466,8 @@ var SyncedDb = class {
           this.inMemManager.writeBatch(collection, items, operation);
         },
         broadcastUpdates: (updates) => this.crossTabSync.broadcastMetaUpdate(updates),
-        getPendingChange: (collection, id) => this.pendingChanges.getPendingChange(collection, id)
+        getPendingChange: (collection, id) => this.pendingChanges.getPendingChange(collection, id),
+        isSyncAllowed: (collection) => this.isSyncAllowed(collection)
       }
     });
     if (config.wakeSyncEnabled) {
@@ -3500,6 +3510,41 @@ var SyncedDb = class {
   isLeaderTab() {
     return this.leaderElection.isLeader();
   }
+  /**
+   * Restrict sync to only these collections. When non-empty, only the listed
+   * collections load from Dexie→in-mem and download from server. Pass an empty
+   * array to sync all collections again.
+   *
+   * Newly-allowed collections are loaded from Dexie immediately and a sync is
+   * triggered if online.
+   */
+  async setSyncOnlyTheseCollections(collections) {
+    const prevAllowed = /* @__PURE__ */ new Set();
+    for (const [name] of this.collections) {
+      if (this.isSyncAllowed(name)) prevAllowed.add(name);
+    }
+    this.syncOnlyCollections = collections.length > 0 ? new Set(collections) : null;
+    const newlyAllowed = [];
+    for (const [name] of this.collections) {
+      if (this.isSyncAllowed(name) && !prevAllowed.has(name)) {
+        newlyAllowed.push(name);
+      }
+    }
+    for (const name of newlyAllowed) {
+      await this.loadCollectionToInMem(name);
+    }
+    if (newlyAllowed.length > 0 && this.connectionManager.canSync()) {
+      this.sync("setSyncOnlyTheseCollections").catch(() => {
+      });
+    }
+  }
+  /**
+   * Get the current syncOnlyTheseCollections filter.
+   * Returns null when all collections are synced.
+   */
+  getSyncOnlyTheseCollections() {
+    return this.syncOnlyCollections;
+  }
   /**
    * Test helper: simulate receiving a cross-tab broadcast from another instance.
    */
@@ -3523,26 +3568,9 @@ var SyncedDb = class {
       );
     }
     await this.pendingChanges.recoverPendingWrites();
-    for (const [name, config] of this.collections) {
-      if (config.writeOnly) continue;
-      this.inMemManager.clearCollection(name);
-      await this.dexieDb.forEachBatch(name, 2e3, async (chunk) => {
-        let writeIdx = 0;
-        for (let i = 0; i < chunk.length; i++) {
-          const item = chunk[i];
-          if (!item._deleted && !item._archived) {
-            chunk[writeIdx++] = item;
-          }
-        }
-        chunk.length = writeIdx;
-        if (chunk.length > 0) {
-          this.inMemManager.writeBatch(name, chunk, "upsert");
-        }
-      });
-      const meta = await this.dexieDb.getSyncMeta(name);
-      if (meta) {
-        this.syncMetaCache.set(name, meta);
-      }
+    for (const [name] of this.collections) {
+      if (!this.isSyncAllowed(name)) continue;
+      await this.loadCollectionToInMem(name);
     }
     this.leaderElection.init();
     this.crossTabSync.init();
@@ -3904,7 +3932,7 @@ var SyncedDb = class {
     if (existing) {
       return this.save(collection, existing._id, update);
     } else {
-      const id = new ObjectId2();
+      const id = new ObjectId2().toHexString();
       const newDoc = __spreadValues({ _id: id }, update);
       return this.insert(collection, newDoc);
     }
@@ -3912,7 +3940,7 @@ var SyncedDb = class {
   async insert(collection, data) {
     var _a;
     this.assertCollection(collection);
-    const id = data._id || new ObjectId2();
+    const id = data._id ? String(data._id) : new ObjectId2().toHexString();
     const existing = await this.dexieDb.getById(collection, id);
     if (existing && !existing._deleted && !existing._archived) {
       console.warn(
@@ -4263,6 +4291,42 @@ var SyncedDb = class {
       returnArchived: (_b = opts == null ? void 0 : opts.returnArchived) != null ? _b : this.defaultReturnArchived
     });
   }
+  /**
+   * Whether a collection participates in sync (server download,
+   * WS notifications, cross-tab sync, Dexie→in-mem loading).
+   * False for writeOnly collections and collections excluded by syncOnlyCollections.
+   */
+  isSyncAllowed(collection) {
+    const config = this.collections.get(collection);
+    if (!config) return false;
+    if (config.writeOnly) return false;
+    if (this.syncOnlyCollections && !this.syncOnlyCollections.has(collection)) return false;
+    return true;
+  }
+  /**
+   * Load a single collection from Dexie into in-memory cache.
+   * Filters out deleted and archived items.
+   */
+  async loadCollectionToInMem(name) {
+    this.inMemManager.clearCollection(name);
+    await this.dexieDb.forEachBatch(name, 2e3, async (chunk) => {
+      let writeIdx = 0;
+      for (let i = 0; i < chunk.length; i++) {
+        const item = chunk[i];
+        if (!item._deleted && !item._archived) {
+          chunk[writeIdx++] = item;
+        }
+      }
+      chunk.length = writeIdx;
+      if (chunk.length > 0) {
+        this.inMemManager.writeBatch(name, chunk, "upsert");
+      }
+    });
+    const meta = await this.dexieDb.getSyncMeta(name);
+    if (meta) {
+      this.syncMetaCache.set(name, meta);
+    }
+  }
   assertCollection(name) {
     if (!this.collections.has(name)) {
       throw new Error(`Collection "${name}" not configured`);
@@ -4345,6 +4409,12 @@ var DexieDb = class extends Dexie {
   idToString(id) {
     return String(id);
   }
+  /** Ensure _id is a primitive string. IndexedDB rejects ObjectId objects as keys. */
+  ensureStringId(item) {
+    if (item._id && typeof item._id === "object") {
+      item._id = String(item._id);
+    }
+  }
   async save(collection, id, data) {
     const table = this.getTable(collection);
     const key = this.idToString(id);
@@ -4353,17 +4423,19 @@ var DexieDb = class extends Dexie {
       await table.update(key, data);
     } else {
       await table.put(__spreadValues({
-        _id: id
+        _id: key
       }, data));
     }
   }
   async insert(collection, data) {
     const table = this.getTable(collection);
+    this.ensureStringId(data);
     await table.put(data);
   }
   async saveMany(collection, items) {
     if (items.length === 0) return;
     const table = this.getTable(collection);
+    for (const item of items) this.ensureStringId(item);
     await table.bulkPut(items);
   }
   async deleteOne(collection, id) {
@@ -4382,6 +4454,7 @@ var DexieDb = class extends Dexie {
     const table = this.getTable(collection);
     await table.clear();
     if (data.length > 0) {
+      for (const item of data) this.ensureStringId(item);
       await table.bulkPut(data);
     }
   }

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

@@ -15,6 +15,8 @@ export declare class DexieDb extends Dexie implements I_DexieDb {
     constructor(tenant: string, collectionConfigs: CollectionConfig<any>[]);
     private getTable;
     private idToString;
+    /** Ensure _id is a primitive string. IndexedDB rejects ObjectId objects as keys. */
+    private ensureStringId;
     save<T extends LocalDbEntity>(collection: string, id: Id, data: Partial<T>): Promise<void>;
     insert<T extends LocalDbEntity>(collection: string, data: T): Promise<void>;
     saveMany<T extends LocalDbEntity>(collection: string, items: T[]): Promise<void>;

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

@@ -27,6 +27,8 @@ export declare class SyncedDb implements I_SyncedDb {
     private syncing;
     private syncLock;
     private wsUpdateQueue;
+    /** When non-null, only these collections participate in sync/in-mem loading. */
+    private syncOnlyCollections;
     private readonly updaterId;
     private readonly syncedDbInstanceId;
     private syncMetaCache;
@@ -44,6 +46,20 @@ export declare class SyncedDb implements I_SyncedDb {
     getInstanceId(): string;
     getCrossTabSyncDebounceMs(): number;
     isLeaderTab(): boolean;
+    /**
+     * Restrict sync to only these collections. When non-empty, only the listed
+     * collections load from Dexie→in-mem and download from server. Pass an empty
+     * array to sync all collections again.
+     *
+     * Newly-allowed collections are loaded from Dexie immediately and a sync is
+     * triggered if online.
+     */
+    setSyncOnlyTheseCollections(collections: string[]): Promise<void>;
+    /**
+     * Get the current syncOnlyTheseCollections filter.
+     * Returns null when all collections are synced.
+     */
+    getSyncOnlyTheseCollections(): ReadonlySet<string> | null;
     /**
      * Test helper: simulate receiving a cross-tab broadcast from another instance.
      */
@@ -114,6 +130,17 @@ export declare class SyncedDb implements I_SyncedDb {
      * Per-call values take precedence over global defaults.
      */
     private resolveOpts;
+    /**
+     * Whether a collection participates in sync (server download,
+     * WS notifications, cross-tab sync, Dexie→in-mem loading).
+     * False for writeOnly collections and collections excluded by syncOnlyCollections.
+     */
+    private isSyncAllowed;
+    /**
+     * Load a single collection from Dexie into in-memory cache.
+     * Filters out deleted and archived items.
+     */
+    private loadCollectionToInMem;
     private assertCollection;
     /**
      * Asserts write-only collection has online connectivity for reads.

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

@@ -50,6 +50,8 @@ export interface CrossTabSyncDeps {
     dexieDb: I_DexieDb;
     /** Write to in-mem batch. */
     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;
 }
 export interface CrossTabSyncConfig {
     tenant: string;
@@ -225,6 +227,8 @@ export interface SyncEngineDeps {
     awaitRestUpload: () => Promise<void>;
     /** Broadcast updated IDs to other tabs */
     broadcastUpdates: (updates: Record<string, string[]>) => void;
+    /** Whether a collection participates in sync (not writeOnly, not filtered out). */
+    isSyncAllowed: (collection: string) => boolean;
 }
 export interface SyncEngineConfig {
     tenant: string;
@@ -256,6 +260,8 @@ export interface ServerUpdateHandlerDeps {
     getPendingChange: (collection: string, id: Id) => PendingChange | undefined;
     broadcastUpdates: (updates: Record<string, string[]>) => void;
     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;
 }
 export interface ServerUpdateHandlerConfig {
     tenant: string;

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

@@ -518,6 +518,18 @@ export interface I_SyncedDb {
     sync(calledFrom?: string): Promise<void>;
     /** Ali je sinhronizacija v teku */
     isSyncing(): boolean;
+    /**
+     * Restrict sync to only these collections. When non-empty, only listed
+     * collections load Dexie→in-mem and download from server. Pass empty
+     * array to sync all collections. Newly-allowed collections are loaded
+     * immediately and a sync is triggered if online.
+     */
+    setSyncOnlyTheseCollections(collections: string[]): Promise<void>;
+    /**
+     * Get the current syncOnlyTheseCollections filter.
+     * Returns null when all collections are synced.
+     */
+    getSyncOnlyTheseCollections(): ReadonlySet<string> | null;
     /**
      * Izvede batch upsert na serverju
      *

package/package.json

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