cry-synced-db-client 0.1.184 → 0.1.185

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # 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

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,12 +6648,46 @@ 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
    * missing array containers AND missing intermediate plain objects so the
@@ -6905,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}`);
@@ -7074,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);
@@ -7104,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,6 +519,19 @@ 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
      * missing array containers AND missing intermediate plain objects so the

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