dexie-cloud-addon 4.2.0 → 4.2.2

package/dist/umd/service-worker.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.2.0, Wed Aug 13 2025
+ * Version 4.2.2, Sat Oct 04 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, Wed Aug 13 2025
+     * Version 4.2.1, Sat Oct 04 2025
      *
      * https://dexie.org
      *
@@ -16005,6 +16065,7 @@
                                 let values = 'values' in req ? req.values : [];
                                 let changeSpec = 'changeSpec' in req ? req.changeSpec : undefined;
                                 let updates = 'updates' in req ? req.updates : undefined;
+                                let upsert = updates && 'upsert' in req ? req.upsert : false;
                                 if (hasFailures) {
                                     keys = keys.filter((_, idx) => !failures[idx]);
                                     values = values.filter((_, idx) => !failures[idx]);
@@ -16036,29 +16097,32 @@
                                         };
                                         const validKeys = new Dexie.RangeSet();
                                         let anyChangeSpecBecameEmpty = false;
-                                        for (let i = 0, l = strippedChangeSpecs.length; i < l; ++i) {
-                                            if (Object.keys(strippedChangeSpecs[i]).length > 0) {
-                                                newUpdates.keys.push(updates.keys[i]);
-                                                newUpdates.changeSpecs.push(strippedChangeSpecs[i]);
-                                                validKeys.addKey(updates.keys[i]);
-                                            }
-                                            else {
-                                                anyChangeSpecBecameEmpty = true;
+                                        if (!upsert) {
+                                            for (let i = 0, l = strippedChangeSpecs.length; i < l; ++i) {
+                                                if (Object.keys(strippedChangeSpecs[i]).length > 0) {
+                                                    newUpdates.keys.push(updates.keys[i]);
+                                                    newUpdates.changeSpecs.push(strippedChangeSpecs[i]);
+                                                    validKeys.addKey(updates.keys[i]);
+                                                }
+                                                else {
+                                                    anyChangeSpecBecameEmpty = true;
+                                                }
                                             }
-                                        }
-                                        updates = newUpdates;
-                                        if (anyChangeSpecBecameEmpty) {
-                                            // Some keys were stripped. We must also strip them from keys and values
-                                            let newKeys = [];
-                                            let newValues = [];
-                                            for (let i = 0, l = keys.length; i < l; ++i) {
-                                                if (validKeys.hasKey(keys[i])) {
-                                                    newKeys.push(keys[i]);
-                                                    newValues.push(values[i]);
+                                            updates = newUpdates;
+                                            if (anyChangeSpecBecameEmpty) {
+                                                // Some keys were stripped. We must also strip them from keys and values
+                                                // unless this is an upsert operation in which case we want to send them all.
+                                                let newKeys = [];
+                                                let newValues = [];
+                                                for (let i = 0, l = keys.length; i < l; ++i) {
+                                                    if (validKeys.hasKey(keys[i])) {
+                                                        newKeys.push(keys[i]);
+                                                        newValues.push(values[i]);
+                                                    }
                                                 }
+                                                keys = newKeys;
+                                                values = newValues;
                                             }
-                                            keys = newKeys;
-                                            values = newValues;
                                         }
                                     }
                                 }
@@ -16100,49 +16164,59 @@
                                             userId,
                                             values,
                                         }
-                                        : criteria && changeSpec
-                                            ? {
-                                                // Common changeSpec for all keys
-                                                type: 'modify',
-                                                ts,
-                                                opNo,
-                                                keys,
-                                                criteria,
-                                                changeSpec,
-                                                txid,
-                                                userId,
-                                            }
-                                            : changeSpec
+                                        : upsert ? {
+                                            type: 'upsert',
+                                            ts,
+                                            opNo,
+                                            keys,
+                                            values,
+                                            changeSpecs: updates.changeSpecs.filter((_, idx) => !failures[idx]),
+                                            txid,
+                                            userId,
+                                        }
+                                            : criteria && changeSpec
                                                 ? {
-                                                    // In case criteria involved an unsynced property, we go for keys instead.
-                                                    type: 'update',
+                                                    // Common changeSpec for all keys
+                                                    type: 'modify',
                                                     ts,
                                                     opNo,
                                                     keys,
-                                                    changeSpecs: keys.map(() => changeSpec),
+                                                    criteria,
+                                                    changeSpec,
                                                     txid,
                                                     userId,
                                                 }
-                                                : updates
+                                                : changeSpec
                                                     ? {
-                                                        // One changeSpec per key
+                                                        // In case criteria involved an unsynced property, we go for keys instead.
                                                         type: 'update',
                                                         ts,
                                                         opNo,
-                                                        keys: updates.keys,
-                                                        changeSpecs: updates.changeSpecs,
-                                                        txid,
-                                                        userId,
-                                                    }
-                                                    : {
-                                                        type: 'upsert',
-                                                        ts,
-                                                        opNo,
                                                         keys,
-                                                        values,
+                                                        changeSpecs: keys.map(() => changeSpec),
                                                         txid,
                                                         userId,
-                                                    };
+                                                    }
+                                                    : updates
+                                                        ? {
+                                                            // One changeSpec per key
+                                                            type: 'update',
+                                                            ts,
+                                                            opNo,
+                                                            keys: updates.keys,
+                                                            changeSpecs: updates.changeSpecs,
+                                                            txid,
+                                                            userId,
+                                                        }
+                                                        : {
+                                                            type: 'upsert',
+                                                            ts,
+                                                            opNo,
+                                                            keys,
+                                                            values,
+                                                            txid,
+                                                            userId,
+                                                        };
                                 if ('isAdditionalChunk' in req && req.isAdditionalChunk) {
                                     mut.isAdditionalChunk = true;
                                 }
@@ -17299,34 +17373,85 @@
             alignItems: "center",
             display: "flex",
             justifyContent: "center",
+            padding: "16px",
+            boxSizing: "border-box"
         },
         DialogInner: {
             position: "relative",
             color: "#222",
             backgroundColor: "#fff",
-            padding: "30px",
+            padding: "24px",
             marginBottom: "2em",
-            maxWidth: "90%",
+            maxWidth: "400px",
+            width: "100%",
             maxHeight: "90%",
             overflowY: "auto",
             border: "3px solid #3d3d5d",
             borderRadius: "8px",
             boxShadow: "0 0 80px 10px #666",
-            width: "auto",
             fontFamily: "sans-serif",
+            boxSizing: "border-box"
         },
         Input: {
             height: "35px",
-            width: "17em",
+            width: "100%",
+            maxWidth: "100%",
             borderColor: "#ccf4",
             outline: "none",
-            fontSize: "17pt",
-            padding: "8px"
+            fontSize: "16px",
+            padding: "8px",
+            boxSizing: "border-box"
+        },
+        Button: {
+            padding: "10px 20px",
+            margin: "0 4px",
+            border: "1px solid #d1d5db",
+            borderRadius: "6px",
+            backgroundColor: "#ffffff",
+            cursor: "pointer",
+            fontSize: "14px",
+            fontWeight: "500",
+            color: "#374151",
+            transition: "all 0.2s ease"
+        },
+        PrimaryButton: {
+            padding: "10px 20px",
+            margin: "0 4px",
+            border: "1px solid #3b82f6",
+            borderRadius: "6px",
+            backgroundColor: "#3b82f6",
+            color: "white",
+            cursor: "pointer",
+            fontSize: "14px",
+            fontWeight: "500",
+            transition: "all 0.2s ease"
+        },
+        ButtonsDiv: {
+            display: "flex",
+            justifyContent: "flex-end",
+            gap: "12px",
+            marginTop: "24px",
+            paddingTop: "20px"
+        },
+        Label: {
+            display: "block",
+            marginBottom: "12px",
+            fontSize: "14px",
+            fontWeight: "500",
+            color: "#333"
+        },
+        WindowHeader: {
+            margin: "0 0 20px 0",
+            fontSize: "18px",
+            fontWeight: "600",
+            color: "#333",
+            borderBottom: "1px solid #eee",
+            paddingBottom: "10px"
         }
     };
 
     function Dialog({ children, className }) {
-        return (h("div", { className: className },
+        return (h("div", { className: `dexie-dialog ${className || ''}` },
             h("div", { style: Styles.Darken }),
             h("div", { style: Styles.DialogOuter },
                 h("div", { style: Styles.DialogInner }, children))));
@@ -17378,7 +17503,7 @@
                         } })))))),
             h("div", { style: Styles.ButtonsDiv },
                 h(p$1, null,
-                    h("button", { type: "submit", style: Styles.Button, onClick: () => onSubmit(params) }, submitLabel),
+                    h("button", { type: "submit", style: Styles.PrimaryButton, onClick: () => onSubmit(params) }, submitLabel),
                     cancelLabel && (h("button", { style: Styles.Button, onClick: onCancel }, cancelLabel))))));
     }
     function valueTransformer(type, value) {
@@ -18009,7 +18134,7 @@
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.2.0",
+            version: "4.2.2",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -18326,7 +18451,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.2.0";
+    dexieCloud.version = "4.2.2";
     Dexie.Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections: