cry-synced-db-client 0.1.202 → 0.1.204

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Versions
 
+## 0.1.204 (2026-06-17)
+
+### Per-collection error isolation in `uploadDirtyItems`
+
+Celoten per-collection cikel (`getDirty`, `getByIds`, `saveMany`,
+`incrementDirtyUploadAttempts`, ...) je zdaj zavit v `try/catch`. Če Dexie
+operacija za eno kolekcijo vrže (npr. corrupted transaction, IndexedDB error),
+odpade samo tista kolekcija — ostale se normalno pošljejo naprej.
+
+**Before:** ena kolekcija pade → celoten upload crasne, vse ostale collection
+dirty entry-ji ostanejo neposlani do naslednjega sync cycle-a.
+**After:** napaka se logira (`console.error`), zanka gre na naslednjo kolekcijo.
+
+876 pass, 0 fail.
+
+## 0.1.203 (2026-06-15)
+
+### `onDirtyItemStuck` callback zdaj prejme tudi `itemsContent: DirtyChange[]`
+
+`DirtyItemStuckInfo` je dobil novo polje `itemsContent` — polni `DirtyChange[]`
+entry-ji (vključno s `changes` payload-om), ne samo `DirtyMeta[]` z metapodatki.
+
+**Affected paths:**
+
+- `callOnDirtyItemStuck` v `SyncEngine.ts`: async, fetcha polne entry-je prek
+  `dexieDb.getDirtyChangesBatch()` in jih posreduje kot `itemsContent`
+
+```typescript
+onDirtyItemStuck: (info) => {
+  // info.items — DirtyMeta[] (isto kot prej)
+  // info.itemsContent — DirtyChange[] (polni entry-ji s `changes` payload-om)
+  console.log('Stuck changes:', info.itemsContent[0]!.changes);
+}
+```
+
+899 pass, 0 fail.
+
 ## 0.1.201 (2026-06-14)
 
 ### `onBeforeDirtyClearAll` callback zdaj prejme `DirtyChange[]` (ne samo `DirtyMeta[]`)
@@ -9,11 +46,13 @@ callback dobi poleg metapodatkov (`id`, `collection`, `stuckSince`, ...) tudi
 `changes` payload z dejanskimi field-level spremembami.
 
 **Affected paths:**
+
 - `clearDirty()` clear-all path: fetcha `DirtyChange[]` prek `getDirtyChangesBatch`
 - `discardStuckItems()`: zamenja `getDirty` + `find` (ki je vračal
   `Partial<LocalDbEntity>[]`) z `getDirtyChangesBatch` za pravilne `DirtyChange[]`
 
 **Type change (backward-compatible):**
+
 - `items` v `BeforeDirtyClearAllInfo`: `DirtyMeta[]` → `DirtyChange[]`
 - `DirtyChange` je superset of `DirtyMeta`; vsa obstoječa polja (`id`,
   `collection`, `createdAt`, `updatedAt`, `stuckSince`, ...) so še vedno na voljo
@@ -33,11 +72,13 @@ bi postali stuck — zdaj se po 3 skipih (vsak sync da 2 incrementa = main + fol
 dobijo `stuckSince`.
 
 **Internal:**
+
 - V `uploadDirtyItems` zbira `preprocessSkippedIds` v obeh poteh, batch-write v
   `incrementDirtyUploadAttempts` takoj za `for` zanko (en DB write za vse skipane
   iteme namesto N write-ov)
 
 **Tests:** 5 novih testov v `test/preprocessDirtyItem.test.ts`:
+
 - `undefined/throw: numUploadAttempts increments across sync cycles, eventually stuck`
 - `undefined/throw: onDirtyItemStuck fires when item becomes stuck`
 - `mixed: stuck item via getStuckItems while non-stuck dirty still active`
@@ -51,17 +92,21 @@ dobijo `stuckSince`.
 Nov mehanizem za detekcijo dirty itemov, ki jih server vztrajno zavrača.
 
 **Fields na `DirtyChange` / `DirtyMeta`:**
+
 - `firstUploadAttempt?`, `lastUploadAttempt?`, `numUploadAttempts?`, `stuckSince?`
 - `stuckSince` se nastavi ko `numUploadAttempts > DIRTY_STUCK_AFTER_UPLOAD_ATTEMPTS` (2)
 
 **Nove metode na `SyncedDb`:**
+
 - `getStuckItems()` — vrne samo stuck dirty iteme po kolekcijah (`Record<collection, DirtyMeta[]>`)
 - `discardStuckItems(calledFrom?)` — zbriše vse stuck dirty iteme, sproži `onBeforeDirtyClearAll` z `reason: "discard-stuck"`
 
 **Nov callback:**
+
 - `onDirtyItemStuck(info: DirtyItemStuckInfo)` — sproži se ko item prvič postane stuck (po 3. neuspelem uploadu). Vsebuje `collection`, `items: DirtyMeta[]`, `calledFrom`, `timestamp`.
 
 **Internal:**
+
 - `I_DexieDb.incrementDirtyUploadAttempts(collection, ids)` — nova metoda, vrača `DirtyMeta[]` na novo stuck itemov
 - Vgrajena v `SyncEngine.uploadDirtyItems` in `uploadDirtyItemsForCollection` — per-collection result (errored ids) in catch block (network/timeout)
 - `DexieDb.getDirtyMeta` sedaj vključuje nova polja v izhod
@@ -84,6 +129,7 @@ Razlika od `refreshInBackground`: `refreshImmediately` je blokiren — počaka
 na odgovor serverja in vrne ažuriran podatek.
 
 Internal:
+
 - `_refreshImmediately()` — nova zasebna metoda: fetča s serverja, primerja
   `_rev`, posodobi Dexie samo če server novejši; za iteme z dirty spremembami
   delegira `processCollectionServerData`
@@ -108,7 +154,6 @@ in-mem. `referToServer` zdaj resnično awaita sveže podatke s serverja.
 Internal: `ensureItemsAreLoaded` — odstranjena Dexie pre-check (`getByIds`
 → `missingIds`).
 
-
 ## 0.1.194 (2026-06-09)
 
 ### Preload status `ready` fix
@@ -118,7 +163,6 @@ je `state === "hydrated"`, ne glede na `itemCount` ali `everDownloaded`.
 Prazen (še nikoli sinhroniziran) direktorij je še vedno ready — svežina
 podatkov je globalni koncept (`lastSuccessfulServerSync`).
 
-
 ## 0.1.193 (2026-05-25)
 
 Adds per-collection preload status reporting (non-breaking, additive).
@@ -256,6 +300,7 @@ batched download leaves collections registered; next auto-sync tick
 retries via the normal sync flow.
 
 Compared to looping `addCollectionToSync(spec)` per item:
+
 - N collections × per-collection RTT (sequential or `Promise.all`)
   → 1 RTT for the whole batch.
 - Hydration also parallelized.
@@ -647,6 +692,7 @@ paths are preserved. After the prune, `entry.baseTs` / `entry.baseRev`
 advance to the new floor.
 
 Implemented in:
+
 - `src/db/DexieDb.ts` — new module-level `rebaseDirtyOnServerAdvance`
   called from both `addDirtyChange` and `addDirtyChangesBatch` before
   `mergeDirtyChanges`.
@@ -716,6 +762,7 @@ drop silently. These fields are server-mirrored — local materialization
 with partial data could diverge from the canonical state.
 
 Tests:
+
 - `test/applyDiffLocallyObiskShape.test.ts` — 5 new cases covering
   multi-segment prefix shapes plus the `_`-prefix silent-drop contract.
 - `test/applyDiffLocallyMaterialize.test.ts` — flipped the
@@ -815,6 +862,7 @@ sentry/log dashboards.
 
 What's NOT routed through `networkError` (intentional — these are real
 bugs regardless of network state):
+
 - Caller bugs (falsy `_id`, missing `_id`, id mismatch, no id provided)
 - Dexie failures (`bulkPut failed`, `Failed to write to Dexie`, etc.)
 - Consumer-supplied callback throws (`onSyncEnd callback failed`, etc.)
@@ -994,6 +1042,7 @@ in the same scannable line as the tag while the full error object remains
 attached for devtools inspection.
 
 Also fixed:
+
 - `SyncedDb.findById`: bare `console.error(err)` → tag line first, Error
   object as second arg.
 - `Ebus2ProxyNotifier`: WebSocket error event and server-error payload now
@@ -1215,6 +1264,7 @@ Behavior on subsequent calls (inspected against the existing config's
 spec; the new config (whatever shape) drives future syncs alone.
 
 Constraints:
+
 - Dexie schema must already declare the table (Dexie does not support
   adding tables to an open database). The auto-register handles only the
   runtime SyncedDb-level config.
@@ -1528,6 +1578,7 @@ spread that would replace top-level array/object fields wholesale and
 drop nested fields the caller's `update` didn't mention.
 
 Replaced with `applyDiffLocally(base, diff, id)`:
+
 1. Deep-clone `base` (currentMem ?? existing) via `safeDeepClone`
    (handles Date and `ObjectId`-like values; avoids `structuredClone`
    throwing on bson class instances)
@@ -1544,6 +1595,7 @@ Replaced with `applyDiffLocally(base, diff, id)`:
 Reverted automatic `_id` stamping for objects appearing as array elements.
 If an array of objects lacks `_id`, the caller's element shape is now
 preserved. This allows callers to mix:
+
 - Whole-element bracket replace: `update.postavke = [{...}]`
 - Bracket-by-_id sub-field path: `update["postavke[<id>].field"] = value`
 in the same payload without the client mutating element identity.
@@ -1562,6 +1614,7 @@ in the same payload without the client mutating element identity.
 | Different `_id` set | mixed: `$pull` + `$push` + sub-field |
 
 For composition changes, `computeDiff` now emits:
+
 - **Removed `_id`**: `arr[<id>] = undefined` (server: `$pull`)
 - **Added `_id`**: `arr[<id>] = [element]` (server: `$concatArrays + $filter`)
 - **Retained `_id`**: element-wise sub-field via `arr[<id>].field`
@@ -2069,6 +2122,7 @@ streams separately. **Non-breaking**: consumers that destructure
 `{ collection, loaded, total }` and ignore `phase` keep working unchanged.
 
 Type change in `I_SyncedDb.SyncedDbConfig` and internal `SyncEngineCallbacks`:
+
 ```ts
 onSyncProgress?: (info: {
   phase: 'dexie' | 'server';

package/dist/index.js

@@ -3195,7 +3195,6 @@ var SUPRESS_DB_WARNINGS = true;
 var _SyncEngine = class _SyncEngine {
   constructor(config) {
     this.tenant = config.tenant;
-    this.updaterId = config.updaterId;
     this.collections = config.collections;
     this.dexieDb = config.dexieDb;
     this.restInterface = config.restInterface;
@@ -3529,59 +3528,80 @@ var _SyncEngine = class _SyncEngine {
   async uploadDirtyItems(calledFrom) {
     var _a, _b;
     const collectionBatches = [];
-    for (const [collectionName] of this.collections) {
-      const dirtyChanges = await this.dexieDb.getDirty(collectionName);
-      if (dirtyChanges.length === 0) continue;
-      const dirtyChangesMap = /* @__PURE__ */ new Map();
-      for (const dirtyItem of dirtyChanges) {
-        dirtyChangesMap.set(String(dirtyItem._id), dirtyItem);
-      }
-      const updates = [];
-      const skipped = [];
-      const ids = dirtyChanges.map((dc) => dc._id);
-      const fullItems = await this.dexieDb.getByIds(
-        collectionName,
-        ids
-      );
-      const orphanReconstructed = [];
-      for (let i = 0; i < fullItems.length; i++) {
-        const fullItem = fullItems[i];
-        const id = ids[i];
-        if (fullItem) {
-          const delta = dirtyChangesMap.get(String(fullItem._id));
-          if (delta) {
-            const currentServerRev = typeof fullItem._rev === "number" ? fullItem._rev : void 0;
-            updates.push({ _id: fullItem._id, delta, currentServerRev });
+    for (const [collectionName] of this.collections)
+      try {
+        const dirtyChanges = await this.dexieDb.getDirty(collectionName);
+        if (dirtyChanges.length === 0) continue;
+        const dirtyChangesMap = /* @__PURE__ */ new Map();
+        for (const dirtyItem of dirtyChanges) {
+          dirtyChangesMap.set(String(dirtyItem._id), dirtyItem);
+        }
+        const updates = [];
+        const skipped = [];
+        const ids = dirtyChanges.map((dc) => dc._id);
+        const fullItems = await this.dexieDb.getByIds(
+          collectionName,
+          ids
+        );
+        const orphanReconstructed = [];
+        for (let i = 0; i < fullItems.length; i++) {
+          const fullItem = fullItems[i];
+          const id = ids[i];
+          if (fullItem) {
+            const delta = dirtyChangesMap.get(String(fullItem._id));
+            if (delta) {
+              const currentServerRev = typeof fullItem._rev === "number" ? fullItem._rev : void 0;
+              updates.push({ _id: fullItem._id, delta, currentServerRev });
+            } else {
+              skipped.push({
+                _id: String(fullItem._id),
+                reason: "no-delta-for-fullitem"
+              });
+            }
+          } else if (id != null) {
+            const delta = dirtyChangesMap.get(String(id));
+            if (delta) {
+              const reconstructed = __spreadProps(__spreadValues({}, delta), { _id: id });
+              orphanReconstructed.push(reconstructed);
+              updates.push({ _id: id, delta });
+            } else {
+              skipped.push({ _id: String(id), reason: "no-delta-for-orphan" });
+            }
           } else {
-            skipped.push({
-              _id: String(fullItem._id),
-              reason: "no-delta-for-fullitem"
-            });
+            skipped.push({ _id: "<null>", reason: "no-fullitem-no-id" });
           }
-        } else if (id != null) {
-          const delta = dirtyChangesMap.get(String(id));
-          if (delta) {
-            const reconstructed = __spreadProps(__spreadValues({}, delta), { _id: id });
-            orphanReconstructed.push(reconstructed);
-            updates.push({ _id: id, delta });
-          } else {
-            skipped.push({ _id: String(id), reason: "no-delta-for-orphan" });
+        }
+        if (orphanReconstructed.length > 0) {
+          await this.dexieDb.saveMany(collectionName, orphanReconstructed);
+        }
+        if (updates.length === 0) {
+          console.warn(
+            `[SyncEngine] uploadDirtyItems: ${collectionName} has`,
+            dirtyChanges.length,
+            "dirty entries but 0 resolvable items",
+            skipped
+          );
+          if (this.callbacks.onUploadSkip) {
+            try {
+              this.callbacks.onUploadSkip({
+                collection: collectionName,
+                reason: "no-resolvable-items",
+                dirtyCount: dirtyChanges.length,
+                skippedIds: skipped.slice(0, 20).map((s) => s._id),
+                skipReasons: skipped.slice(0, 20),
+                calledFrom,
+                timestamp: /* @__PURE__ */ new Date()
+              });
+            } catch (err) {
+              console.error(
+                `[SyncEngine] onUploadSkip callback failed: ${err}`,
+                err
+              );
+            }
           }
-        } else {
-          skipped.push({ _id: "<null>", reason: "no-fullitem-no-id" });
+          continue;
         }
-      }
-      if (orphanReconstructed.length > 0) {
-        await this.dexieDb.saveMany(collectionName, orphanReconstructed);
-      }
-      if (updates.length === 0) {
-        console.warn(
-          `[SyncEngine] uploadDirtyItems: ${collectionName} has`,
-          dirtyChanges.length,
-          "dirty entries but 0 resolvable items",
-          skipped
-        );
-        if (this.callbacks.onUploadSkip) {
+        if (skipped.length > 0 && this.callbacks.onUploadSkip) {
           try {
             this.callbacks.onUploadSkip({
               collection: collectionName,
@@ -3599,86 +3619,75 @@ var _SyncEngine = class _SyncEngine {
             );
           }
         }
-        continue;
-      }
-      if (skipped.length > 0 && this.callbacks.onUploadSkip) {
-        try {
-          this.callbacks.onUploadSkip({
-            collection: collectionName,
-            reason: "no-resolvable-items",
-            dirtyCount: dirtyChanges.length,
-            skippedIds: skipped.slice(0, 20).map((s) => s._id),
-            skipReasons: skipped.slice(0, 20),
-            calledFrom,
-            timestamp: /* @__PURE__ */ new Date()
-          });
-        } catch (err) {
-          console.error(
-            `[SyncEngine] onUploadSkip callback failed: ${err}`,
-            err
+        const mappedUpdates = [];
+        const preprocessSkippedIds = [];
+        for (const item of updates) {
+          const dirtyBaseRev = typeof item.delta._rev === "number" ? item.delta._rev : void 0;
+          const stripped = stripServerManagedFromChanges(
+            item.delta
           );
-        }
-      }
-      const mappedUpdates = [];
-      const preprocessSkippedIds = [];
-      for (const item of updates) {
-        const dirtyBaseRev = typeof item.delta._rev === "number" ? item.delta._rev : void 0;
-        const stripped = stripServerManagedFromChanges(
-          item.delta
-        );
-        const fixed = fixDotnetArrays(
-          stripped,
-          item.currentServerRev,
-          dirtyBaseRev
-        );
-        let candidate = {
-          _id: item._id,
-          update: fixed
-        };
-        if (this.preprocessDirtyItem) {
-          try {
-            const processed = this.preprocessDirtyItem(
-              candidate,
-              collectionName
-            );
-            if (processed === void 0) {
+          const fixed = fixDotnetArrays(
+            stripped,
+            item.currentServerRev,
+            dirtyBaseRev
+          );
+          let candidate = {
+            _id: item._id,
+            update: fixed
+          };
+          if (this.preprocessDirtyItem) {
+            try {
+              const processed = this.preprocessDirtyItem(
+                candidate,
+                collectionName
+              );
+              if (processed === void 0) {
+                preprocessSkippedIds.push(item._id);
+                continue;
+              }
+              candidate = processed;
+            } catch (err) {
+              console.error(
+                `[SyncEngine] preprocessDirtyItem(${collectionName}) failed for _id=${String(item._id)}; keeping dirty for retry:`,
+                err
+              );
               preprocessSkippedIds.push(item._id);
               continue;
             }
-            candidate = processed;
-          } catch (err) {
-            console.error(
-              `[SyncEngine] preprocessDirtyItem(${collectionName}) failed for _id=${String(item._id)}; keeping dirty for retry:`,
-              err
-            );
-            preprocessSkippedIds.push(item._id);
-            continue;
           }
+          mappedUpdates.push({
+            _id: candidate._id,
+            _rev: dirtyBaseRev != null ? dirtyBaseRev : 0,
+            update: candidate.update
+          });
         }
-        mappedUpdates.push({
-          _id: candidate._id,
-          _rev: dirtyBaseRev != null ? dirtyBaseRev : 0,
-          update: candidate.update
-        });
-      }
-      if (preprocessSkippedIds.length > 0) {
-        const newlyStuck = await this.dexieDb.incrementDirtyUploadAttempts(
-          collectionName,
-          preprocessSkippedIds
+        if (preprocessSkippedIds.length > 0) {
+          const newlyStuck = await this.dexieDb.incrementDirtyUploadAttempts(
+            collectionName,
+            preprocessSkippedIds
+          );
+          await this.callOnDirtyItemStuck(
+            collectionName,
+            newlyStuck,
+            calledFrom
+          );
+        }
+        if (mappedUpdates.length === 0) continue;
+        collectionBatches.push([
+          {
+            collection: collectionName,
+            batch: {
+              updates: mappedUpdates,
+              deletes: []
+            }
+          }
+        ]);
+      } catch (err) {
+        console.error(
+          `[SyncEngine] uploadDirtyItems: failed for collection "${collectionName}":`,
+          err
         );
-        this.callOnDirtyItemStuck(collectionName, newlyStuck, calledFrom);
       }
-      if (mappedUpdates.length === 0) continue;
-      collectionBatches.push([
-        {
-          collection: collectionName,
-          batch: {
-            updates: mappedUpdates,
-            deletes: []
-          }
-        }
-      ]);
-    }
     if (collectionBatches.length === 0) {
       return { sentCount: 0 };
     }
@@ -3719,7 +3728,7 @@ var _SyncEngine = class _SyncEngine {
             b.collection,
             allIds
           );
-          this.callOnDirtyItemStuck(b.collection, newlyStuck, calledFrom);
+          await this.callOnDirtyItemStuck(b.collection, newlyStuck, calledFrom);
         }
       }
       throw err;
@@ -3798,7 +3807,7 @@ var _SyncEngine = class _SyncEngine {
           collection,
           retainedIds
         );
-        this.callOnDirtyItemStuck(collection, newlyStuck, calledFrom);
+        await this.callOnDirtyItemStuck(collection, newlyStuck, calledFrom);
       }
       let collectionSentCount = 0;
       const isWriteOnly = (_b = this.collections.get(collection)) == null ? void 0 : _b.writeOnly;
@@ -4343,12 +4352,18 @@ var _SyncEngine = class _SyncEngine {
       }
     }
   }
-  callOnDirtyItemStuck(collection, stuckMetas, calledFrom) {
+  async callOnDirtyItemStuck(collection, stuckMetas, calledFrom) {
     if (!this.callbacks.onDirtyItemStuck || stuckMetas.length === 0) return;
     try {
+      const ids = stuckMetas.map(
+        (m) => m.id
+      );
+      const fullMap = await this.dexieDb.getDirtyChangesBatch(collection, ids);
+      const itemsContent = stuckMetas.map((m) => fullMap.get(String(m.id))).filter(Boolean);
       this.callbacks.onDirtyItemStuck({
         collection,
         items: stuckMetas,
+        itemsContent,
         calledFrom,
         timestamp: /* @__PURE__ */ new Date()
       });

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

@@ -12,7 +12,6 @@ import type { I_SyncEngine, SyncEngineConfig, SyncExtras } from "../types/manage
 import type { UploadResult } from "../types/internal";
 export declare class SyncEngine implements I_SyncEngine {
     private readonly tenant;
-    private readonly updaterId;
     private readonly collections;
     private readonly dexieDb;
     private readonly restInterface;

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

@@ -1,7 +1,7 @@
 import type { AggregateOptions } from "mongodb";
 import type { Id, DbEntity, LocalDbEntity } from "./DbEntity";
 import type { QuerySpec, QueryOpts, UpdateSpec, InsertSpec, BatchSpec, I_RestInterface, CollectionUpdateRequest, CollectionUpdateResult, GetNewerSpec } from "./I_RestInterface";
-import type { DirtyMeta, I_DexieDb } from "./I_DexieDb";
+import type { DirtyMeta, DirtyChange, I_DexieDb } from "./I_DexieDb";
 import type { I_InMemDb } from "./I_InMemDb";
 import type { I_ServerUpdateNotifier } from "./I_ServerUpdateNotifier";
 import type { WakeSyncInfo, NetworkStatusChangeInfo } from "../db/types/managers";
@@ -101,6 +101,11 @@ export interface DirtyItemStuckInfo {
     collection: string;
     /** Meta podatki stuck itemov (vsebujejo `stuckSince`, `numUploadAttempts`, itd.) */
     items: import("./I_DexieDb").DirtyMeta[];
+    /**
+     * Polni DirtyChange entry-ji (vključno s `changes` payload-om) za stuck iteme.
+     * Vsebuje dejanske spremenjene field-e, ne samo metapodatke.
+     */
+    itemsContent: DirtyChange[];
     /** Optional caller tag */
     calledFrom?: string;
     /** Timestamp when stuck was detected */

package/package.json

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