cry-synced-db-client 2.0.5 → 2.0.7

package/dist/index.js

@@ -919,21 +919,23 @@ var InMemManager = class {
     const config = this.collections.get(collection);
     const source = (_a = opts == null ? void 0 : opts.source) != null ? _a : "incremental";
     if (operation === "upsert") {
-      this.inMemDb.saveMany(collection, items, { source });
+      const itemsToWrite = source === "incremental" ? this.dropRevRegressions(collection, items) : items;
+      if (itemsToWrite.length === 0) return;
+      this.inMemDb.saveMany(collection, itemsToWrite, { source });
       if (this.useObjectMetadata && (config == null ? void 0 : config.hasMetadata)) {
         const ids = [];
-        for (const item of items) ids.push(item._id);
+        for (const item of itemsToWrite) ids.push(item._id);
         let metadatas;
         if (config.onObjectsUpdated) {
           try {
-            metadatas = config.onObjectsUpdated(items);
+            metadatas = config.onObjectsUpdated(itemsToWrite);
           } catch (err) {
             console.error(`[InMem] onObjectsUpdated callback failed: ${err}`, err);
             return;
           }
         } else if (config.onObjectUpdated) {
           try {
-            metadatas = items.map((item) => config.onObjectUpdated(item));
+            metadatas = itemsToWrite.map((item) => config.onObjectUpdated(item));
           } catch (err) {
             console.error(`[InMem] onObjectUpdated callback failed: ${err}`, err);
             return;
@@ -952,6 +954,30 @@ var InMemManager = class {
       }
     }
   }
+  /**
+   * Filter out items whose `_rev` is lower than what in-mem already holds
+   * for that id — an incremental write with a stale rev is, by definition,
+   * confirming/echoing a write that a later one has already superseded.
+   * Items without a numeric `_rev` on either side are let through unchanged
+   * (legacy collections without rev tracking).
+   */
+  dropRevRegressions(collection, items) {
+    const result = [];
+    for (const item of items) {
+      const incomingRev = item._rev;
+      if (typeof incomingRev !== "number") {
+        result.push(item);
+        continue;
+      }
+      const current = this.inMemDb.getById(collection, item._id);
+      const currentRev = current == null ? void 0 : current._rev;
+      if (typeof currentRev === "number" && incomingRev < currentRev) {
+        continue;
+      }
+      result.push(item);
+    }
+    return result;
+  }
   /**
    * Initialize collection from Dexie data.
    * Called during SyncedDb.init().
@@ -3866,8 +3892,8 @@ var SyncEngine = class {
             collection,
             idsToCheck
           );
-          const dexieSaveBatch = [];
-          const inMemUpdateBatch = [];
+          const saveIds = [];
+          const revById = /* @__PURE__ */ new Map();
           const inMemDeleteIds = [];
           const dexieDeleteIds = [];
           for (let i = 0; i < insertedAndUpdated.length; i++) {
@@ -3875,17 +3901,29 @@ var SyncEngine = class {
             const dexieItem = dexieItems[i];
             if (mustRefreshIds.has(String(entity._id))) continue;
             if (dexieItem) {
-              dexieItem._rev = entity._rev;
-              dexieItem._ts = entity._ts;
               if (dexieItem._deleted) {
                 inMemDeleteIds.push(entity._id);
                 dexieDeleteIds.push(entity._id);
               } else {
-                dexieSaveBatch.push(dexieItem);
-                inMemUpdateBatch.push(dexieItem);
+                saveIds.push(entity._id);
+                revById.set(String(entity._id), { rev: entity._rev, ts: entity._ts });
               }
             }
           }
+          const dexieSaveBatch = [];
+          const inMemUpdateBatch = [];
+          if (saveIds.length > 0) {
+            const freshItems = await this.dexieDb.getByIds(collection, saveIds);
+            for (const freshItem of freshItems) {
+              if (!freshItem) continue;
+              const revTs = revById.get(String(freshItem._id));
+              if (!revTs) continue;
+              freshItem._rev = revTs.rev;
+              freshItem._ts = revTs.ts;
+              dexieSaveBatch.push(freshItem);
+              inMemUpdateBatch.push(freshItem);
+            }
+          }
           if (dexieSaveBatch.length > 0) {
             await this.dexieDb.saveMany(collection, dexieSaveBatch);
           }
@@ -4525,7 +4563,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 +4618,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 +4639,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 +4930,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 +4949,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 +5032,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/managers/InMemManager.d.ts

@@ -28,6 +28,14 @@ export declare class InMemManager implements I_InMemManager {
     writeBatch<T extends DbEntity>(collection: string, items: T[], operation: "upsert" | "delete", opts?: {
         source?: SyncSource;
     }): void;
+    /**
+     * Filter out items whose `_rev` is lower than what in-mem already holds
+     * for that id — an incremental write with a stale rev is, by definition,
+     * confirming/echoing a write that a later one has already superseded.
+     * Items without a numeric `_rev` on either side are let through unchanged
+     * (legacy collections without rev tracking).
+     */
+    private dropRevRegressions;
     /**
      * Initialize collection from Dexie data.
      * Called during SyncedDb.init().

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.7",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -20,8 +20,9 @@
     "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",
     "build:types": "tsc --emitDeclarationOnly --outDir dist",
-    "test": "bun test --preload ./test/preload-bun.cjs test/*.test.ts test/restProxy/*.test.ts; vitest run",
-    "test:bun": "bun test test/*.test.ts test/restProxy/*.test.ts",
+    "test": "bash test/run-all.sh",
+    "test:ci": "SKIP_REAL_MONGO=1 bash test/run-all.sh",
+    "test:bun": "bun test --preload ./test/preload-bun.cjs test/*.test.ts test/restProxy/*.test.ts test/node-only-bun/*.test.ts",
     "test:node-only": "vitest run",
     "test:real-mongo": "USE_REAL_MONGO=1 npx vitest run test/node-only/",
     "prepublishOnly": "bun run build"