dexie-cloud-addon 1.0.0-beta.10 → 1.0.0-beta.11

package/dist/umd/dexie-cloud-addon.js

@@ -104,7 +104,7 @@
      *
      * ==========================================================================
      *
-     * Version 1.0.0-beta.10, Wed Sep 08 2021
+     * Version 1.0.0-beta.10, Wed Oct 06 2021
      *
      * https://dexie.org
      *
@@ -3142,6 +3142,151 @@
         };
         return BroadcastedAndLocalEvent;
     }(rxjs.Observable));
+    function computeRealmSetHash(_g) {
+        var realms = _g.realms, inviteRealms = _g.inviteRealms;
+        return __awaiter(this, void 0, void 0, function () {
+            var data, byteArray, digestBytes, base64;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0:
+                        data = JSON.stringify(__spreadArray(__spreadArray([], realms.map(function (realmId) { return ({ realmId: realmId, accepted: true }); })), inviteRealms.map(function (realmId) { return ({ realmId: realmId, accepted: false }); })).sort(function (a, b) { return a.realmId < b.realmId ? -1 : a.realmId > b.realmId ? 1 : 0; }));
+                        byteArray = new TextEncoder().encode(data);
+                        return [4 /*yield*/, crypto.subtle.digest('SHA-1', byteArray)];
+                    case 1:
+                        digestBytes = _h.sent();
+                        base64 = b64encode(digestBytes);
+                        return [2 /*return*/, base64];
+                }
+            });
+        });
+    }
+    function getSyncableTables(db) {
+        return Object.entries(db.cloud.schema || {})
+            .filter(function (_g) {
+            var markedForSync = _g[1].markedForSync;
+            return markedForSync;
+        })
+            .map(function (_g) {
+            var tbl = _g[0];
+            return db.table(tbl);
+        });
+    }
+    function getMutationTable(tableName) {
+        return "$" + tableName + "_mutations";
+    }
+    function getTableFromMutationTable(mutationTable) {
+        var _a;
+        var tableName = (_a = /^\$(.*)_mutations$/.exec(mutationTable)) === null || _a === void 0 ? void 0 : _a[1];
+        if (!tableName)
+            throw new Error("Given mutationTable " + mutationTable + " is not correct");
+        return tableName;
+    }
+    function listClientChanges(mutationTables, db, _g) {
+        var _h = _g === void 0 ? {} : _g, _j = _h.since, since = _j === void 0 ? {} : _j, _k = _h.limit, limit = _k === void 0 ? Infinity : _k;
+        return __awaiter(this, void 0, void 0, function () {
+            var allMutsOnTables;
+            var _this_1 = this;
+            return __generator(this, function (_l) {
+                switch (_l.label) {
+                    case 0: return [4 /*yield*/, Promise.all(mutationTables.map(function (mutationTable) { return __awaiter(_this_1, void 0, void 0, function () {
+                            var tableName, lastRevision, query, muts;
+                            return __generator(this, function (_g) {
+                                switch (_g.label) {
+                                    case 0:
+                                        tableName = getTableFromMutationTable(mutationTable.name);
+                                        lastRevision = since[tableName];
+                                        query = lastRevision
+                                            ? mutationTable.where("rev").above(lastRevision)
+                                            : mutationTable;
+                                        if (limit < Infinity)
+                                            query = query.limit(limit);
+                                        return [4 /*yield*/, query.toArray()];
+                                    case 1:
+                                        muts = _g.sent();
+                                        //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 [2 /*return*/, {
+                                                table: tableName,
+                                                muts: muts,
+                                            }];
+                                }
+                            });
+                        }); }))];
+                    case 1:
+                        allMutsOnTables = _l.sent();
+                        // Filter out those tables that doesn't have any mutations:
+                        return [2 /*return*/, allMutsOnTables.filter(function (_g) {
+                                var muts = _g.muts;
+                                return muts.length > 0;
+                            })];
+                }
+            });
+        });
+    }
+    function listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ignoredRealms_1, inserts;
+            var _this_1 = this;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        if (!currentUser.isLoggedIn) return [3 /*break*/, 2];
+                        if (!(tablesToSyncify.length > 0)) return [3 /*break*/, 2];
+                        ignoredRealms_1 = new Set(alreadySyncedRealms || []);
+                        return [4 /*yield*/, Promise.all(tablesToSyncify.map(function (table) { return __awaiter(_this_1, void 0, void 0, function () {
+                                var extractKey, dexieCloudTableSchema, query, unsyncedObjects, mut;
+                                return __generator(this, function (_g) {
+                                    switch (_g.label) {
+                                        case 0:
+                                            extractKey = table.core.schema.primaryKey.extractKey;
+                                            if (!extractKey)
+                                                return [2 /*return*/, { table: table.name, muts: [] }]; // Outbound tables are not synced.
+                                            dexieCloudTableSchema = schema[table.name];
+                                            query = (dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.generatedGlobalId)
+                                                ? table.filter(function (item) { return !ignoredRealms_1.has(item.realmId || "") && isValidSyncableID(extractKey(item)); })
+                                                : table.filter(function (item) { return !ignoredRealms_1.has(item.realmId || "") && isValidAtID(extractKey(item), dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.idPrefix); });
+                                            return [4 /*yield*/, query.toArray()];
+                                        case 1:
+                                            unsyncedObjects = _g.sent();
+                                            if (unsyncedObjects.length > 0) {
+                                                mut = {
+                                                    type: "insert",
+                                                    values: unsyncedObjects,
+                                                    keys: unsyncedObjects.map(extractKey),
+                                                    userId: currentUser.userId,
+                                                };
+                                                return [2 /*return*/, {
+                                                        table: table.name,
+                                                        muts: [mut],
+                                                    }];
+                                            }
+                                            else {
+                                                return [2 /*return*/, {
+                                                        table: table.name,
+                                                        muts: []
+                                                    }];
+                                            }
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        inserts = _g.sent();
+                        return [2 /*return*/, inserts.filter(function (op) { return op.muts.length > 0; })];
+                    case 2: return [2 /*return*/, []];
+                }
+            });
+        });
+    }
+    function getTablesToSyncify(db, syncState) {
+        var syncedTables = (syncState === null || syncState === void 0 ? void 0 : syncState.syncedTables) || [];
+        var syncableTables = getSyncableTables(db);
+        var tablesToSyncify = syncableTables.filter(function (tbl) { return !syncedTables.includes(tbl.name); });
+        return tablesToSyncify;
+    }
     var toStr = {}.toString;
     function getToStringTag(val) {
         return toStr.call(val).slice(8, -1);
@@ -3661,22 +3806,6 @@
     //   else
     //     serverRev.rev = new FakeBigInt(server.rev)
     var hasBigIntSupport = typeof BigInt(0) === 'bigint';
-    function getValueOfBigInt(x) {
-        if (typeof x === 'bigint') {
-            return x;
-        }
-        if (hasBigIntSupport) {
-            return typeof x === 'string' ? BigInt(x) : BigInt(x.v);
-        }
-        else {
-            return typeof x === 'string' ? Number(x) : Number(x.v);
-        }
-    }
-    function compareBigInts(a, b) {
-        var valA = getValueOfBigInt(a);
-        var valB = getValueOfBigInt(b);
-        return valA < valB ? -1 : valA > valB ? 1 : 0;
-    }
     var FakeBigInt = /** @class */ (function () {
         function FakeBigInt(value) {
             this.v = value;
@@ -3702,151 +3831,6 @@
         }));
     var TSON = TypesonSimplified(builtin, defs);
     var BISON = Bison(defs);
-    function computeRealmSetHash(_g) {
-        var realms = _g.realms, inviteRealms = _g.inviteRealms;
-        return __awaiter(this, void 0, void 0, function () {
-            var data, byteArray, digestBytes, base64;
-            return __generator(this, function (_h) {
-                switch (_h.label) {
-                    case 0:
-                        data = JSON.stringify(__spreadArray(__spreadArray([], realms.map(function (realmId) { return ({ realmId: realmId, accepted: true }); })), inviteRealms.map(function (realmId) { return ({ realmId: realmId, accepted: false }); })).sort(function (a, b) { return a.realmId < b.realmId ? -1 : a.realmId > b.realmId ? 1 : 0; }));
-                        byteArray = new TextEncoder().encode(data);
-                        return [4 /*yield*/, crypto.subtle.digest('SHA-1', byteArray)];
-                    case 1:
-                        digestBytes = _h.sent();
-                        base64 = b64encode(digestBytes);
-                        return [2 /*return*/, base64];
-                }
-            });
-        });
-    }
-    function getSyncableTables(db) {
-        return Object.entries(db.cloud.schema || {})
-            .filter(function (_g) {
-            var markedForSync = _g[1].markedForSync;
-            return markedForSync;
-        })
-            .map(function (_g) {
-            var tbl = _g[0];
-            return db.table(tbl);
-        });
-    }
-    function getMutationTable(tableName) {
-        return "$" + tableName + "_mutations";
-    }
-    function getTableFromMutationTable(mutationTable) {
-        var _a;
-        var tableName = (_a = /^\$(.*)_mutations$/.exec(mutationTable)) === null || _a === void 0 ? void 0 : _a[1];
-        if (!tableName)
-            throw new Error("Given mutationTable " + mutationTable + " is not correct");
-        return tableName;
-    }
-    function listClientChanges(mutationTables, db, _g) {
-        var _h = _g === void 0 ? {} : _g, _j = _h.since, since = _j === void 0 ? {} : _j, _k = _h.limit, limit = _k === void 0 ? Infinity : _k;
-        return __awaiter(this, void 0, void 0, function () {
-            var allMutsOnTables;
-            var _this_1 = this;
-            return __generator(this, function (_l) {
-                switch (_l.label) {
-                    case 0: return [4 /*yield*/, Promise.all(mutationTables.map(function (mutationTable) { return __awaiter(_this_1, void 0, void 0, function () {
-                            var tableName, lastRevision, query, muts;
-                            return __generator(this, function (_g) {
-                                switch (_g.label) {
-                                    case 0:
-                                        tableName = getTableFromMutationTable(mutationTable.name);
-                                        lastRevision = since[tableName];
-                                        query = lastRevision
-                                            ? mutationTable.where("rev").above(lastRevision)
-                                            : mutationTable;
-                                        if (limit < Infinity)
-                                            query = query.limit(limit);
-                                        return [4 /*yield*/, query.toArray()];
-                                    case 1:
-                                        muts = _g.sent();
-                                        //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 [2 /*return*/, {
-                                                table: tableName,
-                                                muts: muts,
-                                            }];
-                                }
-                            });
-                        }); }))];
-                    case 1:
-                        allMutsOnTables = _l.sent();
-                        // Filter out those tables that doesn't have any mutations:
-                        return [2 /*return*/, allMutsOnTables.filter(function (_g) {
-                                var muts = _g.muts;
-                                return muts.length > 0;
-                            })];
-                }
-            });
-        });
-    }
-    function listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms) {
-        return __awaiter(this, void 0, void 0, function () {
-            var ignoredRealms_1, inserts;
-            var _this_1 = this;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
-                    case 0:
-                        if (!currentUser.isLoggedIn) return [3 /*break*/, 2];
-                        if (!(tablesToSyncify.length > 0)) return [3 /*break*/, 2];
-                        ignoredRealms_1 = new Set(alreadySyncedRealms || []);
-                        return [4 /*yield*/, Promise.all(tablesToSyncify.map(function (table) { return __awaiter(_this_1, void 0, void 0, function () {
-                                var extractKey, dexieCloudTableSchema, query, unsyncedObjects, mut;
-                                return __generator(this, function (_g) {
-                                    switch (_g.label) {
-                                        case 0:
-                                            extractKey = table.core.schema.primaryKey.extractKey;
-                                            if (!extractKey)
-                                                return [2 /*return*/, { table: table.name, muts: [] }]; // Outbound tables are not synced.
-                                            dexieCloudTableSchema = schema[table.name];
-                                            query = (dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.generatedGlobalId)
-                                                ? table.filter(function (item) { return !ignoredRealms_1.has(item.realmId || "") && isValidSyncableID(extractKey(item)); })
-                                                : table.filter(function (item) { return !ignoredRealms_1.has(item.realmId || "") && isValidAtID(extractKey(item), dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.idPrefix); });
-                                            return [4 /*yield*/, query.toArray()];
-                                        case 1:
-                                            unsyncedObjects = _g.sent();
-                                            if (unsyncedObjects.length > 0) {
-                                                mut = {
-                                                    type: "insert",
-                                                    values: unsyncedObjects,
-                                                    keys: unsyncedObjects.map(extractKey),
-                                                    userId: currentUser.userId,
-                                                };
-                                                return [2 /*return*/, {
-                                                        table: table.name,
-                                                        muts: [mut],
-                                                    }];
-                                            }
-                                            else {
-                                                return [2 /*return*/, {
-                                                        table: table.name,
-                                                        muts: []
-                                                    }];
-                                            }
-                                    }
-                                });
-                            }); }))];
-                    case 1:
-                        inserts = _g.sent();
-                        return [2 /*return*/, inserts.filter(function (op) { return op.muts.length > 0; })];
-                    case 2: return [2 /*return*/, []];
-                }
-            });
-        });
-    }
-    function getTablesToSyncify(db, syncState) {
-        var syncedTables = (syncState === null || syncState === void 0 ? void 0 : syncState.syncedTables) || [];
-        var syncableTables = getSyncableTables(db);
-        var tablesToSyncify = syncableTables.filter(function (tbl) { return !syncedTables.includes(tbl.name); });
-        return tablesToSyncify;
-    }
     //import {BisonWebStreamReader} from "dreambase-library/dist/typeson-simplified/BisonWebStreamReader";
     function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, clientIdentity) {
         return __awaiter(this, void 0, void 0, function () {
@@ -3865,6 +3849,7 @@
                             headers.Authorization = "Bearer " + accessToken;
                         }
                         syncRequest = {
+                            v: 2,
                             dbID: syncState === null || syncState === void 0 ? void 0 : syncState.remoteDbId,
                             clientIdentity: clientIdentity,
                             schema: schema || {},
@@ -4046,8 +4031,8 @@
         if (lastRevisions === void 0) { lastRevisions = {}; }
         for (var _g = 0, clientChangeSet_1 = clientChangeSet; _g < clientChangeSet_1.length; _g++) {
             var _h = clientChangeSet_1[_g], table = _h.table, muts = _h.muts;
-            var lastRev = muts.length > 0 ? muts[muts.length - 1].rev || 0 : 0;
-            lastRevisions[table] = lastRev;
+            var lastRev = muts.length > 0 ? muts[muts.length - 1].rev : null;
+            lastRevisions[table] = lastRev || lastRevisions[table] || 0;
         }
         return lastRevisions;
     }
@@ -4552,27 +4537,49 @@
         var readyToServe = new rxjs.BehaviorSubject(true);
         var event = new rxjs.BehaviorSubject(null);
         var isWorking = false;
+        var loopWarning = 0;
+        var loopDetection = [0, 0, 0, 0, 0, 0, 0, 0, 0, Date.now()];
         event.subscribe(function () { return __awaiter(_this_1, void 0, void 0, function () {
             return __generator(this, function (_g) {
                 switch (_g.label) {
                     case 0:
                         if (isWorking)
                             return [2 /*return*/];
-                        if (!(queue.length > 0)) return [3 /*break*/, 4];
+                        if (!(queue.length > 0)) return [3 /*break*/, 8];
                         isWorking = true;
+                        loopDetection.shift();
+                        loopDetection.push(Date.now());
                         readyToServe.next(false);
                         _g.label = 1;
                     case 1:
-                        _g.trys.push([1, , 3, 4]);
+                        _g.trys.push([1, , 3, 8]);
                         return [4 /*yield*/, consumeQueue()];
                     case 2:
                         _g.sent();
-                        return [3 /*break*/, 4];
+                        return [3 /*break*/, 8];
                     case 3:
+                        if (!(loopDetection[loopDetection.length - 1] - loopDetection[0] < 10000)) return [3 /*break*/, 7];
+                        if (!(Date.now() - loopWarning < 5000)) return [3 /*break*/, 5];
+                        // Last time we did this, we ended up here too. Wait for a minute.
+                        console.warn("Slowing down websocket loop for one minute");
+                        loopWarning = Date.now() + 60000;
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 60000); })];
+                    case 4:
+                        _g.sent();
+                        return [3 /*break*/, 7];
+                    case 5:
+                        // This is a one-time event. Just pause 10 seconds.
+                        console.warn("Slowing down websocket loop for 10 seconds");
+                        loopWarning = Date.now() + 10000;
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10000); })];
+                    case 6:
+                        _g.sent();
+                        _g.label = 7;
+                    case 7:
                         isWorking = false;
                         readyToServe.next(true);
                         return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
+                    case 8: return [2 /*return*/];
                 }
             });
         }); });
@@ -4597,6 +4604,9 @@
                                         case 1:
                                             _j.trys.push([1, 12, , 13]);
                                             console.debug('processing msg', msg);
+                                            // If the sync worker or service worker is syncing, wait 'til thei're done.
+                                            // It's no need to have two channels at the same time - even though it wouldnt
+                                            // be a problem - this is an optimization.
                                             return [4 /*yield*/, db.cloud.syncState
                                                     .pipe(filter(function (_g) {
                                                     var phase = _g.phase;
@@ -4604,6 +4614,9 @@
                                                 }), take(1))
                                                     .toPromise()];
                                         case 2:
+                                            // If the sync worker or service worker is syncing, wait 'til thei're done.
+                                            // It's no need to have two channels at the same time - even though it wouldnt
+                                            // be a problem - this is an optimization.
                                             _j.sent();
                                             console.debug('processing msg', msg);
                                             persistedSyncState = db.cloud.persistedSyncState.value;
@@ -4613,9 +4626,9 @@
                                             _h = msg.type;
                                             switch (_h) {
                                                 case 'token-expired': return [3 /*break*/, 3];
-                                                case 'rev': return [3 /*break*/, 6];
-                                                case 'realm-added': return [3 /*break*/, 7];
-                                                case 'realm-removed': return [3 /*break*/, 8];
+                                                case 'realm-added': return [3 /*break*/, 6];
+                                                case 'realm-removed': return [3 /*break*/, 7];
+                                                case 'realms-changed': return [3 /*break*/, 8];
                                                 case 'changes': return [3 /*break*/, 9];
                                             }
                                             return [3 /*break*/, 11];
@@ -4638,25 +4651,22 @@
                                             // new token. So we don't need to do anything more here.
                                             return [3 /*break*/, 11];
                                         case 6:
-                                            if (!(persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.serverRevision) ||
-                                                compareBigInts(persistedSyncState.serverRevision, msg.rev) < 0) {
-                                                triggerSync(db, "pull");
+                                            if (!((_a = persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.realms) === null || _a === void 0 ? void 0 : _a.includes(msg.realm))) {
+                                                triggerSync(db, 'pull');
                                             }
                                             return [3 /*break*/, 11];
                                         case 7:
-                                            if (!((_a = persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.realms) === null || _a === void 0 ? void 0 : _a.includes(msg.realm))) {
-                                                triggerSync(db, "pull");
+                                            if ((_b = persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.realms) === null || _b === void 0 ? void 0 : _b.includes(msg.realm)) {
+                                                triggerSync(db, 'pull');
                                             }
                                             return [3 /*break*/, 11];
                                         case 8:
-                                            if ((_b = persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.realms) === null || _b === void 0 ? void 0 : _b.includes(msg.realm)) {
-                                                triggerSync(db, "pull");
-                                            }
+                                            triggerSync(db, 'pull');
                                             return [3 /*break*/, 11];
                                         case 9:
                                             console.debug('changes');
                                             if (((_c = db.cloud.syncState.value) === null || _c === void 0 ? void 0 : _c.phase) === 'error') {
-                                                triggerSync(db, "pull");
+                                                triggerSync(db, 'pull');
                                                 return [3 /*break*/, 11];
                                             }
                                             return [4 /*yield*/, db.transaction('rw', db.dx.tables, function (tx) { return __awaiter(_this_1, void 0, void 0, function () {
@@ -4685,17 +4695,35 @@
                                                                     return [2 /*return*/]; // Initial sync must have taken place - otherwise, ignore this.
                                                                 }
                                                                 // Verify again in ACID tx that we're on same server revision.
-                                                                if (compareBigInts(msg.baseRev, syncState.serverRevision) !== 0) {
+                                                                if (msg.baseRev !== syncState.serverRevision) {
                                                                     console.debug("baseRev (" + msg.baseRev + ") differs from our serverRevision in syncState (" + syncState.serverRevision + ")");
+                                                                    // Should we trigger a sync now? No. This is a normal case
+                                                                    // when another local peer (such as the SW or a websocket channel on other tab) has
+                                                                    // updated syncState from new server information but we are not aware yet. It would
+                                                                    // be unnescessary to do a sync in that case. Instead, the caller of this consumeQueue()
+                                                                    // function will do readyToServe.next(true) right after this return, which will lead
+                                                                    // to a "ready" message being sent to server with the new accurate serverRev we have,
+                                                                    // so that the next message indeed will be correct.
+                                                                    if (typeof msg.baseRev === 'string' && // v2 format
+                                                                        (typeof syncState.serverRevision === 'bigint' || // v1 format
+                                                                            typeof syncState.serverRevision === 'object') // v1 format old browser
+                                                                    ) {
+                                                                        // The reason for the diff seems to be that server has migrated the revision format.
+                                                                        // Do a full sync to update revision format.
+                                                                        // If we don't do a sync request now, we could stuck in an endless loop.
+                                                                        triggerSync(db, 'pull');
+                                                                    }
                                                                     return [2 /*return*/]; // Ignore message
                                                                 }
-                                                                return [4 /*yield*/, Dexie__default['default'].waitFor(computeRealmSetHash(syncState))];
+                                                                return [4 /*yield*/, Dexie__default['default'].waitFor(
+                                                                    // Keep TX in non-IDB work
+                                                                    computeRealmSetHash(syncState))];
                                                             case 2:
                                                                 ourRealmSetHash = _h.sent();
                                                                 console.debug('ourRealmSetHash', ourRealmSetHash);
                                                                 if (ourRealmSetHash !== msg.realmSetHash) {
                                                                     console.debug('not same realmSetHash', msg.realmSetHash);
-                                                                    triggerSync(db, "pull");
+                                                                    triggerSync(db, 'pull');
                                                                     // The message isn't based on the same realms.
                                                                     // Trigger a sync instead to resolve all things up.
                                                                     return [2 /*return*/];
@@ -4709,6 +4737,7 @@
                                                                 console.debug('msg queue: client changes', clientChanges);
                                                                 _h.label = 4;
                                                             case 4:
+                                                                if (!(msg.changes.length > 0)) return [3 /*break*/, 6];
                                                                 filteredChanges = filterServerChangesThroughAddedClientChanges(msg.changes, clientChanges);
                                                                 //
                                                                 // apply server changes
@@ -4717,6 +4746,8 @@
                                                                 return [4 /*yield*/, applyServerChanges(filteredChanges, db)];
                                                             case 5:
                                                                 _h.sent();
+                                                                _h.label = 6;
+                                                            case 6:
                                                                 // Update latest revisions per table in case there are unsynced changes
                                                                 // This can be a real case in future when we allow non-eagery sync.
                                                                 // And it can actually be realistic now also, but very rare.
@@ -4725,14 +4756,14 @@
                                                                 // Update base revs
                                                                 console.debug('Updating baseRefs', syncState.latestRevisions);
                                                                 return [4 /*yield*/, updateBaseRevs(db, schema, syncState.latestRevisions, msg.newRev)];
-                                                            case 6:
+                                                            case 7:
                                                                 _h.sent();
                                                                 //
                                                                 // Update syncState
                                                                 //
                                                                 console.debug('Updating syncState', syncState);
                                                                 return [4 /*yield*/, db.$syncState.put(syncState, 'syncState')];
-                                                            case 7:
+                                                            case 8:
                                                                 _h.sent();
                                                                 return [2 /*return*/];
                                                         }
@@ -5619,20 +5650,21 @@
     var FAIL_RETRY_WAIT_TIME = 60000;
     var WSObservable = /** @class */ (function (_super_1) {
         __extends$1(WSObservable, _super_1);
-        function WSObservable(databaseUrl, rev, clientIdentity, messageProducer, webSocketStatus, token, tokenExpiration) {
-            return _super_1.call(this, function (subscriber) { return new WSConnection(databaseUrl, rev, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus); }) || this;
+        function WSObservable(databaseUrl, rev, realmSetHash, clientIdentity, messageProducer, webSocketStatus, token, tokenExpiration) {
+            return _super_1.call(this, function (subscriber) { return new WSConnection(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus); }) || this;
         }
         return WSObservable;
     }(rxjs.Observable));
     var counter = 0;
     var WSConnection = /** @class */ (function (_super_1) {
         __extends$1(WSConnection, _super_1);
-        function WSConnection(databaseUrl, rev, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus) {
+        function WSConnection(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus) {
             var _this_1 = _super_1.call(this, function () { return _this_1.teardown(); }) || this;
             _this_1.id = ++counter;
             console.debug('New WebSocket Connection', _this_1.id, token ? 'authorized' : 'unauthorized');
             _this_1.databaseUrl = databaseUrl;
             _this_1.rev = rev;
+            _this_1.realmSetHash = realmSetHash;
             _this_1.clientIdentity = clientIdentity;
             _this_1.token = token;
             _this_1.tokenExpiration = tokenExpiration;
@@ -5747,7 +5779,9 @@
                             searchParams = new URLSearchParams();
                             if (this.subscriber.closed)
                                 return [2 /*return*/];
+                            searchParams.set('v', "2");
                             searchParams.set('rev', this.rev);
+                            searchParams.set('realmsHash', this.realmSetHash);
                             searchParams.set('clientId', this.clientIdentity);
                             if (this.token) {
                                 searchParams.set('token', this.token);
@@ -5864,12 +5898,26 @@
             var _this_1 = this;
             return db.cloud.persistedSyncState.pipe(filter(function (syncState) { return syncState === null || syncState === void 0 ? void 0 : syncState.serverRevision; }), // Don't connect before there's no initial sync performed.
             take(1), // Don't continue waking up whenever syncState change
-            switchMap(function () { return db.cloud.currentUser; }), switchMap(function (userLogin) { return userIsReallyActive.pipe(map(function (isActive) { return (isActive ? userLogin : null); })); }), switchMap(function (userLogin) {
+            switchMap(function (syncState) { return db.cloud.currentUser.pipe(map(function (userLogin) { return [userLogin, syncState]; })); }), switchMap(function (_g) {
+                var userLogin = _g[0], syncState = _g[1];
+                return userIsReallyActive.pipe(map(function (isActive) { return [isActive ? userLogin : null, syncState]; }));
+            }), switchMap(function (_g) {
+                var userLogin = _g[0], syncState = _g[1];
+                return __awaiter(_this_1, void 0, void 0, function () { var _h; return __generator(this, function (_j) {
+                    switch (_j.label) {
+                        case 0:
+                            _h = [userLogin];
+                            return [4 /*yield*/, computeRealmSetHash(syncState)];
+                        case 1: return [2 /*return*/, _h.concat([_j.sent()])];
+                    }
+                }); });
+            }), switchMap(function (_g) {
+                var userLogin = _g[0], realmSetHash = _g[1];
                 // Let server end query changes from last entry of same client-ID and forward.
                 // If no new entries, server won't bother the client. If new entries, server sends only those
                 // and the baseRev of the last from same client-ID.
                 return userLogin
-                    ? new WSObservable(db.cloud.options.databaseUrl, db.cloud.persistedSyncState.value.serverRevision, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin.accessToken, userLogin.accessTokenExpiration)
+                    ? new WSObservable(db.cloud.options.databaseUrl, db.cloud.persistedSyncState.value.serverRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin.accessToken, userLogin.accessTokenExpiration)
                     : rxjs.from([]);
             }), catchError(function (error) {
                 if ((error === null || error === void 0 ? void 0 : error.name) === 'TokenExpiredError') {
@@ -6025,22 +6073,26 @@
         var cancelToken = { cancelled: false };
         function syncAndRetry(purpose, retryNum) {
             if (retryNum === void 0) { retryNum = 1; }
-            syncIfPossible(db, cloudOptions, cloudSchema, {
-                cancelToken: cancelToken,
-                retryImmediatelyOnFetchError: true,
-                purpose: purpose
-            }).catch(function (e) {
-                console.error('error in syncIfPossible()', e);
-                if (cancelToken.cancelled) {
-                    stop();
-                }
-                else if (retryNum < 3) {
-                    // Mimic service worker sync event: retry 3 times
-                    // * first retry after 5 minutes
-                    // * second retry 15 minutes later
-                    setTimeout(function () { return syncAndRetry(purpose, retryNum + 1); }, [0, 5, 15][retryNum] * MINUTES);
-                }
-            });
+            // Use setTimeout() to get onto a clean stack and
+            // break free from possible active transaction:
+            setTimeout(function () {
+                syncIfPossible(db, cloudOptions, cloudSchema, {
+                    cancelToken: cancelToken,
+                    retryImmediatelyOnFetchError: true,
+                    purpose: purpose,
+                }).catch(function (e) {
+                    console.error('error in syncIfPossible()', e);
+                    if (cancelToken.cancelled) {
+                        stop();
+                    }
+                    else if (retryNum < 3) {
+                        // Mimic service worker sync event: retry 3 times
+                        // * first retry after 5 minutes
+                        // * second retry 15 minutes later
+                        setTimeout(function () { return syncAndRetry(purpose, retryNum + 1); }, [0, 5, 15][retryNum] * MINUTES);
+                    }
+                });
+            }, 0);
         }
         var start = function () {
             // Sync eagerly whenever a change has happened (+ initially when there's no syncState yet)
@@ -6049,7 +6101,7 @@
             localSyncEventSubscription = db.localSyncEvent.subscribe(function (_g) {
                 var purpose = _g.purpose;
                 try {
-                    syncAndRetry(purpose || "pull");
+                    syncAndRetry(purpose || 'pull');
                 }
                 catch (err) {
                     console.error('What-the....', err);