cry-synced-db-client 0.1.166 → 0.1.167

package/dist/index.js

@@ -4963,7 +4963,8 @@ var _SyncedDb = class _SyncedDb {
     const merged = _SyncedDb.applyDiffLocally(
       currentMem != null ? currentMem : existing,
       diff,
-      id
+      id,
+      collection
     );
     this.pendingChanges.schedule(collection, id, merged, 0, "save");
     if (!isWriteOnly && !(existing == null ? void 0 : existing._deleted) && !(existing == null ? void 0 : existing._archived)) {
@@ -6122,7 +6123,7 @@ var _SyncedDb = class _SyncedDb {
    * Returns a new object (the cloned-and-mutated `base`); never mutates
    * the input `base` reference.
    */
-  static applyDiffLocally(base, diff, fallbackId) {
+  static applyDiffLocally(base, diff, fallbackId, collection) {
     const seed = base ? _SyncedDb.safeDeepClone(base) : { _id: fallbackId };
     if (seed._id == null) seed._id = fallbackId;
     for (const path of Object.keys(diff)) {
@@ -6136,10 +6137,98 @@ var _SyncedDb = class _SyncedDb {
         continue;
       }
       const ok = setByPath(seed, path, value);
-      if (!ok) seed[path] = value;
+      if (!ok) {
+        _SyncedDb.materializeBracketPath(seed, path, value, collection, fallbackId);
+      }
     }
     return seed;
   }
+  /**
+   * 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.
+   *
+   * Replaces the pre-fix blind `seed[path] = value` fallback that stamped
+   * literal bracket-keyed top-level properties (e.g. `"postavke[<id>]": [<el>]`)
+   * onto Dexie rows and in-mem state, persisting forever through subsequent
+   * `safeDeepClone`-based save cycles.
+   */
+  static materializeBracketPath(seed, path, value, collection, id) {
+    const tokens = tokenizePath(path);
+    const firstToken = tokens[0];
+    const dropSilently = typeof firstToken === "string" && firstToken.startsWith("_");
+    const drop = (reason) => {
+      if (dropSilently) return;
+      console.error(
+        `SyncedDb.applyDiffLocally: dropping bracket-path diff entry (${reason})`,
+        { collection, _id: String(id), path, value }
+      );
+    };
+    if (tokens.length < 2 || tokens.length > 3) {
+      drop(`unsupported token count ${tokens.length}`);
+      return;
+    }
+    if (firstToken === void 0 || firstToken.startsWith("[")) {
+      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");
+      return;
+    }
+    if (tokens.length === 3 && tokens[2].startsWith("[")) {
+      drop("nested bracket path");
+      return;
+    }
+    const bracketId = secondToken.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`);
+      return;
+    }
+    if (tokens.length === 2) {
+      let element = value;
+      if (Array.isArray(value) && value.length === 1 && value[0] != null && typeof value[0] === "object") {
+        element = value[0];
+      }
+      if (element == null || typeof element !== "object" || Array.isArray(element)) {
+        drop("value is not a single element or wire-form wrapper");
+        return;
+      }
+      if (element._id == null) {
+        element._id = bracketId;
+      }
+      if (existing == null) {
+        seed[firstToken] = [element];
+      } else {
+        existing.push(element);
+      }
+      return;
+    }
+    const fieldName = tokens[2];
+    const newElement = { _id: bracketId, [fieldName]: value };
+    if (existing == null) {
+      seed[firstToken] = [newElement];
+    } else {
+      existing.push(newElement);
+    }
+  }
   /**
    * Deep clone for `applyDiffLocally`. Recurses into plain objects and
    * arrays; preserves `Date` (cloned to avoid shared reference) and

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

@@ -435,6 +435,28 @@ export declare class SyncedDb implements I_SyncedDb {
      * the input `base` reference.
      */
     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.
+     *
+     * Replaces the pre-fix blind `seed[path] = value` fallback that stamped
+     * literal bracket-keyed top-level properties (e.g. `"postavke[<id>]": [<el>]`)
+     * onto Dexie rows and in-mem state, persisting forever through subsequent
+     * `safeDeepClone`-based save cycles.
+     */
+    private static materializeBracketPath;
     /**
      * Deep clone for `applyDiffLocally`. Recurses into plain objects and
      * arrays; preserves `Date` (cloned to avoid shared reference) and

package/package.json

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