dexie-cloud-addon 4.1.0-beta.43 → 4.1.0-beta.45

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

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.1.0-beta.43, Fri Feb 07 2025
+ * Version 4.1.0-beta.45, Mon Mar 31 2025
  *
  * https://dexie.org
  *
@@ -1017,6 +1017,7 @@
                         break;
                     case 'u-s':
                         writeVarUint8Array(encoder, msg.u);
+                        writeVarString(encoder, msg.r || '');
                         break;
                 }
         }
@@ -1403,7 +1404,8 @@
                             table,
                             prop,
                             k,
-                            u: readVarUint8Array(decoder)
+                            u: readVarUint8Array(decoder),
+                            r: (decoder.pos < decoder.arr.length && readVarString(decoder)) || undefined,
                         };
                     default:
                         throw new TypeError(`Unknown message type: ${type}`);
@@ -3680,8 +3682,6 @@
      */
     function setCurrentUser(db, user) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (user.userId === db.cloud.currentUserId)
-                return; // Already this user.
             const $logins = db.table('$logins');
             yield db.transaction('rw', $logins, (tx) => __awaiter(this, void 0, void 0, function* () {
                 const existingLogins = yield $logins.toArray();
@@ -4771,6 +4771,7 @@
                 baseRevs,
                 changes: encodeIdsForServer(db.dx.core.schema, currentUser, changes),
                 y,
+                dxcv: db.cloud.version
             };
             console.debug('Sync request', syncRequest);
             db.syncStateChangedEvent.next({
@@ -4913,9 +4914,11 @@
         return __awaiter(this, void 0, void 0, function* () {
             console.debug('Applying server changes', changes, Dexie.currentTransaction);
             for (const { table: tableName, muts } of changes) {
+                if (!db.dx._allTables[tableName]) {
+                    console.debug(`Server sent changes for table ${tableName} that we don't have. Ignoring.`);
+                    continue;
+                }
                 const table = db.table(tableName);
-                if (!table)
-                    continue; // If server sends changes on a table we don't have, ignore it.
                 const { primaryKey } = table.core.schema;
                 const keyDecoder = (key) => {
                     switch (key[0]) {
@@ -5101,9 +5104,15 @@
 
     function getUpdatesTable(db, table, ydocProp) {
         var _a, _b, _c;
+        if (!db.dx._allTables[table])
+            return undefined;
         const utbl = (_c = (_b = (_a = db.table(table)) === null || _a === void 0 ? void 0 : _a.schema.yProps) === null || _b === void 0 ? void 0 : _b.find(p => p.prop === ydocProp)) === null || _c === void 0 ? void 0 : _c.updatesTable;
-        if (!utbl)
-            throw new Error(`No updatesTable found for ${table}.${ydocProp}`);
+        if (!utbl) {
+            console.debug(`No updatesTable found for ${table}.${ydocProp}`);
+            return undefined;
+        }
+        if (!db.dx._allTables[utbl])
+            return undefined;
         return db.table(utbl);
     }
 
@@ -5114,74 +5123,91 @@
             let resyncNeeded = false;
             let yServerRevision;
             for (const m of yMessages) {
-                switch (m.type) {
-                    case 'u-s': {
-                        const utbl = getUpdatesTable(db, m.table, m.prop);
-                        receivedUntils[utbl.name] = yield utbl.add({
-                            k: m.k,
-                            u: m.u,
-                        });
-                        break;
-                    }
-                    case 'u-ack': {
-                        const utbl = getUpdatesTable(db, m.table, m.prop);
-                        yield db.transaction('rw', utbl, (tx) => __awaiter(this, void 0, void 0, function* () {
-                            let syncer = (yield tx
-                                .table(utbl.name)
-                                .get(DEXIE_CLOUD_SYNCER_ID));
-                            yield tx.table(utbl.name).put(Object.assign(Object.assign({}, (syncer || { i: DEXIE_CLOUD_SYNCER_ID })), { unsentFrom: Math.max((syncer === null || syncer === void 0 ? void 0 : syncer.unsentFrom) || 1, m.i + 1) }));
-                        }));
-                        break;
-                    }
-                    case 'u-reject': {
-                        // Acces control or constraint rejected the update.
-                        // We delete it. It's not going to be sent again.
-                        // What's missing is a way to notify consumers, such as Tiptap editor, that the update was rejected.
-                        // This is only an issue when the document is open. We could find the open document and
-                        // in a perfect world, we should send a reverse update to the open document to undo the change.
-                        // See my question in https://discuss.yjs.dev/t/generate-an-inverse-update/2765
-                        console.debug(`Y update rejected. Deleting it.`);
-                        const utbl = getUpdatesTable(db, m.table, m.prop);
-                        // Delete the rejected update and all local updates since (avoid holes in the CRDT)
-                        // and destroy it's open document if there is one.
-                        const primaryKey = (_a = (yield utbl.get(m.i))) === null || _a === void 0 ? void 0 : _a.k;
-                        if (primaryKey != null) {
-                            yield db.transaction('rw', utbl, (tx) => {
-                                // @ts-ignore
-                                tx.idbtrans._rejecting_y_ypdate = true; // Inform ydoc triggers that we delete because of a rejection and not GC
-                                return utbl
-                                    .where('i')
-                                    .aboveOrEqual(m.i)
-                                    .filter((u) => Dexie.cmp(u.k, primaryKey) === 0 && ((u.f || 0) & 1) === 1)
-                                    .delete();
-                            });
-                            // Destroy active doc
-                            const activeDoc = Dexie.DexieYProvider.getDocCache(db.dx).find(m.table, primaryKey, m.prop);
-                            if (activeDoc)
-                                activeDoc.destroy(); // Destroy the document so that editors don't continue to work on it
+                try {
+                    switch (m.type) {
+                        case 'u-s': {
+                            const utbl = getUpdatesTable(db, m.table, m.prop);
+                            if (utbl) {
+                                const updateRow = {
+                                    k: m.k,
+                                    u: m.u,
+                                };
+                                if (m.r) {
+                                    // @ts-ignore
+                                    updateRow.r = m.r;
+                                    yServerRevision = m.r;
+                                }
+                                receivedUntils[utbl.name] = yield utbl.add(updateRow);
+                            }
+                            break;
                         }
-                        break;
-                    }
-                    case 'in-sync': {
-                        const doc = Dexie.DexieYProvider.getDocCache(db.dx).find(m.table, m.k, m.prop);
-                        if (doc && !doc.isSynced) {
-                            doc.emit('sync', [true]);
+                        case 'u-ack': {
+                            const utbl = getUpdatesTable(db, m.table, m.prop);
+                            if (utbl) {
+                                yield db.transaction('rw', utbl, (tx) => __awaiter(this, void 0, void 0, function* () {
+                                    let syncer = (yield tx
+                                        .table(utbl.name)
+                                        .get(DEXIE_CLOUD_SYNCER_ID));
+                                    yield tx.table(utbl.name).put(Object.assign(Object.assign({}, (syncer || { i: DEXIE_CLOUD_SYNCER_ID })), { unsentFrom: Math.max((syncer === null || syncer === void 0 ? void 0 : syncer.unsentFrom) || 1, m.i + 1) }));
+                                }));
+                            }
+                            break;
                         }
-                        break;
-                    }
-                    case 'y-complete-sync-done': {
-                        yServerRevision = m.yServerRev;
-                        break;
+                        case 'u-reject': {
+                            // Acces control or constraint rejected the update.
+                            // We delete it. It's not going to be sent again.
+                            // What's missing is a way to notify consumers, such as Tiptap editor, that the update was rejected.
+                            // This is only an issue when the document is open. We could find the open document and
+                            // in a perfect world, we should send a reverse update to the open document to undo the change.
+                            // See my question in https://discuss.yjs.dev/t/generate-an-inverse-update/2765
+                            console.debug(`Y update rejected. Deleting it.`);
+                            const utbl = getUpdatesTable(db, m.table, m.prop);
+                            if (!utbl)
+                                break;
+                            // Delete the rejected update and all local updates since (avoid holes in the CRDT)
+                            // and destroy it's open document if there is one.
+                            const primaryKey = (_a = (yield utbl.get(m.i))) === null || _a === void 0 ? void 0 : _a.k;
+                            if (primaryKey != null) {
+                                yield db.transaction('rw', utbl, (tx) => {
+                                    // @ts-ignore
+                                    tx.idbtrans._rejecting_y_ypdate = true; // Inform ydoc triggers that we delete because of a rejection and not GC
+                                    return utbl
+                                        .where('i')
+                                        .aboveOrEqual(m.i)
+                                        .filter((u) => Dexie.cmp(u.k, primaryKey) === 0 && ((u.f || 0) & 1) === 1)
+                                        .delete();
+                                });
+                                // Destroy active doc
+                                const activeDoc = Dexie.DexieYProvider.getDocCache(db.dx).find(m.table, primaryKey, m.prop);
+                                if (activeDoc)
+                                    activeDoc.destroy(); // Destroy the document so that editors don't continue to work on it
+                            }
+                            break;
+                        }
+                        case 'in-sync': {
+                            const doc = Dexie.DexieYProvider.getDocCache(db.dx).find(m.table, m.k, m.prop);
+                            if (doc && !doc.isSynced) {
+                                doc.emit('sync', [true]);
+                            }
+                            break;
+                        }
+                        case 'y-complete-sync-done': {
+                            yServerRevision = m.yServerRev;
+                            break;
+                        }
+                        case 'outdated-server-rev':
+                            resyncNeeded = true;
+                            break;
                     }
-                    case 'outdated-server-rev':
-                        resyncNeeded = true;
-                        break;
+                }
+                catch (e) {
+                    console.error(`Failed to apply YMessage`, m, e);
                 }
             }
             return {
                 receivedUntils,
                 resyncNeeded,
-                yServerRevision
+                yServerRevision,
             };
         });
     }
@@ -5292,7 +5318,9 @@
                                     throw new Error(`Protocol error from ${databaseUrl}/y/download`);
                                 }
                                 const yTable = getUpdatesTable(db, currentTable, currentProp);
-                                yield yTable.bulkAdd(docsToInsert);
+                                if (yTable) {
+                                    yield yTable.bulkAdd(docsToInsert);
+                                }
                                 docsToInsert = [];
                             }
                             if (currentRealmId &&
@@ -5628,12 +5656,12 @@
             return false; // Not needed anymore
         });
     }
-    function deleteObjectsFromRemovedRealms(db, res, prevState) {
+    function deleteObjectsFromRemovedRealms(db, res, syncState) {
         return __awaiter(this, void 0, void 0, function* () {
             const deletedRealms = new Set();
             const rejectedRealms = new Set();
-            const previousRealmSet = prevState ? prevState.realms : [];
-            const previousInviteRealmSet = prevState ? prevState.inviteRealms : [];
+            const previousRealmSet = syncState ? syncState.realms : [];
+            const previousInviteRealmSet = syncState ? syncState.inviteRealms : [];
             const updatedRealmSet = new Set(res.realms);
             const updatedTotalRealmSet = new Set(res.realms.concat(res.inviteRealms));
             for (const realmId of previousRealmSet) {
@@ -5675,17 +5703,10 @@
                     }
                 }
             }
-            if (rejectedRealms.size > 0) {
-                // Remove rejected/deleted realms from yDownloadedRealms because of the following use case:
-                // 1. User becomes added to the realm
-                // 2. User syncs and all documents of the realm is downloaded (downloadYDocsFromServer.ts)
-                // 3. User leaves the realm and all docs are deleted locally (built-in-trigger of deleting their rows in this file)
-                // 4. User is yet again added to the realm. At this point, we must make sure the docs are not considered already downloaded.
-                const updateSpec = {};
+            if (rejectedRealms.size > 0 && (syncState === null || syncState === void 0 ? void 0 : syncState.yDownloadedRealms)) {
                 for (const realmId of rejectedRealms) {
-                    updateSpec[`yDownloadedRealms.${realmId}`] = undefined; // Setting to undefined will delete the property
+                    delete syncState.yDownloadedRealms[realmId];
                 }
-                yield db.$syncState.update('syncState', updateSpec);
             }
         });
     }
@@ -6161,8 +6182,14 @@
                         }
                         return Object.assign(Object.assign({}, table), { mutate: (req) => {
                                 var _a, _b;
-                                // @ts-ignore
-                                if (req.trans.disableChangeTracking) {
+                                const idbtrans = req.trans;
+                                if (idbtrans.mode === 'versionchange') {
+                                    // Tell all the other middlewares to skip bothering. We're in versionchange mode.
+                                    // dexie-cloud is not initialized yet.
+                                    idbtrans.disableChangeTracking = true;
+                                    idbtrans.disableAccessControl = true;
+                                }
+                                if (idbtrans.disableChangeTracking) {
                                     // Disable ID policy checks and ID generation
                                     return table.mutate(req);
                                 }
@@ -6219,17 +6246,13 @@
                 return Object.assign(Object.assign({}, core), { table: (tableName) => {
                         const table = core.table(tableName);
                         return Object.assign(Object.assign({}, table), { mutate: (req) => {
-                                var _a, _b, _c, _d;
-                                // @ts-ignore
-                                if (req.trans.disableChangeTracking) {
+                                var _a, _b, _c, _d, _e, _f;
+                                const trans = req.trans;
+                                if (trans.disableChangeTracking) {
                                     return table.mutate(req);
                                 }
-                                const trans = req.trans;
-                                if ((_b = (_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[tableName]) === null || _b === void 0 ? void 0 : _b.markedForSync) {
-                                    if (trans.mode === 'versionchange') {
-                                        // Don't mutate tables marked for sync in versionchange transactions.
-                                        return Promise.reject(new Dexie.UpgradeError(`Dexie Cloud Addon: Cannot upgrade or populate synced table "${tableName}". See https://dexie.org/cloud/docs/best-practices`));
-                                    }
+                                const currentUserId = (_b = (_a = trans.currentUser) === null || _a === void 0 ? void 0 : _a.userId) !== null && _b !== void 0 ? _b : UNAUTHORIZED_USER.userId;
+                                if ((_d = (_c = db.cloud.schema) === null || _c === void 0 ? void 0 : _c[tableName]) === null || _d === void 0 ? void 0 : _d.markedForSync) {
                                     if (req.type === 'add' || req.type === 'put') {
                                         if (tableName === 'members') {
                                             for (const member of req.values) {
@@ -6253,12 +6276,12 @@
                                         // and expect them to be returned. That scenario must work also when db.cloud.currentUserId === 'unauthorized'.
                                         for (const obj of req.values) {
                                             if (!obj.owner) {
-                                                obj.owner = trans.currentUser.userId;
+                                                obj.owner = currentUserId;
                                             }
                                             if (!obj.realmId) {
-                                                obj.realmId = trans.currentUser.userId;
+                                                obj.realmId = currentUserId;
                                             }
-                                            const key = (_d = (_c = table.schema.primaryKey).extractKey) === null || _d === void 0 ? void 0 : _d.call(_c, obj);
+                                            const key = (_f = (_e = table.schema.primaryKey).extractKey) === null || _f === void 0 ? void 0 : _f.call(_e, obj);
                                             if (typeof key === 'string' && key[0] === '#') {
                                                 // Add $ts prop for put operations and
                                                 // disable update operations as well as consistent
@@ -6354,16 +6377,14 @@
             name: 'MutationTrackingMiddleware',
             level: 1,
             create: (core) => {
+                const allTableNames = new Set(core.schema.tables.map((t) => t.name));
                 const ordinaryTables = core.schema.tables.filter((t) => !/^\$/.test(t.name));
-                let mutTableMap;
-                try {
-                    mutTableMap = new Map(ordinaryTables.map((tbl) => [
-                        tbl.name,
-                        core.table(`$${tbl.name}_mutations`),
-                    ]));
-                }
-                catch (_a) {
-                    throwVersionIncrementNeeded();
+                const mutTableMap = new Map();
+                for (const tbl of ordinaryTables) {
+                    const mutationTableName = `$${tbl.name}_mutations`;
+                    if (allTableNames.has(mutationTableName)) {
+                        mutTableMap.set(tbl.name, core.table(mutationTableName));
+                    }
                 }
                 return Object.assign(Object.assign({}, core), { transaction: (tables, mode) => {
                         let tx;
@@ -6441,6 +6462,11 @@
                         }
                         const { schema } = table;
                         const mutsTable = mutTableMap.get(tableName);
+                        if (!mutsTable) {
+                            // We cannot track mutations on this table because there is no mutations table for it.
+                            // This might happen in upgraders that executes before cloud schema is applied.
+                            return table;
+                        }
                         return guardedTable(Object.assign(Object.assign({}, table), { mutate: (req) => {
                                 var _a, _b, _c;
                                 const trans = req.trans;
@@ -6899,13 +6925,13 @@
     const CLIENT_PING_INTERVAL = 30000;
     const FAIL_RETRY_WAIT_TIME = 60000;
     class WSObservable extends rxjs.Observable {
-        constructor(db, rev, realmSetHash, clientIdentity, messageProducer, webSocketStatus, user) {
-            super((subscriber) => new WSConnection(db, rev, realmSetHash, clientIdentity, user, subscriber, messageProducer, webSocketStatus));
+        constructor(db, rev, yrev, realmSetHash, clientIdentity, messageProducer, webSocketStatus, user) {
+            super((subscriber) => new WSConnection(db, rev, yrev, realmSetHash, clientIdentity, user, subscriber, messageProducer, webSocketStatus));
         }
     }
     let counter = 0;
     class WSConnection extends rxjs.Subscription {
-        constructor(db, rev, realmSetHash, clientIdentity, user, subscriber, messageProducer, webSocketStatus) {
+        constructor(db, rev, yrev, realmSetHash, clientIdentity, user, subscriber, messageProducer, webSocketStatus) {
             super(() => this.teardown());
             this.id = ++counter;
             this.subscriptions = new Set();
@@ -6914,6 +6940,7 @@
             this.db = db;
             this.databaseUrl = db.cloud.options.databaseUrl;
             this.rev = rev;
+            this.yrev = yrev;
             this.realmSetHash = realmSetHash;
             this.clientIdentity = clientIdentity;
             this.user = user;
@@ -6983,6 +7010,11 @@
                 }
                 this.webSocketStatus.next('connecting');
                 this.pinger = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                    // setInterval here causes unnecessary pings when server is proved active anyway.
+                    // TODO: Use setTimout() here instead. When triggered, check if we really need to ping.
+                    // In case we've had server activity, we don't need to ping. Then schedule then next ping
+                    // to the time when we should ping next time (based on lastServerActivity + CLIENT_PING_INTERVAL).
+                    // Else, ping now and schedule next ping to CLIENT_PING_INTERVAL from now.
                     if (this.closed) {
                         console.debug('pinger check', this.id, 'CLOSED.');
                         this.teardown();
@@ -7029,9 +7061,13 @@
                 if (this.subscriber.closed)
                     return;
                 searchParams.set('v', '2');
-                searchParams.set('rev', this.rev);
+                if (this.rev)
+                    searchParams.set('rev', this.rev);
+                if (this.yrev)
+                    searchParams.set('yrev', this.yrev);
                 searchParams.set('realmsHash', this.realmSetHash);
                 searchParams.set('clientId', this.clientIdentity);
+                searchParams.set('dxcv', this.db.cloud.version);
                 if (this.user.accessToken) {
                     searchParams.set('token', this.user.accessToken);
                 }
@@ -7068,8 +7104,8 @@
                                 }
                             }
                         }
-                        else if (msg.type === 'u-ack' || msg.type === 'u-reject' || msg.type === 'u-s' || msg.type === 'in-sync') {
-                            applyYServerMessages([msg], this.db);
+                        else if (msg.type === 'pong') {
+                            // Do nothing
                         }
                         else if (msg.type === 'doc-open') {
                             const docCache = Dexie.DexieYProvider.getDocCache(this.db.dx);
@@ -7078,11 +7114,26 @@
                                 getOpenDocSignal(doc).next(); // Make yHandler reopen the document on server.
                             }
                         }
-                        else if (msg.type === 'outdated-server-rev' || msg.type === 'y-complete-sync-done') {
-                            // Won't happen but need this for typing.
-                            throw new Error('Outdated server revision or y-complete-sync-done not expected over WebSocket - only in sync using fetch()');
+                        else if (msg.type === 'u-ack' || msg.type === 'u-reject' || msg.type === 'u-s' || msg.type === 'in-sync' || msg.type === 'outdated-server-rev' || msg.type === 'y-complete-sync-done') {
+                            applyYServerMessages([msg], this.db).then((_a) => __awaiter(this, [_a], void 0, function* ({ resyncNeeded, yServerRevision, receivedUntils }) {
+                                if (yServerRevision) {
+                                    yield this.db.$syncState.update('syncState', { yServerRevision: yServerRevision });
+                                }
+                                if (msg.type === 'u-s' && receivedUntils) {
+                                    const utbl = getUpdatesTable(this.db, msg.table, msg.prop);
+                                    if (utbl) {
+                                        const receivedUntil = receivedUntils[utbl.name];
+                                        if (receivedUntil) {
+                                            yield utbl.update(DEXIE_CLOUD_SYNCER_ID, { receivedUntil });
+                                        }
+                                    }
+                                }
+                                if (resyncNeeded) {
+                                    yield this.db.cloud.sync({ purpose: 'pull', wait: true });
+                                }
+                            }));
                         }
-                        else if (msg.type !== 'pong') {
+                        else {
                             // Forward the request to our subscriber, wich is in messageFromServerQueue.ts (via connectWebSocket's subscribe() at the end!)
                             this.subscriber.next(msg);
                         }
@@ -7215,7 +7266,7 @@
                 // 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.
                 if (userLogin) {
-                    return new WSObservable(db, db.cloud.persistedSyncState.value.serverRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin);
+                    return new WSObservable(db, db.cloud.persistedSyncState.value.serverRevision, db.cloud.persistedSyncState.value.yServerRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin);
                 }
                 else {
                     return rxjs.from([]);
@@ -7345,61 +7396,95 @@
     }
 
     const SECONDS = 1000;
-    const MINUTES = 60 * SECONDS;
 
     function LocalSyncWorker(db, cloudOptions, cloudSchema) {
         let localSyncEventSubscription = null;
-        //let syncHandler: ((event: Event) => void) | null = null;
-        //let periodicSyncHandler: ((event: Event) => void) | null = null;
         let cancelToken = { cancelled: false };
-        let retryHandle = null;
-        let retryPurpose = null; // "pull" is superset of "push"
-        function syncAndRetry(purpose, retryNum = 1) {
+        let nextRetryTime = 0;
+        let syncStartTime = 0;
+        function syncAndRetry(retryNum = 1) {
             // Use setTimeout() to get onto a clean stack and
             // break free from possible active transaction:
             setTimeout(() => {
-                if (retryHandle)
-                    clearTimeout(retryHandle);
-                const combPurpose = retryPurpose === 'pull' ? 'pull' : purpose;
-                retryHandle = null;
-                retryPurpose = null;
+                const purpose = pullSignalled ? 'pull' : 'push';
+                syncStartTime = Date.now();
                 syncIfPossible(db, cloudOptions, cloudSchema, {
                     cancelToken,
                     retryImmediatelyOnFetchError: true, // workaround for "net::ERR_NETWORK_CHANGED" in chrome.
-                    purpose: combPurpose,
-                }).catch((e) => {
-                    console.error('error in syncIfPossible()', e);
+                    purpose,
+                }).then(() => {
                     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
-                        const combinedPurpose = retryPurpose && retryPurpose === 'pull' ? 'pull' : purpose;
-                        const handle = setTimeout(() => syncAndRetry(combinedPurpose, retryNum + 1), [0, 5, 15][retryNum] * MINUTES);
-                        // Cancel the previous retryHandle if it exists to avoid scheduling loads of retries.
-                        if (retryHandle)
-                            clearTimeout(retryHandle);
-                        retryHandle = handle;
-                        retryPurpose = combinedPurpose;
+                    else {
+                        if (pullSignalled || pushSignalled) {
+                            // If we have signalled for more sync, do it now.
+                            pullSignalled = false;
+                            pushSignalled = false;
+                            return syncAndRetry();
+                        }
+                    }
+                    ongoingSync = false;
+                    nextRetryTime = 0;
+                    syncStartTime = 0;
+                }).catch((error) => {
+                    console.error('error in syncIfPossible()', error);
+                    if (cancelToken.cancelled) {
+                        stop();
+                        ongoingSync = false;
+                        nextRetryTime = 0;
+                        syncStartTime = 0;
+                    }
+                    else if (retryNum < 5) {
+                        // Mimic service worker sync event but a bit more eager: retry 4 times
+                        // * first retry after 20 seconds
+                        // * second retry 40 seconds later
+                        // * third retry 5 minutes later
+                        // * last retry 15 minutes later
+                        const retryIn = [0, 20, 40, 300, 900][retryNum] * SECONDS;
+                        nextRetryTime = Date.now() + retryIn;
+                        syncStartTime = 0;
+                        setTimeout(() => syncAndRetry(retryNum + 1), retryIn);
+                    }
+                    else {
+                        ongoingSync = false;
+                        nextRetryTime = 0;
+                        syncStartTime = 0;
                     }
                 });
             }, 0);
         }
+        let pullSignalled = false;
+        let pushSignalled = false;
+        let ongoingSync = false;
+        const consumer = (purpose) => {
+            if (cancelToken.cancelled)
+                return;
+            if (purpose === 'pull') {
+                pullSignalled = true;
+            }
+            if (purpose === 'push') {
+                pushSignalled = true;
+            }
+            if (ongoingSync) {
+                if (nextRetryTime) {
+                    console.debug(`Sync is paused until ${new Date(nextRetryTime).toISOString()} due to error in last sync attempt`);
+                }
+                else if (syncStartTime > 0 && Date.now() - syncStartTime > 20 * SECONDS) {
+                    console.debug(`An existing sync operation is taking more than 20 seconds. Will resync when done.`);
+                }
+                return;
+            }
+            ongoingSync = true;
+            syncAndRetry();
+        };
         const start = () => {
             // Sync eagerly whenever a change has happened (+ initially when there's no syncState yet)
             // This initial subscribe will also trigger an sync also now.
             console.debug('Starting LocalSyncWorker', db.localSyncEvent['id']);
             localSyncEventSubscription = db.localSyncEvent.subscribe(({ purpose }) => {
-                try {
-                    syncAndRetry(purpose || 'pull');
-                }
-                catch (err) {
-                    console.error('What-the....', err);
-                }
+                consumer(purpose || 'pull');
             });
-            //setTimeout(()=>db.localSyncEvent.next({}), 5000);
         };
         const stop = () => {
             console.debug('Stopping LocalSyncWorker');
@@ -8160,8 +8245,8 @@
 
     const ydocTriggers = {};
     const middlewares = new WeakMap();
-    const txRunner = TriggerRunner("tx");
-    const unloadRunner = TriggerRunner("unload");
+    const txRunner = TriggerRunner("tx"); // Trigger registry for transaction completion. Avoids open docs.
+    const unloadRunner = TriggerRunner("unload"); // Trigger registry for unload. Runs when a document is closed.
     function TriggerRunner(name) {
         let triggerExecPromise = null;
         let triggerScheduled = false;
@@ -8171,14 +8256,17 @@
                 for (const { db, parentId, triggers, parentTable, prop, } of registryCopy.values()) {
                     const yDoc = Dexie.DexieYProvider.getOrCreateDocument(db, parentTable, prop, parentId);
                     try {
-                        Dexie.DexieYProvider.load(yDoc); // If doc is open, this would just be a ++refount
-                        yield yDoc.whenLoaded; // If doc is loaded, this would resolve immediately
+                        const provider = Dexie.DexieYProvider.load(yDoc); // If doc is open, this would just be a ++refount
+                        yield provider.whenLoaded; // If doc is loaded, this would resolve immediately
                         for (const trigger of triggers) {
                             yield trigger(yDoc, parentId);
                         }
                     }
                     catch (error) {
-                        console.error(`Error in YDocTrigger ${error}`);
+                        if ((error === null || error === void 0 ? void 0 : error.name) === 'AbortError') ;
+                        else {
+                            console.error(`Error in YDocTrigger ${error}`);
+                        }
                     }
                     finally {
                         Dexie.DexieYProvider.release(yDoc);
@@ -8190,16 +8278,20 @@
             name,
             run() {
                 return __awaiter(this, void 0, void 0, function* () {
+                    console.log(`Running trigger (${name})?`, triggerScheduled, registry.size, !!triggerExecPromise);
                     if (!triggerScheduled && registry.size > 0) {
                         triggerScheduled = true;
                         if (triggerExecPromise)
                             yield triggerExecPromise.catch(() => { });
                         setTimeout(() => {
                             // setTimeout() is to escape from Promise.PSD zones and never run within liveQueries or transaction scopes
+                            console.log("Running trigger really!", name);
                             triggerScheduled = false;
                             const registryCopy = registry;
                             registry = new Map();
-                            triggerExecPromise = execute(registryCopy).finally(() => (triggerExecPromise = null));
+                            triggerExecPromise = execute(registryCopy).finally(() => {
+                                triggerExecPromise = null;
+                            });
                         }, 0);
                     }
                 });
@@ -8215,6 +8307,7 @@
                         prop,
                         triggers: new Set(),
                     };
+                    console.log(`Adding trigger ${key}`);
                     registry.set(key, entry);
                 }
                 entry.triggers.add(trigger);
@@ -8354,7 +8447,7 @@
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.1.0-beta.43",
+            version: "4.1.0-beta.45",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -8672,7 +8765,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.1.0-beta.43";
+    dexieCloud.version = "4.1.0-beta.45";
     Dexie.Cloud = dexieCloud;
 
     exports.default = dexieCloud;