@dxos/client-services 0.4.10-main.4c7b3fa → 0.4.10-main.4d48ccf

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

@@ -60,146 +60,149 @@ export const performInvitation = ({
   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, guestDeviceProfile);
-          guestObservable.subscribe(
-            async (guestInvitation: Invitation) => {
-              switch (guestInvitation.state) {
-                case Invitation.State.CONNECTING: {
-                  if (hooks?.guest?.onConnecting?.(guestObservable)) {
+  void createInvitation(host, options).then((hostObservable) => {
+    hostObservable.subscribe(
+      async (hostInvitation: Invitation) => {
+        switch (hostInvitation.state) {
+          case Invitation.State.CONNECTING: {
+            if (hooks?.host?.onConnecting?.(hostObservable)) {
+              break;
+            }
+            const guestObservable = acceptInvitation(guest, hostInvitation, guestDeviceProfile);
+            guestObservable.subscribe(
+              async (guestInvitation: Invitation) => {
+                switch (guestInvitation.state) {
+                  case Invitation.State.CONNECTING: {
+                    if (hooks?.guest?.onConnecting?.(guestObservable)) {
+                      break;
+                    }
+                    invariant(hostInvitation.swarmKey!.equals(guestInvitation.swarmKey!));
                     break;
                   }
-                  invariant(hostInvitation.swarmKey!.equals(guestInvitation.swarmKey!));
-                  break;
-                }
 
-                case Invitation.State.CONNECTED: {
-                  hooks?.guest?.onConnected?.(guestObservable);
-                  break;
-                }
+                  case Invitation.State.CONNECTED: {
+                    hooks?.guest?.onConnected?.(guestObservable);
+                    break;
+                  }
 
-                case Invitation.State.READY_FOR_AUTHENTICATION: {
-                  if (hooks?.guest?.onReady?.(guestObservable)) {
+                  case Invitation.State.READY_FOR_AUTHENTICATION: {
+                    if (hooks?.guest?.onReady?.(guestObservable)) {
+                      break;
+                    }
+                    await guestObservable.authenticate(await authCode.wait());
                     break;
                   }
-                  await guestObservable.authenticate(await authCode.wait());
-                  break;
-                }
 
-                case Invitation.State.AUTHENTICATING: {
-                  hooks?.guest?.onAuthenticating?.(guestObservable);
-                  break;
-                }
+                  case Invitation.State.AUTHENTICATING: {
+                    hooks?.guest?.onAuthenticating?.(guestObservable);
+                    break;
+                  }
 
-                case Invitation.State.SUCCESS: {
-                  if (hooks?.guest?.onSuccess?.(guestObservable)) {
+                  case Invitation.State.SUCCESS: {
+                    if (hooks?.guest?.onSuccess?.(guestObservable)) {
+                      break;
+                    }
+                    guestComplete.wake({ invitation: guestInvitation });
                     break;
                   }
-                  guestComplete.wake({ invitation: guestInvitation });
-                  break;
-                }
 
-                case Invitation.State.CANCELLED: {
-                  if (hooks?.guest?.onCancelled?.(guestObservable)) {
+                  case Invitation.State.CANCELLED: {
+                    if (hooks?.guest?.onCancelled?.(guestObservable)) {
+                      break;
+                    }
+                    guestComplete.wake({ invitation: guestInvitation });
                     break;
                   }
-                  guestComplete.wake({ invitation: guestInvitation });
-                  break;
-                }
 
-                case Invitation.State.TIMEOUT: {
-                  if (hooks?.guest?.onTimeout?.(guestObservable)) {
-                    return;
+                  case Invitation.State.TIMEOUT: {
+                    if (hooks?.guest?.onTimeout?.(guestObservable)) {
+                      return;
+                    }
+                    guestComplete.wake({ invitation: guestInvitation });
                   }
-                  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;
-        }
+              },
+              (error: Error) => {
+                if (hooks?.guest?.onError?.(guestObservable)) {
+                  return;
+                }
+                guestComplete.wake({ error });
+              },
+            );
+            break;
+          }
 
-        case Invitation.State.READY_FOR_AUTHENTICATION: {
-          if (hooks?.host?.onReady?.(hostObservable)) {
+          case Invitation.State.CONNECTED: {
+            hooks?.host?.onConnected?.(hostObservable);
             break;
           }
-          if (hostInvitation.authCode) {
-            authCode.wake(hostInvitation.authCode);
+
+          case Invitation.State.READY_FOR_AUTHENTICATION: {
+            if (hooks?.host?.onReady?.(hostObservable)) {
+              break;
+            }
+            if (hostInvitation.authCode) {
+              authCode.wake(hostInvitation.authCode);
+            }
+            break;
           }
-          break;
-        }
 
-        case Invitation.State.AUTHENTICATING: {
-          hooks?.host?.onAuthenticating?.(hostObservable);
-          break;
-        }
+          case Invitation.State.AUTHENTICATING: {
+            hooks?.host?.onAuthenticating?.(hostObservable);
+            break;
+          }
 
-        case Invitation.State.SUCCESS: {
-          if (hooks?.host?.onSuccess?.(hostObservable)) {
+          case Invitation.State.SUCCESS: {
+            if (hooks?.host?.onSuccess?.(hostObservable)) {
+              break;
+            }
+            hostComplete.wake({ invitation: hostInvitation });
             break;
           }
-          hostComplete.wake({ invitation: hostInvitation });
-          break;
-        }
 
-        case Invitation.State.CANCELLED: {
-          if (hooks?.host?.onCancelled?.(hostObservable)) {
+          case Invitation.State.CANCELLED: {
+            if (hooks?.host?.onCancelled?.(hostObservable)) {
+              break;
+            }
+            hostComplete.wake({ invitation: hostInvitation });
             break;
           }
-          hostComplete.wake({ invitation: hostInvitation });
-          break;
-        }
 
-        case Invitation.State.TIMEOUT: {
-          if (hooks?.host?.onTimeout?.(hostObservable)) {
+          case Invitation.State.TIMEOUT: {
+            if (hooks?.host?.onTimeout?.(hostObservable)) {
+              break;
+            }
+            hostComplete.wake({ invitation: hostInvitation });
             break;
           }
-          hostComplete.wake({ invitation: hostInvitation });
-          break;
         }
-      }
-    },
-    (error: Error) => {
-      if (hooks?.host?.onError?.(hostObservable)) {
-        return;
-      }
-      hostComplete.wake({ error });
-    },
-  );
+      },
+      (error: Error) => {
+        if (hooks?.host?.onError?.(hostObservable)) {
+          return;
+        }
+        hostComplete.wake({ error });
+      },
+    );
+  });
 
   return [hostComplete.wait(), guestComplete.wait()];
 };
 
-const createInvitation = (
+const createInvitation = async (
   host: ServiceContext | InvitationHost,
   options?: Partial<Invitation>,
-): CancellableInvitation => {
+): Promise<CancellableInvitation> => {
   options ??= {
     authMethod: Invitation.AuthMethod.NONE,
     ...(options ?? {}),
   };
 
   if (host instanceof ServiceContext) {
-    const hostHandler = host.getInvitationHandler({ kind: Invitation.Kind.SPACE, ...options });
-    return host.invitations.createInvitation(hostHandler, options);
+    return host.invitationsManager.createInvitation({
+      kind: Invitation.Kind.SPACE,
+      ...options,
+    });
   }
 
   return host.share(options);

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

@@ -19,9 +19,11 @@ 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 { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { createStorage, StorageType, type Storage } from '@dxos/random-access-storage';
 import { BlobStore } from '@dxos/teleport-extension-object-sync';
 
+import { InvitationsHandler, InvitationsManager, SpaceInvitationProtocol } from '../invitations';
 import { ClientServicesHost, ServiceContext } from '../services';
 import { DataSpaceManager, type SigningContext } from '../spaces';
 
@@ -104,6 +106,7 @@ export type TestPeerProps = {
   signingContext?: SigningContext;
   blobStore?: BlobStore;
   automergeHost?: AutomergeHost;
+  invitationsManager?: InvitationsManager;
 };
 
 export class TestPeer {
@@ -181,7 +184,7 @@ export class TestPeer {
     }));
   }
 
-  get dataSpaceManager() {
+  get dataSpaceManager(): DataSpaceManager {
     return (this._props.dataSpaceManager ??= new DataSpaceManager(
       this.spaceManager,
       this.metadataStore,
@@ -189,6 +192,21 @@ export class TestPeer {
       this.identity,
       this.feedStore,
       this.automergeHost,
+      this.invitationsManager,
+    ));
+  }
+
+  get invitationsManager() {
+    return (this._props.invitationsManager ??= new InvitationsManager(
+      new InvitationsHandler(this.networkManager),
+      (invitation) => {
+        if (invitation.kind === Invitation.Kind.SPACE) {
+          return new SpaceInvitationProtocol(this.dataSpaceManager, this.identity!, this.keyring, invitation.spaceKey!);
+        } else {
+          throw new Error('not implemented');
+        }
+      },
+      this.metadataStore,
     ));
   }
 

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.4.10-main.4c7b3fa";
+export const DXOS_VERSION = "0.4.10-main.4d48ccf";