dexie-cloud-addon 4.2.0-rc.1 → 4.2.1

package/dist/umd/service-worker.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.2.0-rc.1, Wed Aug 06 2025
+ * Version 4.2.1, Wed Oct 01 2025
  *
  * https://dexie.org
  *
@@ -409,17 +409,14 @@
                     : mutationTable;
                 if (limit < Infinity)
                     query = query.limit(limit);
-                const muts = yield query.toArray();
-                //const objTable = db.table(tableName);
-                /*for (const mut of muts) {
-                  if (mut.type === "insert" || mut.type === "upsert") {
-                    mut.values = await objTable.bulkGet(mut.keys);
-                  }
-                }*/
-                return muts.map((mut) => ({
+                let muts = yield query.toArray();
+                muts = canonicalizeToUpdateOps(muts);
+                muts = removeRedundantUpdateOps(muts);
+                const rv = muts.map((mut) => ({
                     table: tableName,
                     mut,
                 }));
+                return rv;
             })));
             // Sort by time to get a true order of the operations (between tables)
             const sorted = flatten(allMutsOnTables).sort((a, b) => a.mut.txid === b.mut.txid
@@ -448,6 +445,69 @@
             return result;
         });
     }
+    function removeRedundantUpdateOps(muts) {
+        const updateCoverage = new Map();
+        for (const mut of muts) {
+            if (mut.type === 'update') {
+                if (mut.keys.length !== 1 || mut.changeSpecs.length !== 1) {
+                    continue; // Don't optimize multi-key updates
+                }
+                const strKey = '' + mut.keys[0];
+                const changeSpecs = mut.changeSpecs[0];
+                if (Object.values(changeSpecs).some(v => typeof v === "object" && v && "@@propmod" in v)) {
+                    continue; // Cannot optimize if any PropModification is present
+                }
+                let keyCoverage = updateCoverage.get(strKey);
+                if (keyCoverage) {
+                    keyCoverage.push({ txid: mut.txid, updateSpec: changeSpecs });
+                }
+                else {
+                    updateCoverage.set(strKey, [{ txid: mut.txid, updateSpec: changeSpecs }]);
+                }
+            }
+        }
+        muts = muts.filter(mut => {
+            // Only apply optimization to update mutations that are single-key
+            if (mut.type !== 'update')
+                return true;
+            if (mut.keys.length !== 1 || mut.changeSpecs.length !== 1)
+                return true;
+            // Keep track of properties that aren't overlapped by later transactions
+            const unoverlappedProps = new Set(Object.keys(mut.changeSpecs[0]));
+            const strKey = '' + mut.keys[0];
+            const keyCoverage = updateCoverage.get(strKey);
+            for (let i = keyCoverage.length - 1; i >= 0; --i) {
+                const { txid, updateSpec } = keyCoverage[i];
+                if (txid === mut.txid)
+                    break; // Stop when reaching own txid
+                // If all changes in updateSpec are covered by all props on all mut.changeSpecs then
+                // txid is redundant and can be removed.
+                for (const keyPath of Object.keys(updateSpec)) {
+                    unoverlappedProps.delete(keyPath);
+                }
+            }
+            if (unoverlappedProps.size === 0) {
+                // This operation is completely overlapped by later operations. It can be removed.
+                return false;
+            }
+            return true;
+        });
+        return muts;
+    }
+    function canonicalizeToUpdateOps(muts) {
+        muts = muts.map(mut => {
+            if (mut.type === 'modify' && mut.criteria.index === null) {
+                // The criteria is on primary key. Convert to an update operation instead.
+                // It is simpler for the server to handle and also more efficient.
+                const updateMut = Object.assign(Object.assign({}, mut), { criteria: undefined, changeSpec: undefined, type: 'update', keys: mut.keys, changeSpecs: [mut.changeSpec] });
+                delete updateMut.criteria;
+                delete updateMut.changeSpec;
+                return updateMut;
+            }
+            return mut;
+        });
+        return muts;
+    }
 
     function randomString$1(bytes) {
         const buf = new Uint8Array(bytes);
@@ -13889,7 +13949,7 @@
      *
      * ==========================================================================
      *
-     * Version 4.2.0-rc.1, Wed Aug 06 2025
+     * Version 4.2.1, Wed Oct 01 2025
      *
      * https://dexie.org
      *
@@ -18009,7 +18069,7 @@
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.2.0-rc.1",
+            version: "4.2.1",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -18326,7 +18386,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.2.0-rc.1";
+    dexieCloud.version = "4.2.1";
     Dexie.Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections: