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

package/dist/module-es5/dexie-cloud-addon.js

@@ -97,7 +97,7 @@ function __spreadArray(to, from) {
  *
  * ==========================================================================
  *
- * Version 1.0.0-beta.10, Wed Sep 08 2021
+ * Version 1.0.0-beta.10, Wed Oct 06 2021
  *
  * https://dexie.org
  *
@@ -3135,6 +3135,151 @@ var BroadcastedAndLocalEvent = /** @class */ (function (_super_1) {
     };
     return BroadcastedAndLocalEvent;
 }(Observable$1));
+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);
@@ -3654,22 +3799,6 @@ var undefinedDef = {
 //   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;
@@ -3695,151 +3824,6 @@ var defs = __assign(__assign({}, undefinedDef), (hasBigIntSupport
     }));
 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 () {
@@ -3858,6 +3842,7 @@ function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, c
                         headers.Authorization = "Bearer " + accessToken;
                     }
                     syncRequest = {
+                        v: 2,
                         dbID: syncState === null || syncState === void 0 ? void 0 : syncState.remoteDbId,
                         clientIdentity: clientIdentity,
                         schema: schema || {},
@@ -4039,8 +4024,8 @@ function getLatestRevisionsPerTable(clientChangeSet, lastRevisions) {
     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;
 }
@@ -4545,27 +4530,49 @@ function MessagesFromServerConsumer(db) {
     var readyToServe = new BehaviorSubject(true);
     var event = new 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*/];
             }
         });
     }); });
@@ -4590,6 +4597,9 @@ function MessagesFromServerConsumer(db) {
                                     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;
@@ -4597,6 +4607,9 @@ function MessagesFromServerConsumer(db) {
                                             }), 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;
@@ -4606,9 +4619,9 @@ function MessagesFromServerConsumer(db) {
                                         _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];
@@ -4631,25 +4644,22 @@ function MessagesFromServerConsumer(db) {
                                         // 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 () {
@@ -4678,17 +4688,35 @@ function MessagesFromServerConsumer(db) {
                                                                 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.waitFor(computeRealmSetHash(syncState))];
+                                                            return [4 /*yield*/, Dexie.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*/];
@@ -4702,6 +4730,7 @@ function MessagesFromServerConsumer(db) {
                                                             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
@@ -4710,6 +4739,8 @@ function MessagesFromServerConsumer(db) {
                                                             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.
@@ -4718,14 +4749,14 @@ function MessagesFromServerConsumer(db) {
                                                             // 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*/];
                                                     }
@@ -5612,20 +5643,21 @@ var CLIENT_PING_INTERVAL = 30000;
 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;
 }(Observable$1));
 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;
@@ -5740,7 +5772,9 @@ var WSConnection = /** @class */ (function (_super_1) {
                         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);
@@ -5857,12 +5891,26 @@ function connectWebSocket(db) {
         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)
                 : from$1([]);
         }), catchError(function (error) {
             if ((error === null || error === void 0 ? void 0 : error.name) === 'TokenExpiredError') {
@@ -6018,22 +6066,26 @@ function LocalSyncWorker(db, cloudOptions, cloudSchema) {
     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)
@@ -6042,7 +6094,7 @@ function LocalSyncWorker(db, cloudOptions, cloudSchema) {
         localSyncEventSubscription = db.localSyncEvent.subscribe(function (_g) {
             var purpose = _g.purpose;
             try {
-                syncAndRetry(purpose || "pull");
+                syncAndRetry(purpose || 'pull');
             }
             catch (err) {
                 console.error('What-the....', err);