@dxos/client-services 0.1.2 → 0.1.4

package/src/packlets/services/service-host.ts

@@ -2,100 +2,100 @@
 // Copyright 2021 DXOS.org
 //
 
-import assert from 'assert';
-
 import { Config } from '@dxos/config';
+import { raise } from '@dxos/debug';
+import { DataServiceImpl } from '@dxos/echo-db';
 import { log } from '@dxos/log';
-import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
 import { ModelFactory } from '@dxos/model-factory';
-import { createWebRTCTransportFactory, MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
+import { NetworkManager } from '@dxos/network-manager';
 import { ObjectModel } from '@dxos/object-model';
+import { TextModel } from '@dxos/text-model';
 
+import { SpaceServiceImpl, ProfileServiceImpl, SystemServiceImpl, TracingServiceImpl } from '../deprecated';
+import { DevtoolsServiceImpl, DevtoolsHostEvents } from '../devtools';
+import { DevicesServiceImpl } from '../identity/devices-service-impl';
+import { SpaceInvitationsServiceImpl } from '../invitations';
+import { SpacesServiceImpl } from '../spaces';
 import { createStorageObjects } from '../storage';
 import { ServiceContext } from './service-context';
-import { createServices } from './service-factory';
-import { ClientServiceProvider, ClientServices } from './services';
-import { HaloSigner } from './signer';
-// import { DevtoolsHostEvents } from '../devtools';
-
-// TODO(burdon): Remove (no memory defaults).
-const memorySignalManagerContext = new MemorySignalManagerContext();
-
-// TODO(burdon): Factor out.
-export const createNetworkManager = (config: Config): NetworkManager => {
-  const signalServer = config.get('runtime.services.signal.server');
-  // TODO(burdon): Remove.
-  if (!signalServer) {
-    log.warn('DEPRECATED: falling back to MemorySignalManager');
-    return new NetworkManager({
-      log: true,
-      signalManager: new MemorySignalManager(memorySignalManagerContext),
-      transportFactory: MemoryTransportFactory
-    });
-  }
-  assert(signalServer);
-
-  return new NetworkManager({
-    log: true,
-    signalManager: new WebsocketSignalManager([signalServer]),
-    transportFactory: createWebRTCTransportFactory({
-      iceServers: config.get('runtime.services.ice')
-    })
-  });
-};
+import { ClientServicesProvider, ClientServices, clientServiceBundle } from './service-definitions';
+import { ServiceRegistry } from './service-registry';
 
-type ClientServiceHostParams = {
+type ClientServicesHostParams = {
   config: Config;
-  signer?: HaloSigner;
   modelFactory?: ModelFactory;
   networkManager: NetworkManager;
 };
 
+// TODO(burdon): Factor out to spaces.
+// TODO(burdon): Defaults (with TextModel).
+export const createDefaultModelFactory = () => {
+  return new ModelFactory().registerModel(ObjectModel).registerModel(TextModel);
+};
+
 /**
  * Remote service implementation.
  */
-export class ClientServiceHost implements ClientServiceProvider {
-  private readonly _config: Config;
-  private readonly _signer?: HaloSigner;
-  private readonly _context: ServiceContext;
-  private readonly _services: ClientServices;
+// TODO(burdon): Reconcile Host/Backend, etc.
+export class ClientServicesHost implements ClientServicesProvider {
+  private readonly _serviceContext: ServiceContext;
+  private readonly _serviceRegistry: ServiceRegistry<ClientServices>;
 
   constructor({
     config,
-    modelFactory = new ModelFactory().registerModel(ObjectModel),
-    signer,
+    modelFactory = createDefaultModelFactory(),
+    // TODO(burdon): Create ApolloLink abstraction (see Client).
     networkManager
-  }: ClientServiceHostParams) {
-    this._config = config;
-    this._signer = signer;
-
+  }: ClientServicesHostParams) {
     // TODO(dmaretskyi): Remove keyStorage.
-    const { storage } = createStorageObjects(this._config.get('runtime.client.storage', {})!);
-    this._context = new ServiceContext(storage, networkManager, modelFactory);
+    const { storage } = createStorageObjects(config.get('runtime.client.storage', {})!);
+
+    // TODO(burdon): Break into components.
+    this._serviceContext = new ServiceContext(storage, networkManager, modelFactory);
+
+    // TODO(burdon): Start to think of DMG (dynamic services).
+    this._serviceRegistry = new ServiceRegistry<ClientServices>(clientServiceBundle, {
+      SpacesService: new SpacesServiceImpl(),
+      SpaceInvitationsService: new SpaceInvitationsServiceImpl(
+        this._serviceContext.identityManager,
+        () => this._serviceContext.spaceManager ?? raise(new Error('SpaceManager not initialized')),
+        () => this._serviceContext.spaceInvitations ?? raise(new Error('SpaceInvitations not initialized'))
+      ),
 
-    this._services = createServices({
-      config: this._config,
-      context: this._context,
-      signer: this._signer,
-      networkManager
+      SpaceService: new SpaceServiceImpl(this._serviceContext),
+      DataService: new DataServiceImpl(this._serviceContext.dataServiceSubscriptions),
+
+      ProfileService: new ProfileServiceImpl(this._serviceContext),
+      SystemService: new SystemServiceImpl(config),
+      TracingService: new TracingServiceImpl(config),
+      DevtoolsHost: new DevtoolsServiceImpl({
+        events: new DevtoolsHostEvents(),
+        config,
+        context: this._serviceContext
+      }),
+      DevicesService: new DevicesServiceImpl(this._serviceContext.identityManager)
     });
   }
 
+  get descriptors() {
+    return this._serviceRegistry.descriptors;
+  }
+
   get services() {
-    return this._services;
+    return this._serviceRegistry.services;
   }
 
-  // TODO(dmaretskyi): progress.
-  async open(onProgressCallback?: ((progress: any) => void) | undefined) {
-    log('opening...');
-    await this._context.open();
-    // this._devtoolsEvents.ready.emit();
-    log('opened');
+  async open() {
+    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
+    log('opening...', { deviceKey });
+    await this._serviceContext.open();
+    log('opened', { deviceKey });
   }
 
   async close() {
-    log('closing...');
-    await this._context.close();
-    log('closed');
+    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
+    log('closing...', { deviceKey });
+    await this._serviceContext.close();
+    log('closed', { deviceKey });
   }
 }

package/src/packlets/services/service-proxy.ts

@@ -0,0 +1,54 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { asyncTimeout } from '@dxos/async';
+import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
+
+import { RemoteServiceConnectionTimeout } from '../../errors';
+import { ClientServicesProvider, ClientServices, clientServiceBundle } from './service-definitions';
+
+/**
+ * Implements services that are not local to the app.
+ * For example, the services can be located in Wallet Extension.
+ */
+// TODO(burdon): Separate construction of port from availability of services.
+// TODO(burdon): Create `@dxos/client-proxy` package with thin-client only dependencies (for code-splitting).
+export class ClientServicesProxy implements ClientServicesProvider {
+  private readonly _proxy: ProtoRpcPeer<ClientServices>;
+
+  // prettier-ignore
+  constructor(
+    port: RpcPort,
+    // NOTE: With lower timeout the shared worker does not have enough time to start.
+    // TODO(dmaretskyi): Find better ways to detected when the worker has finished loading. It might take a while on slow connections.
+    private readonly _timeout = 1000
+  ) {
+    this._proxy = createProtoRpcPeer({
+      requested: clientServiceBundle,
+      exposed: {},
+      handlers: {},
+      port
+    });
+  }
+
+  get proxy() {
+    return this._proxy;
+  }
+
+  get descriptors() {
+    return clientServiceBundle;
+  }
+
+  get services() {
+    return this._proxy.rpc;
+  }
+
+  async open() {
+    await asyncTimeout(this._proxy.open(), this._timeout, new RemoteServiceConnectionTimeout());
+  }
+
+  async close() {
+    await this._proxy.close();
+  }
+}

package/src/packlets/services/service-registry.test.ts

@@ -0,0 +1,95 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'assert';
+
+import { Trigger } from '@dxos/async';
+import { log } from '@dxos/log';
+import { schema } from '@dxos/protocols';
+import { Invitation, InvitationsService } from '@dxos/protocols/proto/dxos/client/services';
+import { createLinkedPorts, createProtoRpcPeer, createServiceBundle } from '@dxos/rpc';
+
+import { SpaceInvitationsProxy, SpaceInvitationsServiceImpl } from '../invitations';
+import { createServiceContext } from '../testing';
+import { ServiceRegistry } from './service-registry';
+
+// TODO(burdon): Create TestService (that doesn't require peers).
+
+type TestServices = {
+  SpaceInvitationsService: InvitationsService;
+};
+
+const serviceBundle = createServiceBundle<TestServices>({
+  SpaceInvitationsService: schema.getService('dxos.client.services.InvitationsService')
+});
+
+describe('service registry', function () {
+  it('builds a service registry', async function () {
+    const serviceContext = createServiceContext();
+    await serviceContext.open();
+    await serviceContext.createIdentity();
+
+    assert(serviceContext.spaceManager);
+    assert(serviceContext.spaceInvitations);
+    const space = await serviceContext.spaceManager.createSpace();
+
+    const serviceRegistry = new ServiceRegistry(serviceBundle, {
+      SpaceInvitationsService: new SpaceInvitationsServiceImpl(
+        serviceContext.identityManager,
+        () => serviceContext.spaceManager!,
+        () => serviceContext.spaceInvitations!
+      )
+    });
+
+    const [proxyPort, serverPort] = createLinkedPorts();
+
+    const proxy = createProtoRpcPeer({
+      requested: serviceRegistry.descriptors,
+      exposed: {},
+      handlers: {},
+      port: proxyPort
+    });
+
+    const server = createProtoRpcPeer({
+      exposed: serviceRegistry.descriptors,
+      handlers: serviceRegistry.services,
+      port: serverPort
+    });
+
+    log('opening...');
+    await Promise.all([proxy.open(), server.open()]);
+    log('open');
+
+    const done = new Trigger(); // createRpcServer
+
+    {
+      const spaceInvitationsProxy = new SpaceInvitationsProxy(proxy.rpc.SpaceInvitationsService);
+      const observer = spaceInvitationsProxy.createInvitation(space.key);
+      observer.subscribe({
+        onConnecting: (invitation: Invitation) => {
+          log('connecting', invitation);
+          void observer.cancel();
+        },
+        onCancelled: () => {
+          done.wake();
+        },
+        onSuccess: (_invitation: Invitation) => {
+          throw new Error('Not not implemented.');
+        },
+        onError: () => {
+          throw new Error('Not not implemented.');
+        }
+      });
+    }
+
+    await done.wait();
+
+    // TODO(burdon): Error handling (create tests).
+    //  Uncaught Error: Request was terminated because the RPC endpoint is closed.
+    // log('closing...');
+    // await Promise.all([proxy.close(), server.close()]);
+    // await serviceContext.close();
+    // log('closed');
+  });
+});

package/src/packlets/services/service-registry.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { ServiceBundle } from '@dxos/rpc';
+
+/**
+ * Registry of operational services.
+ */
+export class ServiceRegistry<Services> {
+  // prettier-ignore
+  constructor (
+    private readonly _serviceBundle: ServiceBundle<Services>,
+    private readonly _handlers: Services
+  ) {}
+
+  get descriptors() {
+    return this._serviceBundle;
+  }
+
+  get services() {
+    return this._handlers;
+  }
+}

package/src/packlets/services/signer.ts

@@ -5,9 +5,7 @@
 import { SignRequest, SignResponse } from '@dxos/protocols/proto/dxos/client';
 import { KeyRecord } from '@dxos/protocols/proto/dxos/halo/keys';
 
-/**
- *
- */
+// TODO(burdon): Remove (was required for registry client).
 export interface HaloSigner {
   sign: (request: SignRequest, key: KeyRecord) => Promise<SignResponse>;
 }

package/src/packlets/spaces/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export * from './spaces-service';

package/src/packlets/spaces/spaces-service.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Stream } from '@dxos/codec-protobuf';
+import {
+  QueryMembersRequest,
+  QueryMembersResponse,
+  Space,
+  SpacesService
+} from '@dxos/protocols/proto/dxos/client/services';
+
+/**
+ *
+ */
+export class SpacesServiceImpl implements SpacesService {
+  async createSpace(): Promise<Space> {
+    throw new Error();
+  }
+
+  querySpaces(): Stream<Space> {
+    throw new Error();
+  }
+
+  queryMembers(query: QueryMembersRequest): Stream<QueryMembersResponse> {
+    throw new Error();
+  }
+}

package/src/packlets/storage/storage.ts

@@ -2,7 +2,7 @@
 // Copyright 2021 DXOS.org
 //
 
-import jsondown from 'jsondown';
+import jsondown from 'jsondown'; // TODO(burdon): Uses custom implementation.
 import leveljs from 'level-js';
 import memdown from 'memdown';
 

package/src/packlets/testing/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export * from './test-builder';

package/src/packlets/testing/test-builder.ts

@@ -0,0 +1,80 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { Config } from '@dxos/config';
+import { ISpace } from '@dxos/echo-db';
+import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
+import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
+import { createStorage, Storage, StorageType } from '@dxos/random-access-storage';
+
+import { createDefaultModelFactory, ClientServicesHost, ServiceContext } from '../services';
+
+//
+// TODO(burdon): Replace with test builder.
+//
+
+export const createServiceHost = (config: Config, signalManagerContext: MemorySignalManagerContext) => {
+  const networkManager = new NetworkManager({
+    signalManager: new MemorySignalManager(signalManagerContext),
+    transportFactory: MemoryTransportFactory
+  });
+
+  return new ClientServicesHost({
+    config,
+    networkManager
+  });
+};
+
+export const createServiceContext = ({
+  signalContext = new MemorySignalManagerContext(),
+  storage = createStorage({ type: StorageType.RAM })
+}: {
+  signalContext?: MemorySignalManagerContext;
+  storage?: Storage;
+} = {}) => {
+  const networkManager = new NetworkManager({
+    signalManager: new MemorySignalManager(signalContext),
+    transportFactory: MemoryTransportFactory
+  });
+
+  const modelFactory = createDefaultModelFactory();
+  return new ServiceContext(storage, networkManager, modelFactory);
+};
+
+export const createPeers = async (numPeers: number) => {
+  const signalContext = new MemorySignalManagerContext();
+
+  return await Promise.all(
+    Array.from(Array(numPeers)).map(async () => {
+      const peer = createServiceContext({ signalContext });
+      await peer.open();
+      return peer;
+    })
+  );
+};
+
+export const createIdentity = async (peer: ServiceContext) => {
+  await peer.createIdentity();
+  return peer;
+};
+
+// TODO(wittjosiah): Factor out to client-testing?
+// TODO(burdon): Create builder and make configurable.
+export const syncItems = async (space1: ISpace, space2: ISpace) => {
+  {
+    // Check item replicated from 1 => 2.
+    const item1 = await space1.database!.createItem({ type: 'type-1' });
+    const item2 = await space2.database!.waitForItem({ type: 'type-1' });
+    expect(item1.id).to.eq(item2.id);
+  }
+
+  {
+    // Check item replicated from 2 => 1.
+    const item1 = await space2.database!.createItem({ type: 'type-2' });
+    const item2 = await space1.database!.waitForItem({ type: 'type-2' });
+    expect(item1.id).to.eq(item2.id);
+  }
+};

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

@@ -0,0 +1,68 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { WebRTCTransportService } from '@dxos/network-manager';
+import { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
+import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
+import { PortMuxer } from '@dxos/rpc-tunnel';
+
+import { iframeServiceBundle, WorkerServiceBundle, workerServiceBundle } from './services';
+
+export type IframeRuntimeParams = {
+  portMuxer: PortMuxer;
+};
+
+/**
+ * Manages the client connection to the shared worker.
+ */
+export class IFrameRuntime {
+  private readonly _systemPort: RpcPort;
+  private readonly _windowAppPort: RpcPort;
+  private readonly _workerAppPort: RpcPort;
+  private readonly _systemRpc: ProtoRpcPeer<WorkerServiceBundle>;
+  private readonly _transportService = new WebRTCTransportService();
+
+  constructor({ portMuxer }: IframeRuntimeParams) {
+    this._systemPort = portMuxer.createWorkerPort({ channel: 'dxos:system' });
+    this._workerAppPort = portMuxer.createWorkerPort({ channel: 'dxos:app' });
+    this._windowAppPort = portMuxer.createIFramePort({
+      channel: 'dxos:app',
+      onOrigin: (origin) => this.open(origin)
+    });
+
+    this._systemRpc = createProtoRpcPeer({
+      requested: workerServiceBundle,
+      exposed: iframeServiceBundle,
+      handlers: {
+        BridgeService: this._transportService as BridgeService,
+        IframeService: {
+          async heartbeat() {
+            // Ok.
+          }
+        }
+      },
+      port: this._systemPort,
+      timeout: 200
+    });
+  }
+
+  start() {
+    this._workerAppPort.subscribe((msg) => this._windowAppPort.send(msg));
+    this._windowAppPort.subscribe((msg) => this._workerAppPort.send(msg));
+
+    window.addEventListener('beforeunload', () => {
+      this.close().catch((err) => console.error(err));
+    });
+  }
+
+  async open(origin: string) {
+    await this._systemRpc.open();
+    await this._systemRpc.rpc.WorkerService.start({ origin });
+  }
+
+  async close() {
+    await this._systemRpc.rpc.WorkerService.stop();
+    await this._systemRpc.close();
+  }
+}

package/src/packlets/vault/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export * from './iframe-runtime';
+export * from './worker-runtime';
+export * from './worker-session';

package/src/packlets/vault/services.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { schema } from '@dxos/protocols';
+import type { IframeService, WorkerService } from '@dxos/protocols/proto/dxos/iframe';
+import type { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
+import { ServiceBundle } from '@dxos/rpc';
+
+export type IframeServiceBundle = {
+  IframeService: IframeService;
+  BridgeService: BridgeService;
+};
+
+export const iframeServiceBundle: ServiceBundle<IframeServiceBundle> = {
+  IframeService: schema.getService('dxos.iframe.IframeService'),
+  BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
+};
+
+export type WorkerServiceBundle = {
+  WorkerService: WorkerService;
+};
+
+export const workerServiceBundle: ServiceBundle<WorkerServiceBundle> = {
+  WorkerService: schema.getService('dxos.iframe.WorkerService')
+};