@dxos/client-services 0.1.2 → 0.1.3

package/src/packlets/devtools/spaces.ts

@@ -4,33 +4,34 @@
 
 import { Stream } from '@dxos/codec-protobuf';
 import { Space } from '@dxos/echo-db';
-import { SubscribeToPartiesRequest, SubscribeToPartiesResponse } from '@dxos/protocols/proto/dxos/devtools/host';
-import { PartyMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { SubscribeToSpacesRequest, SubscribeToSpacesResponse } from '@dxos/protocols/proto/dxos/devtools/host';
+import { SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 
 import { ServiceContext } from '../services';
 
-export const subscribeToSpaces = (context: ServiceContext, { partyKeys = [] }: SubscribeToPartiesRequest) =>
-  new Stream<SubscribeToPartiesResponse>(({ next }) => {
+export const subscribeToSpaces = (context: ServiceContext, { spaceKeys = [] }: SubscribeToSpacesRequest) =>
+  new Stream<SubscribeToSpacesResponse>(({ next }) => {
     let unsubscribe: () => void;
 
     const update = async () => {
-      const parties: Space[] = [...context.spaceManager!.spaces.values()];
-      const filteredParties = parties.filter(
-        (party) => !partyKeys?.length || partyKeys.some((partyKey) => partyKey.equals(party.key))
+      const spaces: Space[] = [...context.spaceManager!.spaces.values()];
+      const filteredSpaces = spaces.filter(
+        (space) => !spaceKeys?.length || spaceKeys.some((spaceKey) => spaceKey.equals(space.key))
       );
 
       next({
-        parties: filteredParties.map((party) => {
-          const partyMetadata = context.metadataStore.parties.find((partyMetadata: PartyMetadata) =>
-            partyMetadata.key.equals(party.key)
+        spaces: filteredSpaces.map((space) => {
+          const spaceMetadata = context.metadataStore.spaces.find((spaceMetadata: SpaceMetadata) =>
+            spaceMetadata.key.equals(space.key)
           );
+
           return {
-            key: party.key,
-            isOpen: party.isOpen,
-            timeframe: partyMetadata!.latestTimeframe!,
-            genesisFeed: party.genesisFeedKey,
-            controlFeed: party.controlFeedKey,
-            dataFeed: party.dataFeedKey
+            key: space.key,
+            isOpen: space.isOpen,
+            timeframe: spaceMetadata!.latestTimeframe!,
+            genesisFeed: space.genesisFeedKey,
+            controlFeed: space.controlFeedKey,
+            dataFeed: space.dataFeedKey
           };
         })
       });
@@ -38,9 +39,9 @@ export const subscribeToSpaces = (context: ServiceContext, { partyKeys = [] }: S
 
     setImmediate(async () => {
       await context.initialized.wait();
-      unsubscribe = context.spaceManager!.update.on(() => update());
+      unsubscribe = context.spaceManager!.updated.on(() => update());
 
-      // Send initial parties.
+      // Send initial spaces.
       await update();
     });
 

package/src/packlets/identity/devices-service-impl.ts

@@ -0,0 +1,54 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { EventSubscriptions } from '@dxos/async';
+import { Stream } from '@dxos/codec-protobuf';
+import { Device, DevicesService, QueryDevicesResponse } from '@dxos/protocols/proto/dxos/client/services';
+
+import { IdentityManager } from './identity-manager';
+
+export class DevicesServiceImpl implements DevicesService {
+  constructor(private readonly _identityManager: IdentityManager) {}
+
+  updateDevice(): Promise<Device> {
+    throw new Error('Method not implemented.');
+  }
+
+  queryDevices(): Stream<QueryDevicesResponse> {
+    return new Stream(({ next }) => {
+      const update = () => {
+        const deviceKeys = this._identityManager.identity?.authorizedDeviceKeys;
+        if (!deviceKeys) {
+          next({ devices: [] });
+        } else {
+          next({
+            devices: Array.from(deviceKeys.values()).map((key) => ({
+              deviceKey: key
+            }))
+          });
+        }
+      };
+
+      const dispose = new EventSubscriptions();
+
+      dispose.add(
+        this._identityManager.stateUpdate.on(() => {
+          update();
+
+          if (this._identityManager.identity) {
+            dispose.add(
+              this._identityManager.identity.stateUpdate.on(() => {
+                update();
+              })
+            );
+          }
+        })
+      );
+
+      update();
+
+      return () => dispose.clear();
+    });
+  }
+}

package/src/packlets/identity/identity-manager.test.ts

@@ -2,19 +2,18 @@
 // Copyright 2022 DXOS.org
 //
 
-import expect from 'expect';
+import { expect } from 'chai';
 
 import { valueEncoding, MetadataStore } from '@dxos/echo-db';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
-import { ModelFactory } from '@dxos/model-factory';
 import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
-import { ObjectModel } from '@dxos/object-model';
 import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { createStorage, Storage, StorageType } from '@dxos/random-access-storage';
 import { afterTest } from '@dxos/testutils';
 
+import { createDefaultModelFactory } from '../services';
 import { IdentityManager } from './identity-manager';
 
 describe('identity/identity-manager', function () {
@@ -50,7 +49,7 @@ describe('identity/identity-manager', function () {
       feedStore,
       keyring,
       networkManager,
-      new ModelFactory().registerModel(ObjectModel)
+      createDefaultModelFactory()
     );
 
     return {
@@ -65,7 +64,7 @@ describe('identity/identity-manager', function () {
     afterTest(() => identityManager.close());
 
     const identity = await identityManager.createIdentity();
-    expect(identity).toBeTruthy();
+    expect(identity).to.exist;
   });
 
   it('reload from storage', async function () {
@@ -80,9 +79,9 @@ describe('identity/identity-manager', function () {
     const peer2 = await setupPeer({ storage });
     await peer2.identityManager.open();
 
-    expect(peer2.identityManager.identity).toBeDefined();
-    expect(peer2.identityManager.identity!.identityKey).toEqual(identity1.identityKey);
-    expect(peer2.identityManager.identity!.deviceKey).toEqual(identity1.deviceKey);
+    expect(peer2.identityManager.identity).to.exist;
+    expect(peer2.identityManager.identity!.identityKey).to.deep.eq(identity1.identityKey);
+    expect(peer2.identityManager.identity!.deviceKey).to.deep.eq(identity1.deviceKey);
 
     // TODO(dmaretskyi): Check that identity is "alive" (space is working and can write mutations).
   });

package/src/packlets/identity/identity.test.ts

@@ -10,18 +10,17 @@ import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
-import { ModelFactory } from '@dxos/model-factory';
 import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
-import { ObjectModel } from '@dxos/object-model';
 import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { AdmittedFeed } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { createStorage, StorageType } from '@dxos/random-access-storage';
 import { afterTest } from '@dxos/testutils';
 
+import { createDefaultModelFactory } from '../services';
 import { createHaloAuthProvider, createHaloAuthVerifier } from './authenticator';
 import { Identity } from './identity';
 
-const modelFactory = new ModelFactory().registerModel(ObjectModel);
+const modelFactory = createDefaultModelFactory();
 
 describe('identity/identity', function () {
   it('create', async function () {

package/src/packlets/identity/identity.ts

@@ -4,6 +4,7 @@
 
 import assert from 'assert';
 
+import { Event } from '@dxos/async';
 import {
   DeviceStateMachine,
   CredentialSigner,
@@ -34,6 +35,8 @@ export class Identity {
   public readonly identityKey: PublicKey;
   public readonly deviceKey: PublicKey;
 
+  public readonly stateUpdate = new Event();
+
   constructor({ space, signer, identityKey, deviceKey }: IdentityParams) {
     this._space = space;
     this._signer = signer;
@@ -43,9 +46,10 @@ export class Identity {
 
     this._deviceStateMachine = new DeviceStateMachine(this.identityKey, this.deviceKey);
 
-    // Save device key chain credential when processed by the party state machine.
+    // Save device key chain credential when processed by the space state machine.
     this._space.onCredentialProcessed.set(async (credential) => {
       await this._deviceStateMachine.process(credential);
+      this.stateUpdate.emit();
     });
   }
 

package/src/packlets/invitations/encoder.test.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { PublicKey } from '@dxos/keys';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+
+import { InvitationEncoder } from './encoder';
+
+describe('Invitation utils', function () {
+  it('encodes and decodes an invitation', function () {
+    const invitation: Invitation = {
+      swarmKey: PublicKey.random()
+    };
+
+    const encoded = InvitationEncoder.encode(invitation);
+    const decoded = InvitationEncoder.decode(encoded);
+    expect(decoded.swarmKey).to.deep.eq(invitation.swarmKey);
+  });
+});

package/src/packlets/invitations/encoder.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import base from 'base-x';
+
+import { schema } from '@dxos/protocols';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+
+// Encode with URL-safe alpha-numeric characters.
+const base62 = base('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
+
+const codec = schema.getCodecForType('dxos.client.services.Invitation');
+
+/**
+ * Encodes and decodes an invitation proto into/from alphanumeric chars.
+ */
+export class InvitationEncoder {
+  static decode(text: string): Invitation {
+    return codec.decode(base62.decode(text));
+  }
+
+  static encode(invitation: Invitation): string {
+    return base62.encode(codec.encode(invitation));
+  }
+}

package/src/packlets/{services/testing/halo.test.ts → invitations/halo-invitations.test.ts}

@@ -7,11 +7,11 @@ import { expect } from 'chai';
 import { MemorySignalManagerContext } from '@dxos/messaging';
 import { afterTest } from '@dxos/testutils';
 
-import { createServiceContext } from './testing';
+import { createServiceContext } from '../testing';
 
 describe('services/halo', function () {
   it('creates identity', async function () {
-    const peer = await createServiceContext();
+    const peer = createServiceContext();
     await peer.open();
     afterTest(() => peer.close());
 
@@ -19,11 +19,11 @@ describe('services/halo', function () {
     expect(identity).not.to.be.undefined;
   });
 
-  it('device invitations', async function () {
+  it('invitations', async function () {
     const signalContext = new MemorySignalManagerContext();
 
-    const peer1 = await createServiceContext({ signalContext });
-    const peer2 = await createServiceContext({ signalContext });
+    const peer1 = createServiceContext({ signalContext });
+    const peer2 = createServiceContext({ signalContext });
     await peer1.open();
     await peer2.open();
     afterTest(() => peer1.close());

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

@@ -2,6 +2,8 @@
 // Copyright 2022 DXOS.org
 //
 
+import assert from 'assert';
+
 import { Trigger } from '@dxos/async';
 import { failUndefined } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
@@ -9,7 +11,7 @@ import { log } from '@dxos/log';
 import { createProtocolFactory, NetworkManager, StarTopology } from '@dxos/network-manager';
 import { createRpcPlugin } from '@dxos/protocol-plugin-rpc';
 import { schema } from '@dxos/protocols';
-import { InvitationDescriptor } from '@dxos/protocols/proto/dxos/halo/invitations';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { createProtoRpcPeer } from '@dxos/rpc';
 
 import { Identity, IdentityManager } from '../identity';
@@ -27,12 +29,11 @@ export class HaloInvitations {
   /**
    * Sends a HALO admission offer and waits for guest to accept.
    */
-  async createInvitation({ onFinish }: { onFinish?: () => void } = {}): Promise<InvitationDescriptor> {
+  async createInvitation({ onFinish }: { onFinish?: () => void } = {}): Promise<Invitation> {
     const identity = this._identityManager.identity ?? failUndefined();
 
     const plugin = createRpcPlugin(async (port) => {
       const peer = createProtoRpcPeer({
-        port,
         requested: {
           HaloGuestService: schema.getService('dxos.halo.invitations.HaloGuestService')
         },
@@ -61,7 +62,8 @@ export class HaloInvitations {
               // TODO(dmaretskyi): Admit guest's feeds otherwise messages from them won't be processed by the pipeline.
             }
           }
-        }
+        },
+        port
       });
 
       await peer.open();
@@ -90,21 +92,19 @@ export class HaloInvitations {
     });
 
     return {
-      type: InvitationDescriptor.Type.INTERACTIVE,
-      swarmKey: topic.asUint8Array(),
-      invitation: new Uint8Array() // TODO(burdon): Remove.
+      type: Invitation.Type.INTERACTIVE,
+      swarmKey: topic
     };
   }
 
   /**
    * Joins an existing identity HALO by invitation.
    */
-  async acceptInvitation(invitation: InvitationDescriptor): Promise<Identity> {
+  async acceptInvitation(invitation: Invitation): Promise<Identity> {
     const admitted = new Trigger<Identity>(); // TODO(burdon): Must not share across multiple connections.
 
     const plugin = createRpcPlugin(async (port) => {
       const peer = createProtoRpcPeer({
-        port,
         requested: {
           // TODO(burdon): Rename in-bound.
           HaloHostService: schema.getService('dxos.halo.invitations.HaloHostService')
@@ -136,7 +136,8 @@ export class HaloInvitations {
               admitted.wake(identity);
             }
           }
-        }
+        },
+        port
       });
 
       await peer.open();
@@ -144,6 +145,7 @@ export class HaloInvitations {
       await peer.close();
     });
 
+    assert(invitation.swarmKey);
     const topic = PublicKey.from(invitation.swarmKey);
     const peerId = PublicKey.random(); // TODO(burdon): Fails if using the actual peer key.
     const connection = await this._networkManager.openSwarmConnection({

package/src/packlets/invitations/index.ts

@@ -2,7 +2,10 @@
 // Copyright 2022 DXOS.org
 //
 
-export * from './common';
+export * from './encoder';
 export * from './halo-invitations';
-export * from './invitation-wrapper';
-export * from './space-invitations';
+export * from './invitations';
+export * from './invitations-proxy';
+export * from './space-invitations-handler';
+export * from './space-invitations-proxy';
+export * from './space-invitations-service';

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

@@ -0,0 +1,157 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'assert';
+
+import { observableError } from '@dxos/async';
+import { Stream } from '@dxos/codec-protobuf';
+import { log } from '@dxos/log';
+import { Invitation, InvitationsService } from '@dxos/protocols/proto/dxos/client/services';
+
+import {
+  AuthenticatingInvitationObservable,
+  AuthenticatingInvitationProvider,
+  CreateInvitationsOptions,
+  InvitationsProxy,
+  InvitationObservable,
+  InvitationObservableProvider
+} from './invitations';
+
+/**
+ * Adapts invitations service observable to client/service stream.
+ * Used by both HALO and Spaces client/service interfaces.
+ */
+export abstract class AbstractInvitationsProxy<T> implements InvitationsProxy<T> {
+  // prettier-ignore
+  constructor(
+    private readonly _invitationsService: InvitationsService
+  ) {}
+
+  abstract createInvitationObject(context: T): Invitation;
+
+  createInvitation(context: T, options?: CreateInvitationsOptions): InvitationObservable {
+    assert(context);
+
+    let invitationId: string;
+    const observable = new InvitationObservableProvider(async () => {
+      if (invitationId) {
+        await this._invitationsService.cancelInvitation({ invitationId });
+      }
+    });
+
+    const invitation = { ...this.createInvitationObject(context), ...options };
+    const stream: Stream<Invitation> = this._invitationsService.createInvitation(invitation);
+
+    stream.subscribe(
+      (invitation: Invitation) => {
+        observable.setInvitation(invitation);
+
+        switch (invitation.state) {
+          case Invitation.State.CONNECTING: {
+            assert(invitation.invitationId);
+            invitationId = invitation.invitationId;
+            observable.callback.onConnecting?.(invitation);
+            break;
+          }
+
+          case Invitation.State.CONNECTED: {
+            observable.callback.onConnected?.(invitation);
+            break;
+          }
+
+          case Invitation.State.AUTHENTICATING: {
+            observable.callback.onAuthenticating?.(invitation);
+            break;
+          }
+
+          case Invitation.State.SUCCESS: {
+            observable.callback.onSuccess?.(invitation);
+            break;
+          }
+
+          case Invitation.State.CANCELLED: {
+            observable.callback.onCancelled?.();
+            break;
+          }
+
+          default: {
+            log.error(`Invalid state: ${invitation.state}`);
+          }
+        }
+      },
+      (err) => {
+        if (err) {
+          observableError(observable, err);
+        }
+      }
+    );
+
+    return observable;
+  }
+
+  acceptInvitation(invitation: Invitation): AuthenticatingInvitationObservable {
+    assert(invitation && invitation.swarmKey);
+
+    const observable = new AuthenticatingInvitationProvider({
+      onCancel: async () => {
+        const invitationId = observable.invitation?.invitationId;
+        assert(invitationId);
+        await this._invitationsService.cancelInvitation({ invitationId });
+      },
+
+      onAuthenticate: async (authenticationCode: string) => {
+        const invitationId = observable.invitation?.invitationId;
+        assert(invitationId);
+        await this._invitationsService.authenticate({ invitationId, authenticationCode });
+      }
+    });
+
+    const stream: Stream<Invitation> = this._invitationsService.acceptInvitation(invitation);
+
+    stream.subscribe(
+      (invitation: Invitation) => {
+        assert(invitation.invitationId);
+        observable.setInvitation(invitation);
+
+        switch (invitation.state) {
+          case Invitation.State.CONNECTING: {
+            observable.callback.onConnecting?.(invitation);
+            break;
+          }
+
+          case Invitation.State.CONNECTED: {
+            observable.callback.onConnected?.(invitation);
+            break;
+          }
+
+          case Invitation.State.AUTHENTICATING: {
+            observable.callback.onAuthenticating?.(invitation);
+            break;
+          }
+
+          case Invitation.State.SUCCESS: {
+            observable.callback.onSuccess?.(invitation);
+            break;
+          }
+
+          case Invitation.State.CANCELLED: {
+            observable.callback.onCancelled?.();
+            break;
+          }
+
+          default: {
+            log.error(`Invalid state: ${invitation.state}`);
+          }
+        }
+      },
+      (err) => {
+        if (err) {
+          observableError(observable, err);
+        }
+      }
+    );
+
+    return observable;
+  }
+}