cry-synced-db-client 0.1.166 → 0.1.168

package/dist/index.js

@@ -329,6 +329,22 @@ function sameIdSequence(a, b) {
   }
   return true;
 }
+function containsIdArrayDescendant(value) {
+  if (value === null || typeof value !== "object") return false;
+  if (value instanceof Date || isObjectIdLike(value)) return false;
+  if (Array.isArray(value)) {
+    if (value.length > 0 && allElementsHaveId(value)) return true;
+    for (const v of value) {
+      if (containsIdArrayDescendant(v)) return true;
+    }
+    return false;
+  }
+  if (!isPlainObject(value)) return false;
+  for (const key of Object.keys(value)) {
+    if (containsIdArrayDescendant(value[key])) return true;
+  }
+  return false;
+}
 function computeArrayDiff(existingArr, updateArr, basePath, diff) {
   if (existingArr.length === 0 && updateArr.length === 0) return;
   if (!allElementsHaveId(updateArr) || existingArr.length > 0 && !allElementsHaveId(existingArr)) {
@@ -354,12 +370,14 @@ function computeArrayDiff(existingArr, updateArr, basePath, diff) {
     if (sameIdSequence(existingArr, updateArr)) {
       for (let i = 0; i < updateArr.length; i++) {
         const elementId = String(updateArr[i]._id);
-        computeDiffInto(
-          existingArr[i],
-          updateArr[i],
-          `${basePath}[${elementId}]`,
-          diff
-        );
+        const elementPath = `${basePath}[${elementId}]`;
+        if (containsIdArrayDescendant(updateArr[i])) {
+          if (!deepEquals(existingArr[i], updateArr[i])) {
+            diff[elementPath] = updateArr[i];
+          }
+        } else {
+          computeDiffInto(existingArr[i], updateArr[i], elementPath, diff);
+        }
       }
     } else {
       diff[basePath] = updateArr;
@@ -383,12 +401,19 @@ function computeArrayDiff(existingArr, updateArr, basePath, diff) {
     for (const updateEl of updateArr) {
       const id = String(updateEl._id);
       if (existingIds.has(id)) {
-        computeDiffInto(
-          existingById.get(id),
-          updateEl,
-          `${basePath}[${id}]`,
-          diff
-        );
+        const elementPath = `${basePath}[${id}]`;
+        if (containsIdArrayDescendant(updateEl)) {
+          if (!deepEquals(existingById.get(id), updateEl)) {
+            diff[elementPath] = updateEl;
+          }
+        } else {
+          computeDiffInto(
+            existingById.get(id),
+            updateEl,
+            elementPath,
+            diff
+          );
+        }
       }
     }
   }
@@ -3271,11 +3296,45 @@ var _SyncEngine = class _SyncEngine {
     let sentCount = 0;
     const collectionSentCounts = {};
     for (const result of results) {
-      const { collection, results: { inserted, updated, deleted, errors: errors2 } } = result;
+      const {
+        collection,
+        results: { inserted, updated, deleted, errors: errors2, warnings }
+      } = result;
+      const erroredIds = /* @__PURE__ */ new Set();
+      if (errors2 && errors2.length > 0) {
+        for (const e of errors2) erroredIds.add(String(e._id));
+      }
       const allSuccessIds = [];
-      for (const e of inserted) allSuccessIds.push(e._id);
-      for (const e of updated) allSuccessIds.push(e._id);
-      for (const e of deleted) allSuccessIds.push(e._id);
+      const ambiguous = [];
+      for (const e of inserted) {
+        const sid = String(e._id);
+        if (erroredIds.has(sid)) {
+          ambiguous.push(sid);
+          continue;
+        }
+        allSuccessIds.push(e._id);
+      }
+      for (const e of updated) {
+        const sid = String(e._id);
+        if (erroredIds.has(sid)) {
+          ambiguous.push(sid);
+          continue;
+        }
+        allSuccessIds.push(e._id);
+      }
+      for (const e of deleted) {
+        const sid = String(e._id);
+        if (erroredIds.has(sid)) {
+          ambiguous.push(sid);
+          continue;
+        }
+        allSuccessIds.push(e._id);
+      }
+      if (ambiguous.length > 0) {
+        console.error(
+          `Sync upload [${collection}]: ${ambiguous.length} id(s) appeared in BOTH inserted/updated/deleted AND errors[] \u2014 keeping dirty for safety. _ids: ${ambiguous.join(", ")}`
+        );
+      }
       if (allSuccessIds.length > 0) {
         await this.dexieDb.clearDirtyChangesBatch(collection, allSuccessIds);
       }
@@ -3368,12 +3427,19 @@ var _SyncEngine = class _SyncEngine {
           });
         }
       }
-      if (errors2) {
-        console.error(
-          `Sync upload errors for ${collection}:`,
-          errors2,
-          "\u2014 dirty entries for failed items will persist until retry"
-        );
+      if (errors2 && errors2.length > 0) {
+        for (const e of errors2) {
+          console.error(
+            `Sync upload error [${collection}] _id=${e._id}: ${e.error} \u2014 dirty entry will persist until retry`
+          );
+        }
+      }
+      if (warnings && warnings.length > 0) {
+        for (const w of warnings) {
+          console.warn(
+            `Sync upload warning [${collection}] _id=${w._id}: ${w.error}`
+          );
+        }
       }
       const sentIds = /* @__PURE__ */ new Set([
         ...collectionBatches.flat().filter((b) => b.collection === collection).flatMap((b) => [
@@ -3433,15 +3499,60 @@ var _SyncEngine = class _SyncEngine {
     );
     let sentCount = 0;
     for (const result of results) {
-      const { results: { inserted, updated, deleted } } = result;
+      const {
+        results: { inserted, updated, deleted, errors: errors2, warnings }
+      } = result;
+      const erroredIds = /* @__PURE__ */ new Set();
+      if (errors2 && errors2.length > 0) {
+        for (const e of errors2) {
+          erroredIds.add(String(e._id));
+          console.error(
+            `Sync upload error [${collection}] _id=${e._id}: ${e.error} \u2014 dirty entry will persist until retry`
+          );
+        }
+      }
+      if (warnings && warnings.length > 0) {
+        for (const w of warnings) {
+          console.warn(
+            `Sync upload warning [${collection}] _id=${w._id}: ${w.error}`
+          );
+        }
+      }
       const allSuccessIds = [];
-      for (const e of inserted) allSuccessIds.push(e._id);
-      for (const e of updated) allSuccessIds.push(e._id);
-      for (const e of deleted) allSuccessIds.push(e._id);
+      const ambiguous = [];
+      for (const e of inserted) {
+        const sid = String(e._id);
+        if (erroredIds.has(sid)) {
+          ambiguous.push(sid);
+          continue;
+        }
+        allSuccessIds.push(e._id);
+      }
+      for (const e of updated) {
+        const sid = String(e._id);
+        if (erroredIds.has(sid)) {
+          ambiguous.push(sid);
+          continue;
+        }
+        allSuccessIds.push(e._id);
+      }
+      for (const e of deleted) {
+        const sid = String(e._id);
+        if (erroredIds.has(sid)) {
+          ambiguous.push(sid);
+          continue;
+        }
+        allSuccessIds.push(e._id);
+      }
+      if (ambiguous.length > 0) {
+        console.error(
+          `Sync upload [${collection}]: ${ambiguous.length} id(s) appeared in BOTH inserted/updated/deleted AND errors[] \u2014 keeping dirty for safety. _ids: ${ambiguous.join(", ")}`
+        );
+      }
       if (allSuccessIds.length > 0) {
         await this.dexieDb.clearDirtyChangesBatch(collection, allSuccessIds);
       }
-      sentCount += inserted.length + updated.length + deleted.length;
+      sentCount += allSuccessIds.length;
     }
     return { sentCount };
   }
@@ -4963,7 +5074,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 +6234,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 +6248,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/RestProxy.d.ts

@@ -43,7 +43,6 @@ export interface RestProxyConfig {
  * ## Performance
  *
  * Benchmarked at ~5ms per request (after warmup) on localhost.
- * Native fetch performs comparably to undici with connection pooling.
  *
  * ## Progress Callback Limitations
  *

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.168",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -18,7 +18,7 @@
   "scripts": {
     "clean": "rm -rf dist",
     "build": "bun run clean && bun run build:js && bun run build:types",
-    "build:js": "esbuild ./src/index.ts --bundle --outdir=./dist --target=es2017 --format=esm --platform=browser --external:dexie --external:bson --external:cry-helpers --external:notepack.io",
+    "build:js": "esbuild ./src/index.ts --bundle --outdir=./dist --target=es2017 --format=esm --platform=browser --external:dexie --external:bson --external:cry-helpers",
     "build:types": "tsc --emitDeclarationOnly --outDir dist",
     "test": "bun test test/*.test.ts test/restProxy/*.test.ts && vitest run",
     "test:bun": "bun test test/*.test.ts test/restProxy/*.test.ts",
@@ -39,10 +39,7 @@
   "dependencies": {
     "cry-helpers": "^2.1.194",
     "msgpackr": "^2.0.1",
-    "notepack": "^0.0.2",
-    "notepack.io": "^3.0.1",
-    "superjson": "^2.2.6",
-    "undici": "^8.2.0"
+    "superjson": "^2.2.6"
   },
   "peerDependencies": {
     "bson": "^6.0.0 || ^7.0.0",