@dxos/client-services 0.1.41 → 0.1.45-next.45667d4

package/src/packlets/vault/worker-session.ts

@@ -5,11 +5,11 @@
 import assert from 'node:assert';
 
 import { asyncTimeout, Trigger } from '@dxos/async';
-import { iframeServiceBundle, IframeServiceBundle, workerServiceBundle } from '@dxos/client';
+import { iframeServiceBundle, IframeServiceBundle, workerServiceBundle } from '@dxos/client-protocol';
 import { log, logInfo } from '@dxos/log';
 import { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
-import { Callback } from '@dxos/util';
+import { Callback, MaybePromise } from '@dxos/util';
 
 import { ClientServicesHost } from '../services';
 import { ClientRpcServer, ClientRpcServerParams } from '../services/client-rpc-server';
@@ -20,9 +20,6 @@ export type WorkerSessionParams = {
   appPort: RpcPort;
   shellPort: RpcPort;
   readySignal: Trigger<Error | undefined>;
-  options?: {
-    heartbeatInterval: number;
-  };
 };
 
 /**
@@ -34,29 +31,19 @@ export class WorkerSession {
   private readonly _iframeRpc: ProtoRpcPeer<IframeServiceBundle>;
   private readonly _startTrigger = new Trigger();
   private readonly _serviceHost: ClientServicesHost;
-  private readonly _options: NonNullable<WorkerSessionParams['options']>;
-  private _heartbeatTimer?: NodeJS.Timeout;
 
   public readonly onClose = new Callback<() => Promise<void>>();
 
   @logInfo
   public origin?: string;
 
+  @logInfo
+  public lockKey?: string;
+
   public bridgeService?: BridgeService;
 
-  constructor({
-    serviceHost,
-    systemPort,
-    appPort,
-    shellPort,
-    readySignal,
-    options = {
-      heartbeatInterval: 1_000
-    }
-  }: WorkerSessionParams) {
-    assert(options);
+  constructor({ serviceHost, systemPort, appPort, shellPort, readySignal }: WorkerSessionParams) {
     assert(serviceHost);
-    this._options = options;
     this._serviceHost = serviceHost;
 
     const middleware: Pick<ClientRpcServerParams, 'handleCall' | 'handleStream'> = {
@@ -75,18 +62,18 @@ export class WorkerSession {
         }
 
         return handler(method, params);
-      }
+      },
     };
 
     this._clientRpc = new ClientRpcServer({
       serviceRegistry: this._serviceHost.serviceRegistry,
       port: appPort,
-      ...middleware
+      ...middleware,
     });
     this._shellClientRpc = new ClientRpcServer({
       serviceRegistry: this._serviceHost.serviceRegistry,
       port: shellPort,
-      ...middleware
+      ...middleware,
     });
 
     this._iframeRpc = createProtoRpcPeer({
@@ -96,6 +83,7 @@ export class WorkerSession {
         WorkerService: {
           start: async (request) => {
             this.origin = request.origin;
+            this.lockKey = request.lockKey;
             this._startTrigger.wake();
           },
 
@@ -107,11 +95,11 @@ export class WorkerSession {
                 log.catch(err);
               }
             });
-          }
-        }
+          },
+        },
       },
       port: systemPort,
-      timeout: 1000 // With low timeout heartbeat may fail if the tab's thread is saturated.
+      timeout: 1000, // With low timeout heartbeat may fail if the tab's thread is saturated.
     });
 
     this.bridgeService = this._iframeRpc.rpc.BridgeService;
@@ -122,22 +110,9 @@ export class WorkerSession {
     await Promise.all([this._clientRpc.open(), this._iframeRpc.open(), this._maybeOpenShell()]);
 
     await this._startTrigger.wait({ timeout: 3_000 });
-
-    // Detect if bridge is present.
-    // TODO(burdon): Add heartbeat to client's System service.
-    //  How do we detect if the client's tab closed?
-    this._heartbeatTimer = setInterval(async () => {
-      try {
-        await this._iframeRpc.rpc.IframeService.heartbeat();
-      } catch (err) {
-        log.warn('Heartbeat failed', { err });
-        try {
-          await this.close();
-        } catch (err: any) {
-          log.catch(err);
-        }
-      }
-    }, this._options.heartbeatInterval);
+    if (this.lockKey) {
+      void this._afterLockReleases(this.lockKey, () => this.close());
+    }
   }
 
   async close() {
@@ -148,10 +123,6 @@ export class WorkerSession {
       log.catch(err);
     }
 
-    if (this._heartbeatTimer !== undefined) {
-      clearInterval(this._heartbeatTimer);
-    }
-
     await Promise.all([this._clientRpc.close(), this._iframeRpc.close()]);
   }
 
@@ -162,4 +133,12 @@ export class WorkerSession {
       log.info('No shell connected.');
     }
   }
+
+  private _afterLockReleases(lockKey: string, callback: () => MaybePromise<void>): Promise<void> {
+    return navigator.locks
+      .request(lockKey, () => {
+        // No-op.
+      })
+      .then(callback);
+  }
 }