dexie-cloud-addon 4.2.0 → 4.2.2

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.2, Sat Oct 04 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);
@@ -4224,6 +4284,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                             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]);
@@ -4255,29 +4316,32 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                     };
                                     const validKeys = new 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;
                                     }
                                 }
                             }
@@ -4319,49 +4383,59 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                         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;
                             }
@@ -5256,34 +5330,85 @@ const Styles = {
         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))));
@@ -5335,7 +5460,7 @@ function LoginDialog({ title, type, alerts, fields, submitLabel, cancelLabel, on
                     } })))))),
         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) {
@@ -6137,7 +6262,7 @@ function dexieCloud(dexie) {
     const syncComplete = new Subject();
     dexie.cloud = {
         // @ts-ignore
-        version: "4.2.0",
+        version: "4.2.2",
         options: Object.assign({}, DEFAULT_OPTIONS),
         schema: null,
         get currentUserId() {
@@ -6454,7 +6579,7 @@ function dexieCloud(dexie) {
     }
 }
 // @ts-ignore
-dexieCloud.version = "4.2.0";
+dexieCloud.version = "4.2.2";
 Dexie.Cloud = dexieCloud;
 
 export { dexieCloud as default, defineYDocTrigger, dexieCloud, getTiedObjectId, getTiedRealmId, resolveText };