cry-synced-db-client 0.1.183 → 0.1.185

package/CHANGELOG.md

@@ -1,5 +1,123 @@
 # Versions
 
+## 0.1.185 (2026-05-14)
+
+### Fix: server-wins rebase resolves dirty-merge path conflicts (`sestevki`)
+
+Production bug (klikvet, 2026-05-14): obisk records stuck dirty with
+repeated upload errors —
+
+```
+[SyncEngine] Sync upload error [obiski] _id=…:
+  Updating the path 'sestevki.skupaj.prc' would create a conflict at 'sestevki'
+```
+
+Reproduction sequence (see `test/sestevkiPathConflict.test.ts`):
+
+1. Local record exists; `sestevki` is missing.
+2. App writes a partial `sestevki = {kritje: {…}}`. `computeDiff` emits
+   a single full-replace key; dirty entry stores
+   `changes = {sestevki: {kritje}}` at `baseRev = 1`.
+3. WS-push of a server-side update lands `sestevki.skupaj = {…}` into
+   the Dexie row and bumps `_rev` to `2`. The dirty entry's
+   accumulated `sestevki` value is NOT touched.
+4. App writes `sestevki.skupaj.prc = 50`. `computeDiff` against the
+   advanced Dexie row emits a deep dot-path. `mergeDirtyPath`'s
+   Case 1 (`setByPath` into the accumulated parent) fails on the
+   missing intermediate `skupaj` and falls through to Case 3, which
+   writes the deep path as a SIBLING key alongside the parent. The
+   dirty payload now carries BOTH `sestevki = {…}` AND
+   `sestevki.skupaj.prc = 50` — mongo `$set` refuses every retry.
+
+**Rule** (per user directive): for any given path, when the server's
+`_rev` is greater than the local `_rev` the path was emitted against,
+**the server wins** — drop the locally-accumulated path. `baseMeta`
+passed into `addDirtyChange*` is sampled from the live Dexie row by
+`save`, so `baseMeta._rev > entry.baseRev` is the trigger.
+
+Surgical scope: only existing paths that OVERLAP with an incoming path
+(equal / ancestor / descendant) are dropped. Unrelated accumulated
+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`.
+- `test/mocks/MockDexieDb.ts` — same logic so the bun-test suite
+  exercises the same merge semantics (the mock previously used shallow
+  spread `{...existing.changes, ...changes}` and masked this bug).
+- `src/utils/computeDiff.ts` — new exported `pathsOverlap(a, b)` helper.
+
+### Fix: `applyDiffLocally` materializes plain dot-path intermediates
+
+Companion fix: even with the dirty merge cleaned up, the second save's
+deep dot-path `sestevki.skupaj.prc` still needs to land in the local
+in-mem snapshot. The seed (cloned from `currentMem ?? existing`) may
+be missing the `skupaj` intermediate (in-mem wasn't touched by the
+external WS-push). Previously `setByPath` failed → fell to
+`materializeBracketPath` → dropped with `no bracket segment found`.
+
+New `materializePlainDotPath` private helper walks a dot-only path,
+auto-creates plain-object intermediates, and lands the value:
+
+| Shape | Result |
+|---|---|
+| `a.b.c = v` with seed missing `b` and `c` | `seed.a = {b: {c: v}}` |
+| Existing intermediate is not a plain object (Date, primitive, array) | Refuses (false), falls through |
+| Path contains numeric or bracket segment | Refuses (false), falls through to `materializeBracketPath` |
+
+Called between `setByPath` and `materializeBracketPath` in
+`applyDiffLocally`. Bracket-containing paths still take the existing
+bracket-fallback path.
+
+## 0.1.184 (2026-05-14)
+
+### Fix: `applyDiffLocally` supports multi-segment plain prefix before bracket-by-id
+
+The materialization fallback used to require the bracket-by-id to live
+at token position [1] — anything deeper failed the
+`secondToken.startsWith("[")` check and dropped with
+`second segment is not a bracket-by-id`. Diff paths like
+`outer.field[<id>]` or `a.b.c.arr[<id>].deep` fell through this gap;
+the data was silently lost locally (visible drop unless the first
+segment started with `_`).
+
+Now any plain dot-notation prefix before a single bracket-by-id is
+materialized:
+
+```
+plain1.plain2…plainN[<id>][.subA.subB…]  →  materialize
+```
+
+| Shape | Result |
+|---|---|
+| `outer.arr[<newId>] = <obj>` | `seed.outer = {arr: [<obj>]}` |
+| `outer.arr[<newId>].field = v` | `seed.outer = {arr: [{_id: <newId>, field: v}]}` |
+| `a.b.c.arr[<id>].seg1.seg2 = v` | `seed.a = {b: {c: {arr: [{_id, seg1: {seg2: v}}]}}}` |
+| Matching `_id` exists, intermediate missing | Walk into element, create missing intermediates, set leaf. No duplicate element. |
+| Existing intermediate is not a plain object (Date, primitive, array) | Drop visibly — refuse to overwrite. |
+
+**Still drops**: multi-bracket paths (`outer[a].sub[b]`,
+`outer.a.sub[i].nested[j]`) — these need shape knowledge the fallback
+can't reconstruct; server applies the path and next sync hydrates the
+canonical state.
+
+**Backward-compat for `_`-mirrored roots**: paths under `_redundanca`,
+`_dobavnica_saved`, etc. that extend beyond the originally-supported
+single-segment-prefix shape (e.g. `_redundanca.terapije[<id>]`) still
+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
+  `a.b[<id>]` case from "drops with diagnostic log" to
+  "materializes `{a: {b: [<el>]}}`".
+
+Full suite: 767 bun + 18 vitest pass.
+
 ## 0.1.183 (2026-05-14)
 
 ### Fix: `applyDiffLocally` materializes deep sub-field paths under bracket-by-id

package/dist/index.js

@@ -488,6 +488,9 @@ function isDescendantOrEqual(path, candidate) {
   const next = path[candidate.length];
   return next === "." || next === "[";
 }
+function pathsOverlap(a, b) {
+  return isDescendantOrEqual(a, b) || isDescendantOrEqual(b, a);
+}
 function tokenizePath(path) {
   const out = [];
   let buf = "";
@@ -6645,33 +6648,80 @@ var _SyncedDb = class _SyncedDb {
         continue;
       }
       const ok = setByPath(seed, path, value);
-      if (!ok) {
-        _SyncedDb.materializeBracketPath(seed, path, value, collection, fallbackId);
+      if (ok) continue;
+      if (!path.includes("[") && _SyncedDb.materializePlainDotPath(seed, path, value)) {
+        continue;
       }
+      _SyncedDb.materializeBracketPath(seed, path, value, collection, fallbackId);
     }
     return seed;
   }
+  /**
+   * Bracket-free dot-path fallback for `applyDiffLocally`. Walks the path,
+   * creating missing plain-object intermediates as needed, and sets the
+   * leaf. Refuses (returns `false`) if any segment is numeric (array
+   * index) or `[<id>]` (bracket selector) — those need shape knowledge
+   * outside the scope of plain-object materialization. Also refuses if
+   * an existing intermediate is non-plain (array, Date, primitive) —
+   * overwriting would risk silent data loss.
+   *
+   * Used after `setByPath` fails on a dot-only path (no `[` in `path`).
+   * Counterpart to `materializeBracketPath` for the bracket case.
+   */
+  static materializePlainDotPath(seed, path, value) {
+    const parts = tokenizePath(path);
+    if (parts.length < 2) return false;
+    for (const seg of parts) {
+      if (seg.startsWith("[") || /^\d+$/.test(seg)) return false;
+    }
+    let cur = seed;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const seg = parts[i];
+      const next = cur[seg];
+      if (next == null) {
+        cur[seg] = {};
+      } else if (typeof next !== "object" || Array.isArray(next) || next instanceof Date) {
+        return false;
+      }
+      cur = cur[seg];
+    }
+    cur[parts[parts.length - 1]] = value;
+    return true;
+  }
   /**
    * Fallback for `setByPath` failures inside `applyDiffLocally`. Materializes
-   * the parent array when it's missing from `seed`, OR fills in missing
-   * intermediate objects under an existing array element when the diff
-   * path reaches deeper than the element currently holds.
+   * missing array containers AND missing intermediate plain objects so the
+   * diff entry can land locally instead of being dropped.
+   *
+   * Supported path shape (tokenizes to `[…plain prefix, [<id>], …plain suffix]`):
+   *
+   *   • Single-segment prefix:
+   *     - `polje[<id>] = <obj>`           →  seed.polje = [<obj>]
+   *     - `polje[<id>].field = <v>`       →  seed.polje = [{_id, field: <v>}]
+   *     - `polje[<id>].a.b.c = <v>`       →  seed.polje = [{_id, a: {b: {c: <v>}}}]
+   *
+   *   • Multi-segment plain prefix:
+   *     - `outer.polje[<id>] = <obj>`              →  seed.outer = {polje: [<obj>]}
+   *     - `outer.inner.polje[<id>].field = <v>`    →  seed.outer = {inner: {polje: [{_id, field: <v>}]}}
    *
-   * Supported shapes (path tokenizes to `[firstField, [<id>], …rest]`):
+   *   • Existing matching `_id` on the target array: walk into the element
+   *     and create missing intermediates on the way down; set the leaf
+   *     without pushing a duplicate element.
    *
-   *   1. `polje[<id>] = <obj>`                          →  seed.polje = [<obj>]
-   *   2. `polje[<id>].field = <v>`                      →  seed.polje = [{_id: <id>, field: <v>}]
-   *   3. `polje[<id>].a.b = <v>`                        →  seed.polje = [{_id: <id>, a: {b: <v>}}]
-   *   4. `polje[<id>].a.b.c.d = <v>`                    →  seed.polje = [{_id: <id>, a: {b: {c: {d: <v>}}}}]
-   *   5. Existing element with `_id` matches `<id>` but missing intermediate
-   *      → walk down the element, create missing intermediate plain objects,
-   *        set the leaf. No duplicate element pushed.
+   * Dropped:
+   *   • Multi-bracket paths (e.g. `polje[a].sub[b]`, `outer[a].sub.inner[b]`)
+   *     — require shape knowledge the fallback can't reconstruct. Server
+   *     applies the path; next sync hydrates the canonical state locally.
+   *   • Existing intermediate that is a non-plain value (Date, primitive,
+   *     array where an object is expected).
    *
-   * Dropped (multi-bracket / nested-via-dots-before-bracket / non-plain
-   * intermediates) — materializing those locally would risk corrupting
-   * unrelated invariants on the nested objects. Dirty-change still
-   * carries the path, so the server applies it; next sync brings the
-   * canonical state back to local.
+   * `_`-prefixed first segment (e.g. `_redundanca…`): for shapes that
+   * extend BEYOND the originally-supported single-segment prefix, the
+   * drop is **silent** and unconditional — these fields are server-
+   * mirrored and local materialization could create state that diverges
+   * from the canonical server form. Simple single-segment shapes
+   * (`_field[<id>]`, `_field[<id>].sub`, `_field[<id>].sub.deep…`) still
+   * materialize as before.
    *
    * Replaces the pre-fix blind `seed[path] = value` fallback that stamped
    * literal bracket-keyed top-level properties (e.g. `"postavke[<id>]": [<el>]`)
@@ -6697,28 +6747,59 @@ var _SyncedDb = class _SyncedDb {
       drop("first segment is not a plain field");
       return;
     }
-    const secondToken = tokens[1];
-    if (!secondToken.startsWith("[") || !secondToken.endsWith("]")) {
-      drop("second segment is not a bracket-by-id");
+    let bracketIdx = -1;
+    for (let i = 1; i < tokens.length; i++) {
+      if (tokens[i].startsWith("[")) {
+        bracketIdx = i;
+        break;
+      }
+    }
+    if (bracketIdx < 0) {
+      drop("no bracket segment found");
       return;
     }
-    for (let i = 2; i < tokens.length; i++) {
+    for (let i = bracketIdx + 1; i < tokens.length; i++) {
       if (tokens[i].startsWith("[")) {
         drop("nested bracket path");
         return;
       }
     }
-    const bracketId = secondToken.slice(1, -1);
+    if (dropSilently && bracketIdx > 1) {
+      return;
+    }
+    const prefixTokens = tokens.slice(0, bracketIdx);
+    const bracketToken = tokens[bracketIdx];
+    const suffixTokens = tokens.slice(bracketIdx + 1);
+    const bracketId = bracketToken.slice(1, -1);
     if (bracketId.length === 0) {
       drop("empty bracket id");
       return;
     }
-    const existing = seed[firstToken];
-    if (existing != null && !Array.isArray(existing)) {
-      drop(`existing "${firstToken}" is not an array`);
+    let parent = seed;
+    for (let i = 0; i < prefixTokens.length - 1; i++) {
+      const seg = prefixTokens[i];
+      const cur = parent[seg];
+      if (cur === void 0 || cur === null) {
+        parent[seg] = {};
+      } else if (typeof cur !== "object" || Array.isArray(cur) || cur instanceof Date) {
+        drop(
+          `existing intermediate "${prefixTokens.slice(0, i + 1).join(".")}" is not a plain object`
+        );
+        return;
+      }
+      parent = parent[seg];
+    }
+    const lastPrefixSeg = prefixTokens[prefixTokens.length - 1];
+    let arr = parent[lastPrefixSeg];
+    if (arr != null && !Array.isArray(arr)) {
+      drop(`existing "${prefixTokens.join(".")}" is not an array`);
       return;
     }
-    if (tokens.length === 2) {
+    if (arr == null) {
+      arr = [];
+      parent[lastPrefixSeg] = arr;
+    }
+    if (suffixTokens.length === 0) {
       let element = value;
       if (Array.isArray(value) && value.length === 1 && value[0] != null && typeof value[0] === "object") {
         element = value[0];
@@ -6730,14 +6811,16 @@ var _SyncedDb = class _SyncedDb {
       if (element._id == null) {
         element._id = bracketId;
       }
-      if (existing == null) {
-        seed[firstToken] = [element];
+      const replaceIdx = arr.findIndex(
+        (it) => it != null && typeof it === "object" && String(it._id) === bracketId
+      );
+      if (replaceIdx >= 0) {
+        arr[replaceIdx] = element;
       } else {
-        existing.push(element);
+        arr.push(element);
       }
       return;
     }
-    const subFieldPath = tokens.slice(2);
     const buildNestedSubTree = (segs, leaf) => {
       let acc = leaf;
       for (let i = segs.length - 1; i >= 0; i--) {
@@ -6745,28 +6828,23 @@ var _SyncedDb = class _SyncedDb {
       }
       return acc;
     };
-    if (existing == null) {
-      const subTree = buildNestedSubTree(subFieldPath, value);
-      seed[firstToken] = [__spreadValues({ _id: bracketId }, subTree)];
-      return;
-    }
-    const existingIdx = existing.findIndex(
+    const existingIdx = arr.findIndex(
       (it) => it != null && typeof it === "object" && String(it._id) === bracketId
     );
     if (existingIdx >= 0) {
-      let cur = existing[existingIdx];
-      for (let i = 0; i < subFieldPath.length - 1; i++) {
-        const seg = subFieldPath[i];
+      let cur = arr[existingIdx];
+      for (let i = 0; i < suffixTokens.length - 1; i++) {
+        const seg = suffixTokens[i];
         const next = cur[seg];
         if (next == null || typeof next !== "object" || Array.isArray(next)) {
           cur[seg] = {};
         }
         cur = cur[seg];
       }
-      cur[subFieldPath[subFieldPath.length - 1]] = value;
+      cur[suffixTokens[suffixTokens.length - 1]] = value;
     } else {
-      const subTree = buildNestedSubTree(subFieldPath, value);
-      existing.push(__spreadValues({ _id: bracketId }, subTree));
+      const subTree = buildNestedSubTree(suffixTokens, value);
+      arr.push(__spreadValues({ _id: bracketId }, subTree));
     }
   }
   /**
@@ -6864,6 +6942,22 @@ function isMetaOnlyChanges(changes) {
   }
   return true;
 }
+function rebaseDirtyOnServerAdvance(entry, newChanges, baseMeta) {
+  const newRev = baseMeta == null ? void 0 : baseMeta._rev;
+  if (typeof newRev !== "number" || typeof entry.baseRev !== "number" || newRev <= entry.baseRev) {
+    return;
+  }
+  const existingPaths = Object.keys(entry.changes);
+  for (const newPath of Object.keys(newChanges)) {
+    for (const existingPath of existingPaths) {
+      if (pathsOverlap(newPath, existingPath)) {
+        delete entry.changes[existingPath];
+      }
+    }
+  }
+  entry.baseTs = baseMeta._ts;
+  entry.baseRev = newRev;
+}
 var DexieDb = class extends Dexie {
   constructor(tenant, collectionConfigs) {
     super(`synced-db-${tenant}`);
@@ -7033,6 +7127,7 @@ var DexieDb = class extends Dexie {
     const existing = await this.dirtyChanges.get([collection, stringId]);
     const now = Date.now();
     if (existing) {
+      rebaseDirtyOnServerAdvance(existing, changes, baseMeta);
       mergeDirtyChanges(existing.changes, changes);
       existing.updatedAt = now;
       await this.dirtyChanges.put(existing);
@@ -7063,6 +7158,7 @@ var DexieDb = class extends Dexie {
       const stringId = this.idToString(changeItem.id);
       const existing = existingEntries[i];
       if (existing) {
+        rebaseDirtyOnServerAdvance(existing, changeItem.changes, changeItem.baseMeta);
         mergeDirtyChanges(existing.changes, changeItem.changes);
         existing.updatedAt = now;
         toWrite.push(existing);

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

@@ -519,27 +519,53 @@ export declare class SyncedDb implements I_SyncedDb {
      * the input `base` reference.
      */
     private static applyDiffLocally;
+    /**
+     * Bracket-free dot-path fallback for `applyDiffLocally`. Walks the path,
+     * creating missing plain-object intermediates as needed, and sets the
+     * leaf. Refuses (returns `false`) if any segment is numeric (array
+     * index) or `[<id>]` (bracket selector) — those need shape knowledge
+     * outside the scope of plain-object materialization. Also refuses if
+     * an existing intermediate is non-plain (array, Date, primitive) —
+     * overwriting would risk silent data loss.
+     *
+     * Used after `setByPath` fails on a dot-only path (no `[` in `path`).
+     * Counterpart to `materializeBracketPath` for the bracket case.
+     */
+    private static materializePlainDotPath;
     /**
      * Fallback for `setByPath` failures inside `applyDiffLocally`. Materializes
-     * the parent array when it's missing from `seed`, OR fills in missing
-     * intermediate objects under an existing array element when the diff
-     * path reaches deeper than the element currently holds.
-     *
-     * Supported shapes (path tokenizes to `[firstField, [<id>], …rest]`):
-     *
-     *   1. `polje[<id>] = <obj>`                          →  seed.polje = [<obj>]
-     *   2. `polje[<id>].field = <v>`                      →  seed.polje = [{_id: <id>, field: <v>}]
-     *   3. `polje[<id>].a.b = <v>`                        →  seed.polje = [{_id: <id>, a: {b: <v>}}]
-     *   4. `polje[<id>].a.b.c.d = <v>`                    →  seed.polje = [{_id: <id>, a: {b: {c: {d: <v>}}}}]
-     *   5. Existing element with `_id` matches `<id>` but missing intermediate
-     *      → walk down the element, create missing intermediate plain objects,
-     *        set the leaf. No duplicate element pushed.
-     *
-     * Dropped (multi-bracket / nested-via-dots-before-bracket / non-plain
-     * intermediates) — materializing those locally would risk corrupting
-     * unrelated invariants on the nested objects. Dirty-change still
-     * carries the path, so the server applies it; next sync brings the
-     * canonical state back to local.
+     * missing array containers AND missing intermediate plain objects so the
+     * diff entry can land locally instead of being dropped.
+     *
+     * Supported path shape (tokenizes to `[…plain prefix, [<id>], …plain suffix]`):
+     *
+     *   • Single-segment prefix:
+     *     - `polje[<id>] = <obj>`           →  seed.polje = [<obj>]
+     *     - `polje[<id>].field = <v>`       →  seed.polje = [{_id, field: <v>}]
+     *     - `polje[<id>].a.b.c = <v>`       →  seed.polje = [{_id, a: {b: {c: <v>}}}]
+     *
+     *   • Multi-segment plain prefix:
+     *     - `outer.polje[<id>] = <obj>`              →  seed.outer = {polje: [<obj>]}
+     *     - `outer.inner.polje[<id>].field = <v>`    →  seed.outer = {inner: {polje: [{_id, field: <v>}]}}
+     *
+     *   • Existing matching `_id` on the target array: walk into the element
+     *     and create missing intermediates on the way down; set the leaf
+     *     without pushing a duplicate element.
+     *
+     * Dropped:
+     *   • Multi-bracket paths (e.g. `polje[a].sub[b]`, `outer[a].sub.inner[b]`)
+     *     — require shape knowledge the fallback can't reconstruct. Server
+     *     applies the path; next sync hydrates the canonical state locally.
+     *   • Existing intermediate that is a non-plain value (Date, primitive,
+     *     array where an object is expected).
+     *
+     * `_`-prefixed first segment (e.g. `_redundanca…`): for shapes that
+     * extend BEYOND the originally-supported single-segment prefix, the
+     * drop is **silent** and unconditional — these fields are server-
+     * mirrored and local materialization could create state that diverges
+     * from the canonical server form. Simple single-segment shapes
+     * (`_field[<id>]`, `_field[<id>].sub`, `_field[<id>].sub.deep…`) still
+     * materialize as before.
      *
      * Replaces the pre-fix blind `seed[path] = value` fallback that stamped
      * literal bracket-keyed top-level properties (e.g. `"postavke[<id>]": [<el>]`)

package/dist/src/utils/computeDiff.d.ts

@@ -32,6 +32,14 @@ export declare function computeDiff(existing: Record<string, any> | null | undef
  * to legacy Object.assign accumulation.
  */
 export declare function hasDotNotationPaths(changes: Record<string, any>): boolean;
+/**
+ * Symmetric overlap check used by dirty-merge rebase: paths overlap when
+ * they are equal OR one is an ancestor of the other. Returning `true`
+ * means a single mongo `$set` containing both would be rejected with a
+ * "Updating the path X would create a conflict at Y" — or at minimum the
+ * two writes target the same subtree.
+ */
+export declare function pathsOverlap(a: string, b: string): boolean;
 /**
  * Tokenize a dot-notation path that may contain bracket-id segments.
  *

package/package.json

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