cry-synced-db-client 0.1.183 → 0.1.184

package/CHANGELOG.md

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

package/dist/index.js

@@ -6653,25 +6653,38 @@ var _SyncedDb = class _SyncedDb {
   }
   /**
    * 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 shapes (path tokenizes to `[firstField, [<id>], …rest]`):
+   * Supported path shape (tokenizes to `[…plain prefix, [<id>], …plain suffix]`):
    *
-   *   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.
+   *   • 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>}}}]
    *
-   * 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.
+   *   • 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>]`)
@@ -6697,28 +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;
     }
-    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 +6774,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 +6791,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));
     }
   }
   /**

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

@@ -521,25 +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`, 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/package.json

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