@dxos/client-services 0.1.2 → 0.1.3

package/src/packlets/invitations/space-invitations-service.test.ts

@@ -0,0 +1,129 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'assert';
+import { expect } from 'chai';
+
+import { asyncChain, Trigger } from '@dxos/async';
+import { raise } from '@dxos/debug';
+import { Invitation, InvitationsService } from '@dxos/protocols/proto/dxos/client/services';
+import { afterTest } from '@dxos/testutils';
+
+import { ServiceContext } from '../services';
+import { createIdentity, createPeers } from '../testing';
+import { SpaceInvitationsProxy } from './space-invitations-proxy';
+import { SpaceInvitationsServiceImpl } from './space-invitations-service';
+
+const closeAfterTest = async (peer: ServiceContext) => {
+  afterTest(() => peer.close());
+  return peer;
+};
+
+describe('services/space-invitation-service', function () {
+  it('creates space and invites peer', async function () {
+    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+
+    assert(host.spaceManager);
+    assert(host.spaceInvitations);
+    const service1: InvitationsService = new SpaceInvitationsServiceImpl(
+      host.identityManager,
+      () => host.spaceManager!,
+      () => host.spaceInvitations!
+    );
+
+    assert(guest.spaceManager);
+    assert(guest.spaceInvitations);
+    const service2: InvitationsService = new SpaceInvitationsServiceImpl(
+      guest.identityManager,
+      () => guest.spaceManager!,
+      () => guest.spaceInvitations!
+    );
+
+    const space1 = await host.spaceManager.createSpace();
+
+    const success1 = new Trigger<Invitation>();
+    const success2 = new Trigger<Invitation>();
+
+    const authenticationCode = new Trigger<string>();
+
+    {
+      const proxy1 = new SpaceInvitationsProxy(service1);
+      const observable1 = proxy1.createInvitation(space1.key);
+      observable1.subscribe({
+        onConnecting: (invitation: Invitation) => {
+          const proxy2 = new SpaceInvitationsProxy(service2);
+          const observable2 = proxy2.acceptInvitation(invitation);
+          observable2.subscribe({
+            onAuthenticating: async (invitation2: Invitation) => {
+              await observable2.authenticate(await authenticationCode.wait());
+            },
+            onSuccess: (invitation: Invitation) => {
+              success2.wake(invitation);
+            },
+            onError: (err: Error) => raise(new Error(err.message))
+          });
+        },
+        onConnected: (invitation: Invitation) => {
+          assert(invitation.authenticationCode);
+          authenticationCode.wake(invitation.authenticationCode);
+        },
+        onSuccess: (invitation: Invitation) => {
+          success1.wake(invitation);
+        },
+        onCancelled: () => raise(new Error()),
+        onTimeout: (err: Error) => raise(new Error(err.message)),
+        onError: (err: Error) => raise(new Error(err.message))
+      });
+    }
+
+    const [invitation1, invitation2] = await Promise.all([success1.wait(), success2.wait()]);
+    expect(invitation1.spaceKey).to.deep.eq(invitation2.spaceKey);
+    expect(invitation1.state).to.eq(Invitation.State.SUCCESS);
+  });
+
+  it('creates space and cancels invitation', async function () {
+    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+
+    assert(host.spaceManager);
+    assert(host.spaceInvitations);
+    const service1: InvitationsService = new SpaceInvitationsServiceImpl(
+      host.identityManager,
+      () => host.spaceManager!,
+      () => host.spaceInvitations!
+    );
+
+    assert(guest.spaceManager);
+    assert(guest.spaceInvitations);
+    const service2: InvitationsService = new SpaceInvitationsServiceImpl(
+      guest.identityManager,
+      () => guest.spaceManager!,
+      () => guest.spaceInvitations!
+    );
+
+    const space1 = await host.spaceManager.createSpace();
+    const cancelled = new Trigger();
+
+    {
+      const proxy = new SpaceInvitationsProxy(service1);
+      const observable = proxy.createInvitation(space1.key);
+      observable.subscribe({
+        onConnecting: (invitation: Invitation) => {
+          const proxy2 = new SpaceInvitationsProxy(service2);
+          proxy2.acceptInvitation(invitation);
+        },
+        onConnected: (invitation: Invitation) => {
+          void observable.cancel();
+        },
+        onCancelled: () => {
+          cancelled.wake();
+        },
+        onSuccess: () => raise(new Error()),
+        onTimeout: (err: Error) => raise(new Error(err.message)),
+        onError: (err: Error) => raise(new Error(err.message))
+      });
+    }
+
+    await cancelled.wait();
+  });
+});

package/src/packlets/invitations/space-invitations-service.ts

@@ -0,0 +1,196 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'assert';
+
+import { TimeoutError } from '@dxos/async';
+import { Stream } from '@dxos/codec-protobuf';
+import { SpaceManager } from '@dxos/echo-db';
+import { log } from '@dxos/log';
+import { AuthenticationRequest, Invitation, InvitationsService } from '@dxos/protocols/proto/dxos/client/services';
+import { Provider } from '@dxos/util';
+
+import { IdentityManager } from '../identity';
+import { AuthenticatingInvitationObservable, CancellableInvitationObservable } from './invitations';
+import { SpaceInvitationsHandler } from './space-invitations-handler';
+
+/**
+ * Adapts invitation service observable to client/service stream.
+ */
+export class SpaceInvitationsServiceImpl implements InvitationsService {
+  private readonly _createInvitations = new Map<string, CancellableInvitationObservable>();
+  private readonly _acceptInvitations = new Map<string, AuthenticatingInvitationObservable>();
+
+  // prettier-ignore
+  constructor (
+    private readonly _identityManager: IdentityManager,
+    private readonly _getSpaceManager: Provider<SpaceManager>,
+    private readonly _getSpaceInvitations: Provider<SpaceInvitationsHandler>
+  ) {}
+
+  createInvitation(invitation: Invitation): Stream<Invitation> {
+    return new Stream<Invitation>(({ next, close }) => {
+      const spaceManager = this._getSpaceManager();
+      const spaceInvitations = this._getSpaceInvitations();
+
+      assert(invitation.spaceKey);
+      log('stream opened', {
+        host: this._identityManager.identity?.deviceKey,
+        spaceKey: invitation.spaceKey
+      });
+      const space = spaceManager.spaces.get(invitation.spaceKey!);
+      assert(space);
+
+      let invitationId: string;
+      const { type } = invitation;
+      const observable = spaceInvitations.createInvitation(space, { type });
+      observable.subscribe({
+        onConnecting: (invitation) => {
+          assert(invitation.invitationId);
+          invitationId = invitation.invitationId;
+          this._createInvitations.set(invitation.invitationId, observable);
+          invitation.state = Invitation.State.CONNECTING;
+          next(invitation);
+        },
+        onConnected: (invitation) => {
+          assert(invitation.invitationId);
+          invitation.state = Invitation.State.CONNECTED;
+          next(invitation);
+        },
+        onAuthenticating: (invitation) => {
+          assert(invitation.invitationId);
+          invitation.state = Invitation.State.AUTHENTICATING;
+          next(invitation);
+        },
+        onSuccess: (invitation) => {
+          assert(invitation.invitationId);
+          invitation.state = Invitation.State.SUCCESS;
+          next(invitation);
+          close();
+        },
+        onCancelled: () => {
+          assert(invitationId);
+          invitation.invitationId = invitationId;
+          invitation.state = Invitation.State.CANCELLED;
+          next(invitation);
+          close();
+        },
+        onTimeout: (err: TimeoutError) => {
+          invitation.state = Invitation.State.TIMEOUT;
+          close(err);
+        },
+        onError: (err: any) => {
+          invitation.state = Invitation.State.ERROR;
+          close(err);
+        }
+      });
+
+      return (err?: Error) => {
+        const context = {
+          guest: this._identityManager.identity?.deviceKey,
+          spaceKey: invitation.spaceKey
+        };
+        if (err) {
+          log.warn('stream closed', { ...context, err });
+        } else {
+          log('stream closed', context);
+        }
+
+        this._createInvitations.delete(invitation.invitationId!);
+      };
+    });
+  }
+
+  acceptInvitation(invitation: Invitation): Stream<Invitation> {
+    return new Stream<Invitation>(({ next, close }) => {
+      const spaceInvitations = this._getSpaceInvitations();
+
+      assert(invitation.spaceKey);
+      log('stream opened', {
+        guest: this._identityManager.identity?.deviceKey,
+        spaceKey: invitation.spaceKey
+      });
+
+      let invitationId: string;
+      const observable = spaceInvitations.acceptInvitation(invitation);
+      observable.subscribe({
+        onConnecting: (invitation) => {
+          assert(invitation.invitationId);
+          invitationId = invitation.invitationId;
+          this._acceptInvitations.set(invitation.invitationId, observable);
+          invitation.state = Invitation.State.CONNECTING;
+          next(invitation);
+        },
+        onConnected: (invitation) => {
+          assert(invitation.invitationId);
+          invitation.state = Invitation.State.CONNECTED;
+          next(invitation);
+        },
+        onAuthenticating: (invitation) => {
+          assert(invitation.invitationId);
+          invitation.state = Invitation.State.AUTHENTICATING;
+          next(invitation);
+        },
+        onSuccess: (invitation) => {
+          assert(invitation.spaceKey);
+          invitation.state = Invitation.State.SUCCESS;
+          next(invitation);
+          close();
+        },
+        onCancelled: () => {
+          assert(invitationId);
+          invitation.invitationId = invitationId;
+          invitation.state = Invitation.State.CANCELLED;
+          next(invitation);
+          close();
+        },
+        onTimeout: (err: TimeoutError) => {
+          invitation.state = Invitation.State.TIMEOUT;
+          close(err);
+        },
+        onError: (err: any) => {
+          invitation.state = Invitation.State.ERROR;
+          close(err);
+        }
+      });
+
+      return (err?: Error) => {
+        const context = {
+          guest: this._identityManager.identity?.deviceKey,
+          spaceKey: invitation.spaceKey
+        };
+        if (err) {
+          log.warn('stream closed', { ...context, err });
+        } else {
+          log('stream closed', context);
+        }
+
+        this._acceptInvitations.delete(invitation.invitationId!);
+      };
+    });
+  }
+
+  async authenticate({ invitationId, authenticationCode }: AuthenticationRequest): Promise<void> {
+    log('authenticating...');
+    assert(invitationId);
+    const observable = this._acceptInvitations.get(invitationId);
+    if (!observable) {
+      log.warn('invalid invitation', { invitationId });
+    } else {
+      await observable.authenticate(authenticationCode);
+    }
+  }
+
+  async cancelInvitation(invitation: Invitation): Promise<void> {
+    log('cancelling...');
+    assert(invitation.invitationId);
+    const observable =
+      this._createInvitations.get(invitation.invitationId) ?? this._acceptInvitations.get(invitation.invitationId);
+    if (!observable) {
+      log.warn('invalid invitation', { invitationId: invitation.invitationId });
+    } else {
+      await observable?.cancel();
+    }
+  }
+}

package/src/packlets/services/index.ts

@@ -3,7 +3,8 @@
 //
 
 export * from './service-context';
-export * from './service-factory';
+export * from './service-definitions';
 export * from './service-host';
-export * from './services';
+export * from './service-proxy';
+export * from './service-registry';
 export * from './signer';

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

@@ -2,22 +2,19 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'node:assert';
-
 import { Trigger } from '@dxos/async';
-import { failUndefined, raise } from '@dxos/debug';
+import { failUndefined } from '@dxos/debug';
 import {
   MOCK_AUTH_PROVIDER,
   MOCK_AUTH_VERIFIER,
   valueEncoding,
-  DataService,
+  DataServiceSubscriptions,
   MetadataStore,
   SpaceManager,
   SigningContext
 } from '@dxos/echo-db';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
-import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
@@ -25,7 +22,7 @@ import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { Storage } from '@dxos/random-access-storage';
 
 import { IdentityManager } from '../identity';
-import { HaloInvitations, InvitationWrapper, SpaceInvitations } from '../invitations';
+import { HaloInvitations, SpaceInvitationsHandler } from '../invitations';
 
 /**
  * Shared backend for all client services.
@@ -33,10 +30,7 @@ import { HaloInvitations, InvitationWrapper, SpaceInvitations } from '../invitat
 // TODO(burdon): Rename/break-up into smaller components. And/or make members private.
 export class ServiceContext {
   public readonly initialized = new Trigger();
-
-  // TODO(burdon): Factor out with other services.
-  public readonly dataService = new DataService();
-
+  public readonly dataServiceSubscriptions = new DataServiceSubscriptions();
   public readonly metadataStore: MetadataStore;
   public readonly feedStore: FeedStore<FeedMessage>;
   public readonly keyring: Keyring;
@@ -45,7 +39,7 @@ export class ServiceContext {
 
   // Initialized after identity is initialized.
   public spaceManager?: SpaceManager;
-  public spaceInvitations?: SpaceInvitations;
+  public spaceInvitations?: SpaceInvitationsHandler;
 
   // prettier-ignore
   constructor(
@@ -95,31 +89,17 @@ export class ServiceContext {
     await this.spaceManager?.close();
     await this.feedStore.close();
     await this.networkManager.destroy(); // TODO(burdon): Close.
+    this.dataServiceSubscriptions.clear();
     log('closed');
   }
 
   async createIdentity() {
     const identity = await this.identityManager.createIdentity();
-    this.dataService.trackParty(identity.haloSpaceKey, identity.haloDatabase.createDataServiceHost());
+    this.dataServiceSubscriptions.registerSpace(identity.haloSpaceKey, identity.haloDatabase.createDataServiceHost());
     await this._initialize();
     return identity;
   }
 
-  async createInvitation(spaceKey: PublicKey, onFinish?: () => void): Promise<InvitationWrapper> {
-    assert(this.spaceManager);
-    assert(this.spaceInvitations);
-
-    const space = this.spaceManager.spaces.get(spaceKey) ?? raise(new Error('Space not found.'));
-    const invitation = await this.spaceInvitations.createInvitation(space, { onFinish });
-    return InvitationWrapper.fromProto(invitation);
-  }
-
-  async acceptInvitation(invitationDescriptor: InvitationWrapper) {
-    assert(this.spaceInvitations);
-
-    return this.spaceInvitations.acceptInvitation(invitationDescriptor.toProto());
-  }
-
   private async _initialize() {
     const identity = this.identityManager.identity ?? failUndefined();
     const signingContext: SigningContext = {
@@ -136,16 +116,14 @@ export class ServiceContext {
       feedStore: this.feedStore,
       networkManager: this.networkManager,
       keyring: this.keyring,
-      dataService: this.dataService,
+      dataServiceSubscriptions: this.dataServiceSubscriptions,
       modelFactory: this.modelFactory,
       signingContext
     });
 
     await spaceManager.open();
-
     this.spaceManager = spaceManager;
-    this.spaceInvitations = new SpaceInvitations(this.spaceManager, this.networkManager, signingContext);
-
+    this.spaceInvitations = new SpaceInvitationsHandler(this.spaceManager, this.networkManager, signingContext);
     this.initialized.wake();
   }
 }

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

@@ -0,0 +1,54 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { schema } from '@dxos/protocols';
+import { ProfileService, SystemService, SpaceService } from '@dxos/protocols/proto/dxos/client';
+import { SpacesService, InvitationsService, DevicesService } from '@dxos/protocols/proto/dxos/client/services';
+import { DevtoolsHost, TracingService } from '@dxos/protocols/proto/dxos/devtools/host';
+import { DataService } from '@dxos/protocols/proto/dxos/echo/service';
+import { createServiceBundle, ServiceBundle } from '@dxos/rpc';
+
+//
+// NOTE: Should contain client/proxy dependencies only.
+//
+
+export type ClientServices = {
+  SpaceService: SpaceService;
+  DataService: DataService;
+  ProfileService: ProfileService;
+  SystemService: SystemService;
+  DevtoolsHost: DevtoolsHost;
+  TracingService: TracingService;
+
+  SpacesService: SpacesService;
+  SpaceInvitationsService: InvitationsService;
+  DevicesService: DevicesService;
+};
+
+/**
+ * Provide access to client services definitions and service handler.
+ */
+export interface ClientServicesProvider {
+  descriptors: ServiceBundle<ClientServices>;
+  services: ClientServices;
+
+  open(): Promise<void>;
+  close(): Promise<void>;
+}
+
+/**
+ * Services supported by host.
+ */
+export const clientServiceBundle = createServiceBundle<ClientServices>({
+  SpaceService: schema.getService('dxos.client.SpaceService'),
+  DataService: schema.getService('dxos.echo.service.DataService'),
+  ProfileService: schema.getService('dxos.client.ProfileService'),
+  SystemService: schema.getService('dxos.client.SystemService'),
+  DevtoolsHost: schema.getService('dxos.devtools.host.DevtoolsHost'),
+  TracingService: schema.getService('dxos.devtools.host.TracingService'),
+
+  SpacesService: schema.getService('dxos.client.services.SpacesService'),
+  SpaceInvitationsService: schema.getService('dxos.client.services.InvitationsService'),
+  DevicesService: schema.getService('dxos.client.services.DevicesService')
+});

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

@@ -6,13 +6,12 @@ import { expect } from 'chai';
 
 import { latch, Trigger } from '@dxos/async';
 import { Config, ConfigProto } from '@dxos/config';
-import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
-import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
+import { MemorySignalManagerContext } from '@dxos/messaging';
 import { InvitationState } from '@dxos/protocols/proto/dxos/client';
-import { InvitationDescriptor } from '@dxos/protocols/proto/dxos/halo/invitations';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { afterTest } from '@dxos/testutils';
 
-import { ClientServiceHost } from './service-host';
+import { createServiceHost } from '../testing';
 
 const defaultTestingConfig: ConfigProto = {
   version: 1
@@ -26,34 +25,23 @@ const defaultTestingConfig: ConfigProto = {
 };
 
 describe('services/service-host', function () {
-  // TODO(burdon): Factor out.
-  const createPeer = (signalManagerContext: MemorySignalManagerContext) => {
-    const networkManager = new NetworkManager({
-      signalManager: new MemorySignalManager(signalManagerContext),
-      transportFactory: MemoryTransportFactory
-    });
-
-    return new ClientServiceHost({
-      config: new Config(defaultTestingConfig),
-      networkManager
-    });
-  };
-
-  it('process device invitation', async function () {
+  it.skip('process device invitation', async function () {
+    const config = new Config(defaultTestingConfig);
     const signalManagerContext = new MemorySignalManagerContext();
 
-    const peer1 = createPeer(signalManagerContext);
-    const peer2 = createPeer(signalManagerContext);
+    // TODO(burdon): Use builder.
+    const peer1 = createServiceHost(config, signalManagerContext);
+    const peer2 = createServiceHost(config, signalManagerContext);
     await peer1.open();
     await peer2.open();
     afterTest(() => peer1.close());
     afterTest(() => peer2.close());
 
-    const invitationTrigger = new Trigger<InvitationDescriptor>();
+    const invitationTrigger = new Trigger<Invitation>();
     {
       await peer1.services.ProfileService.createProfile({});
       const stream = peer1.services.ProfileService.createInvitation();
-      stream.subscribe((msg) => {
+      stream.subscribe((msg: any) => {
         switch (msg.state) {
           case InvitationState.WAITING_FOR_CONNECTION: {
             invitationTrigger.wake(msg.descriptor!);
@@ -67,7 +55,7 @@ describe('services/service-host', function () {
     {
       const invitation = await invitationTrigger.wait();
       const stream = peer2.services.ProfileService.acceptInvitation(invitation);
-      stream.subscribe((msg) => {
+      stream.subscribe((msg: any) => {
         switch (msg.state) {
           case InvitationState.CONNECTED: {
             setAck();
@@ -75,7 +63,7 @@ describe('services/service-host', function () {
           }
 
           case InvitationState.SUCCESS: {
-            expect(msg.partyKey).not.to.be.undefined;
+            expect(msg.spaceKey).not.to.be.undefined;
             setAck();
             break;
           }