Attempt to fix doc despose try 2

Author: Nateowami

.github/workflows/e2e-tests.yml

@@ -3,8 +3,6 @@ permissions: {}
 
 on:
   pull_request:
-    branches:
-      - "e2e/**"
   merge_group:
   workflow_dispatch:
   schedule:

src/SIL.XForge.Scripture/ClientApp/src/xforge-common/models/realtime-doc.ts

@@ -80,8 +80,6 @@ export abstract class RealtimeDoc<T = any, Ops = any, P = any> {
   private subscribeQueryCount: number = 0;
   private loadOfflineDataPromise?: Promise<void>;
 
-  /** Indicates whether the document is in the process of being disposed. It completes when disposing is finished.*/
-  private readonly isDisposing$ = new BehaviorSubject<boolean>(false);
   docSubscriptions = new Set<DocSubscription>();
 
   constructor(
@@ -141,26 +139,6 @@ export abstract class RealtimeDoc<T = any, Ops = any, P = any> {
     return this._delete$;
   }
 
-  /**
-   * Indicates whether the document is in the process of being disposed. This is important because when a document is
-   * being disposed, it will still be in some places where it is expected (e.g. in the RealtimeService's docs list), but
-   * subscribing to it would not work as expected.
-   */
-  get isDisposing(): boolean {
-    return this.isDisposing$.getValue();
-  }
-
-  /**
-   * A promise that resolves when the document is fully disposed. See `isDisposing`. When getting a realtime document
-   * from the RealtimeService, this promise can be used to wait for the document to be fully disposed before proceeding,
-   * rather than returning a document that is in the process of being disposed.
-   */
-  get disposeCompleted(): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      this.isDisposing$.subscribe({ complete: resolve, error: reject });
-    });
-  }
-
   /**
    * Returns an observable that emits whenever any remote changes occur.
    *
@@ -245,16 +223,16 @@ export abstract class RealtimeDoc<T = any, Ops = any, P = any> {
    * @returns {Promise<void>} Resolves when the data has been successfully disposed.
    */
   async dispose(): Promise<void> {
-    this.isDisposing$.next(true);
-    await this.realtimeService.onLocalDocDispose(this);
+    this.realtimeService.onDocDisposeStarted(this);
     if (this.subscribePromise != null) {
       await this.subscribePromise;
     }
     this.updateOfflineDataSub.unsubscribe();
     this.onDeleteSub.unsubscribe();
     await this.adapter.destroy();
     this.subscribedState = false;
-    this.isDisposing$.complete();
+    await this.realtimeService.onLocalDocDispose(this);
+    this.realtimeService.onDocDisposeFinished(this);
   }
 
   addSubscriber(docSubscription: DocSubscription): void {
@@ -267,7 +245,6 @@ export abstract class RealtimeDoc<T = any, Ops = any, P = any> {
 
       if (this.activeDocSubscriptionsCount === 0) {
         console.log(`No active subscribers for ${this.collection}:${this.id}. Disposing.`);
-        this.realtimeService.docLifecycleMonitor.docDestroyed(`${this.collection}:${this.id}`);
         this.dispose();
       }
     });

src/SIL.XForge.Scripture/ClientApp/src/xforge-common/realtime.service.ts

@@ -1,5 +1,5 @@
 import { DestroyRef, Injectable, Optional } from '@angular/core';
-import { filter, race, take, timer } from 'rxjs';
+import { filter, lastValueFrom, race, Subject, take, timer } from 'rxjs';
 import { AppError } from 'xforge-common/exception-handling.service';
 import { FileService } from './file.service';
 import { DocSubscription, RealtimeDoc } from './models/realtime-doc';
@@ -36,6 +36,7 @@ export const noopDestroyRef: DestroyRef = {
 })
 export class RealtimeService {
   protected readonly docs = new Map<string, RealtimeDoc>();
+  protected readonly disposingDocIds = new Map<string, Subject<void>>();
   protected readonly subscribeQueries = new Map<string, Set<RealtimeQuery>>();
 
   constructor(
@@ -106,9 +107,9 @@ export class RealtimeService {
     let doc = this.docs.get(key);
 
     // Handle documents that currently exist but are in the process of being disposed.
-    if (doc?.isDisposing) {
+    if (doc != null && this.disposingDocIds.has(doc.id)) {
       console.log(`Waiting for document ${key} to be disposed before recreating it.`);
-      await doc.disposeCompleted;
+      await lastValueFrom(this.disposingDocIds.get(doc.id)!);
       // Recursively call this method so if multiple callers are waiting for the same document to be disposed, they will
       // all get the same instance.
       return await this.get<T>(collection, id, subscriber);
@@ -127,7 +128,7 @@ export class RealtimeService {
         });
       }
       this.docs.set(key, doc);
-      this.docLifecycleMonitor.docCreated(`${collection}:${id}`, subscriber.callerContext);
+      this.docLifecycleMonitor.docCreated(getDocKey(collection, id), subscriber.callerContext);
     }
     doc.addSubscriber(subscriber);
 
@@ -249,10 +250,24 @@ export class RealtimeService {
     }
   }
 
+  onDocDisposeStarted(doc: RealtimeDoc): void {
+    this.disposingDocIds.set(doc.id, new Subject<void>());
+    this.docLifecycleMonitor.docDestroyed(getDocKey(doc.collection, doc.id));
+    this.docs.delete(getDocKey(doc.collection, doc.id));
+  }
+
   async onLocalDocDispose(doc: RealtimeDoc): Promise<void> {
     if (this.isSet(doc.collection, doc.id)) {
       await this.offlineStore.delete(doc.collection, doc.id);
-      this.docs.delete(getDocKey(doc.collection, doc.id));
+    }
+  }
+
+  onDocDisposeFinished(doc: RealtimeDoc): void {
+    const disposingDocId = this.disposingDocIds.get(doc.id);
+    if (disposingDocId != null) {
+      disposingDocId.next();
+      disposingDocId.complete();
+      this.disposingDocIds.delete(doc.id);
     }
   }