cry-synced-db-client 0.1.209 → 0.1.212

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

@@ -3332,7 +3332,8 @@ var _SyncEngine = class _SyncEngine {
               },
               onResponseChunkBytes: (bytes) => {
                 responseBytes = (responseBytes != null ? responseBytes : 0) + bytes;
-              }
+              },
+              activityTimeoutMs: this.deps.streamActivityTimeoutMs
             }
           ),
           "findNewerManyStream"
@@ -5087,6 +5088,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(),
@@ -6462,30 +6464,12 @@ var _SyncedDb = class _SyncedDb {
       }
       this.syncing = true;
       this.crossTabSync.startServerSync();
-      let evictionPlan;
-      let evictionServerFailed = false;
-      if (await this._isAutoEvictionDue(calledFrom)) {
-        try {
-          evictionPlan = await this._collectScopeExitPlan("auto");
-        } catch (err) {
-          console.error(
-            "[SyncedDb] [evict] phase 1 failed (skipping bundled eviction):",
-            err
-          );
-        }
-      }
-      const evictionExtras = evictionPlan && evictionPlan.specs.length > 0 ? {
-        specs: evictionPlan.specs,
-        onChunk: (specId, items) => {
-          this._applyScopeExitChunkToPlan(evictionPlan, specId, items);
-        }
-      } : void 0;
       const consumingPendingFullResync = this._pendingFullResync;
       if (consumingPendingFullResync) {
         await this._resetSyncCursors();
       }
       try {
-        await this.syncEngine.sync(calledFrom, evictionExtras);
+        await this.syncEngine.sync(calledFrom);
         if (!this.syncOnlyCollections) {
           const now = /* @__PURE__ */ new Date();
           if (!this._lastFullSyncDate) {
@@ -6505,24 +6489,11 @@ var _SyncedDb = class _SyncedDb {
           if (consumingPendingFullResync) this._pendingFullResync = false;
         }
       } catch (err) {
-        if (evictionExtras) evictionServerFailed = true;
         throw err;
       } finally {
         this.syncing = false;
         this.crossTabSync.endServerSync();
         await this.processQueuedWsUpdates();
-        if (evictionPlan) {
-          try {
-            await this._applyScopeExitPlan(
-              evictionPlan,
-              evictionServerFailed,
-              evictionExtras ? 1 : 0
-            );
-            await this._persistEvictionTimestamp();
-          } catch (err) {
-            console.error(`[SyncedDb] [evict] phase 3 failed: ${err}`, err);
-          }
-        }
       }
     } finally {
       this.syncLock = false;
@@ -10483,16 +10454,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 */
@@ -10669,7 +10641,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

@@ -282,6 +282,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 */

package/package.json

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