cry-synced-db-client 0.1.165 → 0.1.167

package/dist/index.js

@@ -507,6 +507,11 @@ function setSegment(current, part, value) {
     const idStr = part.slice(1, -1);
     if (!Array.isArray(current)) return false;
     const idx = current.findIndex((item) => item && String(item._id) === idStr);
+    if (Array.isArray(value) && value.length === 1 && value[0] && typeof value[0] === "object" && String(value[0]._id) === idStr) {
+      if (idx >= 0) current[idx] = value[0];
+      else current.push(value[0]);
+      return true;
+    }
     if (idx < 0) return false;
     current[idx] = value;
     return true;
@@ -4958,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)) {
@@ -4968,6 +4974,9 @@ var _SyncedDb = class _SyncedDb {
   }
   async upsert(collection, query, update) {
     this.assertCollection(collection);
+    if ((query == null ? void 0 : query._id) != null && update._id == null) {
+      update._id = query._id;
+    }
     this.ensureId(update, "upsert", collection);
     query = _SyncedDb.stringifyObjectIds(query);
     update = _SyncedDb.stringifyObjectIds(update);
@@ -5221,16 +5230,31 @@ var _SyncedDb = class _SyncedDb {
   isSyncing() {
     return this.syncing;
   }
-  // ==================== Batch Operations (online only) ====================
+  // ==================== Batch Operations ====================
+  /**
+   * Run each batch entry through the standard `upsert()` pipeline so every
+   * write — single or batched — goes through `computeDiff` →
+   * `applyDiffLocally` → in-mem write + Dexie schedule + dirty change.
+   *
+   * Server upload remains batched: dirty entries accumulated by the per-item
+   * calls coalesce into one `updateCollections` request at the next sync
+   * flush. We never bypass the diff pipeline (no separate server-only
+   * `restInterface.upsertBatch` route), so bracket-by-_id sub-field path
+   * generation and conflict resolution behave identically to a sequence of
+   * `upsert()` calls.
+   *
+   * Works offline — items queue as dirty and upload on reconnect.
+   *
+   * Per-entry `opts` (`UpsertOptions` / `FindOneAndUpdateOptions`) is
+   * ignored; the diff pipeline has no mongo-`findOneAndUpdate` knob.
+   */
   async upsertBatch(collection, batch) {
     this.assertCollection(collection);
-    if (!this.isOnline()) {
-      throw new Error("upsertBatch requires online connection");
+    const results = [];
+    for (const entry of batch) {
+      results.push(await this.upsert(collection, entry.query, entry.update));
     }
-    return this.connectionManager.withRestTimeout(
-      this.restInterface.upsertBatch(collection, batch),
-      "upsertBatch"
-    );
+    return results;
   }
   // ==================== In-Memory Access ====================
   getMemoryCollection(collection) {
@@ -6099,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)) {
@@ -6113,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

@@ -156,6 +156,23 @@ export declare class SyncedDb implements I_SyncedDb {
     sync(calledFrom?: string): Promise<void>;
     private processQueuedWsUpdates;
     isSyncing(): boolean;
+    /**
+     * Run each batch entry through the standard `upsert()` pipeline so every
+     * write — single or batched — goes through `computeDiff` →
+     * `applyDiffLocally` → in-mem write + Dexie schedule + dirty change.
+     *
+     * Server upload remains batched: dirty entries accumulated by the per-item
+     * calls coalesce into one `updateCollections` request at the next sync
+     * flush. We never bypass the diff pipeline (no separate server-only
+     * `restInterface.upsertBatch` route), so bracket-by-_id sub-field path
+     * generation and conflict resolution behave identically to a sequence of
+     * `upsert()` calls.
+     *
+     * Works offline — items queue as dirty and upload on reconnect.
+     *
+     * Per-entry `opts` (`UpsertOptions` / `FindOneAndUpdateOptions`) is
+     * ignored; the diff pipeline has no mongo-`findOneAndUpdate` knob.
+     */
     upsertBatch<T extends DbEntity>(collection: string, batch: BatchSpec<T>): Promise<T[]>;
     getMemoryCollection<T extends DbEntity>(collection: string): T[];
     getDebounceDexieWritesMs(): number;
@@ -418,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/dist/src/types/I_SyncedDb.d.ts

@@ -866,27 +866,15 @@ export interface I_SyncedDb {
      */
     getSyncOnlyTheseCollections(): ReadonlySet<string> | null;
     /**
-     * Izvede batch upsert na serverju
+     * Batch wrapper around `upsert()` — applies each entry via the standard
+     * write pipeline (`computeDiff` → `applyDiffLocally` → in-mem + Dexie +
+     * dirty change). Dirty entries from all entries coalesce into a single
+     * `updateCollections` request at the next sync flush, so the server side
+     * still sees one batched upload.
      *
-     * IMPORTANT: This method intentionally does NOT update local state (Dexie or in-memory).
-     * This is by design - upsertBatch is meant for server-only operations where local
-     * state updates are not needed or will be handled separately.
-     *
-     * If you need local state to reflect the changes after calling upsertBatch(),
-     * call sync() afterward to fetch the updated data from the server.
-     *
-     * Note: Server notifications (via serverUpdateNotifier) for upsertBatch changes
-     * may trigger handleServerUpdate(), which will update local state. However, this
-     * happens asynchronously and may overwrite concurrent local changes if any exist.
-     *
-     * - Deluje samo online, offline vrže napako
-     * - Ne posodablja dexie ali in-mem baze
-     * - Uporabljeno za operacije, ki ne potrebujejo lokalne sinhronizacije
-     *
-     * @example
-     * // If you need local state updated after batch operation:
-     * await syncedDb.upsertBatch('items', batchSpec);
-     * await syncedDb.sync(); // Fetch changes to local state
+     * Works offline; entries queue as dirty and upload on reconnect.
+     * Per-entry `opts` is ignored (no mongo-`findOneAndUpdate` knob in the
+     * diff pipeline).
      */
     upsertBatch<T extends DbEntity>(collection: string, batch: BatchSpec<T>): Promise<T[]>;
     /** Vrne vse objekte iz in-mem baze za dano kolekcijo */

package/package.json

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