@dxos/client-services 0.1.29-next.ed4ce05 → 0.1.29

package/src/packlets/tests/shared-worker.test.ts

@@ -10,34 +10,41 @@ import { Client, ClientServicesProxy, fromIFrame } from '@dxos/client';
 import { Config } from '@dxos/config';
 import { createLinkedPorts } from '@dxos/rpc';
 import { describe, test, afterTest } from '@dxos/test';
+import { MaybePromise } from '@dxos/util';
 
 import { TestBuilder } from '../testing';
 import { IFrameProxyRuntime, WorkerRuntime } from '../vault';
 
 chai.use(chaiAsPromised);
 
+const setup = (getConfig: () => MaybePromise<Config>) => {
+  const workerRuntime = new WorkerRuntime(getConfig);
+
+  const systemPorts = createLinkedPorts();
+  const workerProxyPorts = createLinkedPorts();
+  const proxyWindowPorts = createLinkedPorts();
+  const shellPorts = createLinkedPorts();
+  void workerRuntime.createSession({
+    systemPort: systemPorts[1],
+    appPort: workerProxyPorts[1],
+    shellPort: shellPorts[1]
+  });
+  const clientProxy = new IFrameProxyRuntime({
+    systemPort: systemPorts[0],
+    windowAppPort: proxyWindowPorts[0],
+    workerAppPort: workerProxyPorts[0],
+    shellPort: shellPorts[0]
+  });
+  const client = new Client({
+    services: new ClientServicesProxy(proxyWindowPorts[1])
+  });
+
+  return { workerRuntime, clientProxy, client };
+};
+
 describe('Shared worker', () => {
   test('client connects to the worker', async () => {
-    const workerRuntime = new WorkerRuntime(() => new Config({}));
-
-    const systemPorts = createLinkedPorts();
-    const workerProxyPorts = createLinkedPorts();
-    const proxyWindowPorts = createLinkedPorts();
-    const shellPorts = createLinkedPorts();
-    void workerRuntime.createSession({
-      systemPort: systemPorts[1],
-      appPort: workerProxyPorts[1],
-      shellPort: shellPorts[1]
-    });
-    const clientProxy = new IFrameProxyRuntime({
-      systemPort: systemPorts[0],
-      windowAppPort: proxyWindowPorts[0],
-      workerAppPort: workerProxyPorts[0],
-      shellPort: shellPorts[0]
-    });
-    const client = new Client({
-      services: new ClientServicesProxy(proxyWindowPorts[1])
-    });
+    const { workerRuntime, clientProxy, client } = setup(() => new Config({}));
 
     await Promise.all([workerRuntime.start(), clientProxy.open('*'), client.initialize()]);
 
@@ -45,32 +52,11 @@ describe('Shared worker', () => {
   });
 
   test('initialization errors get propagated to the client', async () => {
-    const workerRuntime = new WorkerRuntime(async () => {
+    const { workerRuntime, clientProxy, client } = setup(async () => {
       await sleep(1);
       throw new Error('Test error');
     });
 
-    const systemPorts = createLinkedPorts();
-    const workerProxyPorts = createLinkedPorts();
-    const proxyWindowPorts = createLinkedPorts();
-    const shellPorts = createLinkedPorts();
-    void workerRuntime.createSession({
-      systemPort: systemPorts[1],
-      appPort: workerProxyPorts[1],
-      shellPort: shellPorts[1]
-    });
-
-    const clientProxy = new IFrameProxyRuntime({
-      systemPort: systemPorts[0],
-      windowAppPort: proxyWindowPorts[0],
-      workerAppPort: workerProxyPorts[0],
-      shellPort: shellPorts[0]
-    });
-
-    const client = new Client({
-      services: new ClientServicesProxy(proxyWindowPorts[1])
-    });
-
     const promise = Promise.all([
       workerRuntime.start().catch(() => {}), // This error should be propagated to client.initialize() call.
       clientProxy.open('*')
@@ -81,6 +67,17 @@ describe('Shared worker', () => {
     await promise;
   });
 
+  test('host can be initialized after client', async () => {
+    const { workerRuntime, clientProxy, client } = setup(async () => {
+      await sleep(5);
+      return new Config({});
+    });
+
+    await Promise.all([workerRuntime.start(), clientProxy.open('*'), client.initialize()]);
+
+    await client.halo.createIdentity();
+  });
+
   // TODO(burdon): Browser-only.
   test.skip('creates client with remote iframe', async () => {
     const testBuilder = new TestBuilder();

package/src/packlets/vault/iframe-host-runtime.ts

@@ -3,15 +3,15 @@
 //
 
 import { Trigger } from '@dxos/async';
-import { clientServiceBundle, ClientServices } from '@dxos/client';
 import { Config } from '@dxos/config';
 import { log, logInfo } from '@dxos/log';
 import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
 import { createWebRTCTransportFactory, NetworkManager } from '@dxos/network-manager';
-import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
+import { RpcPort } from '@dxos/rpc';
 import { getAsyncValue, Provider } from '@dxos/util';
 
 import { LocalClientServices } from '../services';
+import { ClientRpcServer, ClientRpcServerParams } from '../services/client-rpc-server';
 import { ShellRuntime, ShellRuntimeImpl } from './shell-runtime';
 
 const LOCK_KEY = 'DXOS_RESOURCE_LOCK';
@@ -32,9 +32,6 @@ export class IFrameHostRuntime {
   private readonly _configProvider: Config | Provider<Promise<Config>>;
   private readonly _transportFactory = createWebRTCTransportFactory();
   private readonly _ready = new Trigger<Error | undefined>();
-  private readonly _getService: <Service>(
-    find: (services: Partial<ClientServices>) => Service | undefined
-  ) => Promise<Service>;
 
   private readonly _appPort: RpcPort;
   private readonly _shellPort?: RpcPort;
@@ -42,7 +39,7 @@ export class IFrameHostRuntime {
 
   // TODO(dmaretskyi):  Replace with host and figure out how to return services provider here.
   private _clientServices!: LocalClientServices;
-  private _clientRpc!: ProtoRpcPeer<ClientServices>;
+  private _clientRpc!: ClientRpcServer;
   private _shellRuntime?: ShellRuntimeImpl;
 
   @logInfo
@@ -53,20 +50,6 @@ export class IFrameHostRuntime {
     this._appPort = appPort;
     this._shellPort = shellPort;
 
-    this._getService = async (find) => {
-      const error = await this._ready.wait();
-      if (error) {
-        throw error;
-      }
-
-      const service = await find(this._clientServices.services);
-      if (!service) {
-        throw new Error('Service not found');
-      }
-
-      return service;
-    };
-
     if (this._shellPort) {
       this._shellRuntime = new ShellRuntimeImpl(this._shellPort);
     }
@@ -97,21 +80,29 @@ export class IFrameHostRuntime {
         })
       });
 
-      this._clientRpc = createProtoRpcPeer({
-        exposed: clientServiceBundle,
-        handlers: {
-          DataService: async () => await this._getService((services) => services.DataService),
-          DeviceInvitationsService: async () => await this._getService((services) => services.DeviceInvitationsService),
-          DevicesService: async () => await this._getService((services) => services.DevicesService),
-          DevtoolsHost: async () => await this._getService((services) => services.DevtoolsHost),
-          NetworkService: async () => await this._getService((services) => services.NetworkService),
-          IdentityService: async () => await this._getService((services) => services.IdentityService),
-          SpaceInvitationsService: async () => await this._getService((services) => services.SpaceInvitationsService),
-          SpacesService: async () => await this._getService((services) => services.SpacesService),
-          SystemService: async () => await this._getService((services) => services.SystemService),
-          TracingService: async () => await this._getService((services) => services.TracingService)
+      const middleware: Pick<ClientRpcServerParams, 'handleCall' | 'handleStream'> = {
+        handleCall: async (method, params, handler) => {
+          const error = await this._ready.wait({ timeout: 3_000 });
+          if (error) {
+            throw error;
+          }
+
+          return handler(method, params);
         },
-        port: this._appPort
+        handleStream: async (method, params, handler) => {
+          const error = await this._ready.wait({ timeout: 3_000 });
+          if (error) {
+            throw error;
+          }
+
+          return handler(method, params);
+        }
+      };
+
+      this._clientRpc = new ClientRpcServer({
+        serviceRegistry: this._clientServices.host.serviceRegistry,
+        port: this._appPort,
+        ...middleware
       });
 
       await Promise.all([this._clientServices.open(), this._clientRpc.open(), this._shellRuntime?.open()]);

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

@@ -36,14 +36,16 @@ export class WorkerRuntime {
   // prettier-ignore
   constructor(
     private readonly _configProvider: () => MaybePromise<Config>
-  ) { }
+  ) {
+    this._clientServices = new ClientServicesHost();
+  }
 
   async start() {
     log('starting...');
     try {
       this._config = await this._configProvider();
       const signalServer = this._config.get('runtime.services.signal.server');
-      this._clientServices = new ClientServicesHost({
+      this._clientServices.initialize({
         config: this._config,
         networkManager: new NetworkManager({
           log: true,
@@ -73,19 +75,7 @@ export class WorkerRuntime {
    */
   async createSession({ appPort, systemPort, shellPort }: CreateSessionParams) {
     const session = new WorkerSession({
-      getService: async (find) => {
-        const error = await this._ready.wait();
-        if (error) {
-          throw error;
-        }
-
-        const service = find(this._clientServices.services);
-        if (!service) {
-          throw new Error('Service not found');
-        }
-
-        return service;
-      },
+      serviceHost: this._clientServices,
       appPort,
       systemPort,
       shellPort,

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

@@ -5,20 +5,17 @@
 import assert from 'node:assert';
 
 import { asyncTimeout, Trigger } from '@dxos/async';
-import {
-  clientServiceBundle,
-  ClientServices,
-  iframeServiceBundle,
-  IframeServiceBundle,
-  workerServiceBundle
-} from '@dxos/client';
+import { iframeServiceBundle, IframeServiceBundle, workerServiceBundle } from '@dxos/client';
 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 { ClientServicesHost } from '../services';
+import { ClientRpcServer, ClientRpcServerParams } from '../services/client-rpc-server';
+
 export type WorkerSessionParams = {
-  getService: <Service>(find: (services: Partial<ClientServices>) => Service | undefined) => Promise<Service>;
+  serviceHost: ClientServicesHost;
   systemPort: RpcPort;
   appPort: RpcPort;
   shellPort: RpcPort;
@@ -32,11 +29,11 @@ export type WorkerSessionParams = {
  * Represents a tab connection within the worker.
  */
 export class WorkerSession {
-  private readonly _clientRpc: ProtoRpcPeer<ClientServices>;
-  private readonly _shellClientRpc: ProtoRpcPeer<ClientServices>;
+  private readonly _clientRpc: ClientRpcServer;
+  private readonly _shellClientRpc: ClientRpcServer;
   private readonly _iframeRpc: ProtoRpcPeer<IframeServiceBundle>;
   private readonly _startTrigger = new Trigger();
-  private readonly _getService: WorkerSessionParams['getService'];
+  private readonly _serviceHost: ClientServicesHost;
   private readonly _options: NonNullable<WorkerSessionParams['options']>;
   private _heartbeatTimer?: NodeJS.Timeout;
 
@@ -48,34 +45,49 @@ export class WorkerSession {
   public bridgeService?: BridgeService;
 
   constructor({
-    getService,
+    serviceHost,
     systemPort,
     appPort,
     shellPort,
+    readySignal,
     options = {
       heartbeatInterval: 1_000
     }
   }: WorkerSessionParams) {
     assert(options);
-    assert(getService);
+    assert(serviceHost);
     this._options = options;
-    this._getService = getService;
-
-    const handlers = {
-      DataService: () => this._getService((services) => services.DataService),
-      DeviceInvitationsService: () => this._getService((services) => services.DeviceInvitationsService),
-      DevicesService: () => this._getService((services) => services.DevicesService),
-      DevtoolsHost: () => this._getService((services) => services.DevtoolsHost),
-      NetworkService: () => this._getService((services) => services.NetworkService),
-      IdentityService: () => this._getService((services) => services.IdentityService),
-      SpaceInvitationsService: () => this._getService((services) => services.SpaceInvitationsService),
-      SpacesService: () => this._getService((services) => services.SpacesService),
-      SystemService: () => this._getService((services) => services.SystemService),
-      TracingService: () => this._getService((services) => services.TracingService)
+    this._serviceHost = serviceHost;
+
+    const middleware: Pick<ClientRpcServerParams, 'handleCall' | 'handleStream'> = {
+      handleCall: async (method, params, handler) => {
+        const error = await readySignal.wait({ timeout: 3_000 });
+        if (error) {
+          throw error;
+        }
+
+        return handler(method, params);
+      },
+      handleStream: async (method, params, handler) => {
+        const error = await readySignal.wait({ timeout: 3_000 });
+        if (error) {
+          throw error;
+        }
+
+        return handler(method, params);
+      }
     };
 
-    this._clientRpc = createProtoRpcPeer({ exposed: clientServiceBundle, handlers, port: appPort });
-    this._shellClientRpc = createProtoRpcPeer({ exposed: clientServiceBundle, handlers, port: shellPort });
+    this._clientRpc = new ClientRpcServer({
+      serviceRegistry: this._serviceHost.serviceRegistry,
+      port: appPort,
+      ...middleware
+    });
+    this._shellClientRpc = new ClientRpcServer({
+      serviceRegistry: this._serviceHost.serviceRegistry,
+      port: shellPort,
+      ...middleware
+    });
 
     this._iframeRpc = createProtoRpcPeer({
       requested: iframeServiceBundle,