@dxos/client-services 0.1.35 → 0.1.36-next.ef27157

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

@@ -2,7 +2,10 @@
 // Copyright 2022 DXOS.org
 //
 
+import assert from 'node:assert';
+
 import { Trigger } from '@dxos/async';
+import { Invitation } from '@dxos/client';
 import { CredentialConsumer, getCredentialAssertion } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
 import {
@@ -25,7 +28,12 @@ import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { Storage } from '@dxos/random-access-storage';
 
 import { CreateIdentityOptions, IdentityManager, JoinIdentityParams } from '../identity';
-import { DeviceInvitationsHandler, SpaceInvitationsHandler } from '../invitations';
+import {
+  DeviceInvitationProtocol,
+  InvitationsHandler,
+  InvitationProtocol,
+  SpaceInvitationProtocol
+} from '../invitations';
 import { DataSpaceManager } from '../spaces';
 
 /**
@@ -41,13 +49,17 @@ export class ServiceContext {
   public readonly keyring: Keyring;
   public readonly spaceManager: SpaceManager;
   public readonly identityManager: IdentityManager;
-  public readonly deviceInvitations: DeviceInvitationsHandler;
-
-  private _deviceSpaceSync?: CredentialConsumer<any>;
+  public readonly invitations: InvitationsHandler;
 
   // Initialized after identity is initialized.
   public dataSpaceManager?: DataSpaceManager;
-  public spaceInvitations?: SpaceInvitationsHandler;
+
+  private readonly _handlerFactories = new Map<
+    Invitation.Kind,
+    (invitation: Partial<Invitation>) => InvitationProtocol
+  >();
+
+  private _deviceSpaceSync?: CredentialConsumer<any>;
 
   private readonly _instanceId = PublicKey.random().toHex();
 
@@ -84,14 +96,15 @@ export class ServiceContext {
       this.spaceManager
     );
 
+    this.invitations = new InvitationsHandler(this.networkManager);
+
     // TODO(burdon): _initialize called in multiple places.
     // TODO(burdon): Call _initialize on success.
-    this.deviceInvitations = new DeviceInvitationsHandler({
-      networkManager: this.networkManager,
-      getIdentity: () => this.identityManager.identity ?? failUndefined(),
-      acceptIdentity: this._acceptIdentity.bind(this),
-      keyring: this.keyring
-    });
+    this._handlerFactories.set(Invitation.Kind.DEVICE, () => new DeviceInvitationProtocol(
+      this.keyring,
+      () => this.identityManager.identity ?? failUndefined(),
+      this._acceptIdentity.bind(this)
+    ));
   }
 
   async open() {
@@ -135,6 +148,12 @@ export class ServiceContext {
     return identity;
   }
 
+  getInvitationHandler(invitation: Partial<Invitation> & Pick<Invitation, 'kind'>): InvitationProtocol {
+    const factory = this._handlerFactories.get(invitation.kind);
+    assert(factory, `Unknown invitation kind: ${invitation.kind}`);
+    return factory(invitation);
+  }
+
   private async _acceptIdentity(params: JoinIdentityParams) {
     const identity = await this.identityManager.acceptIdentity(params);
 
@@ -168,12 +187,10 @@ export class ServiceContext {
     );
     await this.dataSpaceManager.open();
 
-    this.spaceInvitations = new SpaceInvitationsHandler(
-      this.networkManager,
-      this.dataSpaceManager,
-      signingContext,
-      this.keyring
-    );
+    this._handlerFactories.set(Invitation.Kind.SPACE, (invitation) => {
+      assert(this.dataSpaceManager, 'dataSpaceManager not initialized yet');
+      return new SpaceInvitationProtocol(this.dataSpaceManager, signingContext, this.keyring, invitation.spaceKey);
+    });
     this.initialized.wake();
 
     this._deviceSpaceSync = identity.space.spaceState.registerProcessor({

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

@@ -7,7 +7,6 @@ import assert from 'node:assert';
 import { Event } from '@dxos/async';
 import { clientServiceBundle, ClientServices, createDefaultModelFactory, PublicKey } from '@dxos/client';
 import { Config } from '@dxos/config';
-import { raise } from '@dxos/debug';
 import { DataServiceImpl } from '@dxos/echo-pipeline';
 import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
@@ -20,7 +19,7 @@ import { TracingServiceImpl } from '../deprecated';
 import { DevicesServiceImpl } from '../devices';
 import { DevtoolsServiceImpl, DevtoolsHostEvents } from '../devtools';
 import { IdentityServiceImpl } from '../identity';
-import { DeviceInvitationsServiceImpl, SpaceInvitationsServiceImpl } from '../invitations';
+import { InvitationsServiceImpl } from '../invitations';
 import { NetworkServiceImpl } from '../network';
 import { SpacesServiceImpl } from '../spaces';
 import { createStorageObjects } from '../storage';
@@ -185,18 +184,11 @@ export class ClientServicesHost {
 
       IdentityService: new IdentityServiceImpl(this._serviceContext),
 
-      DevicesService: new DevicesServiceImpl(this._serviceContext.identityManager),
-
-      DeviceInvitationsService: new DeviceInvitationsServiceImpl(
-        this._serviceContext.identityManager,
-        this._serviceContext.deviceInvitations
+      InvitationsService: new InvitationsServiceImpl(this._serviceContext.invitations, (invitation) =>
+        this._serviceContext.getInvitationHandler(invitation)
       ),
 
-      SpaceInvitationsService: new SpaceInvitationsServiceImpl(
-        this._serviceContext.identityManager,
-        () => this._serviceContext.spaceInvitations ?? raise(new Error('SpaceInvitations not initialized')),
-        () => this._serviceContext.dataSpaceManager ?? raise(new Error('SpaceManager not initialized'))
-      ),
+      DevicesService: new DevicesServiceImpl(this._serviceContext.identityManager),
 
       SpacesService: new SpacesServiceImpl(
         this._serviceContext.identityManager,

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

@@ -5,25 +5,25 @@
 import assert from 'node:assert';
 
 import { Trigger } from '@dxos/async';
-import { ClientServices, SpaceInvitationsProxy } from '@dxos/client';
+import { ClientServices, InvitationsProxy } from '@dxos/client';
 import { log } from '@dxos/log';
 import { schema } from '@dxos/protocols';
-import { Invitation, SpaceInvitationsService } from '@dxos/protocols/proto/dxos/client/services';
+import { Invitation, InvitationsService } from '@dxos/protocols/proto/dxos/client/services';
 import { createLinkedPorts, createProtoRpcPeer, createServiceBundle } from '@dxos/rpc';
 import { describe, test } from '@dxos/test';
 
-import { SpaceInvitationsServiceImpl } from '../invitations';
+import { InvitationsServiceImpl } from '../invitations';
 import { createServiceContext } from '../testing';
 import { ServiceRegistry } from './service-registry';
 
 // TODO(burdon): Create TestService (that doesn't require peers).
 
 type TestServices = {
-  SpaceInvitationsService: SpaceInvitationsService;
+  InvitationsService: InvitationsService;
 };
 
 const serviceBundle = createServiceBundle<TestServices>({
-  SpaceInvitationsService: schema.getService('dxos.client.services.SpaceInvitationsService')
+  InvitationsService: schema.getService('dxos.client.services.InvitationsService')
 });
 
 describe('service registry', () => {
@@ -33,14 +33,11 @@ describe('service registry', () => {
     await serviceContext.createIdentity();
 
     assert(serviceContext.dataSpaceManager);
-    assert(serviceContext.spaceInvitations);
     const space = await serviceContext.dataSpaceManager.createSpace();
 
     const serviceRegistry = new ServiceRegistry(serviceBundle, {
-      SpaceInvitationsService: new SpaceInvitationsServiceImpl(
-        serviceContext.identityManager,
-        () => serviceContext.spaceInvitations!,
-        () => serviceContext.dataSpaceManager!
+      InvitationsService: new InvitationsServiceImpl(serviceContext.invitations, (invitation) =>
+        serviceContext.getInvitationHandler(invitation)
       )
     });
 
@@ -66,21 +63,22 @@ describe('service registry', () => {
     const done = new Trigger(); // createRpcServer
 
     {
-      const spaceInvitationsProxy = new SpaceInvitationsProxy(proxy.rpc.SpaceInvitationsService);
-      const observer = spaceInvitationsProxy.createInvitation(space.key);
-      observer.subscribe({
-        onConnecting: (invitation: Invitation) => {
-          log('connecting', invitation);
-          void observer.cancel();
-        },
-        onCancelled: () => {
-          done.wake();
-        },
-        onSuccess: (_invitation: Invitation) => {
-          throw new Error('Not not implemented.');
-        },
-        onError: () => {
-          throw new Error('Not not implemented.');
+      const spaceInvitationsProxy = new InvitationsProxy(proxy.rpc.InvitationsService, () => ({
+        kind: Invitation.Kind.SPACE,
+        spaceKey: space.key
+      }));
+      const observer = spaceInvitationsProxy.createInvitation();
+      observer.subscribe((invitation: Invitation) => {
+        switch (invitation.state) {
+          case Invitation.State.CONNECTING: {
+            log('connecting', invitation);
+            void observer.cancel();
+            break;
+          }
+
+          case Invitation.State.CANCELLED: {
+            done.wake();
+          }
         }
       });
     }

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

@@ -149,10 +149,15 @@ export class SpacesServiceImpl implements SpacesService {
       spaceKey: space.key,
       state: space.state,
       pipeline: {
-        targetControlTimeframe: space.inner.controlPipeline.state.targetTimeframe,
+        controlFeeds: space.inner.controlPipeline.state.feeds.map((feed) => feed.key),
         currentControlTimeframe: space.inner.controlPipeline.state.timeframe,
+        targetControlTimeframe: space.inner.controlPipeline.state.targetTimeframe,
+        totalControlTimeframe: space.inner.controlPipeline.state.endTimeframe,
+
+        dataFeeds: space.dataPipeline.pipelineState?.feeds.map((feed) => feed.key) ?? [],
         currentDataTimeframe: space.dataPipeline.pipelineState?.timeframe,
-        targetDataTimeframe: space.dataPipeline.pipelineState?.targetTimeframe
+        targetDataTimeframe: space.dataPipeline.pipelineState?.targetTimeframe,
+        totalDataTimeframe: space.dataPipeline.pipelineState?.endTimeframe
       },
       members: Array.from(space.inner.spaceState.members.values()).map((member) => ({
         identity: {

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

@@ -5,39 +5,227 @@
 import assert from 'node:assert';
 
 import { Trigger } from '@dxos/async';
-import { InvitationsHandler } from '@dxos/client';
-import { raise } from '@dxos/debug';
+import {
+  AuthenticatingInvitationObservable,
+  CancellableInvitationObservable,
+  Client,
+  EchoProxy,
+  HaloProxy,
+  InvitationsProxy,
+  SpaceProxy
+} from '@dxos/client';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
-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.
-  const observable1 = await host.createInvitation(context, { type: Invitation.Type.INTERACTIVE_TESTING });
-  observable1.subscribe({
-    onConnecting: async (invitation1: Invitation) => {
-      const observable2 = await guest.acceptInvitation(invitation1, { type: Invitation.Type.INTERACTIVE_TESTING });
-      observable2.subscribe({
-        onConnecting: async (invitation2: Invitation) => {
-          assert(invitation1.swarmKey!.equals(invitation2.swarmKey!));
-        },
-        onConnected: async (invitation2: Invitation) => {},
-        onSuccess: (invitation) => {
-          done2.wake(invitation);
-        },
-        onCancelled: () => raise(new Error()),
-        onTimeout: (err: Error) => raise(err),
-        onError: (err: Error) => raise(err)
-      });
-    },
-    onConnected: async (invitation1: Invitation) => {},
-    onCancelled: () => raise(new Error('cancelled')),
-    onSuccess: (invitation) => {
-      done1.wake(invitation);
+import { ServiceContext } from '../services';
+
+/**
+ * Strip secrets from invitation before giving it to the peer.
+ */
+export const sanitizeInvitation = (invitation: Invitation): Invitation => {
+  return {
+    invitationId: invitation.invitationId,
+    type: invitation.type,
+    kind: invitation.kind,
+    authMethod: invitation.authMethod,
+    swarmKey: invitation.swarmKey,
+    state: invitation.state,
+    timeout: invitation.timeout
+  };
+};
+
+export type PerformInvitationCallbacks<T> = {
+  onConnecting?: (value: T) => boolean | void;
+  onConnected?: (value: T) => boolean | void;
+  onReady?: (value: T) => boolean | void;
+  onAuthenticating?: (value: T) => boolean | void;
+  onSuccess?: (value: T) => boolean | void;
+  onCancelled?: (value: T) => boolean | void;
+  onTimeout?: (value: T) => boolean | void;
+  onError?: (value: T) => boolean | void;
+};
+
+export type PerformInvitationParams = {
+  host: ServiceContext | InvitationsProxy | HaloProxy | SpaceProxy;
+  guest: ServiceContext | InvitationsProxy | HaloProxy | EchoProxy | Client;
+  options?: Partial<Invitation>;
+  hooks?: {
+    host?: PerformInvitationCallbacks<CancellableInvitationObservable>;
+    guest?: PerformInvitationCallbacks<AuthenticatingInvitationObservable>;
+  };
+};
+
+export type Result = { invitation?: Invitation; error?: Error };
+
+export const performInvitation = ({
+  host,
+  guest,
+  options,
+  hooks
+}: PerformInvitationParams): [Promise<Result>, Promise<Result>] => {
+  const hostComplete = new Trigger<Result>();
+  const guestComplete = new Trigger<Result>();
+  const authCode = new Trigger<string>();
+
+  const hostObservable = createInvitation(host, options);
+  hostObservable.subscribe(
+    async (hostInvitation: Invitation) => {
+      switch (hostInvitation.state) {
+        case Invitation.State.CONNECTING: {
+          if (hooks?.host?.onConnecting?.(hostObservable)) {
+            break;
+          }
+          const guestObservable = acceptInvitation(guest, hostInvitation);
+          guestObservable.subscribe(
+            async (guestInvitation: Invitation) => {
+              switch (guestInvitation.state) {
+                case Invitation.State.CONNECTING: {
+                  if (hooks?.guest?.onConnecting?.(guestObservable)) {
+                    break;
+                  }
+                  assert(hostInvitation.swarmKey!.equals(guestInvitation.swarmKey!));
+                  break;
+                }
+
+                case Invitation.State.CONNECTED: {
+                  hooks?.guest?.onConnected?.(guestObservable);
+                  break;
+                }
+
+                case Invitation.State.READY_FOR_AUTHENTICATION: {
+                  if (hooks?.guest?.onReady?.(guestObservable)) {
+                    break;
+                  }
+                  await guestObservable.authenticate(await authCode.wait());
+                  break;
+                }
+
+                case Invitation.State.AUTHENTICATING: {
+                  hooks?.guest?.onAuthenticating?.(guestObservable);
+                  break;
+                }
+
+                case Invitation.State.SUCCESS: {
+                  if (hooks?.guest?.onSuccess?.(guestObservable)) {
+                    break;
+                  }
+                  guestComplete.wake({ invitation: guestInvitation });
+                  break;
+                }
+
+                case Invitation.State.CANCELLED: {
+                  if (hooks?.guest?.onCancelled?.(guestObservable)) {
+                    break;
+                  }
+                  guestComplete.wake({ invitation: guestInvitation });
+                  break;
+                }
+
+                case Invitation.State.TIMEOUT: {
+                  if (hooks?.guest?.onTimeout?.(guestObservable)) {
+                    return;
+                  }
+                  guestComplete.wake({ invitation: guestInvitation });
+                }
+              }
+            },
+            (error: Error) => {
+              if (hooks?.guest?.onError?.(guestObservable)) {
+                return;
+              }
+              guestComplete.wake({ error });
+            }
+          );
+          break;
+        }
+
+        case Invitation.State.CONNECTED: {
+          hooks?.host?.onConnected?.(hostObservable);
+          break;
+        }
+
+        case Invitation.State.READY_FOR_AUTHENTICATION: {
+          if (hooks?.host?.onReady?.(hostObservable)) {
+            break;
+          }
+          if (hostInvitation.authCode) {
+            authCode.wake(hostInvitation.authCode);
+          }
+          break;
+        }
+
+        case Invitation.State.AUTHENTICATING: {
+          hooks?.host?.onAuthenticating?.(hostObservable);
+          break;
+        }
+
+        case Invitation.State.SUCCESS: {
+          if (hooks?.host?.onSuccess?.(hostObservable)) {
+            break;
+          }
+          hostComplete.wake({ invitation: hostInvitation });
+          break;
+        }
+
+        case Invitation.State.CANCELLED: {
+          if (hooks?.host?.onCancelled?.(hostObservable)) {
+            break;
+          }
+          hostComplete.wake({ invitation: hostInvitation });
+          break;
+        }
+
+        case Invitation.State.TIMEOUT: {
+          if (hooks?.host?.onTimeout?.(hostObservable)) {
+            break;
+          }
+          hostComplete.wake({ invitation: hostInvitation });
+          break;
+        }
+      }
     },
-    onTimeout: (err: Error) => raise(err),
-    onError: (err: Error) => raise(err)
-  });
+    (error: Error) => {
+      if (hooks?.host?.onError?.(hostObservable)) {
+        return;
+      }
+      hostComplete.wake({ error });
+    }
+  );
+
+  return [hostComplete.wait(), guestComplete.wait()];
+};
+
+const createInvitation = (
+  host: ServiceContext | InvitationsProxy | HaloProxy | SpaceProxy,
+  options?: Partial<Invitation>
+): CancellableInvitationObservable => {
+  options ??= {
+    authMethod: Invitation.AuthMethod.NONE,
+    ...(options ?? {})
+  };
+
+  if (host instanceof InvitationsProxy || host instanceof HaloProxy || host instanceof SpaceProxy) {
+    return host.createInvitation(options);
+  }
+
+  const hostHandler = host.getInvitationHandler({ kind: Invitation.Kind.SPACE, ...options });
+  return host.invitations.createInvitation(hostHandler, options);
+};
+
+const acceptInvitation = (
+  guest: ServiceContext | InvitationsProxy | HaloProxy | EchoProxy | Client,
+  invitation: Invitation
+): AuthenticatingInvitationObservable => {
+  invitation = sanitizeInvitation(invitation);
+
+  if (
+    guest instanceof InvitationsProxy ||
+    guest instanceof HaloProxy ||
+    guest instanceof EchoProxy ||
+    guest instanceof Client
+  ) {
+    return guest.acceptInvitation(invitation);
+  }
 
-  await done1.wait();
-  await done2.wait();
+  const guestHandler = guest.getInvitationHandler({ kind: invitation.kind });
+  return guest.invitations.acceptInvitation(guestHandler, invitation);
 };

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

@@ -150,27 +150,38 @@ export const joinCommonSpace = async ([initialPeer, ...peers]: Client[], spaceKe
       const hostDone = new Trigger<Invitation>();
       const guestDone = new Trigger<Invitation>();
 
-      const hostObservabli = rootSpace.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
+      const hostObservable = rootSpace.createInvitation({ authMethod: Invitation.AuthMethod.NONE });
       log('invitation created');
-      hostObservabli.subscribe({
-        onConnecting: (invitation) => {
-          const guestObservable = peer.acceptInvitation(invitation);
-          log('invitation accepted');
-
-          guestObservable.subscribe({
-            onSuccess: (invitation: Invitation) => {
-              guestDone.wake(invitation);
-              log('invitation guestDone');
-            },
-            onError: (err: Error) => raise(err)
-          });
+      hostObservable.subscribe(
+        (hostInvitation) => {
+          switch (hostInvitation.state) {
+            case Invitation.State.CONNECTING: {
+              const guestObservable = peer.acceptInvitation(hostInvitation);
+              log('invitation accepted');
+
+              guestObservable.subscribe(
+                (guestInvitation) => {
+                  switch (guestInvitation.state) {
+                    case Invitation.State.SUCCESS: {
+                      guestDone.wake(guestInvitation);
+                      log('invitation guestDone');
+                      break;
+                    }
+                  }
+                },
+                (err) => raise(err)
+              );
+              break;
+            }
+
+            case Invitation.State.SUCCESS: {
+              hostDone.wake(hostInvitation);
+              log('invitation hostDone');
+            }
+          }
         },
-        onSuccess: (invitation) => {
-          hostDone.wake(invitation);
-          log('invitation hostDone');
-        },
-        onError: (err) => raise(err)
-      });
+        (err) => raise(err)
+      );
 
       await Promise.all([hostDone.wait(), guestDone.wait()]);
     })