@dxos/client-services 0.1.28 → 0.1.29-next.1bc50d4

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/data-space-manager.ts

@@ -153,7 +153,7 @@ export class DataSpaceManager {
     const presence = new Presence({
       localPeerId: this._signingContext.deviceKey,
       announceInterval: 1_000,
-      offlineTimeout: 30_000,
+      offlineTimeout: 10_000, // TODO(burdon): Config.
       identityKey: this._signingContext.identityKey
     });
     const snapshotManager = new SnapshotManager(this._snapshotStore);

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/spaces/spaces-service.test.ts

@@ -0,0 +1,107 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+
+import { Trigger } from '@dxos/async';
+import { PublicKey } from '@dxos/keys';
+import { Space, SpacesService } from '@dxos/protocols/proto/dxos/client/services';
+import { afterEach, afterTest, beforeEach, describe, test } from '@dxos/test';
+
+import { ServiceContext } from '../services';
+import { createServiceContext } from '../testing';
+import { SpacesServiceImpl } from './spaces-service';
+
+chai.use(chaiAsPromised);
+
+describe('SpacesService', () => {
+  let serviceContext: ServiceContext;
+  let spacesService: SpacesService;
+
+  beforeEach(async () => {
+    serviceContext = createServiceContext();
+    await serviceContext.open();
+    spacesService = new SpacesServiceImpl(
+      serviceContext.identityManager,
+      serviceContext.spaceManager,
+      serviceContext.dataServiceSubscriptions,
+      async () => {
+        await serviceContext.initialized.wait();
+        return serviceContext.dataSpaceManager!;
+      }
+    );
+  });
+
+  afterEach(async () => {
+    await serviceContext.close();
+  });
+
+  describe('createSpace', () => {
+    test('fails if no identity is available', async () => {
+      await expect(spacesService.createSpace()).to.be.rejectedWith();
+    });
+
+    test('creates a new space', async () => {
+      await serviceContext.createIdentity();
+      const space = await spacesService.createSpace();
+      expect(space).to.exist;
+      expect(space.spaceKey).to.be.instanceof(PublicKey);
+    });
+  });
+
+  describe.skip('updateSpace', () => {});
+
+  describe('querySpaces', () => {
+    test('returns empty list if no identity is available', async () => {
+      const query = spacesService.querySpaces();
+      const result = new Trigger<Space[] | undefined>();
+      query.subscribe(({ spaces }) => {
+        result.wake(spaces);
+      });
+      afterTest(() => query.close());
+      expect(await result.wait()).to.be.length(0);
+    });
+
+    test('returns list of existing spaces', async () => {
+      await serviceContext.createIdentity();
+      const existingSpaces = [
+        await spacesService.createSpace(),
+        await spacesService.createSpace(),
+        await spacesService.createSpace()
+      ];
+
+      const query = spacesService.querySpaces();
+      const result = new Trigger<Space[] | undefined>();
+      query.subscribe(({ spaces }) => {
+        result.wake(spaces);
+      });
+      afterTest(() => query.close());
+
+      const spaces = await result.wait();
+      expect(spaces).to.be.length(3);
+      expect(spaces).to.deep.equal(existingSpaces);
+    });
+
+    test('updates when new space is added', async () => {
+      await serviceContext.createIdentity();
+      const query = spacesService.querySpaces();
+      let result = new Trigger<Space[] | undefined>();
+      query.subscribe(({ spaces }) => {
+        result.wake(spaces);
+      });
+      afterTest(() => query.close());
+      expect(await result.wait()).to.be.length(0);
+
+      result = new Trigger<Space[] | undefined>();
+      const space = await spacesService.createSpace();
+      expect(await result.wait()).to.deep.equal([space]);
+    });
+
+    test.skip('updates when space is updated', async () => {});
+  });
+
+  describe.skip('writeCrendentials', () => {});
+  describe.skip('queryCrendentials', () => {});
+});

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.

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

@@ -1,162 +1,140 @@
 //
-// Copyright 2022 DXOS.org
+// Copyright 2020 DXOS.org
 //
 
-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 { 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(burdon): Remove @dxos/client-testing.
-// TODO(burdon): Create builder and make configurable.
-export const syncItems = async (db1: DataPipelineControllerImpl, db2: DataPipelineControllerImpl) => {
-  await testLocalDatabase(db1, db2);
-  await testLocalDatabase(db2, db1);
-};
-
-export class TestBuilder {
-  public readonly signalContext = new MemorySignalManagerContext();
+import assert from 'node:assert';
 
-  createPeer(): TestPeer {
-    return new TestPeer(this.signalContext);
+import { asyncTimeout } from '@dxos/async';
+import { Client, ClientServices, ClientServicesProxy, createDefaultModelFactory } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { DocumentModel } from '@dxos/document-model';
+import { DatabaseBackendProxy, genesisMutation } from '@dxos/echo-db';
+import { PublicKey } from '@dxos/keys';
+import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
+import { createWebRTCTransportFactory, MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
+import { Storage } from '@dxos/random-access-storage';
+import { createLinkedPorts, createProtoRpcPeer, ProtoRpcPeer } from '@dxos/rpc';
+
+import { ClientServicesHost, LocalClientServices } from '../services';
+
+export const testConfigWithLocalSignal = new Config({
+  version: 1,
+  runtime: {
+    services: {
+      signal: {
+        // TODO(burdon): Port numbers and global consts?
+        server: 'ws://localhost:4000/.well-known/dx/signal'
+      }
+    }
   }
-}
+});
 
-export type TestPeerProps = {
-  storage?: Storage;
-  feedStore?: FeedStore<any>;
-  metadataStore?: MetadataStore;
-  keyring?: Keyring;
-  networkManager?: NetworkManager;
-  spaceManager?: SpaceManager;
-  snapshotStore?: SnapshotStore;
-};
-
-export class TestPeer {
-  private _props: TestPeerProps = {};
+/**
+ * Client builder supports different configurations, incl. signaling, transports, storage.
+ */
+export class TestBuilder {
+  private readonly _config: Config;
 
-  constructor(private readonly signalContext: MemorySignalManagerContext) {}
+  public storage?: Storage;
 
-  get storage() {
-    return (this._props.storage ??= createStorage({ type: StorageType.RAM }));
+  // prettier-ignore
+  constructor (
+    config?: Config,
+    private readonly _modelFactory = createDefaultModelFactory(),
+    private readonly _signalManagerContext = new MemorySignalManagerContext()
+  ) {
+    this._config = config ?? new Config();
   }
 
-  get keyring() {
-    return (this._props.keyring ??= new Keyring(this.storage.createDirectory('keyring')));
+  get config(): Config {
+    return this._config;
   }
 
-  get feedStore() {
-    return (this._props.feedStore ??= new FeedStore({
-      factory: new FeedFactory({
-        root: this.storage.createDirectory('feeds'),
-        signer: this.keyring,
-        hypercore: {
-          valueEncoding
-        }
-      })
-    }));
+  /**
+   * Get network manager using local shared memory or remote signal manager.
+   */
+  get networkManager() {
+    const signalServer = this._config.get('runtime.services.signal.server');
+    if (signalServer) {
+      return new NetworkManager({
+        log: true,
+        signalManager: new WebsocketSignalManager([signalServer]),
+        transportFactory: createWebRTCTransportFactory({
+          iceServers: this._config.get('runtime.services.ice')
+        })
+      });
+    }
+
+    // Memory transport with shared context.
+    return new NetworkManager({
+      log: true,
+      signalManager: new MemorySignalManager(this._signalManagerContext),
+      transportFactory: MemoryTransportFactory
+    });
   }
 
-  get metadataStore() {
-    return (this._props.metadataStore ??= new MetadataStore(this.storage.createDirectory('metadata')));
+  /**
+   * Create backend service handlers.
+   */
+  createClientServicesHost() {
+    return new ClientServicesHost({
+      config: this._config,
+      modelFactory: this._modelFactory,
+      networkManager: this.networkManager,
+      storage: this.storage
+    });
   }
 
-  get snapshotStore() {
-    return (this._props.snapshotStore ??= new SnapshotStore(this.storage.createDirectory('snapshots')));
+  /**
+   * Create local services host.
+   */
+  createLocal() {
+    return new LocalClientServices({
+      config: this._config,
+      modelFactory: this._modelFactory,
+      networkManager: this.networkManager,
+      storage: this.storage
+    });
   }
 
-  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
-    }));
+  /**
+   * Create client/server.
+   */
+  createClientServer(host: ClientServicesHost = this.createClientServicesHost()): [Client, ProtoRpcPeer<{}>] {
+    const [proxyPort, hostPort] = createLinkedPorts();
+    const server = createProtoRpcPeer({
+      exposed: host.descriptors,
+      handlers: host.services as ClientServices,
+      port: hostPort
+    });
+    // TODO(dmaretskyi): Refactor.
+
+    const client = new Client({ services: new ClientServicesProxy(proxyPort) });
+    return [client, server];
   }
 }
 
-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.
-  };
+export const testSpace = async (create: DatabaseBackendProxy, check: DatabaseBackendProxy = create) => {
+  const objectId = PublicKey.random().toHex();
+
+  const result = create.mutate(genesisMutation(objectId, DocumentModel.meta.type));
+
+  await result.getReceipt();
+  // TODO(dmaretskiy): await result.waitToBeProcessed()
+  assert(create._itemManager.entities.has(result.objectsCreated[0].id));
+
+  await asyncTimeout(
+    check._itemManager.update.waitForCondition(() => check._itemManager.entities.has(objectId)),
+    1000
+  );
+
+  return result;
+};
+
+export const syncItems = async (db1: DatabaseBackendProxy, db2: DatabaseBackendProxy) => {
+  // Check item replicated from 1 => 2.
+  await testSpace(db1, db2);
+
+  // Check item replicated from 2 => 1.
+  await testSpace(db2, db1);
 };