@dxos/client-services 0.1.30-next.7c60cd3 → 0.1.31-next.ea8f0bc

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

@@ -5,16 +5,15 @@
 import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
+import { clientServiceBundle, ClientServices, createDefaultModelFactory } from '@dxos/client';
 import { Config } from '@dxos/config';
 import { raise } from '@dxos/debug';
-import { DocumentModel } from '@dxos/document-model';
 import { DataServiceImpl } from '@dxos/echo-pipeline';
 import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { Storage } from '@dxos/random-access-storage';
-import { TextModel } from '@dxos/text-model';
 
 import { TracingServiceImpl } from '../deprecated';
 import { DevicesServiceImpl } from '../devices';
@@ -27,23 +26,24 @@ import { createStorageObjects } from '../storage';
 import { SystemServiceImpl } from '../system';
 import { VaultResourceLock } from '../vault';
 import { ServiceContext } from './service-context';
-import { ClientServices, clientServiceBundle } from './service-definitions';
 import { ServiceRegistry } from './service-registry';
 
-// TODO(burdon): Factor out to spaces.
-// TODO(burdon): Defaults (with TextModel).
-export const createDefaultModelFactory = () => {
-  return new ModelFactory().registerModel(DocumentModel).registerModel(TextModel);
-};
-
 export type ClientServicesHostParams = {
-  config: Config;
+  /**
+   * Can be omitted if `initialize` is later called.
+   */
+  config?: Config;
   modelFactory?: ModelFactory;
-  networkManager: NetworkManager;
+  networkManager?: NetworkManager;
   storage?: Storage;
   lockKey?: string;
 };
 
+export type InitializeOptions = {
+  config?: Config;
+  networkManager?: NetworkManager;
+};
+
 /**
  * Remote service implementation.
  */
@@ -52,11 +52,11 @@ export class ClientServicesHost {
   private readonly _serviceRegistry: ServiceRegistry<ClientServices>;
   private readonly _systemService: SystemServiceImpl;
 
-  private readonly _config: Config;
+  private _config?: Config;
   private readonly _statusUpdate = new Event<void>();
   private readonly _modelFactory: ModelFactory;
-  private readonly _networkManager: NetworkManager;
-  private readonly _storage: Storage;
+  private _networkManager?: NetworkManager;
+  private _storage?: Storage;
 
   /**
    * @internal
@@ -69,14 +69,16 @@ export class ClientServicesHost {
     modelFactory = createDefaultModelFactory(),
     // TODO(burdon): Create ApolloLink abstraction (see Client).
     networkManager,
-    storage = createStorageObjects(config.get('runtime.client.storage', {})!).storage,
+    storage,
     // TODO(wittjosiah): Turn this on by default.
     lockKey
-  }: ClientServicesHostParams) {
-    this._config = config;
-    this._modelFactory = modelFactory;
-    this._networkManager = networkManager;
+  }: ClientServicesHostParams = {}) {
     this._storage = storage;
+    this._modelFactory = modelFactory;
+
+    if (config) {
+      this.initialize({ config, networkManager });
+    }
 
     this._resourceLock = lockKey
       ? new VaultResourceLock({
@@ -117,6 +119,10 @@ export class ClientServicesHost {
     return this._open;
   }
 
+  get serviceRegistry() {
+    return this._serviceRegistry;
+  }
+
   get descriptors() {
     return this._serviceRegistry.descriptors;
   }
@@ -125,11 +131,38 @@ export class ClientServicesHost {
     return this._serviceRegistry.services;
   }
 
+  /**
+   * Initialize the service host with the config.
+   * Config can also be provided in the constructor.
+   * Can only be called once.
+   */
+  initialize({ config, networkManager }: InitializeOptions) {
+    assert(!this._open, 'service host is open');
+
+    if (config) {
+      assert(!this._config, 'config already set');
+
+      this._config = config;
+      if (!this._storage) {
+        this._storage = createStorageObjects(config.get('runtime.client.storage', {})!).storage;
+      }
+    }
+
+    if (networkManager) {
+      assert(!this._networkManager, 'network manager already set');
+      this._networkManager = networkManager;
+    }
+  }
+
   async open() {
     if (this._open) {
       return;
     }
 
+    assert(this._config, 'config not set');
+    assert(this._storage, 'storage not set');
+    assert(this._networkManager, 'network manager not set');
+
     log('opening...');
     await this._resourceLock?.acquire();
 

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

@@ -5,15 +5,15 @@
 import assert from 'node:assert';
 
 import { Trigger } from '@dxos/async';
+import { ClientServices, SpaceInvitationsProxy } from '@dxos/client';
 import { log } from '@dxos/log';
 import { schema } from '@dxos/protocols';
 import { Invitation, SpaceInvitationsService } from '@dxos/protocols/proto/dxos/client/services';
 import { createLinkedPorts, createProtoRpcPeer, createServiceBundle } from '@dxos/rpc';
 import { describe, test } from '@dxos/test';
 
-import { SpaceInvitationsProxy, SpaceInvitationsServiceImpl } from '../invitations';
+import { SpaceInvitationsServiceImpl } from '../invitations';
 import { createServiceContext } from '../testing';
-import { ClientServices } from './service-definitions';
 import { ServiceRegistry } from './service-registry';
 
 // TODO(burdon): Create TestService (that doesn't require peers).

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

@@ -11,7 +11,7 @@ export class ServiceRegistry<Services> {
   // prettier-ignore
   constructor (
     private readonly _serviceBundle: ServiceBundle<Services>,
-    private _handlers: Partial<Services>
+    private _handlers: Partial<Services> = {}
   ) {}
 
   get descriptors() {
@@ -25,4 +25,12 @@ export class ServiceRegistry<Services> {
   setServices(services: Partial<Services>) {
     this._handlers = services;
   }
+
+  addService(name: keyof Services, service: Services[keyof Services]) {
+    this._handlers[name] = service;
+  }
+
+  removeService(name: keyof Services) {
+    delete this._handlers[name];
+  }
 }

package/src/packlets/services/utils.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { ClientServicesProvider } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { log } from '@dxos/log';
+import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
+import {
+  createWebRTCTransportFactory,
+  MemoryTransportFactory,
+  NetworkManager,
+  NetworkManagerOptions
+} from '@dxos/network-manager';
+
+import { LocalClientServices } from './local-client-services';
+
+/**
+ * Creates stand-alone services without rpc.
+ */
+export const fromHost = (config: Config = new Config()): ClientServicesProvider => {
+  return new LocalClientServices({
+    config,
+    networkManager: createNetworkManager(config)
+  });
+};
+
+/**
+ * Creates a WebRTC network manager connected to the specified signal server.
+ */
+// TODO(burdon): Move to client-services and remove dependencies from here.
+const createNetworkManager = (config: Config, options: Partial<NetworkManagerOptions> = {}): NetworkManager => {
+  const signalServer = config.get('runtime.services.signal.server');
+  if (signalServer) {
+    const {
+      log = true,
+      signalManager = new WebsocketSignalManager([signalServer]),
+      transportFactory = createWebRTCTransportFactory({
+        iceServers: config.get('runtime.services.ice')
+      })
+    } = options;
+
+    return new NetworkManager({ log, signalManager, transportFactory });
+  }
+
+  // TODO(burdon): Should not provide a memory signal manager since no shared context.
+  //  Use TestClientBuilder for shared memory tests.
+  log.warn('P2P network is not configured.');
+  return new NetworkManager({
+    signalManager: new MemorySignalManager(new MemorySignalManagerContext()),
+    transportFactory: MemoryTransportFactory
+  });
+};

package/src/packlets/spaces/data-space-manager.test.ts

@@ -12,12 +12,12 @@ import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { test, describe } from '@dxos/test';
 
-import { createSigningContext, syncItems, TestBuilder } from '../testing';
+import { createSigningContext, HostTestBuilder, syncItemsLocal } from '../testing';
 import { DataSpaceManager } from './data-space-manager';
 
 describe('DataSpaceManager', () => {
   test('create space', async () => {
-    const builder = new TestBuilder();
+    const builder = new HostTestBuilder();
 
     const peer = builder.createPeer();
     const identity = await createSigningContext(peer.keyring);
@@ -43,7 +43,7 @@ describe('DataSpaceManager', () => {
   });
 
   test('sync between peers', async () => {
-    const builder = new TestBuilder();
+    const builder = new HostTestBuilder();
 
     const peer1 = builder.createPeer();
     const identity1 = await createSigningContext(peer1.keyring);
@@ -121,7 +121,7 @@ describe('DataSpaceManager', () => {
     });
     log.break();
 
-    await syncItems(space1.dataPipelineController, space2.dataPipelineController);
+    await syncItemsLocal(space1.dataPipelineController, space2.dataPipelineController);
 
     expect(space1.inner.protocol.sessions.get(identity2.deviceKey)).to.exist;
     expect(space1.inner.protocol.sessions.get(identity2.deviceKey)?.authStatus).to.equal(AuthStatus.SUCCESS);

package/src/packlets/spaces/index.ts

@@ -2,4 +2,6 @@
 // Copyright 2022 DXOS.org
 //
 
+export * from './data-space-manager';
+export * from './data-space';
 export * from './spaces-service';

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

@@ -14,7 +14,7 @@ import {
 import { MaybePromise } from '@dxos/util';
 
 export type SystemServiceOptions = {
-  config: Config;
+  config?: Config;
   statusUpdate: Event<void>;
   getCurrentStatus: () => SystemStatus;
   onUpdateStatus: (status: SystemStatus) => MaybePromise<void>;
@@ -25,7 +25,7 @@ export type SystemServiceOptions = {
  *
  */
 export class SystemServiceImpl implements SystemService {
-  private readonly _config: SystemServiceOptions['config'];
+  private readonly _config?: SystemServiceOptions['config'];
   private readonly _statusUpdate: SystemServiceOptions['statusUpdate'];
   private readonly _getCurrentStatus: SystemServiceOptions['getCurrentStatus'];
   private readonly _onUpdateStatus: SystemServiceOptions['onUpdateStatus'];
@@ -40,7 +40,7 @@ export class SystemServiceImpl implements SystemService {
   }
 
   async getConfig() {
-    return this._config.values;
+    return this._config?.values ?? {};
   }
 
   async updateStatus({ status }: UpdateSystemStatusRequest) {

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

@@ -0,0 +1,163 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { createDefaultModelFactory } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
+import {
+  SnapshotStore,
+  DataPipelineControllerImpl,
+  MetadataStore,
+  SigningContext,
+  SpaceManager,
+  valueEncoding
+} from '@dxos/echo-pipeline';
+import { testLocalDatabase } from '@dxos/echo-pipeline/testing';
+import { FeedFactory, FeedStore } from '@dxos/feed-store';
+import { Keyring } from '@dxos/keyring';
+import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
+import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
+import { createStorage, Storage, StorageType } from '@dxos/random-access-storage';
+
+import { 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(burdon): Remove @dxos/client-testing.
+// TODO(burdon): Create builder and make configurable.
+export const syncItemsLocal = async (db1: DataPipelineControllerImpl, db2: DataPipelineControllerImpl) => {
+  await testLocalDatabase(db1, db2);
+  await testLocalDatabase(db2, db1);
+};
+
+export class HostTestBuilder {
+  public readonly signalContext = new MemorySignalManagerContext();
+
+  createPeer(): TestPeer {
+    return new TestPeer(this.signalContext);
+  }
+}
+
+export type TestPeerProps = {
+  storage?: Storage;
+  feedStore?: FeedStore<any>;
+  metadataStore?: MetadataStore;
+  keyring?: Keyring;
+  networkManager?: NetworkManager;
+  spaceManager?: SpaceManager;
+  snapshotStore?: SnapshotStore;
+};
+
+export class TestPeer {
+  private _props: TestPeerProps = {};
+
+  constructor(private readonly signalContext: MemorySignalManagerContext) {}
+
+  get storage() {
+    return (this._props.storage ??= createStorage({ type: StorageType.RAM }));
+  }
+
+  get keyring() {
+    return (this._props.keyring ??= new Keyring(this.storage.createDirectory('keyring')));
+  }
+
+  get feedStore() {
+    return (this._props.feedStore ??= new FeedStore({
+      factory: new FeedFactory({
+        root: this.storage.createDirectory('feeds'),
+        signer: this.keyring,
+        hypercore: {
+          valueEncoding
+        }
+      })
+    }));
+  }
+
+  get metadataStore() {
+    return (this._props.metadataStore ??= new MetadataStore(this.storage.createDirectory('metadata')));
+  }
+
+  get snapshotStore() {
+    return (this._props.snapshotStore ??= new SnapshotStore(this.storage.createDirectory('snapshots')));
+  }
+
+  get networkManager() {
+    return (this._props.networkManager ??= new NetworkManager({
+      signalManager: new MemorySignalManager(this.signalContext),
+      transportFactory: MemoryTransportFactory
+    }));
+  }
+
+  get spaceManager() {
+    return (this._props.spaceManager ??= new SpaceManager({
+      feedStore: this.feedStore,
+      networkManager: this.networkManager
+    }));
+  }
+}
+
+export const createSigningContext = async (keyring: Keyring): Promise<SigningContext> => {
+  const identityKey = await keyring.createKey();
+  const deviceKey = await keyring.createKey();
+
+  return {
+    identityKey,
+    deviceKey,
+    credentialSigner: createCredentialSignerWithChain(
+      keyring,
+      {
+        credential: await new CredentialGenerator(keyring, identityKey, deviceKey).createDeviceAuthorization(deviceKey)
+      },
+      deviceKey
+    ),
+    recordCredential: async () => {} // No-op.
+  };
+};

package/src/packlets/testing/index.ts

@@ -3,5 +3,6 @@
 //
 
 export * from './credential-utils';
+export * from './host-test-builder';
 export * from './invitation-utils';
 export * from './test-builder';

package/src/packlets/testing/invitation-utils.ts

@@ -5,11 +5,10 @@
 import assert from 'node:assert';
 
 import { Trigger } from '@dxos/async';
+import { InvitationsHandler } from '@dxos/client';
 import { raise } from '@dxos/debug';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
-import { InvitationsHandler } from '../invitations';
-
 export const performInvitation = async <T>(host: InvitationsHandler<T>, guest: InvitationsHandler<T>, context: T) => {
   const done1 = new Trigger<Invitation>(); // peer 1 connected.
   const done2 = new Trigger<Invitation>(); // peer 2 connected.