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

package/dist/modern/DexieCloudOptions.d.ts

@@ -10,6 +10,9 @@ export interface DexieCloudOptions {
     periodicSync?: PeriodicSyncOptions;
     customLoginGui?: boolean;
     unsyncedTables?: string[];
+    unsyncedProperties?: {
+        [tableName: string]: string[];
+    };
     nameSuffix?: boolean;
     disableWebSocket?: boolean;
     disableEagerSync?: boolean;

package/dist/modern/dexie-cloud-addon.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
  *
@@ -16,7 +16,7 @@
  * 
  */
 
-import Dexie, { PropModification, cmp, DexieYProvider, liveQuery, RangeSet } from 'dexie';
+import Dexie, { PropModification, cmp, DexieYProvider, RangeSet, liveQuery } from 'dexie';
 import { firstValueFrom, from as from$1, filter as filter$1, Observable as Observable$1, BehaviorSubject, Subject, fromEvent, of, merge, switchMap as switchMap$1, tap as tap$1, mergeMap as mergeMap$1, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1 } from 'rxjs';
 
 /******************************************************************************
@@ -6321,8 +6321,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                             outstandingTransactions.next(outstandingTransactions.value);
                         };
                         const txComplete = () => {
-                            if (tx.mutationsAdded &&
-                                !isEagerSyncDisabled(db)) {
+                            if (tx.mutationsAdded && !isEagerSyncDisabled(db)) {
                                 triggerSync(db, 'push');
                             }
                             removeTransaction();
@@ -6404,26 +6403,107 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                 : 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 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',
@@ -6444,7 +6524,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                         userId,
                                         values,
                                     }
-                                    : criteria && req.changeSpec
+                                    : criteria && changeSpec
                                         ? {
                                             // Common changeSpec for all keys
                                             type: 'modify',
@@ -6452,30 +6532,41 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                             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;
                             }
@@ -8002,7 +8093,7 @@ function dexieCloud(dexie) {
     const syncComplete = new 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() {
@@ -8304,7 +8395,7 @@ function dexieCloud(dexie) {
     }
 }
 // @ts-ignore
-dexieCloud.version = "4.1.0-alpha.12";
+dexieCloud.version = "4.1.0-alpha.14";
 Dexie.Cloud = dexieCloud;
 
 const ydocTriggers = {};
@@ -8328,8 +8419,8 @@ const createMiddleware = (db) => ({
                 return Object.assign(Object.assign({}, coreTable), { mutate(req) {
                         switch (req.type) {
                             case 'add': {
-                                for (const obj of req.values) {
-                                    const primaryKey = coreTable.schema.primaryKey.extractKey(obj);
+                                for (const yUpdateRow of req.values) {
+                                    const primaryKey = yUpdateRow.k;
                                     const doc = DexieYProvider.getDocCache(db).find(parentTable, primaryKey, prop);
                                     if (doc) {
                                         if (!docIsAlreadyHooked.has(doc)) {
@@ -8338,7 +8429,7 @@ const createMiddleware = (db) => ({
                                         }
                                     }
                                     else {
-                                        enqueueTrigger(tblName, primaryKey, trigger);
+                                        enqueueTrigger(db, tblName, primaryKey, trigger);
                                     }
                                 }
                                 break;
@@ -8361,7 +8452,7 @@ const createMiddleware = (db) => ({
                                             keySet.addKey(k);
                                         }
                                         for (const key of keySet) {
-                                            enqueueTrigger(tblName, key, trigger);
+                                            enqueueTrigger(db, tblName, key, trigger);
                                         }
                                     });
                                 }
@@ -8403,11 +8494,12 @@ function executeTriggers(triggersToRun) {
         }
     });
 }
-function enqueueTrigger(updatesTable, parentId, trigger) {
-    var _a;
-    ((_a = scheduledTriggers[updatesTable]) !== null && _a !== void 0 ? _a : (scheduledTriggers[updatesTable] = [])).push({
+function enqueueTrigger(db, updatesTable, parentId, trigger) {
+    scheduledTriggers.push({
+        db,
         parentId,
         trigger,
+        updatesTable
     });
 }
 function onTransactionCommitted() {