cry-synced-db-client 0.1.72 → 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,33 +2169,45 @@ class SyncEngine {
       }
       this.callOnFindNewerManyCall(syncSpecs, calledFrom);
       const findNewerManyStartTime = Date.now();
-      let allServerData;
+      const collectionState = new Map;
+      for (const [name] of configMap) {
+        collectionState.set(name, {
+          maxTs: undefined,
+          conflicts: 0,
+          receivedCount: 0
+        });
+      }
       try {
-        allServerData = await this.deps.withSyncTimeout(this.restInterface.findNewerMany(syncSpecs), "findNewerMany");
-        this.callOnFindNewerManyResult(syncSpecs, allServerData, findNewerManyStartTime, true, calledFrom);
+        await this.deps.withSyncTimeout(this.restInterface.findNewerManyStream(syncSpecs, async (collection, items) => {
+          const config = configMap.get(collection);
+          if (!config)
+            return;
+          const state = collectionState.get(collection);
+          state.receivedCount += items.length;
+          const stats = await this.processIncomingServerData(collection, config, items);
+          state.conflicts += stats.conflictsResolved;
+          if (stats.maxTs) {
+            if (!state.maxTs || this.compareTimestamps(stats.maxTs, state.maxTs) > 0) {
+              state.maxTs = stats.maxTs;
+            }
+          }
+          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
+          };
+        }
+        this.callOnFindNewerManyResult(syncSpecs, {}, findNewerManyStartTime, true, calledFrom);
       } catch (err) {
         this.callOnFindNewerManyResult(syncSpecs, {}, findNewerManyStartTime, false, calledFrom, err);
         throw err;
       }
-      const allUpdatedIds = {};
-      for (const [collectionName, config] of configMap) {
-        const serverData = allServerData[collectionName] || [];
-        delete allServerData[collectionName];
-        receivedCount += serverData.length;
-        collectionStats[collectionName] = {
-          receivedCount: serverData.length,
-          sentCount: 0,
-          receivedItems: []
-        };
-        const stats = await this.processIncomingServerData(collectionName, config, serverData);
-        conflictsResolved += stats.conflictsResolved;
-        if (stats.updatedIds.length > 0) {
-          allUpdatedIds[collectionName] = stats.updatedIds;
-        }
-      }
-      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 || {})) {
@@ -2190,8 +2216,7 @@ class SyncEngine {
         } else {
           collectionStats[collectionName] = {
             receivedCount: 0,
-            sentCount: stats,
-            receivedItems: []
+            sentCount: stats
           };
         }
       }
@@ -2278,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 = [];
@@ -2297,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) {
@@ -2324,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;
+            }
           }
         }
       }
@@ -2399,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);
       }
@@ -2432,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 = [];
@@ -2442,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;
@@ -2481,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);
@@ -2740,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");
@@ -2801,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 = {};
@@ -3259,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);
@@ -3430,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);
@@ -3458,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);
@@ -3938,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) {
@@ -3961,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,
@@ -4007,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++) {
@@ -4015,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,
@@ -4042,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];
@@ -4059,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) {
@@ -6227,6 +6312,47 @@ var unpack2 = (x) => unpackr.unpack(x);
 var DEFAULT_TIMEOUT = 5000;
 var DEFAULT_PROGRESS_CHUNK_SIZE = 16 * 1024;
 
+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 {
   endpoint;
   tenant;
@@ -6386,6 +6512,129 @@ class RestProxy {
   async findNewerMany(spec) {
     return await this.restCall("findNewerMany", { spec });
   }
+  async findNewerManyStream(spec, onChunk, options) {
+    const connectTimeout = options?.timeoutMs ?? this.defaultTimeoutMs;
+    const activityTimeout = options?.activityTimeoutMs ?? 30000;
+    const externalSignal = options?.signal ?? this.globalSignal;
+    const startTime = this.timeRequests ? performance.now() : 0;
+    const data = {
+      payload: {
+        db: this.tenant,
+        operation: "findNewerMany",
+        spec
+      },
+      audit: {
+        tenant: this.tenant,
+        user: this.audit.user,
+        naprava: this.audit.device
+      }
+    };
+    const body = pack2(data);
+    const requestUrl = this.apiKey ? `${this.endpoint}?apikey=${this.apiKey}&stream=1` : `${this.endpoint}?stream=1`;
+    const controller = new AbortController;
+    let timeoutId = setTimeout(() => controller.abort(), connectTimeout);
+    const combinedSignal = externalSignal ? this.combineSignals(externalSignal, controller.signal) : controller.signal;
+    try {
+      const response = await fetch(requestUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/octet-stream" },
+        body,
+        signal: combinedSignal
+      });
+      clearTimeout(timeoutId);
+      timeoutId = undefined;
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`REST call failed: ${response.status} - ${errorText}`);
+      }
+      const resetActivity = () => {
+        if (timeoutId !== undefined)
+          clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => controller.abort(), activityTimeout);
+      };
+      resetActivity();
+      await this.parseStreamingResponse(response, onChunk, resetActivity);
+      if (timeoutId !== undefined)
+        clearTimeout(timeoutId);
+      timeoutId = undefined;
+      if (this.timeRequests) {
+        const elapsed = performance.now() - startTime;
+        this._lastRequestMs = elapsed;
+        this._totalRequestMs += elapsed;
+        this._requestCount++;
+        if (this.timeRequestsPrint) {
+          console.log(`[RestProxy] findNewerManyStream: ${elapsed.toFixed(2)}ms (total: ${this._totalRequestMs.toFixed(2)}ms, count: ${this._requestCount})`);
+        }
+      }
+    } catch (err) {
+      if (timeoutId !== undefined)
+        clearTimeout(timeoutId);
+      if (err.name === "AbortError") {
+        if (controller.signal.aborted && !externalSignal?.aborted) {
+          throw new Error(`REST call timeout: findNewerManyStream`);
+        }
+        throw new Error("REST call aborted: findNewerManyStream");
+      }
+      throw err;
+    }
+  }
+  async parseStreamingResponse(response, onChunk, onActivity) {
+    const reader = response.body.getReader();
+    const buffer = new StreamBuffer;
+    const decoder2 = new TextDecoder;
+    const readMore = async () => {
+      const { done, value } = await reader.read();
+      if (done)
+        return false;
+      onActivity();
+      buffer.append(value);
+      return true;
+    };
+    while (buffer.length < 1) {
+      if (!await readMore())
+        return;
+    }
+    const firstByte = buffer.at(0);
+    if (firstByte !== 0 && firstByte !== 1) {
+      while (await readMore()) {}
+      const result = unpack2(buffer.subarray(0, buffer.length));
+      for (const [collection, items] of Object.entries(result)) {
+        if (items.length > 0) {
+          await onChunk(collection, items);
+        }
+      }
+      return;
+    }
+    while (true) {
+      while (buffer.length < 1) {
+        if (!await readMore())
+          return;
+      }
+      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.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 = decoder2.decode(buffer.subarray(3, 3 + nameLen));
+      const dataOffset = 3 + nameLen;
+      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 items = unpack2(buffer.subarray(headerSize, totalChunkSize));
+      buffer.consume(totalChunkSize);
+      await onChunk(collection, items);
+    }
+  }
   async deleteOne(collection, query) {
     return await this.restCall("deleteOne", { collection, query });
   }

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/RestProxy.d.ts

@@ -101,6 +101,28 @@ export declare class RestProxy implements I_RestInterface {
     findByIds<T>(collection: string, ids: Id[]): Promise<T[]>;
     findNewer<T>(collection: string, timestamp: Timestamp | number | string | Date, query?: QuerySpec<T>, opts?: QueryOpts): Promise<T[]>;
     findNewerMany<T>(spec?: GetNewerSpec<T>[]): Promise<Record<string, any[]>>;
+    /**
+     * Streaming variant of findNewerMany.
+     * Reads chunked binary response and calls onChunk for each batch.
+     * Peak memory = one chunk (~200 docs) instead of entire result set.
+     *
+     * Binary chunk format:
+     *   [type:1][nameLen:2][name:N][dataLen:4][msgpack(items[]):M]
+     *   type=0x01 for data, type=0x00 for end-of-stream.
+     */
+    findNewerManyStream<T>(spec: GetNewerSpec<T>[], onChunk: (collection: string, items: T[]) => Promise<void>, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+        activityTimeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * Parse streaming response. Auto-detects format:
+     * - Streaming: first byte is 0x00 (end) or 0x01 (data chunk)
+     * - Legacy msgpack: first byte is msgpack type marker (0x80+ for map, etc.)
+     *
+     * Streaming chunk format: [type:1][nameLen:2][name:N][dataLen:4][msgpack(items[]):M]
+     */
+    private parseStreamingResponse;
     deleteOne<T>(collection: string, query: QuerySpec<T>): Promise<T>;
     aggregate<T>(collection: string, pipeline: object[], opts?: AggregateOptions): Promise<T[]>;
     upsertBatch<T>(collection: string, batch: BatchSpec<T>): Promise<T[]>;

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_RestInterface.d.ts

@@ -67,6 +67,11 @@ export interface I_RestInterface {
     findByIds<T>(collection: string, ids: Id[]): Promise<T[]>;
     findNewer<T>(collection: string, timestamp: Timestamp | number | string | Date, query?: QuerySpec<T>, opts?: QueryOpts): Promise<T[]>;
     findNewerMany<T>(spec?: GetNewerSpec<T>[]): Promise<Record<string, any[]>>;
+    /** Streaming variant of findNewerMany. Calls onChunk for each batch of items as they arrive. */
+    findNewerManyStream<T>(spec: GetNewerSpec<T>[], onChunk: (collection: string, items: T[]) => Promise<void>, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
     deleteOne<T>(collection: string, query: QuerySpec<T>): Promise<T>;
     /** Izvede agregacijo na serverju */
     aggregate<T>(collection: string, pipeline: object[], opts?: AggregateOptions): Promise<T[]>;

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.72",
+  "version": "0.1.74",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",