cry-synced-db-client 0.1.210 → 0.1.213

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Versions
 
+## 0.1.211 (2026-06-25)
+
+### Added `streamActivityTimeoutMs` to SyncedDbConfig
+
+`findNewerManyStream` has two internal timeouts: `connectTimeout` (configurable via
+`defaultTimeoutMs`) and `activityTimeout` (was hardcoded to 30s). The activity
+timeout fires between stream chunk reads — if Dexie writes + Vuex reactivity for
+a 2000-item chunk exceed 30s, the stream is aborted.
+
+New fields:
+- `RestProxy.defaultActivityTimeoutMs` — default for all streams (falls back to 30s)
+- `SyncedDbConfig.streamActivityTimeoutMs` — threaded through SyncedDb → SyncEngine
+  → RestProxy.findNewerManyStream(options.activityTimeoutMs)
+
 ## 0.1.209 (2026-06-25)
 
 ### Removed hardcoded `{ returnDeleted: true }` from sync specs

package/dist/index.js

@@ -3219,6 +3219,7 @@ var _SyncEngine = class _SyncEngine {
     let conflictsResolved = 0;
     const collectionStats = {};
     this.callOnSyncStart({ calledFrom, initialSync: false });
+    const _perCollectionItems = /* @__PURE__ */ new Map();
     try {
       this.deps.cancelRestUploadTimer();
       await this.deps.awaitRestUpload();
@@ -3297,12 +3298,14 @@ var _SyncEngine = class _SyncEngine {
               if (!config) return;
               const state = collectionState.get(collection);
               state.receivedCount += items.length;
+              const _tProcess = performance.now();
               const stats = await this.processIncomingServerData(
                 collection,
                 config,
                 items,
                 state.source
               );
+              const _processingMs = performance.now() - _tProcess;
               state.conflicts += stats.conflictsResolved;
               if (stats.maxTs) {
                 if (!state.maxTs || this.compareTimestamps(stats.maxTs, state.maxTs) > 0) {
@@ -3312,16 +3315,24 @@ var _SyncEngine = class _SyncEngine {
               if (stats.updatedIds.length > 0) {
                 this.deps.broadcastUpdates({ [collection]: stats.updatedIds });
               }
-              if (!completedCollections.has(collection)) {
+              const isNewColl = !completedCollections.has(collection);
+              if (isNewColl) {
                 completedCollections.add(collection);
-                this.callbackSafe(this.callbacks.onSyncProgress, {
-                  phase: "server",
-                  collection,
-                  loaded: completedCollections.size,
-                  total: syncSpecs.length,
-                  items: items.length
-                });
               }
+              _perCollectionItems.set(
+                collection,
+                (_perCollectionItems.get(collection) || 0) + items.length
+              );
+              this.callbackSafe(this.callbacks.onSyncProgress, {
+                phase: "server",
+                collection,
+                loaded: completedCollections.size,
+                total: syncSpecs.length,
+                items: items.length,
+                itemsCumulative: _perCollectionItems.get(collection),
+                isNewCollection: isNewColl,
+                processingMs: Math.round(_processingMs)
+              });
             },
             {
               onRequestBytes: (bytes) => {
@@ -3332,7 +3343,8 @@ var _SyncEngine = class _SyncEngine {
               },
               onResponseChunkBytes: (bytes) => {
                 responseBytes = (responseBytes != null ? responseBytes : 0) + bytes;
-              }
+              },
+              activityTimeoutMs: this.deps.streamActivityTimeoutMs
             }
           ),
           "findNewerManyStream"
@@ -4140,10 +4152,12 @@ var _SyncEngine = class _SyncEngine {
   }
   async processIncomingServerData(collectionName, config, serverData, source = "incremental") {
     if (serverData.length === 0) {
-      return { conflictsResolved: 0, maxTs: void 0, updatedIds: [] };
+      return { conflictsResolved: 0, maxTs: void 0, updatedIds: [], dexieMs: 0, inMemMs: 0 };
     }
     let maxTs;
     let conflictsResolved = 0;
+    let totalDexieMs = 0;
+    let totalInMemMs = 0;
     const allUpdatedIds = [];
     const BATCH = _SyncEngine.SYNC_BATCH_SIZE;
     for (let offset = 0; offset < serverData.length; offset += BATCH) {
@@ -4202,13 +4216,22 @@ var _SyncEngine = class _SyncEngine {
           }
         }
       }
+      let _timingDexieMs = 0;
+      let _timingInMemMs = 0;
       if (dexieBatch.length > 0) {
+        const _t0 = performance.now();
         await this.dexieDb.saveMany(collectionName, dexieBatch);
+        _timingDexieMs = performance.now() - _t0;
+        totalDexieMs += _timingDexieMs;
       }
       if (inMemSaveBatch.length > 0) {
+        const _t1 = performance.now();
         this.deps.writeToInMemBatch(collectionName, inMemSaveBatch, "upsert", {
           source
         });
+        const _inMemMs = performance.now() - _t1;
+        _timingInMemMs += _inMemMs;
+        totalInMemMs += _inMemMs;
       }
       if (inMemDeleteIds.length > 0) {
         this.deps.writeToInMemBatch(
@@ -4227,7 +4250,7 @@ var _SyncEngine = class _SyncEngine {
         lastSyncTs: maxTs
       });
     }
-    return { conflictsResolved, maxTs, updatedIds: allUpdatedIds };
+    return { conflictsResolved, maxTs, updatedIds: allUpdatedIds, dexieMs: totalDexieMs, inMemMs: totalInMemMs };
   }
   // ============================================================
   // Private Helpers
@@ -5087,6 +5110,7 @@ var _SyncedDb = class _SyncedDb {
         },
         getInMemById: (collection, id) => this.inMemDb.getById(collection, id),
         withSyncTimeout: (promise, operation) => this.connectionManager.withSyncTimeout(promise, operation),
+        streamActivityTimeoutMs: config.streamActivityTimeoutMs,
         onSyncFailed: (reason) => this.connectionManager.callOnSyncFailed(reason),
         flushAllPendingChanges: () => this.pendingChanges.flushAll(),
         cancelRestUploadTimer: () => this.pendingChanges.cancelRestUploadTimer(),
@@ -10452,16 +10476,17 @@ var RestProxy = class {
     this._lastRequestMs = 0;
     this._totalRequestMs = 0;
     this._requestCount = 0;
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
     this.endpoint = config.endpoint;
     this.tenant = config.tenant;
     this.apiKey = config.apiKey;
     this.defaultTimeoutMs = (_a = config.defaultTimeoutMs) != null ? _a : DEFAULT_TIMEOUT;
-    this.audit = (_b = config.audit) != null ? _b : {};
-    this.timeRequestsPrint = (_c = config.timeRequestsPrint) != null ? _c : false;
-    this.timeRequests = (_d = config.timeRequests) != null ? _d : this.timeRequestsPrint;
+    this.defaultActivityTimeoutMs = (_b = config.defaultActivityTimeoutMs) != null ? _b : 3e4;
+    this.audit = (_c = config.audit) != null ? _c : {};
+    this.timeRequestsPrint = (_d = config.timeRequestsPrint) != null ? _d : false;
+    this.timeRequests = (_e = config.timeRequests) != null ? _e : this.timeRequestsPrint;
     this.onProgressCallback = config.onProgressCallback;
-    this.progressChunkSize = (_e = config.progressChunkSize) != null ? _e : DEFAULT_PROGRESS_CHUNK_SIZE;
+    this.progressChunkSize = (_f = config.progressChunkSize) != null ? _f : DEFAULT_PROGRESS_CHUNK_SIZE;
     this.globalSignal = config.signal;
   }
   /** Set global abort signal */
@@ -10638,7 +10663,7 @@ var RestProxy = class {
   async findNewerManyStream(spec, onChunk, options) {
     var _a, _b, _c, _d, _e;
     const connectTimeout = (_a = options == null ? void 0 : options.timeoutMs) != null ? _a : this.defaultTimeoutMs;
-    const activityTimeout = (_b = options == null ? void 0 : options.activityTimeoutMs) != null ? _b : 3e4;
+    const activityTimeout = (_b = options == null ? void 0 : options.activityTimeoutMs) != null ? _b : this.defaultActivityTimeoutMs;
     const externalSignal = (_c = options == null ? void 0 : options.signal) != null ? _c : this.globalSignal;
     const startTime = this.timeRequests ? performance.now() : 0;
     const fetchStart = performance.now();

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

@@ -13,6 +13,17 @@ export interface RestProxyConfig {
     apiKey?: string;
     /** Default timeout in ms (default: 5000) */
     defaultTimeoutMs?: number;
+    /**
+     * Default activity timeout for streaming responses (default: 30000).
+     *
+     * Unlike `defaultTimeoutMs` which covers the initial fetch() connection,
+     * this timeout fires if the gap between individual chunk reads exceeds
+     * the limit. Streaming syncs with many large collections (e.g. initial
+     * sync on a new device with 60+ collections and 2000-item chunks) need
+     * a higher value because Dexie writes + Vuex reactivity between reads
+     * can delay the next read() past the default 30s.
+     */
+    defaultActivityTimeoutMs?: number;
     /** Audit info for requests */
     audit?: {
         user?: string;
@@ -64,6 +75,7 @@ export declare class RestProxy implements I_RestInterface {
     private tenant;
     private apiKey?;
     private defaultTimeoutMs;
+    private defaultActivityTimeoutMs;
     private audit;
     private timeRequests;
     private timeRequestsPrint;

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

@@ -248,6 +248,9 @@ export interface SyncEngineCallbacks {
         loaded: number;
         total: number;
         items: number;
+        itemsCumulative?: number;
+        isNewCollection?: boolean;
+        processingMs?: number;
     }) => void;
     onServerSyncStart?: (info: {
         calledFrom?: string;
@@ -282,6 +285,8 @@ export interface SyncEngineDeps {
     }) => void;
     getInMemById: <T extends DbEntity>(collection: string, id: Id) => T | undefined;
     withSyncTimeout: <T>(promise: Promise<T>, operation: string) => Promise<T>;
+    /** Activity timeout for streaming `findNewerManyStream` (ms). Default 30000. */
+    streamActivityTimeoutMs?: number;
     /** Notify consumers that a sync cycle failed. Does not mutate online state. */
     onSyncFailed: (reason: string) => void;
     flushAllPendingChanges: () => Promise<void>;

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

@@ -133,6 +133,7 @@ export interface I_RestInterface {
     findNewerManyStream<T>(spec: GetNewerSpec<T>[], onChunk: (collection: string, items: T[], specId?: string) => Promise<void>, options?: {
         timeoutMs?: number;
         signal?: AbortSignal;
+        activityTimeoutMs?: number;
         onRequestBytes?: (bytes: number) => void;
         onTtfbMs?: (ms: number) => void;
         onResponseChunkBytes?: (bytes: number) => void;

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

@@ -592,6 +592,16 @@ export interface SyncedDbConfig {
     restTimeoutMs?: number;
     /** Timeout za sync REST klice v ms (default: 120000) - daljši ker sync prenaša več podatkov */
     syncTimeoutMs?: number;
+    /**
+     * Activity timeout za streaming odgovore (default: 30000).
+     *
+     * Za razliko od `restTimeoutMs` (ki pokriva začetno fetch() povezavo),
+     * ta timeout sproži če je premor med posameznimi chunk read()-i daljši
+     * od meje. Initial sync na novi napravi (60+ kolekcij, 2000-item chunk-i)
+     * potrebuje višjo vrednost, ker Dexie writes + Vuex reactivity med read()-i
+     * lahko podaljšajo naslednji read() čez privzetih 30s.
+     */
+    streamActivityTimeoutMs?: number;
     /** Debounce čas za zapis v Dexie v ms (default: 200) */
     debounceDexieWritesMs?: number;
     /** Debounce čas za pošiljanje na REST v ms (default: 1000) - po uspešnem zapisu v Dexie */
@@ -664,6 +674,12 @@ export interface SyncedDbConfig {
         loaded: number;
         total: number;
         items: number;
+        /** Cumulative items for this collection across all chunks so far */
+        itemsCumulative?: number;
+        /** True only for the first chunk of a new collection */
+        isNewCollection?: boolean;
+        /** Processing time for this chunk: Dexie save + InMem write (ms) */
+        processingMs?: number;
     }) => void;
     /**
      * Callback when per-collection hydration status changes (hydration end,

package/package.json

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