dexie-cloud-addon 4.2.0 → 4.2.1

package/dexie-cloud-import.json

@@ -0,0 +1,6 @@
+{
+  "demoUsers": {
+    "foo@demo.local": {},
+    "bar@demo.local": {}
+  }
+}

package/dist/modern/dexie-cloud-addon.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.2.0, Wed Aug 13 2025
+ * Version 4.2.1, Wed Oct 01 2025
  *
  * https://dexie.org
  *
@@ -1653,17 +1653,14 @@ function listClientChanges(mutationTables_1, db_1) {
                 : 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
@@ -1692,6 +1689,69 @@ function listClientChanges(mutationTables_1, db_1) {
         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(bytes) {
     const buf = new Uint8Array(bytes);
@@ -6137,7 +6197,7 @@ function dexieCloud(dexie) {
     const syncComplete = new Subject();
     dexie.cloud = {
         // @ts-ignore
-        version: "4.2.0",
+        version: "4.2.1",
         options: Object.assign({}, DEFAULT_OPTIONS),
         schema: null,
         get currentUserId() {
@@ -6454,7 +6514,7 @@ function dexieCloud(dexie) {
     }
 }
 // @ts-ignore
-dexieCloud.version = "4.2.0";
+dexieCloud.version = "4.2.1";
 Dexie.Cloud = dexieCloud;
 
 export { dexieCloud as default, defineYDocTrigger, dexieCloud, getTiedObjectId, getTiedRealmId, resolveText };