Dexie Cloud: Support for unsynced properties (local-only properties t…

…hat are never synced to server)

addons/dexie-cloud/src/DexieCloudOptions.ts

@@ -29,6 +29,10 @@ export interface DexieCloudOptions {
   // not be synced with Dexie Cloud
   unsyncedTables?: string[];
 
+  unsyncedProperties?: {
+    [tableName: string]: string[];
+  }
+
   // By default Dexie Cloud will suffix the cloud DB ID to your IndexedDB database name
   // in order to ensure that the local database is uniquely tied to the remote one and
   // will use another local database if databaseURL is changed or if dexieCloud addon

addons/dexie-cloud/src/define-ydoc-trigger.ts

@@ -45,9 +45,8 @@ const createMiddleware: (db: Dexie) => Middleware<DBCore> = (db) => ({
           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 as YUpdateRow).k;
                   const doc = DexieYProvider.getDocCache(db).find(
                     parentTable,
                     primaryKey,

addons/dexie-cloud/src/middlewares/createMutationTrackingMiddleware.ts

@@ -7,8 +7,9 @@ import {
   DBCoreTable,
   DBCoreTransaction,
   Middleware,
+  RangeSet,
 } from 'dexie';
-import { DBOperation } from 'dexie-cloud-common';
+import { DBOperation, DBUpdateOperation } from 'dexie-cloud-common';
 import { BehaviorSubject } from 'rxjs';
 import { DexieCloudDB } from '../db/DexieCloudDB';
 import { UserLogin } from '../db/entities/UserLogin';
@@ -94,10 +95,7 @@ export function createMutationTrackingMiddleware({
               outstandingTransactions.next(outstandingTransactions.value);
             };
             const txComplete = () => {
-              if (
-                tx.mutationsAdded &&
-                !isEagerSyncDisabled(db)
-              ) {
+              if (tx.mutationsAdded && !isEagerSyncDisabled(db)) {
                 triggerSync(db, 'push');
               }
               removeTransaction();
@@ -193,27 +191,98 @@ export function createMutationTrackingMiddleware({
             req: DBCoreDeleteRequest | DBCoreAddRequest | DBCorePutRequest
           ): Promise<DBCoreMutateResponse> {
             const trans = req.trans as DBCoreTransaction & TXExpandos;
-            trans.mutationsAdded = true;
+            const unsyncedProps =
+              db.cloud.options?.unsyncedProperties?.[tableName];
             const {
               txid,
               currentUser: { userId },
             } = trans;
             const { type } = req;
             const opNo = ++trans.opCount;
 
+            function stripChangeSpec(changeSpec: { [keyPath: string]: any }) {
+              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 = { ...changeSpec }; // clone on demand
+                  delete rv[keyPath];
+                }
+              }
+              return rv;
+            }
+
             return table.mutate(req).then((res) => {
               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 = { ...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: DBCorePutRequest['updates'] = {
+                    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: any[] = [];
+                    let newValues: any[] = [];
+                    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 =
+              let criteria =
                 'criteria' in req && req.criteria
                   ? {
                       ...req.criteria,
@@ -223,6 +292,20 @@ export function createMutationTrackingMiddleware({
                           : req.criteria.index,
                     }
                   : undefined;
+              if (unsyncedProps && criteria?.index) {
+                const keyPaths = schema.indexes.find(
+                  (idx) => idx.name === criteria!.index
+                )?.keyPath;
+                const involvedProps = keyPaths
+                  ? typeof keyPaths === 'string'
+                    ? [keyPaths]
+                    : keyPaths
+                  : [];
+                if (involvedProps.some((p) => unsyncedProps?.includes(p))) {
+                  // Don't log criteria on unsynced properties as the server could not test them.
+                  criteria = undefined;
+                }
+              }
 
               const mut: DBOperation =
                 req.type === 'delete'
@@ -245,15 +328,26 @@ export function createMutationTrackingMiddleware({
                       userId,
                       values,
                     }
-                  : criteria && req.changeSpec
+                  : criteria && changeSpec
                   ? {
                       // Common changeSpec for all keys
                       type: 'modify',
                       ts,
                       opNo,
                       keys,
                       criteria,
-                      changeSpec: req.changeSpec,
+                      changeSpec,
+                      txid,
+                      userId,
+                    }
+                  : changeSpec
+                  ? {
+                      // In case criteria involved an unsynced property, we go for keys instead.
+                      type: 'update',
+                      ts,
+                      opNo,
+                      keys,
+                      changeSpecs: keys.map(() => changeSpec!),
                       txid,
                       userId,
                     }