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

package/dist/umd/service-worker.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.1.0-alpha.10, Wed Oct 16 2024
+ * Version 4.1.0-alpha.12, Wed Oct 16 2024
  *
  * https://dexie.org
  *
@@ -4755,6 +4755,7 @@
     }
 
     function applyYServerMessages(yMessages, db) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const result = {};
             for (const m of yMessages) {
@@ -4786,7 +4787,24 @@
                         // 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);
-                        yield utbl.delete(m.i);
+                        // 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': {
@@ -7807,125 +7825,137 @@
     function createYHandler(db) {
         return (provider) => {
             var _a;
-            const awap = getAwarenessLibrary(db);
             const doc = provider.doc;
-            const { parentTable, parentId, parentProp, updatesTable } = doc.meta;
+            const { parentTable } = doc.meta || {};
             if (!((_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[parentTable].markedForSync)) {
                 return; // The table that holds the doc is not marked for sync - leave it to dexie. No syncing, no awareness.
             }
-            let awareness = new awap.Awareness(doc);
-            awarenessWeakMap.set(doc, awareness);
-            provider.awareness = awareness;
-            awareness.on('update', ({ added, updated, removed }, origin) => {
-                // Send the update
-                const changedClients = added.concat(updated).concat(removed);
-                const user = db.cloud.currentUser.value;
-                if (origin !== 'server' && user.isLoggedIn && !isEagerSyncDisabled(db)) {
-                    const update = awap.encodeAwarenessUpdate(awareness, changedClients);
+            let awareness;
+            Object.defineProperty(provider, "awareness", {
+                get() {
+                    if (awareness)
+                        return awareness;
+                    awarenessWeakMap.set(doc, awareness);
+                    awareness = createAwareness(db, doc, provider);
+                    return awareness;
+                }
+            });
+        };
+    }
+    function createAwareness(db, doc, provider) {
+        const { parentTable, parentId, parentProp, updatesTable } = doc.meta;
+        const awap = getAwarenessLibrary(db);
+        const awareness = new awap.Awareness(doc);
+        awareness.on('update', ({ added, updated, removed }, origin) => {
+            // Send the update
+            const changedClients = added.concat(updated).concat(removed);
+            const user = db.cloud.currentUser.value;
+            if (origin !== 'server' && user.isLoggedIn && !isEagerSyncDisabled(db)) {
+                const update = awap.encodeAwarenessUpdate(awareness, changedClients);
+                db.messageProducer.next({
+                    type: 'aware',
+                    table: parentTable,
+                    prop: parentProp,
+                    k: doc.meta.parentId,
+                    u: update,
+                });
+                if (provider.destroyed) {
+                    // We're called from awareness.on('destroy') that did
+                    // removeAwarenessStates. 
+                    // It's time to also send the doc-close message that dexie-cloud understands
+                    // and uses to stop subscribing for updates and awareness updates and brings
+                    // down the cached information in memory on the WS connection for this.
                     db.messageProducer.next({
-                        type: 'aware',
+                        type: 'doc-close',
                         table: parentTable,
                         prop: parentProp,
-                        k: doc.meta.parentId,
-                        u: update,
+                        k: doc.meta.parentId
                     });
-                    if (provider.destroyed) {
-                        // We're called from awareness.on('destroy') that did
-                        // removeAwarenessStates. 
-                        // It's time to also send the doc-close message that dexie-cloud understands
-                        // and uses to stop subscribing for updates and awareness updates and brings
-                        // down the cached information in memory on the WS connection for this.
-                        db.messageProducer.next({
-                            type: 'doc-close',
-                            table: parentTable,
-                            prop: parentProp,
-                            k: doc.meta.parentId
-                        });
-                    }
                 }
-            });
-            awareness.on('destroy', () => {
-                // Signal to server that this provider is destroyed (the update event will be triggered, which
-                // in turn will trigger db.messageProducer that will send the message to the server if WS is connected)
-                awap.removeAwarenessStates(awareness, [doc.clientID], 'provider destroyed');
-            });
-            // Now wait til document is loaded and then open the document on the server
-            provider.on('load', () => __awaiter(this, void 0, void 0, function* () {
+            }
+        });
+        awareness.on('destroy', () => {
+            // Signal to server that this provider is destroyed (the update event will be triggered, which
+            // in turn will trigger db.messageProducer that will send the message to the server if WS is connected)
+            awap.removeAwarenessStates(awareness, [doc.clientID], 'provider destroyed');
+        });
+        // Open the document on the server
+        (() => __awaiter(this, void 0, void 0, function* () {
+            if (provider.destroyed)
+                return;
+            let connected = false;
+            let currentFlowId = 1;
+            const subscription = db.cloud.webSocketStatus.subscribe((wsStatus) => {
                 if (provider.destroyed)
                     return;
-                let connected = false;
-                let currentFlowId = 1;
-                const subscription = db.cloud.webSocketStatus.subscribe((wsStatus) => {
-                    if (provider.destroyed)
+                // Keep "connected" state in a variable so we can check it after async operations
+                connected = wsStatus === 'connected';
+                // We are or got connected. Open the document on the server.
+                const user = db.cloud.currentUser.value;
+                if (wsStatus === "connected" && user.isLoggedIn && !isEagerSyncDisabled(db)) {
+                    ++currentFlowId;
+                    openDocumentOnServer().catch(error => {
+                        console.warn(`Error catched in createYHandler.ts: ${error}`);
+                    });
+                }
+            });
+            // Wait until WebSocket is connected
+            provider.addCleanupHandler(subscription);
+            /** Sends an 'doc-open' message to server whenever websocket becomes
+             * connected, or if it is already connected.
+             * The flow is aborted in case websocket is disconnected while querying
+             * information required to compute the state vector. Flow is also
+             * aborted in case document or provider has been destroyed during
+             * the async parts of the task.
+             *
+             * The state vector is only computed from the updates that have occured
+             * after the last full sync - which could very often be zero - in which
+             * case no state vector is sent (then the server already knows us by
+             * revision)
+             *
+             * When server gets the doc-open message, it will authorized us for
+             * whether we are allowed to read / write to this document, and then
+             * keep the cached information in memory on the WS connection for this
+             * particular document, as well as subscribe to updates and awareness updates
+             * from other clients on the document.
+             */
+            function openDocumentOnServer(wsStatus) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const myFlow = currentFlowId; // So we can abort when a new flow is started
+                    const yTbl = db.table(updatesTable);
+                    const syncState = yield yTbl.get(DEXIE_CLOUD_SYNCER_ID);
+                    // After every await, check if we still should be working on this task.
+                    if (provider.destroyed || currentFlowId !== myFlow || !connected)
                         return;
-                    // Keep "connected" state in a variable so we can check it after async operations
-                    connected = wsStatus === 'connected';
-                    // We are or got connected. Open the document on the server.
-                    const user = db.cloud.currentUser.value;
-                    if (wsStatus === "connected" && user.isLoggedIn && !isEagerSyncDisabled(db)) {
-                        ++currentFlowId;
-                        openDocumentOnServer().catch(error => {
-                            console.warn(`Error catched in createYHandler.ts: ${error}`);
-                        });
+                    const receivedUntil = (syncState === null || syncState === void 0 ? void 0 : syncState.receivedUntil) || 0;
+                    const docOpenMsg = {
+                        type: 'doc-open',
+                        table: parentTable,
+                        prop: parentProp,
+                        k: parentId,
+                        serverRev: syncState === null || syncState === void 0 ? void 0 : syncState.serverRev,
+                    };
+                    const serverUpdatesSinceLastSync = yield yTbl
+                        .where('i')
+                        .between(receivedUntil, Infinity, false)
+                        .filter((update) => Dexie.cmp(update.k, parentId) === 0 && // Only updates for this document
+                        ((update.f || 0) & 1) === 0 // Don't include local changes
+                    )
+                        .toArray();
+                    // After every await, check if we still should be working on this task.
+                    if (provider.destroyed || currentFlowId !== myFlow || !connected)
+                        return;
+                    if (serverUpdatesSinceLastSync.length > 0) {
+                        const Y = $Y(db); // Get the Yjs library from Dexie constructor options
+                        const mergedUpdate = Y.mergeUpdatesV2(serverUpdatesSinceLastSync.map((update) => update.u));
+                        const stateVector = Y.encodeStateVectorFromUpdateV2(mergedUpdate);
+                        docOpenMsg.sv = stateVector;
                     }
+                    db.messageProducer.next(docOpenMsg);
                 });
-                // Wait until WebSocket is connected
-                provider.addCleanupHandler(subscription);
-                /** Sends an 'doc-open' message to server whenever websocket becomes
-                 * connected, or if it is already connected.
-                 * The flow is aborted in case websocket is disconnected while querying
-                 * information required to compute the state vector. Flow is also
-                 * aborted in case document or provider has been destroyed during
-                 * the async parts of the task.
-                 *
-                 * The state vector is only computed from the updates that have occured
-                 * after the last full sync - which could very often be zero - in which
-                 * case no state vector is sent (then the server already knows us by
-                 * revision)
-                 *
-                 * When server gets the doc-open message, it will authorized us for
-                 * whether we are allowed to read / write to this document, and then
-                 * keep the cached information in memory on the WS connection for this
-                 * particular document, as well as subscribe to updates and awareness updates
-                 * from other clients on the document.
-                 */
-                function openDocumentOnServer(wsStatus) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        const myFlow = currentFlowId; // So we can abort when a new flow is started
-                        const yTbl = db.table(updatesTable);
-                        const syncState = yield yTbl.get(DEXIE_CLOUD_SYNCER_ID);
-                        // After every await, check if we still should be working on this task.
-                        if (provider.destroyed || currentFlowId !== myFlow || !connected)
-                            return;
-                        const receivedUntil = (syncState === null || syncState === void 0 ? void 0 : syncState.receivedUntil) || 0;
-                        const docOpenMsg = {
-                            type: 'doc-open',
-                            table: parentTable,
-                            prop: parentProp,
-                            k: parentId,
-                            serverRev: syncState === null || syncState === void 0 ? void 0 : syncState.serverRev,
-                        };
-                        const serverUpdatesSinceLastSync = yield yTbl
-                            .where('i')
-                            .between(receivedUntil, Infinity, false)
-                            .filter((update) => Dexie.cmp(update.k, parentId) === 0 && // Only updates for this document
-                            ((update.f || 0) & 1) === 0 // Don't include local changes
-                        )
-                            .toArray();
-                        // After every await, check if we still should be working on this task.
-                        if (provider.destroyed || currentFlowId !== myFlow || !connected)
-                            return;
-                        if (serverUpdatesSinceLastSync.length > 0) {
-                            const Y = $Y(db); // Get the Yjs library from Dexie constructor options
-                            const mergedUpdate = Y.mergeUpdatesV2(serverUpdatesSinceLastSync.map((update) => update.u));
-                            const stateVector = Y.encodeStateVectorFromUpdateV2(mergedUpdate);
-                            docOpenMsg.sv = stateVector;
-                        }
-                        db.messageProducer.next(docOpenMsg);
-                    });
-                }
-            }));
-        };
+            }
+        }))();
+        return awareness;
     }
 
     const DEFAULT_OPTIONS = {
@@ -7968,7 +7998,7 @@
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.1.0-alpha.10",
+            version: "4.1.0-alpha.12",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -8270,7 +8300,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.1.0-alpha.10";
+    dexieCloud.version = "4.1.0-alpha.12";
     Dexie.Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections: