cry-synced-db-client 0.1.73 → 0.1.74

package/dist/index.js

@@ -125,7 +125,7 @@ function sortItems(items, sort) {
   const sortEntries = Object.entries(sort);
   if (sortEntries.length === 0)
     return items;
-  return [...items].sort((a, b) => {
+  return items.slice().sort((a, b) => {
     for (const [field, direction] of sortEntries) {
       const aVal = getNestedValue(a, field);
       const bVal = getNestedValue(b, field);
@@ -194,7 +194,7 @@ function projectItem(item, project) {
     }
     return result;
   } else {
-    const result = { ...item };
+    const result = Object.assign({}, item);
     for (const [field, value] of entries) {
       if (value === false || value === 0) {
         delete result[field];
@@ -237,7 +237,9 @@ class InMemManager {
     if (operation === "upsert") {
       this.inMemDb.saveMany(collection, items);
       if (this.useObjectMetadata && config?.hasMetadata) {
-        const ids = items.map((item) => item._id);
+        const ids = [];
+        for (const item of items)
+          ids.push(item._id);
         let metadatas;
         if (config.onObjectsUpdated) {
           try {
@@ -259,7 +261,9 @@ class InMemManager {
         this.setObjectsMetadataInternal(collection, ids, metadatas);
       }
     } else if (operation === "delete") {
-      const ids = items.map((item) => item._id);
+      const ids = [];
+      for (const item of items)
+        ids.push(item._id);
       this.inMemDb.deleteManyByIds(collection, ids);
       if (this.useObjectMetadata && config?.hasMetadata) {
         this.deleteObjectsMetadataInternal(collection, ids);
@@ -271,7 +275,9 @@ class InMemManager {
     if (this.useObjectMetadata && items.length > 0) {
       const config = this.collections.get(collection);
       if (config?.hasMetadata) {
-        const ids = items.map((item) => item._id);
+        const ids = [];
+        for (const item of items)
+          ids.push(item._id);
         let metadatas;
         if (config.onObjectsUpdated) {
           try {
@@ -1722,11 +1728,12 @@ function savePendingWrite(tenant, collection, id, delta) {
     let pending;
     if (existingRaw) {
       const existing = dist_default.parse(existingRaw);
+      Object.assign(existing.data, delta);
       pending = {
         tenant,
         collection,
         id: String(id),
-        data: { ...existing.data, ...delta },
+        data: existing.data,
         timestamp: now
       };
     } else {
@@ -1808,7 +1815,7 @@ class PendingChangesManager {
     }
     const deltaWithId = existing ? data : { _id: id, ...data };
     savePendingWrite(this.tenant, collection, id, deltaWithId);
-    const fullData = existing ? { ...existing.data, ...data } : { _id: id, ...data };
+    const fullData = existing ? Object.assign(existing.data, data) : { _id: id, ...data };
     const timer = setTimeout(() => {
       this.executePendingChange(key);
     }, this.debounceDexieWritesMs);
@@ -1879,7 +1886,8 @@ class PendingChangesManager {
             baseMeta: { _ts: existing?._ts, _rev: existing?._rev }
           });
           if (existing) {
-            saveBatch.push({ ...existing, ...write.data });
+            Object.assign(existing, write.data);
+            saveBatch.push(existing);
           } else {
             insertBatch.push(write.data);
           }
@@ -1887,7 +1895,7 @@ class PendingChangesManager {
         if (dirtyChangesBatch.length > 0) {
           await this.deps.dexieDb.addDirtyChangesBatch(collection, dirtyChangesBatch);
         }
-        const allToSave = [...saveBatch, ...insertBatch];
+        const allToSave = saveBatch.concat(insertBatch);
         if (allToSave.length > 0) {
           await this.deps.dexieDb.saveMany(collection, allToSave);
         }
@@ -2063,20 +2071,26 @@ function mergeObjects(local, external) {
 }
 function mergeArrays(local, external) {
   if (local.length === 0) {
-    return [...external];
+    return external.slice();
   }
   const firstLocal = local[0];
   const firstExternal = external[0];
   if (typeof firstLocal === "string" || typeof firstExternal === "string") {
-    return [...new Set([...local, ...external])];
+    const set2 = new Set(local);
+    for (const item of external)
+      set2.add(item);
+    return Array.from(set2);
   }
   if (isPlainObject3(firstLocal) || isPlainObject3(firstExternal)) {
     return mergeObjectArrays(local, external);
   }
-  return [...new Set([...local, ...external])];
+  const set = new Set(local);
+  for (const item of external)
+    set.add(item);
+  return Array.from(set);
 }
 function mergeObjectArrays(local, external) {
-  const result = [...local];
+  const result = local.slice();
   const localIds = new Map;
   for (let i = 0;i < local.length; i++) {
     const item = local[i];
@@ -2155,13 +2169,11 @@ class SyncEngine {
       }
       this.callOnFindNewerManyCall(syncSpecs, calledFrom);
       const findNewerManyStartTime = Date.now();
-      const allUpdatedIds = {};
       const collectionState = new Map;
       for (const [name] of configMap) {
         collectionState.set(name, {
           maxTs: undefined,
           conflicts: 0,
-          updatedIds: [],
           receivedCount: 0
         });
       }
@@ -2179,28 +2191,23 @@ class SyncEngine {
               state.maxTs = stats.maxTs;
             }
           }
-          state.updatedIds.push(...stats.updatedIds);
+          if (stats.updatedIds.length > 0) {
+            this.deps.broadcastUpdates({ [collection]: stats.updatedIds });
+          }
         }), "findNewerManyStream");
         for (const [name, state] of collectionState) {
           receivedCount += state.receivedCount;
           conflictsResolved += state.conflicts;
           collectionStats[name] = {
             receivedCount: state.receivedCount,
-            sentCount: 0,
-            receivedItems: []
+            sentCount: 0
           };
-          if (state.updatedIds.length > 0) {
-            allUpdatedIds[name] = state.updatedIds;
-          }
         }
         this.callOnFindNewerManyResult(syncSpecs, {}, findNewerManyStartTime, true, calledFrom);
       } catch (err) {
         this.callOnFindNewerManyResult(syncSpecs, {}, findNewerManyStartTime, false, calledFrom, err);
         throw err;
       }
-      if (Object.keys(allUpdatedIds).length > 0) {
-        this.deps.broadcastUpdates(allUpdatedIds);
-      }
       const uploadStats = await this.uploadDirtyItems(calledFrom);
       sentCount = uploadStats.sentCount;
       for (const [collectionName, stats] of Object.entries(uploadStats.collectionSentCounts || {})) {
@@ -2209,8 +2216,7 @@ class SyncEngine {
         } else {
           collectionStats[collectionName] = {
             receivedCount: 0,
-            sentCount: stats,
-            receivedItems: []
+            sentCount: stats
           };
         }
       }
@@ -2297,18 +2303,22 @@ class SyncEngine {
     const collectionSentCounts = {};
     for (const result of results) {
       const { collection, results: { inserted, updated, deleted, errors } } = result;
-      const allSuccessIds = [
-        ...inserted.map((e) => e._id),
-        ...updated.map((e) => e._id),
-        ...deleted.map((e) => e._id)
-      ];
+      const allSuccessIds = [];
+      for (const e of inserted)
+        allSuccessIds.push(e._id);
+      for (const e of updated)
+        allSuccessIds.push(e._id);
+      for (const e of deleted)
+        allSuccessIds.push(e._id);
       if (allSuccessIds.length > 0) {
         await this.dexieDb.clearDirtyChangesBatch(collection, allSuccessIds);
       }
       let collectionSentCount = 0;
-      const insertedAndUpdated = [...inserted, ...updated];
+      const insertedAndUpdated = inserted.concat(updated);
       if (insertedAndUpdated.length > 0) {
-        const idsToCheck = insertedAndUpdated.map((e) => e._id);
+        const idsToCheck = [];
+        for (const e of insertedAndUpdated)
+          idsToCheck.push(e._id);
         const dexieItems = await this.dexieDb.getByIds(collection, idsToCheck);
         const dexieSaveBatch = [];
         const inMemUpdateBatch = [];
@@ -2316,11 +2326,9 @@ class SyncEngine {
           const entity = insertedAndUpdated[i];
           const dexieItem = dexieItems[i];
           if (dexieItem) {
-            dexieSaveBatch.push({
-              ...dexieItem,
-              _rev: entity._rev,
-              _ts: entity._ts
-            });
+            dexieItem._rev = entity._rev;
+            dexieItem._ts = entity._ts;
+            dexieSaveBatch.push(dexieItem);
             if (!dexieItem._deleted) {
               const inMemItem = this.deps.getInMemById(collection, entity._id);
               if (inMemItem) {
@@ -2343,21 +2351,27 @@ class SyncEngine {
         collectionSentCount += insertedAndUpdated.length;
       }
       if (deleted.length > 0) {
-        const deleteIds = deleted.map((e) => e._id);
+        const deleteIds = [];
+        const deleteDbEntities = [];
+        for (const e of deleted) {
+          deleteIds.push(e._id);
+          deleteDbEntities.push({ _id: e._id });
+        }
         await this.dexieDb.deleteMany(collection, deleteIds);
-        this.deps.writeToInMemBatch(collection, deleteIds.map((id) => ({ _id: id })), "delete");
+        this.deps.writeToInMemBatch(collection, deleteDbEntities, "delete");
         sentCount += deleted.length;
         collectionSentCount += deleted.length;
       }
       if (collectionSentCount > 0) {
         collectionSentCounts[collection] = collectionSentCount;
       }
-      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;
+      for (const arr of [inserted, updated, deleted]) {
+        for (const item of arr) {
+          if (item._ts) {
+            if (!maxTs || this.compareTimestamps(item._ts, maxTs) > 0) {
+              maxTs = item._ts;
+            }
           }
         }
       }
@@ -2418,11 +2432,13 @@ class SyncEngine {
     let sentCount = 0;
     for (const result of results) {
       const { results: { inserted, updated, deleted } } = result;
-      const allSuccessIds = [
-        ...inserted.map((e) => e._id),
-        ...updated.map((e) => e._id),
-        ...deleted.map((e) => e._id)
-      ];
+      const allSuccessIds = [];
+      for (const e of inserted)
+        allSuccessIds.push(e._id);
+      for (const e of updated)
+        allSuccessIds.push(e._id);
+      for (const e of deleted)
+        allSuccessIds.push(e._id);
       if (allSuccessIds.length > 0) {
         await this.dexieDb.clearDirtyChangesBatch(collection, allSuccessIds);
       }
@@ -2451,7 +2467,9 @@ class SyncEngine {
     const BATCH = SyncEngine.SYNC_BATCH_SIZE;
     for (let offset = 0;offset < serverData.length; offset += BATCH) {
       const chunk = serverData.slice(offset, offset + BATCH);
-      const chunkIds = chunk.map((item) => item._id);
+      const chunkIds = [];
+      for (const item of chunk)
+        chunkIds.push(item._id);
       const localItems = await this.dexieDb.getByIds(collectionName, chunkIds);
       const dirtyChangesMap = await this.dexieDb.getDirtyChangesBatch(collectionName, chunkIds);
       const dexieBatch = [];
@@ -2461,6 +2479,7 @@ class SyncEngine {
         const serverItem = chunk[i];
         const localItem = localItems[i];
         const dirtyChange = dirtyChangesMap.get(String(serverItem._id));
+        allUpdatedIds.push(String(serverItem._id));
         if (serverItem._ts) {
           if (!maxTs || this.compareTimestamps(serverItem._ts, maxTs) > 0) {
             maxTs = serverItem._ts;
@@ -2500,9 +2519,6 @@ class SyncEngine {
       if (inMemDeleteIds.length > 0) {
         this.deps.writeToInMemBatch(collectionName, inMemDeleteIds.map((id) => ({ _id: id })), "delete");
       }
-      for (const id of chunkIds) {
-        allUpdatedIds.push(String(id));
-      }
     }
     if (maxTs) {
       await this.dexieDb.setSyncMeta(collectionName, maxTs);
@@ -2759,9 +2775,9 @@ class ServerUpdateHandler {
     if (pendingChange) {
       const newFields = this.getNewFieldsFromServer(localItem, serverDelta);
       if (Object.keys(newFields).length > 0) {
-        pendingChange.data = { ...pendingChange.data, ...newFields };
+        Object.assign(pendingChange.data, newFields);
       }
-      const currentInMemState = { ...localItem, ...pendingChange.data };
+      const currentInMemState = Object.assign({}, localItem, pendingChange.data);
       const merged = this.mergeLocalWithDelta(currentInMemState, serverDelta);
       if (!merged._deleted && !merged._archived) {
         this.deps.writeToInMemBatch(collection, [this.stripLocalFields(merged)], "upsert");
@@ -2820,13 +2836,12 @@ class ServerUpdateHandler {
     return false;
   }
   mergeLocalWithDelta(local, delta) {
-    const result = { ...local };
     for (const key of Object.keys(delta)) {
       if (key === "_id" || key === "_dirty")
         continue;
-      result[key] = delta[key];
+      local[key] = delta[key];
     }
-    return result;
+    return local;
   }
   getNewFieldsFromServer(local, server) {
     const newFields = {};
@@ -3278,16 +3293,20 @@ class SyncedDb {
     }
     await this.pendingChanges.recoverPendingWrites();
     for (const [name] of this.collections) {
-      const data = await this.dexieDb.getAll(name);
-      let writeIdx = 0;
-      for (let i = 0;i < data.length; i++) {
-        const item = data[i];
-        if (!item._deleted && !item._archived) {
-          data[writeIdx++] = item;
+      this.inMemManager.clearCollection(name);
+      await this.dexieDb.forEachBatch(name, 2000, 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;
+          }
         }
-      }
-      data.length = writeIdx;
-      this.inMemManager.initCollection(name, data);
+        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);
@@ -3449,26 +3468,48 @@ class SyncedDb {
       await this.syncCollectionForFind(collection, query, opts);
     }
     const all = await this.dexieDb.getAll(collection);
-    const active = all.filter((item) => {
-      if (!opts?.returnDeleted && item._deleted)
-        return false;
-      if (!opts?.returnArchived && item._archived)
-        return false;
-      return true;
-    });
-    const filtered = filterByQuery(active, query);
-    if (filtered.length === 0) {
-      if (opts?.referToServer && this.isOnline()) {
+    const returnDeleted = opts?.returnDeleted;
+    const returnArchived = opts?.returnArchived;
+    const hasSort = opts?.sort && Object.keys(opts.sort).length > 0;
+    if (hasSort) {
+      const filtered = [];
+      for (const item of all) {
+        if (!returnDeleted && item._deleted)
+          continue;
+        if (!returnArchived && item._archived)
+          continue;
+        if (!matchesQuery(item, query))
+          continue;
+        filtered.push(item);
+      }
+      if (filtered.length === 0) {
+        if (opts?.referToServer && this.isOnline())
+          this.referToServerSync(collection, query);
+        return null;
+      }
+      const sorted = applyQueryOpts(filtered, { sort: opts.sort, project: opts?.project });
+      if (opts?.referToServer && this.isOnline())
         this.referToServerSync(collection, query);
+      return sorted[0] ?? null;
+    } else {
+      let result = null;
+      for (const item of all) {
+        if (!returnDeleted && item._deleted)
+          continue;
+        if (!returnArchived && item._archived)
+          continue;
+        if (!matchesQuery(item, query))
+          continue;
+        result = item;
+        break;
       }
-      return null;
-    }
-    const sorted = applyQueryOpts(filtered, { sort: opts?.sort, project: opts?.project });
-    const result = sorted[0];
-    if (opts?.referToServer && this.isOnline()) {
-      this.referToServerSync(collection, query);
+      if (result && opts?.project) {
+        result = projectItem(result, opts.project);
+      }
+      if (opts?.referToServer && this.isOnline())
+        this.referToServerSync(collection, query);
+      return result;
     }
-    return result;
   }
   async find(collection, query, opts) {
     this.assertCollection(collection);
@@ -3477,14 +3518,19 @@ class SyncedDb {
       await this.syncCollectionForFind(collection, query, opts);
     }
     const all = await this.dexieDb.getAll(collection);
-    const active = all.filter((item) => {
-      if (!opts?.returnDeleted && item._deleted)
-        return false;
-      if (!opts?.returnArchived && item._archived)
-        return false;
-      return true;
-    });
-    const filtered = query ? filterByQuery(active, query) : active;
+    const returnDeleted = opts?.returnDeleted;
+    const returnArchived = opts?.returnArchived;
+    const hasQuery = query && Object.keys(query).length > 0;
+    const filtered = [];
+    for (const item of all) {
+      if (!returnDeleted && item._deleted)
+        continue;
+      if (!returnArchived && item._archived)
+        continue;
+      if (hasQuery && !matchesQuery(item, query))
+        continue;
+      filtered.push(item);
+    }
     const result = applyQueryOpts(filtered, opts);
     if (opts?.referToServer && this.isOnline()) {
       this.referToServerSync(collection, query);
@@ -3957,7 +4003,9 @@ class DexieDb extends Dexie {
     if (ids.length === 0)
       return;
     const table = this.getTable(collection);
-    const keys = ids.map((id) => this.idToString(id));
+    const keys = [];
+    for (const id of ids)
+      keys.push(this.idToString(id));
     await table.bulkDelete(keys);
   }
   async saveCollection(collection, data) {
@@ -3980,36 +4028,50 @@ class DexieDb extends Dexie {
     if (ids.length === 0)
       return [];
     const table = this.getTable(collection);
-    const keys = ids.map((id) => this.idToString(id));
+    const keys = [];
+    for (const id of ids)
+      keys.push(this.idToString(id));
     return await table.bulkGet(keys);
   }
   async getAll(collection) {
     const table = this.getTable(collection);
     return await table.toArray();
   }
+  async forEachBatch(collection, batchSize, callback) {
+    const table = this.getTable(collection);
+    let offset = 0;
+    while (true) {
+      const items = await table.offset(offset).limit(batchSize).toArray();
+      if (items.length === 0)
+        break;
+      await callback(items);
+      if (items.length < batchSize)
+        break;
+      offset += items.length;
+    }
+  }
   async count(collection) {
     const table = this.getTable(collection);
     return await table.count();
   }
   async getDirty(collection) {
     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
-    }));
+    const result = [];
+    for (const entry of dirtyEntries) {
+      const obj = { _id: entry.id, _ts: entry.baseTs, _rev: entry.baseRev };
+      Object.assign(obj, entry.changes);
+      result.push(obj);
+    }
+    return result;
   }
   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
-      });
+      Object.assign(existing.changes, changes);
+      existing.updatedAt = now;
+      await this.dirtyChanges.put(existing);
     } else {
       await this.dirtyChanges.put({
         collection,
@@ -4026,7 +4088,9 @@ class DexieDb extends Dexie {
     if (changesList.length === 0)
       return;
     const now = Date.now();
-    const keys = changesList.map((c) => [collection, this.idToString(c.id)]);
+    const keys = [];
+    for (const c of changesList)
+      keys.push([collection, this.idToString(c.id)]);
     const existingEntries = await this.dirtyChanges.bulkGet(keys);
     const toWrite = [];
     for (let i = 0;i < changesList.length; i++) {
@@ -4034,11 +4098,9 @@ class DexieDb extends Dexie {
       const stringId = this.idToString(changeItem.id);
       const existing = existingEntries[i];
       if (existing) {
-        toWrite.push({
-          ...existing,
-          changes: { ...existing.changes, ...changeItem.changes },
-          updatedAt: now
-        });
+        Object.assign(existing.changes, changeItem.changes);
+        existing.updatedAt = now;
+        toWrite.push(existing);
       } else {
         toWrite.push({
           collection,
@@ -4061,7 +4123,9 @@ class DexieDb extends Dexie {
     const result = new Map;
     if (ids.length === 0)
       return result;
-    const keys = ids.map((id) => [collection, this.idToString(id)]);
+    const keys = [];
+    for (const id of ids)
+      keys.push([collection, this.idToString(id)]);
     const entries = await this.dirtyChanges.bulkGet(keys);
     for (let i = 0;i < ids.length; i++) {
       const entry = entries[i];
@@ -4078,7 +4142,9 @@ class DexieDb extends Dexie {
   async clearDirtyChangesBatch(collection, ids) {
     if (ids.length === 0)
       return;
-    const keys = ids.map((id) => [collection, this.idToString(id)]);
+    const keys = [];
+    for (const id of ids)
+      keys.push([collection, this.idToString(id)]);
     await this.dirtyChanges.bulkDelete(keys);
   }
   async clearDirtyChanges(collection) {
@@ -6245,11 +6311,46 @@ var pack2 = (x) => packr.pack(preprocessForPack(x));
 var unpack2 = (x) => unpackr.unpack(x);
 var DEFAULT_TIMEOUT = 5000;
 var DEFAULT_PROGRESS_CHUNK_SIZE = 16 * 1024;
-function concatUint8(a, b) {
-  const result = new Uint8Array(a.length + b.length);
-  result.set(a);
-  result.set(b, a.length);
-  return result;
+
+class StreamBuffer {
+  buf;
+  rPos = 0;
+  wPos = 0;
+  constructor(initialCapacity = 64 * 1024) {
+    this.buf = new Uint8Array(initialCapacity);
+  }
+  get length() {
+    return this.wPos - this.rPos;
+  }
+  append(data) {
+    if (this.rPos > 0 && this.wPos + data.length > this.buf.length) {
+      this.buf.copyWithin(0, this.rPos, this.wPos);
+      this.wPos -= this.rPos;
+      this.rPos = 0;
+    }
+    if (this.wPos + data.length > this.buf.length) {
+      const newSize = Math.max(this.buf.length * 2, this.wPos + data.length);
+      const newBuf = new Uint8Array(newSize);
+      newBuf.set(this.buf.subarray(0, this.wPos));
+      this.buf = newBuf;
+    }
+    this.buf.set(data, this.wPos);
+    this.wPos += data.length;
+  }
+  subarray(start, end) {
+    return this.buf.subarray(this.rPos + start, this.rPos + end);
+  }
+  at(offset) {
+    return this.buf[this.rPos + offset];
+  }
+  consume(n) {
+    this.rPos += n;
+    if (this.rPos > this.buf.length >>> 1) {
+      this.buf.copyWithin(0, this.rPos, this.wPos);
+      this.wPos -= this.rPos;
+      this.rPos = 0;
+    }
+  }
 }
 
 class RestProxy {
@@ -6479,23 +6580,24 @@ class RestProxy {
   }
   async parseStreamingResponse(response, onChunk, onActivity) {
     const reader = response.body.getReader();
-    let buffer = new Uint8Array(0);
+    const buffer = new StreamBuffer;
+    const decoder2 = new TextDecoder;
     const readMore = async () => {
       const { done, value } = await reader.read();
       if (done)
         return false;
       onActivity();
-      buffer = concatUint8(buffer, value);
+      buffer.append(value);
       return true;
     };
     while (buffer.length < 1) {
       if (!await readMore())
         return;
     }
-    const firstByte = buffer[0];
+    const firstByte = buffer.at(0);
     if (firstByte !== 0 && firstByte !== 1) {
       while (await readMore()) {}
-      const result = unpack2(buffer);
+      const result = unpack2(buffer.subarray(0, buffer.length));
       for (const [collection, items] of Object.entries(result)) {
         if (items.length > 0) {
           await onChunk(collection, items);
@@ -6508,29 +6610,28 @@ class RestProxy {
         if (!await readMore())
           return;
       }
-      if (buffer[0] === 0)
+      if (buffer.at(0) === 0)
         return;
       while (buffer.length < 3) {
         if (!await readMore())
           throw new Error("Unexpected end of stream in chunk header");
       }
-      const nameLen = buffer[1] << 8 | buffer[2];
+      const nameLen = buffer.at(1) << 8 | buffer.at(2);
       const headerSize = 1 + 2 + nameLen + 4;
       while (buffer.length < headerSize) {
         if (!await readMore())
           throw new Error("Unexpected end of stream in chunk header");
       }
-      const collection = new TextDecoder().decode(buffer.slice(3, 3 + nameLen));
+      const collection = decoder2.decode(buffer.subarray(3, 3 + nameLen));
       const dataOffset = 3 + nameLen;
-      const dataLen = buffer[dataOffset] << 24 | buffer[dataOffset + 1] << 16 | buffer[dataOffset + 2] << 8 | buffer[dataOffset + 3];
+      const dataLen = buffer.at(dataOffset) << 24 | buffer.at(dataOffset + 1) << 16 | buffer.at(dataOffset + 2) << 8 | buffer.at(dataOffset + 3);
       const totalChunkSize = headerSize + dataLen;
       while (buffer.length < totalChunkSize) {
         if (!await readMore())
           throw new Error("Unexpected end of stream in chunk data");
       }
-      const payloadBytes = buffer.slice(headerSize, totalChunkSize);
-      const items = unpack2(payloadBytes);
-      buffer = buffer.slice(totalChunkSize);
+      const items = unpack2(buffer.subarray(headerSize, totalChunkSize));
+      buffer.consume(totalChunkSize);
       await onChunk(collection, items);
     }
   }

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

@@ -25,6 +25,7 @@ export declare class DexieDb extends Dexie implements I_DexieDb {
     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[]>;
+    forEachBatch<T extends LocalDbEntity>(collection: string, batchSize: number, callback: (items: T[]) => Promise<void>): Promise<void>;
     count(collection: string): Promise<number>;
     getDirty<T extends LocalDbEntity>(collection: string): Promise<Partial<T>[]>;
     addDirtyChange(collection: string, id: Id, changes: Record<string, any>, baseMeta?: {

package/dist/src/db/sync/ServerUpdateHandler.d.ts

@@ -38,6 +38,7 @@ export declare class ServerUpdateHandler implements I_ServerUpdateHandler {
     handleServerItemDelete(collection: string, id: Id): Promise<void>;
     private stripLocalFields;
     private timestampsEqual;
+    /** @mutates local — mutira vhodni objekt namesto kopiranja */
     private mergeLocalWithDelta;
     private getNewFieldsFromServer;
     private callOnWsNotification;

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

@@ -64,6 +64,8 @@ export interface I_DexieDb {
     getByIds<T extends LocalDbEntity>(collection: string, ids: Id[]): Promise<(T | undefined)[]>;
     /** Vrne vse objekte v kolekciji */
     getAll<T extends LocalDbEntity>(collection: string): Promise<T[]>;
+    /** Iterira po kolekciji v chunkih brez nalaganja vseh zapisov naenkrat */
+    forEachBatch<T extends LocalDbEntity>(collection: string, batchSize: number, callback: (items: T[]) => Promise<void>): 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 */

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

@@ -206,8 +206,6 @@ export interface CollectionSyncStats {
     receivedCount: number;
     /** Number of dirty items sent to server for this collection */
     sentCount: number;
-    /** @deprecated Use receivedCount instead. Will be empty array in future streaming mode. */
-    receivedItems: LocalDbEntity[];
 }
 /**
  * Informacije o sinhronizaciji za debugging/logging

package/package.json

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