@dxos/client-services 0.1.4 → 0.1.6

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

@@ -0,0 +1,184 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'assert';
+
+import { TimeoutError } from '@dxos/async';
+import { Stream } from '@dxos/codec-protobuf';
+import { log } from '@dxos/log';
+import { AuthenticationRequest, Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { Provider } from '@dxos/util';
+
+import { IdentityManager } from '../identity';
+import { AuthenticatingInvitationObservable, CancellableInvitationObservable, InvitationsService } from './invitations';
+import { InvitationsHandler, InvitationsOptions } from './invitations-handler';
+
+/**
+ * Adapts invitation service observable to client/service stream.
+ */
+export abstract class AbstractInvitationsService<T = void> implements InvitationsService {
+  private readonly _createInvitations = new Map<string, CancellableInvitationObservable>();
+  private readonly _acceptInvitations = new Map<string, AuthenticatingInvitationObservable>();
+
+  // prettier-ignore
+  protected constructor (
+    private readonly _identityManager: IdentityManager,
+    private readonly _getInvitationsHandler: Provider<InvitationsHandler<T>>
+  ) {}
+
+  // TODO(burdon): Guest/host label.
+  getLoggingContext() {
+    return {
+      deviceKey: this._identityManager.identity?.deviceKey
+    };
+  }
+
+  abstract getContext(invitation: Invitation): T;
+
+  createInvitation(invitation: Invitation): Stream<Invitation> {
+    return new Stream<Invitation>(({ next, close }) => {
+      const invitationsHandler: InvitationsHandler<T> = this._getInvitationsHandler();
+      const context = this.getContext(invitation);
+      log('stream opened', this.getLoggingContext());
+
+      let invitationId: string;
+      const { type } = invitation;
+      const observable = invitationsHandler.createInvitation(context, { 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 = this.getLoggingContext();
+        if (err) {
+          log.warn('stream closed', { ...context, err });
+        } else {
+          log('stream closed', context);
+        }
+
+        this._createInvitations.delete(invitation.invitationId!);
+      };
+    });
+  }
+
+  acceptInvitation(invitation: Invitation, options?: InvitationsOptions): Stream<Invitation> {
+    return new Stream<Invitation>(({ next, close }) => {
+      log('stream opened', this.getLoggingContext());
+      const invitationsHandler = this._getInvitationsHandler();
+
+      let invitationId: string;
+      const observable = invitationsHandler.acceptInvitation(invitation, options);
+      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) => {
+          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 = this.getLoggingContext();
+        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/invitations/invitations.ts

@@ -11,14 +11,22 @@ import {
   Observable,
   CancellableObservableProvider
 } from '@dxos/async';
-import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import type { Stream } from '@dxos/codec-protobuf';
+import { AuthenticationRequest, CancelInvitationRequest, Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
 export const AUTHENTICATION_CODE_LENGTH = 6;
 
-export type CreateInvitationsOptions = {
-  type?: Invitation.Type;
-  timeout?: number;
-};
+export const INVITATION_TIMEOUT = 3 * 60_000; // 3 mins.
+
+// TODO(burdon): Don't close until RPC has complete (bug).
+export const ON_CLOSE_DELAY = 500;
+
+export interface InvitationsService {
+  createInvitation(invitation: Invitation): Stream<Invitation>;
+  authenticate(request: AuthenticationRequest): Promise<void>;
+  acceptInvitation(invitation: Invitation): Stream<Invitation>;
+  cancelInvitation(request: CancelInvitationRequest): Promise<void>;
+}
 
 /**
  * Common invitation events (callbacks) for creating and accepting invitations.
@@ -87,51 +95,11 @@ export class AuthenticatingInvitationProvider
   }
 }
 
-/**
- * Common interface for Halo and Space invitation proxies and handlers.
- * Handles the life-cycle of Space invitations between peers.
- *
- * Host
- * - Creates an invitation containing a swarm topic.
- * - Joins the swarm with the topic and waits for guest's admission request.
- * - Responds with admission offer then waits for guest's credentials.
- * - Writes credentials to control feed then exits.
- *
- * Guest
- * - Joins the swarm with the topic.
- * - NOTE: The topic is transmitted out-of-band (e.g., via a QR code).
- * - Sends an admission request.
- * - If Space handler then creates a local cloned space (with genesis block).
- * - Sends admission credentials (containing local device and feed keys).
- *
- * TODO(burdon): Show proxy/service relationship and reference design doc/diagram.
- *
- *  ```
- *  [Guest]                                                  [Host]
- *   |-------------------------------------RequestAdmission-->|
- *   |<--AdmissionOffer---------------------------------------|
- *   |
- *   |--------------------------PresentAdmissionCredentials-->|
- *  ```
- */
-export interface InvitationsHandler<T> {
-  // TODO(burdon): Pass in options.
-  createInvitation(context: T, options?: CreateInvitationsOptions): InvitationObservable;
-  acceptInvitation(invitation: Invitation): AuthenticatingInvitationObservable;
-}
-
-/**
- * Common interface for Halo and Space proxies.
- */
-export interface InvitationsProxy<T> extends InvitationsHandler<T> {
-  createInvitationObject(context: T): Invitation;
-}
-
 /**
  * Util to wrap observable with promise.
  * @deprecated
  */
-// TODO(burdon): Replace with InvitationObservableProvider.
+// TODO(burdon): Replace with ObservableInvitationProvider.
 export const invitationObservable = async (observable: Observable<InvitationEvents>): Promise<Invitation> => {
   return new Promise((resolve, reject) => {
     const unsubscribe = observable.subscribe({

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

@@ -61,11 +61,11 @@ describe('services/space-invitations-handler', function () {
       onConnecting: async (invitation1: Invitation) => {
         const observable2 = guest.spaceInvitations!.acceptInvitation(invitation1);
         observable2.subscribe({
-          onConnecting: async (invitation2: Invitation) => {},
+          onConnecting: async () => {},
           onConnected: async (invitation2: Invitation) => {
             expect(invitation1.swarmKey).to.eq(invitation2.swarmKey);
           },
-          onAuthenticating: async (invitation2: Invitation) => {
+          onAuthenticating: async () => {
             await observable2.authenticate(await authenticationCode.wait());
           },
           onSuccess: (invitation: Invitation) => {
@@ -81,17 +81,17 @@ describe('services/space-invitations-handler', function () {
         authenticationCode.wake(invitation.authenticationCode);
       },
       onSuccess: (invitation: Invitation) => {
-        complete1.wake(space1.key);
+        complete1.wake(invitation.spaceKey!);
       },
       onCancelled: () => raise(new Error()),
       onTimeout: (err: Error) => raise(new Error(err.message)),
       onError: (err: Error) => raise(new Error(err.message))
     });
 
-    {
-      const [spaceKey1, spaceKey2] = await Promise.all([complete1.wait(), complete2.wait()]);
-      expect(spaceKey1).to.deep.eq(spaceKey2);
+    const [spaceKey1, spaceKey2] = await Promise.all([complete1.wait(), complete2.wait()]);
+    expect(spaceKey1).to.deep.eq(spaceKey2);
 
+    {
       const space1 = host.spaceManager!.spaces.get(spaceKey1)!;
       const space2 = guest.spaceManager!.spaces.get(spaceKey2)!;
       expect(space1).not.to.be.undefined;

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

@@ -18,39 +18,38 @@ import { createProtoRpcPeer } from '@dxos/rpc';
 
 import {
   AuthenticatingInvitationProvider,
-  CreateInvitationsOptions,
-  InvitationsHandler,
   InvitationObservable,
   InvitationObservableProvider,
-  AUTHENTICATION_CODE_LENGTH
+  AUTHENTICATION_CODE_LENGTH,
+  INVITATION_TIMEOUT,
+  ON_CLOSE_DELAY
 } from './invitations';
-
-// TODO(burdon): Pass options from client.
-// TODO(burdon): Don't close until RPC has complete.
-const ON_CLOSE_DELAY = 500;
-const INVITATION_TIMEOUT = 3 * 60_000; // 3 mins.
+import { AbstractInvitationsHandler, InvitationsOptions } from './invitations-handler';
 
 /**
  * Handles the life-cycle of Space invitations between peers.
  */
-export class SpaceInvitationsHandler implements InvitationsHandler<Space> {
+// TODO(dmaretskyi): Split into Host and Guest parts.
+export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
   constructor(
+    networkManager: NetworkManager,
     private readonly _spaceManager: SpaceManager,
-    private readonly _networkManager: NetworkManager,
     private readonly _signingContext: SigningContext
-  ) {}
+  ) {
+    super(networkManager);
+  }
 
   /**
    * Creates an invitation and listens for a join request from the invited (guest) peer.
    */
-  createInvitation(space: Space, options?: CreateInvitationsOptions): InvitationObservable {
+  createInvitation(space: Space, options?: InvitationsOptions): InvitationObservable {
     let swarmConnection: SwarmConnection | undefined;
     const { type, timeout = INVITATION_TIMEOUT } = options ?? {};
     assert(type !== Invitation.Type.OFFLINE);
+    assert(space);
 
     const invitation: Invitation = {
       type,
-      // type: Invitation.Type.INTERACTIVE_TESTING,
       invitationId: PublicKey.random().toHex(),
       swarmKey: PublicKey.random(),
       spaceKey: space.key,
@@ -169,7 +168,8 @@ export class SpaceInvitationsHandler implements InvitationsHandler<Space> {
    * The local guest peer (invitee) then sends the local space invitation to the host,
    * which then writes the guest's credentials to the space.
    */
-  acceptInvitation(invitation: Invitation): AuthenticatingInvitationProvider {
+  acceptInvitation(invitation: Invitation, options?: InvitationsOptions): AuthenticatingInvitationProvider {
+    const { timeout = INVITATION_TIMEOUT } = options ?? {};
     let swarmConnection: SwarmConnection | undefined;
 
     const authenticated = new Trigger<string>();
@@ -211,9 +211,9 @@ export class SpaceInvitationsHandler implements InvitationsHandler<Space> {
         // 2. Get authentication code.
         // TODO(burdon): Test timeout (options for timeouts at different steps).
         if (invitation.type === undefined || invitation.type === Invitation.Type.INTERACTIVE) {
-          log('waiting for authentication code...');
+          log('guest waiting for authentication code...');
           observable.callback.onAuthenticating?.(invitation);
-          const authenticationCode = await authenticated.wait({ timeout: INVITATION_TIMEOUT });
+          const authenticationCode = await authenticated.wait({ timeout });
           log('sending authentication request');
           await peer.rpc.SpaceHostService.authenticate({ authenticationCode });
         }

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

@@ -10,7 +10,7 @@ import { AbstractInvitationsProxy } from './invitations-proxy';
  * Adapts invitation service observable to client/service stream.
  */
 export class SpaceInvitationsProxy extends AbstractInvitationsProxy<PublicKey> {
-  createInvitationObject(spaceKey: PublicKey) {
-    return { spaceKey };
+  getInvitationOptions(context: PublicKey) {
+    return { spaceKey: context };
   }
 }

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

@@ -7,7 +7,7 @@ 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 { Invitation, SpaceInvitationsService } from '@dxos/protocols/proto/dxos/client/services';
 import { afterTest } from '@dxos/testutils';
 
 import { ServiceContext } from '../services';
@@ -26,18 +26,18 @@ describe('services/space-invitation-service', function () {
 
     assert(host.spaceManager);
     assert(host.spaceInvitations);
-    const service1: InvitationsService = new SpaceInvitationsServiceImpl(
+    const service1: SpaceInvitationsService = new SpaceInvitationsServiceImpl(
       host.identityManager,
-      () => host.spaceManager!,
-      () => host.spaceInvitations!
+      () => host.spaceInvitations!,
+      () => host.spaceManager!
     );
 
     assert(guest.spaceManager);
     assert(guest.spaceInvitations);
-    const service2: InvitationsService = new SpaceInvitationsServiceImpl(
+    const service2: SpaceInvitationsService = new SpaceInvitationsServiceImpl(
       guest.identityManager,
-      () => guest.spaceManager!,
-      () => guest.spaceInvitations!
+      () => guest.spaceInvitations!,
+      () => guest.spaceManager!
     );
 
     const space1 = await host.spaceManager.createSpace();
@@ -87,18 +87,18 @@ describe('services/space-invitation-service', function () {
 
     assert(host.spaceManager);
     assert(host.spaceInvitations);
-    const service1: InvitationsService = new SpaceInvitationsServiceImpl(
+    const service1: SpaceInvitationsService = new SpaceInvitationsServiceImpl(
       host.identityManager,
-      () => host.spaceManager!,
-      () => host.spaceInvitations!
+      () => host.spaceInvitations!,
+      () => host.spaceManager!
     );
 
     assert(guest.spaceManager);
     assert(guest.spaceInvitations);
-    const service2: InvitationsService = new SpaceInvitationsServiceImpl(
+    const service2: SpaceInvitationsService = new SpaceInvitationsServiceImpl(
       guest.identityManager,
-      () => guest.spaceManager!,
-      () => guest.spaceInvitations!
+      () => guest.spaceInvitations!,
+      () => guest.spaceManager!
     );
 
     const space1 = await host.spaceManager.createSpace();

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

@@ -4,193 +4,32 @@
 
 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 { Space, SpaceManager } from '@dxos/echo-db';
+import { Invitation } 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';
+import { InvitationsHandler } from './invitations-handler';
+import { AbstractInvitationsService } from './invitations-service';
 
 /**
  * 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>();
-
+export class SpaceInvitationsServiceImpl extends AbstractInvitationsService<Space> {
   // 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);
-    }
+    identityManager: IdentityManager,
+    private readonly invitationsHandler: Provider<InvitationsHandler<Space>>,
+    private readonly _getSpaceManager: Provider<SpaceManager>
+  ) {
+    super(identityManager, invitationsHandler);
   }
 
-  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();
-    }
+  override getContext(invitation: Invitation): Space {
+    assert(invitation.spaceKey);
+    const spaceManager = this._getSpaceManager();
+    const space = spaceManager.spaces.get(invitation.spaceKey!);
+    assert(space);
+    return space;
   }
 }