cry-synced-db-client 2.0.5 → 2.0.6

package/dist/index.js

@@ -4525,7 +4525,7 @@ var ServerUpdateHandler = class {
     return updatedIds;
   }
   async processBracketedItem(collection, item) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     const localItem = await this.dexieDb.getById(collection, item._id);
     if (!localItem) {
       if (item.operation === "insert" && item.bracketedData) {
@@ -4580,13 +4580,18 @@ var ServerUpdateHandler = class {
       case "apply":
         break;
     }
+    const incomingUpdaterId = (_f = item._lastUpdaterId) != null ? _f : (_e = item.bracketedData) == null ? void 0 : _e._lastUpdaterId;
     const pendingChange = this.deps.getPendingChange(collection, item._id);
     if (pendingChange && item.operation === "update") {
-      const diff = this.stripMetaFromDiff(item.bracketedData);
+      const diff = this.dropFieldsOwnedByPending(
+        this.stripMetaFromDiff(item.bracketedData),
+        pendingChange.data,
+        incomingUpdaterId
+      );
       const currentInMemState = Object.assign({}, localItem, pendingChange.data);
       const merged = applyObjDiff(currentInMemState, diff, item._id, "bracketed");
-      merged._rev = (_e = item._rev) != null ? _e : localItem._rev;
-      merged._ts = (_f = item._ts) != null ? _f : localItem._ts;
+      merged._rev = (_g = item._rev) != null ? _g : localItem._rev;
+      merged._ts = (_h = item._ts) != null ? _h : localItem._ts;
       if (!merged._deleted && !merged._archived) {
         this.deps.writeToInMemBatch(collection, [this.stripLocalFields(merged)], "upsert", {
           source: "incremental"
@@ -4596,10 +4601,14 @@ var ServerUpdateHandler = class {
     }
     const dirtyChange = await this.dexieDb.getDirtyChange(collection, item._id);
     if (dirtyChange && item.operation === "update") {
-      const diff = this.stripMetaFromDiff(item.bracketedData);
+      const diff = this.dropFieldsOwnedByPending(
+        this.stripMetaFromDiff(item.bracketedData),
+        dirtyChange,
+        incomingUpdaterId
+      );
       const merged = applyObjDiff(localItem, diff, item._id, "bracketed");
-      merged._rev = (_g = item._rev) != null ? _g : localItem._rev;
-      merged._ts = (_h = item._ts) != null ? _h : localItem._ts;
+      merged._rev = (_i = item._rev) != null ? _i : localItem._rev;
+      merged._ts = (_j = item._ts) != null ? _j : localItem._ts;
       if (!merged._deleted && !merged._archived) {
         await this.dexieDb.insert(collection, merged);
         this.deps.writeToInMemBatch(collection, [this.stripLocalFields(merged)], "upsert", {
@@ -4883,7 +4892,12 @@ var ServerUpdateHandler = class {
         Object.assign(pendingChange.data, newFields);
       }
       const currentInMemState = Object.assign({}, localItem, pendingChange.data);
-      const merged = this.mergeLocalWithDelta(currentInMemState, serverDelta);
+      const filteredDelta = this.dropFieldsOwnedByPending(
+        serverDelta,
+        pendingChange.data,
+        serverDelta._lastUpdaterId
+      );
+      const merged = this.mergeLocalWithDelta(currentInMemState, filteredDelta);
       if (!merged._deleted && !merged._archived) {
         this.deps.writeToInMemBatch(
           collection,
@@ -4897,7 +4911,12 @@ var ServerUpdateHandler = class {
     const dirtyChange = await this.dexieDb.getDirtyChange(collection, serverDelta._id);
     const metaChanged = localItem._rev !== serverDelta._rev || !this.timestampsEqual(localItem._ts, serverDelta._ts);
     if (dirtyChange) {
-      const merged = this.mergeLocalWithDelta(localItem, serverDelta);
+      const filteredDelta = this.dropFieldsOwnedByPending(
+        serverDelta,
+        dirtyChange,
+        serverDelta._lastUpdaterId
+      );
+      const merged = this.mergeLocalWithDelta(localItem, filteredDelta);
       if (metaChanged) {
         await this.dexieDb.save(collection, serverDelta._id, merged);
       }
@@ -4975,6 +4994,50 @@ var ServerUpdateHandler = class {
     }
     return local;
   }
+  /**
+   * Drop fields from an incoming server delta/diff that our OWN in-flight
+   * change (pending or already-dirty) already explicitly touches — but ONLY
+   * when the incoming delta was itself authored by this same client
+   * (`incomingUpdaterId === this.updaterId`). That is the one case where we
+   * can safely assume our own newer local pending/dirty write supersedes the
+   * incoming payload for that field: a slower/older echo of our OWN prior
+   * write (e.g. a lock-write's confirmation arriving after we've already
+   * locally reverted it, via a rev/timing gap the entry-level self-echo
+   * check in `handleServerItemUpdate`/`checkRev` didn't catch) can otherwise
+   * resurrect a field our own newer pending change had deliberately set or
+   * cleared — both `mergeLocalWithDelta` and `applyObjDiff` apply whatever
+   * the incoming payload says with no awareness of a competing, newer local
+   * intent.
+   *
+   * When the incoming delta comes from a genuinely different actor (a true
+   * second writer, or `incomingUpdaterId` is absent/unknown), this is a
+   * skip-through no-op — that delta must always apply so real-time UX stays
+   * live (see `test/secondActor.test.ts`): the field-name overlap alone does
+   * NOT imply staleness for another writer's edit, only for our own.
+   *
+   * `ownedKeys` is checked via `hasOwnProperty` (not truthiness) because a
+   * deliberately-cleared field is `undefined`, not absent, on the owning
+   * diff/pendingChange.data.
+   *
+   * Path-based (bracketed) diff keys like `koraki[id].field` are matched by
+   * their top-level segment — if `koraki` is owned, every path under it is
+   * dropped, which is conservative but safe (reproduced with izdajRacun.vue's
+   * sedajObdeluje lock/unlock race via the dbbracketed/ channel, 2026-07-14).
+   */
+  dropFieldsOwnedByPending(incoming, ownedKeys, incomingUpdaterId) {
+    var _a;
+    if (incomingUpdaterId === void 0 || incomingUpdaterId !== this.updaterId) {
+      return incoming;
+    }
+    const result = {};
+    for (const key in incoming) {
+      if (!Object.prototype.hasOwnProperty.call(incoming, key)) continue;
+      const topField = (_a = key.split(/[.[]/)[0]) != null ? _a : key;
+      if (Object.prototype.hasOwnProperty.call(ownedKeys, topField)) continue;
+      result[key] = incoming[key];
+    }
+    return result;
+  }
   /**
    * Fields from an incoming server delta that our OWN in-flight pending
    * change doesn't already touch — safe to backfill into it so a later

package/dist/src/db/sync/ServerUpdateHandler.d.ts

@@ -81,6 +81,37 @@ export declare class ServerUpdateHandler implements I_ServerUpdateHandler {
     private timestampsEqual;
     /** @mutates local — mutira vhodni objekt namesto kopiranja */
     private mergeLocalWithDelta;
+    /**
+     * Drop fields from an incoming server delta/diff that our OWN in-flight
+     * change (pending or already-dirty) already explicitly touches — but ONLY
+     * when the incoming delta was itself authored by this same client
+     * (`incomingUpdaterId === this.updaterId`). That is the one case where we
+     * can safely assume our own newer local pending/dirty write supersedes the
+     * incoming payload for that field: a slower/older echo of our OWN prior
+     * write (e.g. a lock-write's confirmation arriving after we've already
+     * locally reverted it, via a rev/timing gap the entry-level self-echo
+     * check in `handleServerItemUpdate`/`checkRev` didn't catch) can otherwise
+     * resurrect a field our own newer pending change had deliberately set or
+     * cleared — both `mergeLocalWithDelta` and `applyObjDiff` apply whatever
+     * the incoming payload says with no awareness of a competing, newer local
+     * intent.
+     *
+     * When the incoming delta comes from a genuinely different actor (a true
+     * second writer, or `incomingUpdaterId` is absent/unknown), this is a
+     * skip-through no-op — that delta must always apply so real-time UX stays
+     * live (see `test/secondActor.test.ts`): the field-name overlap alone does
+     * NOT imply staleness for another writer's edit, only for our own.
+     *
+     * `ownedKeys` is checked via `hasOwnProperty` (not truthiness) because a
+     * deliberately-cleared field is `undefined`, not absent, on the owning
+     * diff/pendingChange.data.
+     *
+     * Path-based (bracketed) diff keys like `koraki[id].field` are matched by
+     * their top-level segment — if `koraki` is owned, every path under it is
+     * dropped, which is conservative but safe (reproduced with izdajRacun.vue's
+     * sedajObdeluje lock/unlock race via the dbbracketed/ channel, 2026-07-14).
+     */
+    private dropFieldsOwnedByPending;
     /**
      * Fields from an incoming server delta that our OWN in-flight pending
      * change doesn't already touch — safe to backfill into it so a later

package/package.json

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