cry-synced-db-client 0.1.164 → 0.1.166

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;
@@ -562,6 +567,14 @@ function isTerminalBracketKey(path) {
   const last = tokens[tokens.length - 1];
   return !!(last && last.length >= 2 && last.charCodeAt(0) === 91 && last.charCodeAt(last.length - 1) === 93);
 }
+function canExpandArrayToBrackets(value) {
+  if (!Array.isArray(value) || value.length === 0) return false;
+  for (const el of value) {
+    if (el === null || typeof el !== "object") return false;
+    if (el._id == null) return false;
+  }
+  return true;
+}
 function mergeDirtyPath(accumulated, newPath, newValue) {
   for (const existingKey of Object.keys(accumulated)) {
     if (existingKey === newPath) continue;
@@ -575,7 +588,16 @@ function mergeDirtyPath(accumulated, newPath, newValue) {
       if (existingIsTerminal && Array.isArray(existingValue) && existingValue.length === 1) {
         mutationTarget = existingValue[0];
       }
-      const relativePath = newPath.substring(existingKey.length + 1);
+      if (!existingIsTerminal && newPath[existingKey.length] === "[" && canExpandArrayToBrackets(existingValue)) {
+        delete accumulated[existingKey];
+        for (const el of existingValue) {
+          accumulated[`${existingKey}[${String(el._id)}]`] = [el];
+        }
+        mergeDirtyPath(accumulated, newPath, newValue);
+        return;
+      }
+      const sepChar = newPath[existingKey.length];
+      const relativePath = sepChar === "[" ? newPath.substring(existingKey.length) : newPath.substring(existingKey.length + 1);
       const ok = setByPath(mutationTarget, relativePath, newValue);
       if (ok) return;
       break;
@@ -4951,6 +4973,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);
@@ -5204,16 +5229,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) {

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;

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.164",
+  "version": "0.1.166",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",