cry-synced-db-client 0.1.37 → 0.1.38

package/dist/index.js

@@ -16,7 +16,7 @@ function resolveConflict(local, external) {
 function mergeObjects(local, external) {
   const result = { ...local };
   for (const key of Object.keys(external)) {
-    if (key === "_id" || key === "_dirty" || key === "_localChangedAt") {
+    if (key === "_id" || key === "_dirty") {
       continue;
     }
     const localValue = local[key];
@@ -669,7 +669,9 @@ class SyncedDb {
   }
   async findByIds(collection, ids) {
     this.assertCollection(collection);
-    const items = await Promise.all(ids.map((id) => this.dexieDb.getById(collection, id)));
+    if (ids.length === 0)
+      return [];
+    const items = await this.dexieDb.getByIds(collection, ids);
     const results = [];
     for (const item of items) {
       if (item && !item._deleted) {
@@ -707,10 +709,9 @@ class SyncedDb {
     if (!existing) {
       console.warn(`SyncedDb.save: Object ${String(id)} not found in ${collection}, creating new`);
     }
+    await this.dexieDb.addDirtyChange(collection, id, { ...update, _lastUpdaterId: this.updaterId }, { _ts: existing?._ts, _rev: existing?._rev });
     const newData = {
       ...update,
-      _dirty: true,
-      _localChangedAt: new Date,
       _lastUpdaterId: this.updaterId
     };
     this.schedulePendingChange(collection, id, newData, 0, "save");
@@ -738,11 +739,15 @@ class SyncedDb {
     if (existing && !existing._deleted) {
       console.warn(`SyncedDb.insert: Object ${String(id)} already exists in ${collection}, overwriting`);
     }
+    const insertChanges = { ...data, _lastUpdaterId: this.updaterId };
+    delete insertChanges._id;
+    await this.dexieDb.addDirtyChange(collection, id, insertChanges, {
+      _ts: undefined,
+      _rev: undefined
+    });
     const newData = {
       _id: id,
       ...data,
-      _dirty: true,
-      _localChangedAt: new Date,
       _lastUpdaterId: this.updaterId
     };
     this.schedulePendingChange(collection, id, newData, 0, "insert");
@@ -755,10 +760,9 @@ class SyncedDb {
     if (!existing || existing._deleted) {
       return null;
     }
+    await this.dexieDb.addDirtyChange(collection, id, { _deleted: new Date, _lastUpdaterId: this.updaterId }, { _ts: existing._ts, _rev: existing._rev });
     const deleteUpdate = {
       _deleted: new Date,
-      _dirty: true,
-      _localChangedAt: new Date,
       _lastUpdaterId: this.updaterId
     };
     this.schedulePendingChange(collection, id, deleteUpdate, 0, "deleteOne");
@@ -770,25 +774,35 @@ class SyncedDb {
     const items = await this.find(collection, query);
     if (items.length === 0)
       return 0;
-    const existingItems = await Promise.all(items.map((item) => this.dexieDb.getById(collection, item._id)));
+    const ids = items.map((item) => item._id);
+    const existingItems = await this.dexieDb.getByIds(collection, ids);
     const now = new Date;
-    let count = 0;
+    const dirtyChangesBatch = [];
+    const idsToDelete = [];
     for (let i = 0;i < items.length; i++) {
       const item = items[i];
       const existing = existingItems[i];
       if (!item || !existing || existing._deleted)
         continue;
+      dirtyChangesBatch.push({
+        id: item._id,
+        changes: { _deleted: now, _lastUpdaterId: this.updaterId },
+        baseMeta: { _ts: existing._ts, _rev: existing._rev }
+      });
       const deleteUpdate = {
         _deleted: now,
-        _dirty: true,
-        _localChangedAt: now,
         _lastUpdaterId: this.updaterId
       };
       this.schedulePendingChange(collection, item._id, deleteUpdate, 0, "deleteMany");
-      this.inMemDb.deleteOne(collection, item._id);
-      count++;
+      idsToDelete.push(item._id);
+    }
+    if (dirtyChangesBatch.length > 0) {
+      await this.dexieDb.addDirtyChangesBatch(collection, dirtyChangesBatch);
+    }
+    if (idsToDelete.length > 0) {
+      this.inMemDb.deleteManyByIds(collection, idsToDelete);
     }
-    return count;
+    return idsToDelete.length;
   }
   async hardDeleteOne(collection, id) {
     this.assertCollection(collection);
@@ -1092,8 +1106,7 @@ class SyncedDb {
     }
   }
   stripLocalFields(item) {
-    const { _dirty, _localChangedAt, ...rest } = item;
-    return rest;
+    return item;
   }
   getPendingKey(collection, id) {
     return `${collection}:${String(id)}`;
@@ -1257,13 +1270,17 @@ class SyncedDb {
     if (dirtyItems.length === 0) {
       return { sentCount: 0 };
     }
+    const ids = dirtyItems.map((item) => item._id);
+    const fullItems = await this.dexieDb.getByIds(collection, ids);
     const updates = [];
     const deletes = [];
-    for (const item of dirtyItems) {
-      if (item._deleted) {
-        deletes.push(item);
+    for (const fullItem of fullItems) {
+      if (!fullItem)
+        continue;
+      if (fullItem._deleted) {
+        deletes.push(fullItem);
       } else {
-        updates.push(item);
+        updates.push(fullItem);
       }
     }
     const collectionBatches = [[{
@@ -1280,86 +1297,129 @@ class SyncedDb {
     let sentCount = 0;
     for (const result of results) {
       const { results: { inserted, updated, deleted } } = result;
-      for (const entity of inserted) {
-        await this.dexieDb.save(collection, entity._id, {
-          _rev: entity._rev,
-          _ts: entity._ts,
-          _dirty: false
-        });
-        this.inMemDb.save(collection, entity._id, {
-          _rev: entity._rev,
-          _ts: entity._ts
-        });
-        sentCount++;
-      }
-      for (const entity of updated) {
-        await this.dexieDb.save(collection, entity._id, {
-          _rev: entity._rev,
-          _ts: entity._ts,
-          _dirty: false
-        });
-        this.inMemDb.save(collection, entity._id, {
-          _rev: entity._rev,
-          _ts: entity._ts
-        });
-        sentCount++;
+      const allSuccessIds = [
+        ...inserted.map((e) => e._id),
+        ...updated.map((e) => e._id),
+        ...deleted.map((e) => e._id)
+      ];
+      if (allSuccessIds.length > 0) {
+        await this.dexieDb.clearDirtyChangesBatch(collection, allSuccessIds);
+      }
+      const insertedAndUpdated = [...inserted, ...updated];
+      if (insertedAndUpdated.length > 0) {
+        const idsToUpdate = insertedAndUpdated.map((e) => e._id);
+        const existingItems = await this.dexieDb.getByIds(collection, idsToUpdate);
+        const dexieSaveBatch = [];
+        for (let i = 0;i < insertedAndUpdated.length; i++) {
+          const entity = insertedAndUpdated[i];
+          const existing = existingItems[i];
+          if (existing) {
+            dexieSaveBatch.push({
+              ...existing,
+              _rev: entity._rev,
+              _ts: entity._ts
+            });
+          }
+          this.inMemDb.save(collection, entity._id, {
+            _rev: entity._rev,
+            _ts: entity._ts
+          });
+        }
+        if (dexieSaveBatch.length > 0) {
+          await this.dexieDb.saveMany(collection, dexieSaveBatch);
+        }
+        sentCount += insertedAndUpdated.length;
       }
-      for (const entity of deleted) {
-        await this.dexieDb.deleteOne(collection, entity._id);
-        this.inMemDb.deleteOne(collection, entity._id);
-        sentCount++;
+      if (deleted.length > 0) {
+        const deleteIds = deleted.map((e) => e._id);
+        await this.dexieDb.deleteMany(collection, deleteIds);
+        this.inMemDb.deleteManyByIds(collection, deleteIds);
+        sentCount += deleted.length;
       }
     }
     return { sentCount };
   }
   async recoverPendingWrites() {
     const pending = getPendingWrites(this.tenant);
+    if (pending.length === 0)
+      return;
+    const byCollection = new Map;
     for (const write of pending) {
+      const list = byCollection.get(write.collection) || [];
+      list.push(write);
+      byCollection.set(write.collection, list);
+    }
+    for (const [collection, writes] of byCollection) {
       try {
-        const existing = await this.dexieDb.getById(write.collection, write.id);
-        if (existing) {
-          await this.dexieDb.save(write.collection, write.id, write.data);
-        } else {
-          await this.dexieDb.insert(write.collection, write.data);
+        const ids = writes.map((w) => w.id);
+        const existingItems = await this.dexieDb.getByIds(collection, ids);
+        const dirtyChangesBatch = [];
+        const saveBatch = [];
+        const insertBatch = [];
+        for (let i = 0;i < writes.length; i++) {
+          const write = writes[i];
+          const existing = existingItems[i];
+          const changes = { ...write.data };
+          delete changes._id;
+          dirtyChangesBatch.push({
+            id: write.id,
+            changes,
+            baseMeta: { _ts: existing?._ts, _rev: existing?._rev }
+          });
+          if (existing) {
+            saveBatch.push({ ...existing, ...write.data });
+          } else {
+            insertBatch.push(write.data);
+          }
+        }
+        if (dirtyChangesBatch.length > 0) {
+          await this.dexieDb.addDirtyChangesBatch(collection, dirtyChangesBatch);
+        }
+        const allToSave = [...saveBatch, ...insertBatch];
+        if (allToSave.length > 0) {
+          await this.dexieDb.saveMany(collection, allToSave);
+        }
+        for (const write of writes) {
+          clearPendingWrite(this.tenant, write.collection, write.id);
         }
-        clearPendingWrite(this.tenant, write.collection, write.id);
       } catch (err) {
-        console.error("Failed to recover pending write:", err);
+        console.error(`Failed to recover pending writes for ${collection}:`, err);
       }
     }
   }
   async processIncomingServerData(collectionName, config, serverData) {
+    if (serverData.length === 0) {
+      return { conflictsResolved: 0, maxTs: undefined };
+    }
     let maxTs;
     let conflictsResolved = 0;
+    const serverIds = serverData.map((item) => item._id);
+    const localItems = await this.dexieDb.getByIds(collectionName, serverIds);
+    const dirtyChangesMap = await this.dexieDb.getDirtyChangesBatch(collectionName, serverIds);
     const dexieBatch = [];
     const inMemSaveBatch = [];
     const inMemDeleteIds = [];
-    for (const serverItem of serverData) {
-      const localItem = await this.dexieDb.getById(collectionName, serverItem._id);
+    for (let i = 0;i < serverData.length; i++) {
+      const serverItem = serverData[i];
+      const localItem = localItems[i];
+      const dirtyChange = dirtyChangesMap.get(String(serverItem._id));
       if (serverItem._ts) {
         if (!maxTs || this.compareTimestamps(serverItem._ts, maxTs) > 0) {
           maxTs = serverItem._ts;
         }
       }
       if (localItem) {
-        if (localItem._dirty) {
+        if (dirtyChange) {
           conflictsResolved++;
           const resolved = this.resolveCollectionConflict(collectionName, config, localItem, serverItem, "sync");
-          dexieBatch.push({
-            ...resolved,
-            _dirty: true,
-            _localChangedAt: localItem._localChangedAt
-          });
+          dexieBatch.push(resolved);
           if (!resolved._deleted) {
             inMemSaveBatch.push(this.stripLocalFields(resolved));
           } else {
             inMemDeleteIds.push(serverItem._id);
           }
         } else {
-          dexieBatch.push({
-            ...serverItem,
-            _dirty: false
-          });
+          dexieBatch.push(serverItem);
           if (!serverItem._deleted) {
             inMemSaveBatch.push(this.stripLocalFields(serverItem));
           } else {
@@ -1367,10 +1427,7 @@ class SyncedDb {
           }
         }
       } else {
-        dexieBatch.push({
-          ...serverItem,
-          _dirty: false
-        });
+        dexieBatch.push(serverItem);
         if (!serverItem._deleted) {
           inMemSaveBatch.push(this.stripLocalFields(serverItem));
         }
@@ -1382,8 +1439,8 @@ class SyncedDb {
     if (inMemSaveBatch.length > 0) {
       this.inMemDb.saveMany(collectionName, inMemSaveBatch);
     }
-    for (const id of inMemDeleteIds) {
-      this.inMemDb.deleteOne(collectionName, id);
+    if (inMemDeleteIds.length > 0) {
+      this.inMemDb.deleteManyByIds(collectionName, inMemDeleteIds);
     }
     if (maxTs) {
       await this.dexieDb.setSyncMeta(collectionName, maxTs);
@@ -1399,16 +1456,20 @@ class SyncedDb {
     const collectionBatches = [];
     const dirtyItemsMap = new Map;
     for (const [collectionName] of this.collections) {
-      const dirtyItems = await this.dexieDb.getDirty(collectionName);
-      if (dirtyItems.length === 0)
+      const dirtyChanges = await this.dexieDb.getDirty(collectionName);
+      if (dirtyChanges.length === 0)
         continue;
       const updates = [];
       const deletes = [];
-      for (const item of dirtyItems) {
-        if (item._deleted) {
-          deletes.push(item);
+      const ids = dirtyChanges.map((dc) => dc._id);
+      const fullItems = await this.dexieDb.getByIds(collectionName, ids);
+      for (const fullItem of fullItems) {
+        if (!fullItem)
+          continue;
+        if (fullItem._deleted) {
+          deletes.push(fullItem);
         } else {
-          updates.push(item);
+          updates.push(fullItem);
         }
       }
       dirtyItemsMap.set(collectionName, { updates, deletes });
@@ -1472,34 +1533,50 @@ class SyncedDb {
     let sentCount = 0;
     for (const result of results) {
       const { collection, results: { inserted, updated, deleted, errors } } = result;
-      for (const entity of inserted) {
-        await this.dexieDb.save(collection, entity._id, {
-          _rev: entity._rev,
-          _ts: entity._ts,
-          _dirty: false
-        });
-        this.inMemDb.save(collection, entity._id, {
-          _rev: entity._rev,
-          _ts: entity._ts
-        });
-        sentCount++;
-      }
-      for (const entity of updated) {
-        await this.dexieDb.save(collection, entity._id, {
-          _rev: entity._rev,
-          _ts: entity._ts,
-          _dirty: false
-        });
-        this.inMemDb.save(collection, entity._id, {
-          _rev: entity._rev,
-          _ts: entity._ts
-        });
-        sentCount++;
+      const allSuccessIds = [
+        ...inserted.map((e) => e._id),
+        ...updated.map((e) => e._id),
+        ...deleted.map((e) => e._id)
+      ];
+      if (allSuccessIds.length > 0) {
+        await this.dexieDb.clearDirtyChangesBatch(collection, allSuccessIds);
+      }
+      const insertedAndUpdated = [...inserted, ...updated];
+      if (insertedAndUpdated.length > 0) {
+        const idsToCheck = insertedAndUpdated.map((e) => e._id);
+        const dexieItems = await this.dexieDb.getByIds(collection, idsToCheck);
+        const dexieSaveBatch = [];
+        const inMemSaveIds = [];
+        for (let i = 0;i < insertedAndUpdated.length; i++) {
+          const entity = insertedAndUpdated[i];
+          const dexieItem = dexieItems[i];
+          if (dexieItem) {
+            dexieSaveBatch.push({
+              ...dexieItem,
+              _rev: entity._rev,
+              _ts: entity._ts
+            });
+            if (!dexieItem._deleted) {
+              inMemSaveIds.push({ id: entity._id, rev: entity._rev, ts: entity._ts });
+            }
+          }
+        }
+        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
+          });
+        }
+        sentCount += insertedAndUpdated.length;
       }
-      for (const entity of deleted) {
-        await this.dexieDb.deleteOne(collection, entity._id);
-        this.inMemDb.deleteOne(collection, entity._id);
-        sentCount++;
+      if (deleted.length > 0) {
+        const deleteIds = deleted.map((e) => e._id);
+        await this.dexieDb.deleteMany(collection, deleteIds);
+        this.inMemDb.deleteManyByIds(collection, deleteIds);
+        sentCount += deleted.length;
       }
       if (errors) {
         console.error(`Sync errors for ${collection}:`, errors);
@@ -1669,32 +1746,40 @@ class SyncedDb {
         break;
       }
       case "batch": {
+        const inserts = [];
+        const updates = [];
+        const deletes = [];
         for (const item of payload.data) {
-          if (item.operation === "insert") {
-            const serverItem = item.data;
-            if (serverItem) {
-              await this.handleServerItemInsert(collectionName, serverItem);
-            }
-          } else if (item.operation === "update") {
-            const deltaData = item.data;
-            if (deltaData && deltaData._id) {
-              const localItem = await this.dexieDb.getById(collectionName, deltaData._id);
-              if (localItem) {
-                await this.handleServerItemUpdate(collectionName, localItem, deltaData);
-              } else {
-                const fullItem = await this.restInterface.findById(collectionName, deltaData._id);
-                if (fullItem) {
-                  await this.handleServerItemInsert(collectionName, fullItem);
-                }
+          if (item.operation === "insert" && item.data) {
+            inserts.push(item.data);
+          } else if (item.operation === "update" && item.data && item.data._id) {
+            updates.push(item.data);
+          } else if (item.operation === "delete" && item.data && item.data._id) {
+            deletes.push(item.data);
+          }
+        }
+        for (const serverItem of inserts) {
+          await this.handleServerItemInsert(collectionName, serverItem);
+        }
+        if (updates.length > 0) {
+          const updateIds = updates.map((u) => u._id);
+          const localItems = await this.dexieDb.getByIds(collectionName, updateIds);
+          for (let i = 0;i < updates.length; i++) {
+            const deltaData = updates[i];
+            const localItem = localItems[i];
+            if (localItem) {
+              await this.handleServerItemUpdate(collectionName, localItem, deltaData);
+            } else {
+              const fullItem = await this.restInterface.findById(collectionName, deltaData._id);
+              if (fullItem) {
+                await this.handleServerItemInsert(collectionName, fullItem);
               }
             }
-          } else if (item.operation === "delete") {
-            const deleteData = item.data;
-            if (deleteData && deleteData._id) {
-              await this.handleServerItemDelete(collectionName, deleteData._id);
-            }
           }
         }
+        for (const deleteData of deletes) {
+          await this.handleServerItemDelete(collectionName, deleteData._id);
+        }
         await this.broadcastMetaUpdate(collectionName, Date.now());
         break;
       }
@@ -1703,20 +1788,19 @@ class SyncedDb {
   async handleServerItemInsert(collectionName, serverItem) {
     const localItem = await this.dexieDb.getById(collectionName, serverItem._id);
     if (localItem) {
+      const dirtyChange = await this.dexieDb.getDirtyChange(collectionName, serverItem._id);
       const metaChanged = localItem._rev !== serverItem._rev || !this.timestampsEqual(localItem._ts, serverItem._ts);
-      const dirtyNeedsClearing = localItem._dirty === true;
-      if (metaChanged || dirtyNeedsClearing) {
+      if (metaChanged) {
         await this.dexieDb.save(collectionName, serverItem._id, {
           _rev: serverItem._rev,
-          _ts: serverItem._ts,
-          _dirty: false
+          _ts: serverItem._ts
         });
       }
+      if (dirtyChange && !metaChanged) {
+        await this.dexieDb.clearDirtyChange(collectionName, serverItem._id);
+      }
     } else {
-      await this.dexieDb.insert(collectionName, {
-        ...serverItem,
-        _dirty: false
-      });
+      await this.dexieDb.insert(collectionName, serverItem);
       if (!serverItem._deleted) {
         this.inMemDb.insert(collectionName, this.stripLocalFields(serverItem));
       }
@@ -1726,14 +1810,13 @@ class SyncedDb {
     const isLoopback = serverDelta._lastUpdaterId === this.updaterId && serverDelta._rev !== undefined && localItem._rev !== undefined && serverDelta._rev === localItem._rev + 1;
     if (isLoopback) {
       const metaChanged2 = localItem._rev !== serverDelta._rev || !this.timestampsEqual(localItem._ts, serverDelta._ts);
-      const dirtyNeedsClearing = localItem._dirty === true;
-      if (metaChanged2 || dirtyNeedsClearing) {
+      if (metaChanged2) {
         await this.dexieDb.save(collectionName, serverDelta._id, {
           _rev: serverDelta._rev,
-          _ts: serverDelta._ts,
-          _dirty: false
+          _ts: serverDelta._ts
         });
       }
+      await this.dexieDb.clearDirtyChange(collectionName, serverDelta._id);
       return;
     }
     const pendingKey = this.getPendingKey(collectionName, serverDelta._id);
@@ -1752,14 +1835,12 @@ class SyncedDb {
       }
       return;
     }
+    const dirtyChange = await this.dexieDb.getDirtyChange(collectionName, serverDelta._id);
     const metaChanged = localItem._rev !== serverDelta._rev || !this.timestampsEqual(localItem._ts, serverDelta._ts);
-    if (localItem._dirty) {
+    if (dirtyChange) {
       const merged = this.mergeLocalWithDelta(localItem, serverDelta);
       if (metaChanged) {
-        await this.dexieDb.save(collectionName, serverDelta._id, {
-          ...merged,
-          _dirty: true
-        });
+        await this.dexieDb.save(collectionName, serverDelta._id, merged);
       }
       if (!merged._deleted) {
         this.inMemDb.save(collectionName, serverDelta._id, this.stripLocalFields(merged));
@@ -1769,10 +1850,7 @@ class SyncedDb {
         return;
       }
       const merged = this.mergeLocalWithDelta(localItem, serverDelta);
-      await this.dexieDb.save(collectionName, serverDelta._id, {
-        ...merged,
-        _dirty: false
-      });
+      await this.dexieDb.save(collectionName, serverDelta._id, merged);
       if (!merged._deleted) {
         this.inMemDb.save(collectionName, serverDelta._id, this.stripLocalFields(merged));
       } else {
@@ -1783,7 +1861,7 @@ class SyncedDb {
   getNewFieldsFromServer(local, server) {
     const newFields = {};
     for (const key of Object.keys(server)) {
-      if (key !== "_id" && key !== "_dirty" && key !== "_localChangedAt" && local[key] === undefined) {
+      if (key !== "_id" && key !== "_dirty" && local[key] === undefined) {
         newFields[key] = server[key];
       }
     }
@@ -1792,7 +1870,7 @@ class SyncedDb {
   mergeLocalWithDelta(local, delta) {
     const result = { ...local };
     for (const key of Object.keys(delta)) {
-      if (key === "_id" || key === "_dirty" || key === "_localChangedAt") {
+      if (key === "_id" || key === "_dirty") {
         continue;
       }
       result[key] = delta[key];
@@ -1803,7 +1881,8 @@ class SyncedDb {
     const localItem = await this.dexieDb.getById(collectionName, id);
     if (!localItem)
       return;
-    if (localItem._dirty) {
+    const dirtyChange = await this.dexieDb.getDirtyChange(collectionName, id);
+    if (dirtyChange) {
       await this.dexieDb.save(collectionName, id, {
         _deleted: new Date
       });
@@ -1816,6 +1895,7 @@ class SyncedDb {
 // src/db/DexieDb.ts
 import Dexie from "dexie";
 var SYNC_META_TABLE = "_sync_meta";
+var DIRTY_CHANGES_TABLE = "_dirty_changes";
 
 class DexieDb extends Dexie {
   tenant;
@@ -1823,6 +1903,7 @@ class DexieDb extends Dexie {
   crossTabSyncDebounceMs;
   collections = new Map;
   syncMeta;
+  dirtyChanges;
   broadcastChannel = null;
   pendingBroadcasts = new Map;
   debounceTimer = null;
@@ -1834,13 +1915,15 @@ class DexieDb extends Dexie {
     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", "_dirty", "_rev", ...additionalIndexes.map(String)];
+      const indexes = ["_id", "_rev", ...additionalIndexes.map(String)];
       schema[config.name] = indexes.join(", ");
     }
     this.version(1).stores(schema);
     this.syncMeta = this.table(SYNC_META_TABLE);
+    this.dirtyChanges = this.table(DIRTY_CHANGES_TABLE);
     for (const config of collectionConfigs) {
       this.collections.set(config.name, this.table(config.name));
     }
@@ -1902,27 +1985,17 @@ class DexieDb extends Dexie {
     const key = this.idToString(id);
     const existing = await table.get(key);
     if (existing) {
-      await table.update(key, {
-        ...data,
-        _dirty: data._dirty ?? true,
-        _localChangedAt: new Date
-      });
+      await table.update(key, data);
     } else {
       await table.put({
         _id: id,
-        ...data,
-        _dirty: data._dirty ?? true,
-        _localChangedAt: new Date
+        ...data
       });
     }
   }
   async insert(collection, data) {
     const table = this.getTable(collection);
-    await table.put({
-      ...data,
-      _dirty: true,
-      _localChangedAt: new Date
-    });
+    await table.put(data);
   }
   async saveMany(collection, items) {
     if (items.length === 0)
@@ -1935,6 +2008,13 @@ class DexieDb extends Dexie {
     const key = this.idToString(id);
     await table.delete(key);
   }
+  async deleteMany(collection, ids) {
+    if (ids.length === 0)
+      return;
+    const table = this.getTable(collection);
+    const keys = ids.map((id) => this.idToString(id));
+    await table.bulkDelete(keys);
+  }
   async saveCollection(collection, data) {
     const table = this.getTable(collection);
     await table.clear();
@@ -1951,6 +2031,13 @@ class DexieDb extends Dexie {
     const key = this.idToString(id);
     return await table.get(key);
   }
+  async getByIds(collection, ids) {
+    if (ids.length === 0)
+      return [];
+    const table = this.getTable(collection);
+    const keys = ids.map((id) => this.idToString(id));
+    return await table.bulkGet(keys);
+  }
   async getAll(collection) {
     const table = this.getTable(collection);
     return await table.toArray();
@@ -1960,23 +2047,97 @@ class DexieDb extends Dexie {
     return await table.count();
   }
   async getDirty(collection) {
-    const table = this.getTable(collection);
-    return await table.filter((item) => item._dirty === true).toArray();
+    const dirtyEntries = await this.dirtyChanges.where("[collection+id]").between([collection, Dexie.minKey], [collection, Dexie.maxKey]).toArray();
+    return dirtyEntries.map((entry) => ({
+      _id: entry.id,
+      ...entry.changes,
+      _ts: entry.baseTs,
+      _rev: entry.baseRev
+    }));
   }
-  async markDirty(collection, id) {
-    const table = this.getTable(collection);
-    const key = this.idToString(id);
-    await table.update(key, {
-      _dirty: true,
-      _localChangedAt: new Date
-    });
+  async addDirtyChange(collection, id, changes, baseMeta) {
+    const stringId = this.idToString(id);
+    const existing = await this.dirtyChanges.get([collection, stringId]);
+    const now = Date.now();
+    if (existing) {
+      await this.dirtyChanges.put({
+        ...existing,
+        changes: { ...existing.changes, ...changes },
+        updatedAt: now
+      });
+    } else {
+      await this.dirtyChanges.put({
+        collection,
+        id: stringId,
+        changes,
+        baseTs: baseMeta?._ts,
+        baseRev: baseMeta?._rev,
+        createdAt: now,
+        updatedAt: now
+      });
+    }
   }
-  async markClean(collection, id) {
-    const table = this.getTable(collection);
-    const key = this.idToString(id);
-    await table.update(key, {
-      _dirty: false
-    });
+  async addDirtyChangesBatch(collection, changesList) {
+    if (changesList.length === 0)
+      return;
+    const now = Date.now();
+    const keys = changesList.map((c) => [collection, this.idToString(c.id)]);
+    const existingEntries = await this.dirtyChanges.bulkGet(keys);
+    const toWrite = [];
+    for (let i = 0;i < changesList.length; i++) {
+      const changeItem = changesList[i];
+      const stringId = this.idToString(changeItem.id);
+      const existing = existingEntries[i];
+      if (existing) {
+        toWrite.push({
+          ...existing,
+          changes: { ...existing.changes, ...changeItem.changes },
+          updatedAt: now
+        });
+      } else {
+        toWrite.push({
+          collection,
+          id: stringId,
+          changes: changeItem.changes,
+          baseTs: changeItem.baseMeta?._ts,
+          baseRev: changeItem.baseMeta?._rev,
+          createdAt: now,
+          updatedAt: now
+        });
+      }
+    }
+    await this.dirtyChanges.bulkPut(toWrite);
+  }
+  async getDirtyChange(collection, id) {
+    const stringId = this.idToString(id);
+    return this.dirtyChanges.get([collection, stringId]);
+  }
+  async getDirtyChangesBatch(collection, ids) {
+    const result = new Map;
+    if (ids.length === 0)
+      return result;
+    const keys = ids.map((id) => [collection, this.idToString(id)]);
+    const entries = await this.dirtyChanges.bulkGet(keys);
+    for (let i = 0;i < ids.length; i++) {
+      const entry = entries[i];
+      if (entry) {
+        result.set(this.idToString(ids[i]), entry);
+      }
+    }
+    return result;
+  }
+  async clearDirtyChange(collection, id) {
+    const stringId = this.idToString(id);
+    await this.dirtyChanges.delete([collection, stringId]);
+  }
+  async clearDirtyChangesBatch(collection, ids) {
+    if (ids.length === 0)
+      return;
+    const keys = ids.map((id) => [collection, this.idToString(id)]);
+    await this.dirtyChanges.bulkDelete(keys);
+  }
+  async clearDirtyChanges(collection) {
+    await this.dirtyChanges.where("[collection+id]").between([collection, Dexie.minKey], [collection, Dexie.maxKey]).delete();
   }
   async getSyncMeta(collection) {
     return await this.syncMeta.get([this.tenant, collection]);

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

@@ -1,5 +1,5 @@
 import Dexie from "dexie";
-import type { DexieDbOptions, I_DexieDb, MetaUpdateBroadcast, SyncMeta } from "../types/I_DexieDb";
+import type { DexieDbOptions, DirtyChange, I_DexieDb, MetaUpdateBroadcast, SyncMeta } from "../types/I_DexieDb";
 import type { CollectionConfig } from "../types/CollectionConfig";
 import type { Id, LocalDbEntity } from "../types/DbEntity";
 /**
@@ -12,6 +12,7 @@ export declare class DexieDb extends Dexie implements I_DexieDb {
     private crossTabSyncDebounceMs;
     private collections;
     private syncMeta;
+    private dirtyChanges;
     private broadcastChannel;
     private pendingBroadcasts;
     private debounceTimer;
@@ -26,14 +27,31 @@ export declare class DexieDb extends Dexie implements I_DexieDb {
     insert<T extends LocalDbEntity>(collection: string, data: T): Promise<void>;
     saveMany<T extends LocalDbEntity>(collection: string, items: T[]): Promise<void>;
     deleteOne(collection: string, id: Id): Promise<void>;
+    deleteMany(collection: string, ids: Id[]): Promise<void>;
     saveCollection<T extends LocalDbEntity>(collection: string, data: T[]): Promise<void>;
     deleteCollection(collection: string): Promise<void>;
     getById<T extends LocalDbEntity>(collection: string, id: Id): Promise<T | undefined>;
+    getByIds<T extends LocalDbEntity>(collection: string, ids: Id[]): Promise<(T | undefined)[]>;
     getAll<T extends LocalDbEntity>(collection: string): Promise<T[]>;
     count(collection: string): Promise<number>;
-    getDirty<T extends LocalDbEntity>(collection: string): Promise<T[]>;
-    markDirty(collection: string, id: Id): Promise<void>;
-    markClean(collection: string, id: Id): Promise<void>;
+    getDirty<T extends LocalDbEntity>(collection: string): Promise<Partial<T>[]>;
+    addDirtyChange(collection: string, id: Id, changes: Record<string, any>, baseMeta?: {
+        _ts?: any;
+        _rev?: number;
+    }): Promise<void>;
+    addDirtyChangesBatch(collection: string, changesList: Array<{
+        id: Id;
+        changes: Record<string, any>;
+        baseMeta?: {
+            _ts?: any;
+            _rev?: number;
+        };
+    }>): Promise<void>;
+    getDirtyChange(collection: string, id: Id): Promise<DirtyChange | undefined>;
+    getDirtyChangesBatch(collection: string, ids: Id[]): Promise<Map<string, DirtyChange>>;
+    clearDirtyChange(collection: string, id: Id): Promise<void>;
+    clearDirtyChangesBatch(collection: string, ids: Id[]): Promise<void>;
+    clearDirtyChanges(collection: string): Promise<void>;
     getSyncMeta(collection: string): Promise<SyncMeta | undefined>;
     setSyncMeta(collection: string, lastSyncTs: any): Promise<void>;
     deleteSyncMeta(collection: string): Promise<void>;

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

@@ -202,14 +202,14 @@ export declare class SyncedDb implements I_SyncedDb {
     /**
      * Handle server insert notification.
      * Insert notifications contain full object data.
-     * Only writes to Dexie if metadata changed or _dirty needs clearing.
+     * Only writes to Dexie if metadata changed. Clears dirty change if loopback confirmed.
      */
     private handleServerItemInsert;
     /**
      * Handle server update notification (delta).
      * Update notifications contain only changed fields.
      * Caller must provide the existing local item.
-     * Only writes to Dexie if metadata changed or _dirty needs updating.
+     * Only writes to Dexie if metadata changed.
      */
     private handleServerItemUpdate;
     private getNewFieldsFromServer;

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

@@ -21,10 +21,9 @@ export interface DbEntity {
 /**
  * Razširitev DbEntity z lokalnimi polji za sync tracking
  * Uporablja se v dexie bazi
+ *
+ * Note: _dirty field was removed. Dirty tracking is now handled via
+ * the _dirty_changes table in DexieDb with field-level granularity.
  */
 export interface LocalDbEntity extends DbEntity {
-    /** Označuje, da ima objekt lokalne spremembe, ki čakajo na sync */
-    _dirty?: boolean;
-    /** Čas zadnje lokalne spremembe */
-    _localChangedAt?: Date;
 }

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

@@ -7,6 +7,26 @@ export interface SyncMeta {
     collection: string;
     lastSyncTs?: any;
 }
+/**
+ * Dirty change entry - tracks accumulated changes for a record
+ * Stored in _dirty_changes table with composite key [collection, id]
+ */
+export interface DirtyChange {
+    /** Collection name */
+    collection: string;
+    /** Stringified Id */
+    id: string;
+    /** Accumulated changed fields */
+    changes: Record<string, any>;
+    /** _ts from base record when change was made */
+    baseTs?: any;
+    /** _rev from base record when change was made */
+    baseRev?: number;
+    /** When first change was recorded */
+    createdAt: number;
+    /** When last change was accumulated */
+    updatedAt: number;
+}
 /**
  * Payload for cross-tab meta update broadcasts
  */
@@ -37,22 +57,46 @@ export interface I_DexieDb {
     insert<T extends LocalDbEntity>(collection: string, data: T): Promise<void>;
     /** Izbriše objekt iz kolekcije */
     deleteOne(collection: string, id: Id): Promise<void>;
+    /** Izbriše več objektov iz kolekcije (batch) */
+    deleteMany(collection: string, ids: Id[]): Promise<void>;
     /** Shrani celotno kolekcijo (nadomesti obstoječo) */
     saveCollection<T extends LocalDbEntity>(collection: string, data: T[]): Promise<void>;
     /** Izbriše celotno kolekcijo */
     deleteCollection(collection: string): Promise<void>;
     /** Vrne objekt po ID-ju */
     getById<T extends LocalDbEntity>(collection: string, id: Id): Promise<T | undefined>;
+    /** Vrne več objektov po ID-jih (batch) */
+    getByIds<T extends LocalDbEntity>(collection: string, ids: Id[]): Promise<(T | undefined)[]>;
     /** Vrne vse objekte v kolekciji */
     getAll<T extends LocalDbEntity>(collection: string): Promise<T[]>;
     /** Vrne število objektov v kolekciji */
     count(collection: string): Promise<number>;
-    /** Vrne vse dirty objekte (z lokalnimi spremembami) */
-    getDirty<T extends LocalDbEntity>(collection: string): Promise<T[]>;
-    /** Označi objekt kot umazan (ima lokalne spremembe) */
-    markDirty(collection: string, id: Id): Promise<void>;
-    /** Označi objekt kot čist (sinhroniziran s serverjem) */
-    markClean(collection: string, id: Id): Promise<void>;
+    /** Vrne vse dirty objekte (z lokalnimi spremembami) - returns only changed fields + _id + metadata */
+    getDirty<T extends LocalDbEntity>(collection: string): Promise<Partial<T>[]>;
+    /** Add or accumulate changes for a record */
+    addDirtyChange(collection: string, id: Id, changes: Record<string, any>, baseMeta?: {
+        _ts?: any;
+        _rev?: number;
+    }): Promise<void>;
+    /** Add or accumulate changes for multiple records (batch) */
+    addDirtyChangesBatch(collection: string, changes: Array<{
+        id: Id;
+        changes: Record<string, any>;
+        baseMeta?: {
+            _ts?: any;
+            _rev?: number;
+        };
+    }>): Promise<void>;
+    /** Get dirty change entry for a specific record */
+    getDirtyChange(collection: string, id: Id): Promise<DirtyChange | undefined>;
+    /** Get dirty change entries for multiple records (batch) */
+    getDirtyChangesBatch(collection: string, ids: Id[]): Promise<Map<string, DirtyChange>>;
+    /** Clear dirty change for a record (after successful sync) */
+    clearDirtyChange(collection: string, id: Id): Promise<void>;
+    /** Clear dirty changes for multiple records (batch) */
+    clearDirtyChangesBatch(collection: string, ids: Id[]): Promise<void>;
+    /** Clear all dirty changes for a collection */
+    clearDirtyChanges(collection: string): Promise<void>;
     /** Vrne sync metapodatke za kolekcijo */
     getSyncMeta(collection: string): Promise<SyncMeta | undefined>;
     /** Nastavi sync metapodatke za kolekcijo */

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

@@ -12,6 +12,8 @@ export interface I_InMemDb {
     insert<T extends DbEntity>(collection: string, data: T): void;
     /** Izbriše objekt iz kolekcije */
     deleteOne(collection: string, id: Id): void;
+    /** Izbriše več objektov iz kolekcije po ID-jih */
+    deleteManyByIds(collection: string, ids: Id[]): void;
     /** Shrani celotno kolekcijo (nadomesti obstoječo) */
     saveCollection<T extends DbEntity>(collection: string, data: T[]): void;
     /** Izbriše celotno kolekcijo */

package/package.json

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