dexie-cloud-addon 4.1.0-alpha.12 → 4.1.0-alpha.14

package/dist/umd/service-worker.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.1.0-alpha.12, Wed Oct 16 2024
+ * Version 4.1.0-alpha.14, Fri Oct 18 2024
  *
  * https://dexie.org
  *
@@ -6324,8 +6324,7 @@
                                 outstandingTransactions.next(outstandingTransactions.value);
                             };
                             const txComplete = () => {
-                                if (tx.mutationsAdded &&
-                                    !isEagerSyncDisabled(db)) {
+                                if (tx.mutationsAdded && !isEagerSyncDisabled(db)) {
                                     triggerSync(db, 'push');
                                 }
                                 removeTransaction();
@@ -6407,26 +6406,107 @@
                                     : mutateAndLog(req);
                             } }));
                         function mutateAndLog(req) {
+                            var _a, _b;
                             const trans = req.trans;
-                            trans.mutationsAdded = true;
+                            const unsyncedProps = (_b = (_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.unsyncedProperties) === null || _b === void 0 ? void 0 : _b[tableName];
                             const { txid, currentUser: { userId }, } = trans;
                             const { type } = req;
                             const opNo = ++trans.opCount;
+                            function stripChangeSpec(changeSpec) {
+                                if (!unsyncedProps)
+                                    return changeSpec;
+                                let rv = changeSpec;
+                                for (const keyPath of Object.keys(changeSpec)) {
+                                    if (unsyncedProps.some((p) => keyPath === p || keyPath.startsWith(p + '.'))) {
+                                        if (rv === changeSpec)
+                                            rv = Object.assign({}, changeSpec); // clone on demand
+                                        delete rv[keyPath];
+                                    }
+                                }
+                                return rv;
+                            }
                             return table.mutate(req).then((res) => {
+                                var _a;
                                 const { numFailures: hasFailures, failures } = res;
                                 let keys = type === 'delete' ? req.keys : res.results;
                                 let values = 'values' in req ? req.values : [];
-                                let updates = 'updates' in req && req.updates;
+                                let changeSpec = 'changeSpec' in req ? req.changeSpec : undefined;
+                                let updates = 'updates' in req ? req.updates : undefined;
                                 if (hasFailures) {
                                     keys = keys.filter((_, idx) => !failures[idx]);
                                     values = values.filter((_, idx) => !failures[idx]);
                                 }
+                                if (unsyncedProps) {
+                                    // Filter out unsynced properties
+                                    values = values.map((value) => {
+                                        const newValue = Object.assign({}, value);
+                                        for (const prop of unsyncedProps) {
+                                            delete newValue[prop];
+                                        }
+                                        return newValue;
+                                    });
+                                    if (changeSpec) {
+                                        // modify operation with criteria and changeSpec.
+                                        // We must strip out unsynced properties from changeSpec.
+                                        // We deal with criteria later.
+                                        changeSpec = stripChangeSpec(changeSpec);
+                                        if (Object.keys(changeSpec).length === 0) {
+                                            // Nothing to change on server
+                                            return res;
+                                        }
+                                    }
+                                    if (updates) {
+                                        let strippedChangeSpecs = updates.changeSpecs.map(stripChangeSpec);
+                                        let newUpdates = {
+                                            keys: [],
+                                            changeSpecs: [],
+                                        };
+                                        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;
+                                            }
+                                        }
+                                        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]);
+                                                }
+                                            }
+                                            keys = newKeys;
+                                            values = newValues;
+                                        }
+                                    }
+                                }
                                 const ts = Date.now();
                                 // Canonicalize req.criteria.index to null if it's on the primary key.
-                                const criteria = 'criteria' in req && req.criteria
+                                let criteria = 'criteria' in req && req.criteria
                                     ? Object.assign(Object.assign({}, req.criteria), { index: req.criteria.index === schema.primaryKey.keyPath // Use null to inform server that criteria is on primary key
                                             ? null // This will disable the server from trying to log consistent operations where it shouldnt.
                                             : req.criteria.index }) : undefined;
+                                if (unsyncedProps && (criteria === null || criteria === void 0 ? void 0 : criteria.index)) {
+                                    const keyPaths = (_a = schema.indexes.find((idx) => idx.name === criteria.index)) === null || _a === void 0 ? void 0 : _a.keyPath;
+                                    const involvedProps = keyPaths
+                                        ? typeof keyPaths === 'string'
+                                            ? [keyPaths]
+                                            : keyPaths
+                                        : [];
+                                    if (involvedProps.some((p) => unsyncedProps === null || unsyncedProps === void 0 ? void 0 : unsyncedProps.includes(p))) {
+                                        // Don't log criteria on unsynced properties as the server could not test them.
+                                        criteria = undefined;
+                                    }
+                                }
                                 const mut = req.type === 'delete'
                                     ? {
                                         type: 'delete',
@@ -6447,7 +6527,7 @@
                                             userId,
                                             values,
                                         }
-                                        : criteria && req.changeSpec
+                                        : criteria && changeSpec
                                             ? {
                                                 // Common changeSpec for all keys
                                                 type: 'modify',
@@ -6455,30 +6535,41 @@
                                                 opNo,
                                                 keys,
                                                 criteria,
-                                                changeSpec: req.changeSpec,
+                                                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;
                                 }
@@ -7998,7 +8089,7 @@
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.1.0-alpha.12",
+            version: "4.1.0-alpha.14",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -8300,7 +8391,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.1.0-alpha.12";
+    dexieCloud.version = "4.1.0-alpha.14";
     Dexie.Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections: