cry-synced-db-client 0.1.50 → 0.1.51

package/dist/index.js

@@ -1127,6 +1127,8 @@ class SyncedDb {
   closing = false;
   releasingLeadershipDueToVisibility = false;
   visibilityChangeHandler;
+  useObjectMetadata;
+  _metadata = {};
   constructor(config) {
     this.tenant = config.tenant;
     this.dexieDb = config.dexieDb;
@@ -1158,6 +1160,7 @@ class SyncedDb {
     this.onBecameLeader = config.onBecameLeader;
     this.onLostLeadership = config.onLostLeadership;
     this.onInfrastructureError = config.onInfrastructureError;
+    this.useObjectMetadata = config.useObjectMetadata ?? false;
     this.updaterId = Math.random().toString(36).substring(2, 15);
     this.syncedDbInstanceId = `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
     for (const col of config.collections) {
@@ -1339,7 +1342,7 @@ class SyncedDb {
     for (const [name] of this.collections) {
       const data = await this.dexieDb.getAll(name);
       const activeData = data.filter((item) => !item._deleted);
-      this.inMemDb.saveCollection(name, activeData);
+      this._initCollectionInMem(name, activeData);
       const meta = await this.dexieDb.getSyncMeta(name);
       if (meta) {
         this.syncMetaCache.set(name, meta);
@@ -1617,10 +1620,11 @@ class SyncedDb {
       _lastUpdaterId: this.updaterId
     };
     this.schedulePendingChange(collection, id, newData, 0, "save");
+    const currentMem = this.inMemDb.getById(collection, id);
+    const merged = { ...currentMem || existing || { _id: id }, ...update };
     if (existing?._deleted) {} else {
-      this.inMemDb.save(collection, id, update);
+      this._writeToInMemBatch(collection, [merged], "upsert");
     }
-    const merged = { ...existing || { _id: id }, ...update };
     return this.stripLocalFields(merged);
   }
   async upsert(collection, query, update) {
@@ -1653,7 +1657,7 @@ class SyncedDb {
       _lastUpdaterId: this.updaterId
     };
     this.schedulePendingChange(collection, id, newData, 0, "insert");
-    this.inMemDb.insert(collection, this.stripLocalFields(newData));
+    this._writeToInMemBatch(collection, [this.stripLocalFields(newData)], "upsert");
     return this.stripLocalFields(newData);
   }
   async deleteOne(collection, id) {
@@ -1668,7 +1672,7 @@ class SyncedDb {
       _lastUpdaterId: this.updaterId
     };
     this.schedulePendingChange(collection, id, deleteUpdate, 0, "deleteOne");
-    this.inMemDb.deleteOne(collection, id);
+    this._writeToInMemBatch(collection, [{ _id: id }], "delete");
     return this.stripLocalFields(existing);
   }
   async deleteMany(collection, query) {
@@ -1702,7 +1706,7 @@ class SyncedDb {
       await this.dexieDb.addDirtyChangesBatch(collection, dirtyChangesBatch);
     }
     if (idsToDelete.length > 0) {
-      this.inMemDb.deleteManyByIds(collection, idsToDelete);
+      this._writeToInMemBatch(collection, idsToDelete.map((id) => ({ _id: id })), "delete");
     }
     return idsToDelete.length;
   }
@@ -1717,7 +1721,7 @@ class SyncedDb {
     }
     await this.withRestTimeout(this.restInterface.deleteOne(collection, { _id: id }), "hardDeleteOne");
     await this.dexieDb.deleteOne(collection, id);
-    this.inMemDb.deleteOne(collection, id);
+    this._writeToInMemBatch(collection, [{ _id: id }], "delete");
     return this.stripLocalFields(existing);
   }
   async hardDelete(collection, query) {
@@ -1750,7 +1754,7 @@ class SyncedDb {
         try {
           await this.withRestTimeout(this.restInterface.deleteOne(collection, { _id: item.id }), "hardDelete");
           await this.dexieDb.deleteOne(collection, item.id);
-          this.inMemDb.deleteOne(collection, item.id);
+          this._writeToInMemBatch(collection, [{ _id: item.id }], "delete");
           results.push(true);
         } catch (err) {
           console.error(`Failed to hard delete ${String(item.id)}:`, err);
@@ -1970,7 +1974,7 @@ class SyncedDb {
       }
     }
     await this.dexieDb.deleteCollection(collection);
-    this.inMemDb.deleteCollection(collection);
+    this._clearCollectionInMem(collection);
     await this.dexieDb.deleteSyncMeta(collection);
     await this.dexieDb.clearDirtyChanges(collection);
     this.syncMetaCache.delete(collection);
@@ -2005,7 +2009,7 @@ class SyncedDb {
     }
     for (const collectionName of collectionNames) {
       await this.dexieDb.deleteCollection(collectionName);
-      this.inMemDb.deleteCollection(collectionName);
+      this._clearCollectionInMem(collectionName);
       await this.dexieDb.deleteSyncMeta(collectionName);
       await this.dexieDb.clearDirtyChanges(collectionName);
     }
@@ -2019,6 +2023,75 @@ class SyncedDb {
   stripLocalFields(item) {
     return item;
   }
+  _writeToInMemBatch(collection, items, operation) {
+    if (items.length === 0)
+      return;
+    const config = this.collections.get(collection);
+    if (operation === "upsert") {
+      this.inMemDb.saveMany(collection, items);
+      if (this.useObjectMetadata && config?.hasMetadata) {
+        const ids = items.map((item) => item._id);
+        let metadatas;
+        if (config.onObjectsUpdated) {
+          metadatas = config.onObjectsUpdated(items);
+        } else if (config.onObjectUpdated) {
+          metadatas = items.map((item) => config.onObjectUpdated(item));
+        } else {
+          return;
+        }
+        this._setObjectsMetadataInternal(collection, ids, metadatas);
+      }
+    } else if (operation === "delete") {
+      const ids = items.map((item) => item._id);
+      this.inMemDb.deleteManyByIds(collection, ids);
+      if (this.useObjectMetadata && config?.hasMetadata) {
+        this._deleteObjectsMetadataInternal(collection, ids);
+      }
+    }
+  }
+  _initCollectionInMem(collection, items) {
+    this.inMemDb.saveCollection(collection, items);
+    if (this.useObjectMetadata && items.length > 0) {
+      const config = this.collections.get(collection);
+      if (config?.hasMetadata) {
+        const ids = items.map((item) => item._id);
+        let metadatas;
+        if (config.onObjectsUpdated) {
+          metadatas = config.onObjectsUpdated(items);
+        } else if (config.onObjectUpdated) {
+          metadatas = items.map((item) => config.onObjectUpdated(item));
+        } else {
+          return;
+        }
+        this._setObjectsMetadataInternal(collection, ids, metadatas);
+      }
+    }
+  }
+  _clearCollectionInMem(collection) {
+    this.inMemDb.deleteCollection(collection);
+    if (this.useObjectMetadata) {
+      this._metadata[collection]?.clear();
+      delete this._metadata[collection];
+    }
+  }
+  _setObjectsMetadataInternal(collection, ids, metadatas) {
+    let map = this._metadata[collection];
+    if (!map) {
+      map = new Map;
+      this._metadata[collection] = map;
+    }
+    for (let i = 0;i < ids.length; i++) {
+      map.set(String(ids[i]), metadatas[i]);
+    }
+  }
+  _deleteObjectsMetadataInternal(collection, ids) {
+    const map = this._metadata[collection];
+    if (map) {
+      for (const id of ids) {
+        map.delete(String(id));
+      }
+    }
+  }
   getPendingKey(collection, id) {
     return `${collection}:${String(id)}`;
   }
@@ -2232,6 +2305,7 @@ class SyncedDb {
         const idsToUpdate = insertedAndUpdated.map((e) => e._id);
         const existingItems = await this.dexieDb.getByIds(collection, idsToUpdate);
         const dexieSaveBatch = [];
+        const inMemUpdateBatch = [];
         for (let i = 0;i < insertedAndUpdated.length; i++) {
           const entity = insertedAndUpdated[i];
           const existing = existingItems[i];
@@ -2242,20 +2316,27 @@ class SyncedDb {
               _ts: entity._ts
             });
           }
-          this.inMemDb.save(collection, entity._id, {
-            _rev: entity._rev,
-            _ts: entity._ts
-          });
+          const inMemItem = this.inMemDb.getById(collection, entity._id);
+          if (inMemItem) {
+            inMemUpdateBatch.push({
+              ...inMemItem,
+              _rev: entity._rev,
+              _ts: entity._ts
+            });
+          }
         }
         if (dexieSaveBatch.length > 0) {
           await this.dexieDb.saveMany(collection, dexieSaveBatch);
         }
+        if (inMemUpdateBatch.length > 0) {
+          this._writeToInMemBatch(collection, inMemUpdateBatch, "upsert");
+        }
         sentCount += insertedAndUpdated.length;
       }
       if (deleted.length > 0) {
         const deleteIds = deleted.map((e) => e._id);
         await this.dexieDb.deleteMany(collection, deleteIds);
-        this.inMemDb.deleteManyByIds(collection, deleteIds);
+        this._writeToInMemBatch(collection, deleteIds.map((id) => ({ _id: id })), "delete");
         sentCount += deleted.length;
       }
       const allItems = [...inserted, ...updated, ...deleted];
@@ -2380,10 +2461,10 @@ class SyncedDb {
       await this.dexieDb.saveMany(collectionName, dexieBatch);
     }
     if (inMemSaveBatch.length > 0) {
-      this.inMemDb.saveMany(collectionName, inMemSaveBatch);
+      this._writeToInMemBatch(collectionName, inMemSaveBatch, "upsert");
     }
     if (inMemDeleteIds.length > 0) {
-      this.inMemDb.deleteManyByIds(collectionName, inMemDeleteIds);
+      this._writeToInMemBatch(collectionName, inMemDeleteIds.map((id) => ({ _id: id })), "delete");
     }
     if (maxTs) {
       await this.dexieDb.setSyncMeta(collectionName, maxTs);
@@ -2517,18 +2598,28 @@ class SyncedDb {
         if (dexieSaveBatch.length > 0) {
           await this.dexieDb.saveMany(collection, dexieSaveBatch);
         }
-        for (const item of inMemSaveIds) {
-          this.inMemDb.save(collection, item.id, {
-            _rev: item.rev,
-            _ts: item.ts
-          });
+        if (inMemSaveIds.length > 0) {
+          const inMemUpdateBatch = [];
+          for (const item of inMemSaveIds) {
+            const inMemItem = this.inMemDb.getById(collection, item.id);
+            if (inMemItem) {
+              inMemUpdateBatch.push({
+                ...inMemItem,
+                _rev: item.rev,
+                _ts: item.ts
+              });
+            }
+          }
+          if (inMemUpdateBatch.length > 0) {
+            this._writeToInMemBatch(collection, inMemUpdateBatch, "upsert");
+          }
         }
         sentCount += insertedAndUpdated.length;
       }
       if (deleted.length > 0) {
         const deleteIds = deleted.map((e) => e._id);
         await this.dexieDb.deleteMany(collection, deleteIds);
-        this.inMemDb.deleteManyByIds(collection, deleteIds);
+        this._writeToInMemBatch(collection, deleteIds.map((id) => ({ _id: id })), "delete");
         sentCount += deleted.length;
       }
       const allItems = [...inserted, ...updated, ...deleted];
@@ -2658,17 +2749,30 @@ class SyncedDb {
       }
       try {
         const items = await this.dexieDb.getByIds(collection, ids);
+        const upsertBatch = [];
+        const deleteBatch = [];
         let newItemsCount = 0;
-        for (const item of items) {
-          if (!item)
+        for (let i = 0;i < ids.length; i++) {
+          const item = items[i];
+          const id = ids[i];
+          if (!item) {
+            deleteBatch.push({ _id: id });
+            newItemsCount++;
             continue;
+          }
           if (item._deleted) {
-            this.inMemDb.deleteOne(collection, item._id);
+            deleteBatch.push({ _id: item._id });
           } else {
-            this.inMemDb.save(collection, item._id, this.stripLocalFields(item));
+            upsertBatch.push(this.stripLocalFields(item));
           }
           newItemsCount++;
         }
+        if (upsertBatch.length > 0) {
+          this._writeToInMemBatch(collection, upsertBatch, "upsert");
+        }
+        if (deleteBatch.length > 0) {
+          this._writeToInMemBatch(collection, deleteBatch, "delete");
+        }
         if (this.onCrossTabSync && newItemsCount > 0) {
           try {
             this.onCrossTabSync(collection, newItemsCount);
@@ -2786,13 +2890,13 @@ class SyncedDb {
       if (!serverItem._deleted) {
         const memItem = this.inMemDb.getById(collectionName, serverItem._id);
         if (!memItem) {
-          this.inMemDb.insert(collectionName, this.stripLocalFields(serverItem));
+          this._writeToInMemBatch(collectionName, [this.stripLocalFields(serverItem)], "upsert");
         }
       }
     } else {
       await this.dexieDb.insert(collectionName, serverItem);
       if (!serverItem._deleted) {
-        this.inMemDb.insert(collectionName, this.stripLocalFields(serverItem));
+        this._writeToInMemBatch(collectionName, [this.stripLocalFields(serverItem)], "upsert");
       }
     }
   }
@@ -2816,7 +2920,7 @@ class SyncedDb {
       if (currentMemItem) {
         const merged = this.mergeLocalWithDelta(currentMemItem, serverDelta);
         if (!merged._deleted) {
-          this.inMemDb.save(collectionName, serverDelta._id, this.stripLocalFields(merged));
+          this._writeToInMemBatch(collectionName, [this.stripLocalFields(merged)], "upsert");
         }
         pendingChange.data = {
           ...pendingChange.data,
@@ -2833,7 +2937,7 @@ class SyncedDb {
         await this.dexieDb.save(collectionName, serverDelta._id, merged);
       }
       if (!merged._deleted) {
-        this.inMemDb.save(collectionName, serverDelta._id, this.stripLocalFields(merged));
+        this._writeToInMemBatch(collectionName, [this.stripLocalFields(merged)], "upsert");
       }
     } else {
       if (!metaChanged) {
@@ -2842,9 +2946,9 @@ class SyncedDb {
       const merged = this.mergeLocalWithDelta(localItem, serverDelta);
       await this.dexieDb.save(collectionName, serverDelta._id, merged);
       if (!merged._deleted) {
-        this.inMemDb.save(collectionName, serverDelta._id, this.stripLocalFields(merged));
+        this._writeToInMemBatch(collectionName, [this.stripLocalFields(merged)], "upsert");
       } else {
-        this.inMemDb.deleteOne(collectionName, serverDelta._id);
+        this._writeToInMemBatch(collectionName, [{ _id: serverDelta._id }], "delete");
       }
     }
   }
@@ -2879,7 +2983,48 @@ class SyncedDb {
     } else {
       await this.dexieDb.deleteOne(collectionName, id);
     }
-    this.inMemDb.deleteOne(collectionName, id);
+    this._writeToInMemBatch(collectionName, [{ _id: id }], "delete");
+  }
+  getObjectMetadata(collection, _id) {
+    return this._metadata[collection]?.get(String(_id));
+  }
+  getObjectsMetadata(collection, _ids) {
+    const map = this._metadata[collection];
+    if (!map) {
+      return _ids.map(() => {
+        return;
+      });
+    }
+    return _ids.map((_id) => map.get(String(_id)));
+  }
+  setObjectMetadata(collection, _id, metadata) {
+    let map = this._metadata[collection];
+    if (!map) {
+      map = new Map;
+      this._metadata[collection] = map;
+    }
+    map.set(String(_id), metadata);
+  }
+  setObjectsMetadata(collection, _ids, metadatas) {
+    let map = this._metadata[collection];
+    if (!map) {
+      map = new Map;
+      this._metadata[collection] = map;
+    }
+    for (let i = 0;i < _ids.length; i++) {
+      map.set(String(_ids[i]), metadatas[i]);
+    }
+  }
+  deleteObjectMetadata(collection, _id) {
+    this._metadata[collection]?.delete(String(_id));
+  }
+  deleteObjectsMetadata(collection, _ids) {
+    const map = this._metadata[collection];
+    if (map) {
+      for (const _id of _ids) {
+        map.delete(String(_id));
+      }
+    }
   }
 }
 // src/db/DexieDb.ts

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

@@ -81,6 +81,10 @@ export declare class SyncedDb implements I_SyncedDb {
     private releasingLeadershipDueToVisibility;
     /** Visibility change handler reference for cleanup */
     private visibilityChangeHandler?;
+    /** Whether object metadata feature is enabled */
+    private useObjectMetadata;
+    /** In-memory metadata store: collection -> (_id -> metadata) */
+    private _metadata;
     constructor(config: SyncedDbConfig);
     /** Get the unique instance ID for this SyncedDb */
     getInstanceId(): string;
@@ -181,6 +185,27 @@ export declare class SyncedDb implements I_SyncedDb {
     dropDatabase(force?: boolean): Promise<void>;
     private assertCollection;
     private stripLocalFields;
+    /**
+     * Centralized method for ALL in-mem writes.
+     * Handles metadata callbacks automatically when useObjectMetadata is enabled.
+     *
+     * @param collection - Collection name
+     * @param items - Objects to write (for upsert) or objects with _id (for delete)
+     * @param operation - 'upsert' to save/update, 'delete' to remove
+     */
+    private _writeToInMemBatch;
+    /**
+     * Initialize a collection in in-mem from Dexie data.
+     * Called during init().
+     */
+    private _initCollectionInMem;
+    /**
+     * Clear all data and metadata for a collection.
+     * Used by dropCollection().
+     */
+    private _clearCollectionInMem;
+    private _setObjectsMetadataInternal;
+    private _deleteObjectsMetadataInternal;
     private getPendingKey;
     private schedulePendingChange;
     private executePendingChange;
@@ -262,4 +287,10 @@ export declare class SyncedDb implements I_SyncedDb {
      */
     private mergeLocalWithDelta;
     private handleServerItemDelete;
+    getObjectMetadata<M>(collection: string, _id: Id): M | undefined;
+    getObjectsMetadata<M>(collection: string, _ids: Id[]): (M | undefined)[];
+    setObjectMetadata<M>(collection: string, _id: Id, metadata: M): void;
+    setObjectsMetadata<M>(collection: string, _ids: Id[], metadatas: M[]): void;
+    deleteObjectMetadata(collection: string, _id: Id): void;
+    deleteObjectsMetadata(collection: string, _ids: Id[]): void;
 }

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

@@ -201,13 +201,19 @@ export interface SyncInfo {
 /**
  * Konfiguracija za posamezno kolekcijo
  */
-export interface CollectionConfig<T extends DbEntity = any> {
+export interface CollectionConfig<T extends DbEntity = any, M = any> {
     /** Ime kolekcije */
     name: string;
     /** Opcijski filter za velike tabele - omeji obseg sinhronizacije */
     query?: QuerySpec<any>;
     /** Opcijska funkcija za razreševanje konfliktov */
     resolveSyncConflict?(local: T, external: T): T;
+    /** Whether this collection uses in-memory metadata */
+    hasMetadata?: boolean;
+    /** Callback called when a single object is written to in-mem. Returns metadata to store. */
+    onObjectUpdated?(object: T): M;
+    /** Callback called when multiple objects are written to in-mem. Returns metadata array (same order as input). */
+    onObjectsUpdated?(objects: T[]): M[];
 }
 /**
  * Konfiguracija za SyncedDb - dependencies so podani kot parametri (DI)
@@ -284,6 +290,12 @@ export interface SyncedDbConfig {
      * Client code can use this to show warnings, log telemetry, or adjust behavior.
      */
     onInfrastructureError?: (info: InfrastructureErrorInfo) => void;
+    /**
+     * Enable in-memory object metadata feature.
+     * When true, collections with hasMetadata=true will have their metadata callbacks invoked
+     * whenever objects are written to in-mem. Default: false.
+     */
+    useObjectMetadata?: boolean;
 }
 /**
  * Glavna logika za sinhronizirano bazo podatkov
@@ -434,4 +446,46 @@ export interface I_SyncedDb {
      * @returns true if this instance holds the leader lock
      */
     isLeaderTab(): boolean;
+    /**
+     * Get metadata for a single object.
+     * @param collection Collection name
+     * @param _id Object ID
+     * @returns Metadata for the object, or undefined if not found
+     */
+    getObjectMetadata<M>(collection: string, _id: Id): M | undefined;
+    /**
+     * Get metadata for multiple objects.
+     * @param collection Collection name
+     * @param _ids Object IDs
+     * @returns Array of metadata in same order as input _ids (undefined for missing)
+     */
+    getObjectsMetadata<M>(collection: string, _ids: Id[]): (M | undefined)[];
+    /**
+     * Manually set metadata for a single object.
+     * Rarely needed - metadata callbacks handle this automatically.
+     * @param collection Collection name
+     * @param _id Object ID
+     * @param metadata Metadata to store
+     */
+    setObjectMetadata<M>(collection: string, _id: Id, metadata: M): void;
+    /**
+     * Manually set metadata for multiple objects.
+     * Rarely needed - metadata callbacks handle this automatically.
+     * @param collection Collection name
+     * @param _ids Object IDs
+     * @param metadatas Metadata array (same order as _ids)
+     */
+    setObjectsMetadata<M>(collection: string, _ids: Id[], metadatas: M[]): void;
+    /**
+     * Delete metadata for a single object.
+     * @param collection Collection name
+     * @param _id Object ID
+     */
+    deleteObjectMetadata(collection: string, _id: Id): void;
+    /**
+     * Delete metadata for multiple objects.
+     * @param collection Collection name
+     * @param _ids Object IDs
+     */
+    deleteObjectsMetadata(collection: string, _ids: Id[]): void;
 }

package/package.json

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