cry-synced-db-client 0.1.182 → 0.1.183

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Versions
 
+## 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,25 @@ 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):
+   * 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.
    *
-   *   1. `polje[<id>] = <obj>`         →  seed.polje = [<obj>]
-   *   2. `polje[<id>].<field> = <v>`   →  seed.polje = [{_id: <id>, <field>: <v>}]
+   * Supported shapes (path tokenizes to `[firstField, [<id>], …rest]`):
    *
-   * 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.
+   *   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.
    *
    * Replaces the pre-fix blind `seed[path] = value` fallback that stamped
    * literal bracket-keyed top-level properties (e.g. `"postavke[<id>]": [<el>]`)
@@ -6683,7 +6689,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;
     }
@@ -6696,9 +6702,11 @@ var _SyncedDb = class _SyncedDb {
       drop("second segment is not a bracket-by-id");
       return;
     }
-    if (tokens.length === 3 && tokens[2].startsWith("[")) {
-      drop("nested bracket path");
-      return;
+    for (let i = 2; i < tokens.length; i++) {
+      if (tokens[i].startsWith("[")) {
+        drop("nested bracket path");
+        return;
+      }
     }
     const bracketId = secondToken.slice(1, -1);
     if (bracketId.length === 0) {
@@ -6729,12 +6737,36 @@ var _SyncedDb = class _SyncedDb {
       }
       return;
     }
-    const fieldName = tokens[2];
-    const newElement = { _id: bracketId, [fieldName]: value };
+    const subFieldPath = tokens.slice(2);
+    const buildNestedSubTree = (segs, leaf) => {
+      let acc = leaf;
+      for (let i = segs.length - 1; i >= 0; i--) {
+        acc = { [segs[i]]: acc };
+      }
+      return acc;
+    };
     if (existing == null) {
-      seed[firstToken] = [newElement];
+      const subTree = buildNestedSubTree(subFieldPath, value);
+      seed[firstToken] = [__spreadValues({ _id: bracketId }, subTree)];
+      return;
+    }
+    const existingIdx = existing.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];
+        const next = cur[seg];
+        if (next == null || typeof next !== "object" || Array.isArray(next)) {
+          cur[seg] = {};
+        }
+        cur = cur[seg];
+      }
+      cur[subFieldPath[subFieldPath.length - 1]] = value;
     } else {
-      existing.push(newElement);
+      const subTree = buildNestedSubTree(subFieldPath, value);
+      existing.push(__spreadValues({ _id: bracketId }, subTree));
     }
   }
   /**

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

@@ -521,19 +521,25 @@ 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.
+     * 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.
      *
      * 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.183",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",