cry-synced-db-client 0.1.182 → 0.1.184

package/CHANGELOG.md

@@ -1,5 +1,95 @@
 # Versions
 
+## 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
+
+`materializeBracketPath` (the fallback when `setByPath` can't reach the
+target) capped at `tokens.length ≤ 3`. Any deeper path was dropped with
+a `dropping bracket-path diff entry (unsupported token count N)` log
+(silent when first segment started with `_`, visible otherwise).
+
+Real-world obisk records carry nested objects on every `zaracunaj`
+element — `karence.karence.meso`, `uporabljeneSerijskeNaNapravi.serijske`,
+etc. Saves like
+
+```typescript
+syncedDb.save("obiski", id, {
+  "zaracunaj[<newId>].karence.karence.meso": 5,
+});
+```
+
+dropped the data even though the intent is unambiguous and the data
+shape is valid.
+
+**New behavior** in `materializeBracketPath`:
+
+| Shape | Result |
+|---|---|
+| `polje[<id>] = <obj>` | `seed.polje = [<obj>]` (unchanged) |
+| `polje[<id>].field = v` | `seed.polje = [{_id: <id>, field: v}]` (unchanged) |
+| `polje[<id>].a.b.c = v` (new) | `seed.polje = [{_id: <id>, a: {b: {c: v}}}]` |
+| Matching `_id` exists, intermediate missing (new) | Walk into the element, create missing intermediates on the way down, set the leaf. No duplicate element. |
+
+Multi-bracket paths (e.g. `polje[a].sub[b]`, `polje[a].b.sub[c]`) still
+drop — they require shape knowledge the fallback can't reconstruct;
+server applies them and the next sync hydrates local.
+
+Tests: `test/applyDiffLocallyObiskShape.test.ts` (18 cases) — uses a
+trimmed real-shape obisk fixture with the two _id-arrays (top-level
+`zaracunaj` and `_dobavnica_saved.postavke` nested under a plain
+container), all the composition-change scenarios, the deep-bracket-path
+edge cases that used to drop, and a "no drop-log during typical
+roundtrip" guard. 3 cases were red before the fix; all pass after.
+Full suite: 762 bun + 18 vitest pass.
+
 ## 0.1.182 (2026-05-14)
 
 ### `networkError` utility — quiet log noise during sustained offline

package/dist/index.js

@@ -6653,19 +6653,38 @@ var _SyncedDb = class _SyncedDb {
   }
   /**
    * Fallback for `setByPath` failures inside `applyDiffLocally`. Materializes
-   * the parent array when it's missing from `seed`. Two patterns covered, per
-   * production-spec (mozirje 2026-05-10 — literal bracket-keyed sibling
-   * properties polluting Dexie/in-mem):
+   * missing array containers AND missing intermediate plain objects so the
+   * diff entry can land locally instead of being dropped.
    *
-   *   1. `polje[<id>] = <obj>`         →  seed.polje = [<obj>]
-   *   2. `polje[<id>].<field> = <v>`   →  seed.polje = [{_id: <id>, <field>: <v>}]
+   * Supported path shape (tokenizes to `[…plain prefix, [<id>], …plain suffix]`):
    *
-   * Everything else (nested-via-dots before bracket, multi-bracket paths
-   * like `_redundanca.terapije[<id>].postavke[<id2>]`, deeper sub-fields)
-   * is dropped silently — materializing those locally would risk corrupting
-   * unrelated invariants on the nested objects. Dirty-change still carries
-   * the path, so server applies it; next sync brings the canonical state
-   * back to local.
+   *   • 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>]`)
@@ -6683,7 +6702,7 @@ var _SyncedDb = class _SyncedDb {
         { collection, _id: String(id), path, value }
       );
     };
-    if (tokens.length < 2 || tokens.length > 3) {
+    if (tokens.length < 2) {
       drop(`unsupported token count ${tokens.length}`);
       return;
     }
@@ -6691,26 +6710,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;
     }
-    if (tokens.length === 3 && tokens[2].startsWith("[")) {
-      drop("nested bracket path");
+    for (let i = bracketIdx + 1; i < tokens.length; i++) {
+      if (tokens[i].startsWith("[")) {
+        drop("nested bracket path");
+        return;
+      }
+    }
+    if (dropSilently && bracketIdx > 1) {
       return;
     }
-    const bracketId = secondToken.slice(1, -1);
+    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];
@@ -6722,19 +6774,40 @@ 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 fieldName = tokens[2];
-    const newElement = { _id: bracketId, [fieldName]: value };
-    if (existing == null) {
-      seed[firstToken] = [newElement];
+    const buildNestedSubTree = (segs, leaf) => {
+      let acc = leaf;
+      for (let i = segs.length - 1; i >= 0; i--) {
+        acc = { [segs[i]]: acc };
+      }
+      return acc;
+    };
+    const existingIdx = arr.findIndex(
+      (it) => it != null && typeof it === "object" && String(it._id) === bracketId
+    );
+    if (existingIdx >= 0) {
+      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[suffixTokens[suffixTokens.length - 1]] = value;
     } else {
-      existing.push(newElement);
+      const subTree = buildNestedSubTree(suffixTokens, value);
+      arr.push(__spreadValues({ _id: bracketId }, subTree));
     }
   }
   /**

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

@@ -521,19 +521,38 @@ export declare class SyncedDb implements I_SyncedDb {
     private static applyDiffLocally;
     /**
      * Fallback for `setByPath` failures inside `applyDiffLocally`. Materializes
-     * the parent array when it's missing from `seed`. Two patterns covered, per
-     * production-spec (mozirje 2026-05-10 — literal bracket-keyed sibling
-     * properties polluting Dexie/in-mem):
-     *
-     *   1. `polje[<id>] = <obj>`         →  seed.polje = [<obj>]
-     *   2. `polje[<id>].<field> = <v>`   →  seed.polje = [{_id: <id>, <field>: <v>}]
-     *
-     * Everything else (nested-via-dots before bracket, multi-bracket paths
-     * like `_redundanca.terapije[<id>].postavke[<id2>]`, deeper sub-fields)
-     * is dropped silently — materializing those locally would risk corrupting
-     * unrelated invariants on the nested objects. Dirty-change still carries
-     * the path, so 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/package.json

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