@dxos/client-services 0.4.10-main.e2d2318 → 0.4.10-main.e6ba7bc

package/src/packlets/invitations/space-invitation-protocol.ts

@@ -2,7 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { createAdmissionCredentials, getCredentialAssertion } from '@dxos/credentials';
+import {
+  createAdmissionCredentials,
+  createDelegatedSpaceInvitationCredential,
+  getCredentialAssertion,
+} from '@dxos/credentials';
 import { writeMessages } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -11,7 +15,7 @@ import { log } from '@dxos/log';
 import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
-import { type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { SpaceMember, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
   type AdmissionRequest,
   type AdmissionResponse,
@@ -43,7 +47,11 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     };
   }
 
-  async admit(request: AdmissionRequest, guestProfile?: ProfileDocument | undefined): Promise<AdmissionResponse> {
+  async admit(
+    invitation: Invitation,
+    request: AdmissionRequest,
+    guestProfile?: ProfileDocument | undefined,
+  ): Promise<AdmissionResponse> {
     invariant(this._spaceKey);
     const space = await this._spaceManager.spaces.get(this._spaceKey);
     invariant(space);
@@ -59,6 +67,7 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
       space.key,
       space.inner.genesisFeedKey,
       guestProfile,
+      invitation.delegationCredentialId,
     );
 
     // TODO(dmaretskyi): Refactor.
@@ -76,6 +85,39 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     };
   }
 
+  async delegate(invitation: Invitation): Promise<PublicKey> {
+    invariant(this._spaceKey);
+    const space = await this._spaceManager.spaces.get(this._spaceKey);
+    invariant(space);
+    if (invitation.authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY) {
+      invariant(invitation.guestKeypair?.publicKey);
+    }
+
+    log('writing delegate space invitation', { host: this._signingContext.deviceKey, id: invitation.invitationId });
+    const credential = await createDelegatedSpaceInvitationCredential(
+      this._signingContext.credentialSigner,
+      space.key,
+      {
+        invitationId: invitation.invitationId,
+        authMethod: invitation.authMethod,
+        swarmKey: invitation.swarmKey,
+        role: SpaceMember.Role.ADMIN,
+        expiresOn: invitation.lifetime
+          ? new Date((invitation.created?.getTime() ?? Date.now()) + invitation.lifetime)
+          : undefined,
+        multiUse: invitation.multiUse ?? false,
+        guestKey:
+          invitation.authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY
+            ? invitation.guestKeypair!.publicKey
+            : undefined,
+      },
+    );
+
+    invariant(credential.credential);
+    await writeMessages(space.inner.controlPipeline.writer, [credential]);
+    return credential.credential.credential.id!;
+  }
+
   checkInvitation(invitation: Partial<Invitation>) {
     if (invitation.spaceKey && this._spaceManager.spaces.has(invitation.spaceKey)) {
       return new AlreadyJoinedError('Already joined space.');

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

@@ -5,9 +5,9 @@
 import { expect } from 'chai';
 
 import { asyncTimeout, sleep } from '@dxos/async';
+import { AutomergeContext } from '@dxos/echo-db';
 import { AutomergeHost, DataServiceImpl } from '@dxos/echo-pipeline';
 import { createTestLevel } from '@dxos/echo-pipeline/testing';
-import { AutomergeContext } from '@dxos/echo-schema';
 import { afterTest, describe, test } from '@dxos/test';
 
 describe('AutomergeHost', () => {

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

@@ -10,7 +10,7 @@ import { getCredentialAssertion, type CredentialProcessor } from '@dxos/credenti
 import { failUndefined } from '@dxos/debug';
 import { AutomergeHost, MetadataStore, SnapshotStore, SpaceManager, valueEncoding } from '@dxos/echo-pipeline';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
-import { IndexMetadataStore, IndexStore, Indexer } from '@dxos/indexing';
+import { IndexMetadataStore, IndexStore, Indexer, createStorageCallbacks } from '@dxos/indexing';
 import { invariant } from '@dxos/invariant';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
@@ -32,13 +32,14 @@ import {
   type IdentityManagerRuntimeParams,
   type JoinIdentityParams,
 } from '../identity';
-import { createDocumentsIterator, createSelectedDocumentsIterator } from '../indexing';
+import { createSelectedDocumentsIterator } from '../indexing';
 import {
   DeviceInvitationProtocol,
   InvitationsHandler,
   SpaceInvitationProtocol,
   type InvitationProtocol,
 } from '../invitations';
+import { InvitationsManager } from '../invitations/invitations-manager';
 import { DataSpaceManager, type DataSpaceManagerRuntimeParams, type SigningContext } from '../spaces';
 
 export type ServiceContextRuntimeParams = IdentityManagerRuntimeParams & DataSpaceManagerRuntimeParams;
@@ -62,6 +63,7 @@ export class ServiceContext extends Resource {
   public readonly spaceManager: SpaceManager;
   public readonly identityManager: IdentityManager;
   public readonly invitations: InvitationsHandler;
+  public readonly invitationsManager: InvitationsManager;
   public readonly automergeHost: AutomergeHost;
   public readonly indexMetadata: IndexMetadataStore;
   public readonly indexer: Indexer;
@@ -125,17 +127,22 @@ export class ServiceContext extends Resource {
     this.automergeHost = new AutomergeHost({
       directory: storage.createDirectory('automerge'),
       db: level.sublevel('automerge'),
-      metadata: this.indexMetadata,
+      storageCallbacks: createStorageCallbacks({ host: () => this.automergeHost, metadata: this.indexMetadata }),
     });
 
     this.indexer = new Indexer({
-      indexStore: new IndexStore({ directory: storage.createDirectory('index-store') }),
+      db: this.level,
+      indexStore: new IndexStore({ db: level.sublevel('index-storage') }),
       metadataStore: this.indexMetadata,
       loadDocuments: createSelectedDocumentsIterator(this.automergeHost),
-      getAllDocuments: createDocumentsIterator(this.automergeHost),
     });
 
     this.invitations = new InvitationsHandler(this.networkManager);
+    this.invitationsManager = new InvitationsManager(
+      this.invitations,
+      (invitation) => this.getInvitationHandler(invitation),
+      this.metadataStore,
+    );
 
     // TODO(burdon): _initialize called in multiple places.
     // TODO(burdon): Call _initialize on success.
@@ -166,6 +173,10 @@ export class ServiceContext extends Resource {
     if (this.identityManager.identity) {
       await this._initialize(ctx);
     }
+
+    const loadedInvitations = await this.invitationsManager.loadPersistentInvitations();
+    log('loaded persistent invitations', { count: loadedInvitations.invitations?.length });
+
     log.trace('dxos.sdk.service-context.open', trace.end({ id: this._instanceId }));
     log('opened');
   }
@@ -245,6 +256,7 @@ export class ServiceContext extends Resource {
       signingContext,
       this.feedStore,
       this.automergeHost,
+      this.invitationsManager,
       this._runtimeParams as DataSpaceManagerRuntimeParams,
     );
     await this.dataSpaceManager.open();

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

@@ -13,10 +13,10 @@ import {
   type ObjectStructure,
   encodeReference,
   type SpaceDoc,
-  type MyLevel,
+  type LevelDB,
 } from '@dxos/echo-pipeline';
 import { getTypeReference } from '@dxos/echo-schema';
-import { IndexServiceImpl } from '@dxos/indexing';
+import { QueryServiceImpl } from '@dxos/indexing';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -56,7 +56,7 @@ export type ClientServicesHostParams = {
   signalManager?: SignalManager;
   connectionLog?: boolean;
   storage?: Storage;
-  level?: MyLevel;
+  level?: LevelDB;
   lockKey?: string;
   callbacks?: ClientServicesHostCallbacks;
   runtimeParams?: ServiceContextRuntimeParams;
@@ -83,6 +83,7 @@ export class ClientServicesHost {
   private readonly _systemService: SystemServiceImpl;
   private readonly _loggingService: LoggingServiceImpl;
   private readonly _tracingService = TRACE_PROCESSOR.createTraceSender();
+  private _queryService!: QueryServiceImpl;
 
   private _config?: Config;
   private readonly _statusUpdate = new Event<void>();
@@ -262,6 +263,12 @@ export class ClientServicesHost {
       this._runtimeParams,
     );
 
+    this._queryService = new QueryServiceImpl({
+      indexer: this._serviceContext.indexer,
+      automergeHost: this._serviceContext.automergeHost,
+    });
+    await this._queryService.open(ctx);
+
     this._serviceRegistry.setServices({
       SystemService: this._systemService,
 
@@ -272,11 +279,7 @@ export class ClientServicesHost {
         (profile) => this._serviceContext.broadcastProfileUpdate(profile),
       ),
 
-      InvitationsService: new InvitationsServiceImpl(
-        this._serviceContext.invitations,
-        (invitation) => this._serviceContext.getInvitationHandler(invitation),
-        this._serviceContext.metadataStore,
-      ),
+      InvitationsService: new InvitationsServiceImpl(this._serviceContext.invitationsManager),
 
       DevicesService: new DevicesServiceImpl(this._serviceContext.identityManager),
 
@@ -291,10 +294,7 @@ export class ClientServicesHost {
 
       DataService: new DataServiceImpl(this._serviceContext.automergeHost),
 
-      IndexService: new IndexServiceImpl({
-        indexer: this._serviceContext.indexer,
-        automergeHost: this._serviceContext.automergeHost,
-      }),
+      QueryService: this._queryService,
 
       NetworkService: new NetworkServiceImpl(this._serviceContext.networkManager, this._serviceContext.signalManager),
 
@@ -310,11 +310,6 @@ export class ClientServicesHost {
     });
 
     await this._serviceContext.open(ctx);
-    // TODO(nf): move to InvitationManager in ServiceContext?
-    invariant(this.serviceRegistry.services.InvitationsService);
-    const loadedInvitations = await this.serviceRegistry.services.InvitationsService.loadPersistentInvitations();
-
-    log('loaded persistent invitations', { count: loadedInvitations.invitations?.length });
 
     const devtoolsProxy = this._config?.get('runtime.client.devtoolsProxy');
     if (devtoolsProxy) {
@@ -349,6 +344,7 @@ export class ClientServicesHost {
     await this._devtoolsProxy?.close();
     this._serviceRegistry.setServices({ SystemService: this._systemService });
     await this._loggingService.close();
+    await this._queryService.close();
     await this._serviceContext.close();
     await this._level?.close();
     this._open = false;

package/src/packlets/spaces/data-space-manager.ts

@@ -4,7 +4,7 @@
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { Context, cancelWithContext } from '@dxos/context';
-import { getCredentialAssertion, type CredentialSigner } from '@dxos/credentials';
+import { getCredentialAssertion, type CredentialSigner, type DelegateInvitationCredential } from '@dxos/credentials';
 import { type AutomergeHost, type MetadataStore, type Space, type SpaceManager } from '@dxos/echo-pipeline';
 import { type FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
@@ -12,10 +12,11 @@ import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { trace } from '@dxos/protocols';
-import { SpaceState } from '@dxos/protocols/proto/dxos/client/services';
+import { Invitation, SpaceState } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { type Credential, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type DelegateSpaceInvitation } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
 import { type Timeframe } from '@dxos/timeframe';
 import { ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
@@ -23,6 +24,7 @@ import { ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
 import { DataSpace } from './data-space';
 import { spaceGenesis } from './genesis';
 import { createAuthProvider } from '../identity';
+import { type InvitationsManager } from '../invitations';
 
 const PRESENCE_ANNOUNCE_INTERVAL = 10_000;
 const PRESENCE_OFFLINE_TIMEOUT = 20_000;
@@ -78,6 +80,7 @@ export class DataSpaceManager {
     private readonly _signingContext: SigningContext,
     private readonly _feedStore: FeedStore<FeedMessage>,
     private readonly _automergeHost: AutomergeHost,
+    private readonly _invitationsManager: InvitationsManager,
     params?: DataSpaceManagerRuntimeParams,
   ) {
     const {
@@ -247,6 +250,9 @@ export class DataSpaceManager {
         log.warn('auth failure');
       },
       memberKey: this._signingContext.identityKey,
+      onDelegatedInvitationStatusChange: (invitation, isActive) => {
+        return this._handleInvitationStatusChange(dataSpace, invitation, isActive);
+      },
     });
     controlFeed && (await space.setControlFeed(controlFeed));
     dataFeed && (await space.setDataFeed(dataFeed));
@@ -267,6 +273,7 @@ export class DataSpaceManager {
         afterReady: async () => {
           log('after space ready', { space: space.key, open: this._isOpen });
           if (this._isOpen) {
+            await this._createDelegatedInvitations(dataSpace, [...space.spaceState.invitations.entries()]);
             this.updated.emit();
           }
         },
@@ -289,4 +296,43 @@ export class DataSpaceManager {
     this._spaces.set(metadata.key, dataSpace);
     return dataSpace;
   }
+
+  private async _handleInvitationStatusChange(
+    dataSpace: DataSpace | undefined,
+    delegatedInvitation: DelegateInvitationCredential,
+    isActive: boolean,
+  ): Promise<void> {
+    if (dataSpace?.state !== SpaceState.READY) {
+      return;
+    }
+    if (isActive) {
+      await this._createDelegatedInvitations(dataSpace, [
+        [delegatedInvitation.credentialId, delegatedInvitation.invitation],
+      ]);
+    } else {
+      await this._invitationsManager.cancelInvitation(delegatedInvitation.invitation);
+    }
+  }
+
+  private async _createDelegatedInvitations(
+    space: DataSpace,
+    invitations: Array<[PublicKey, DelegateSpaceInvitation]>,
+  ): Promise<void> {
+    const tasks = invitations.map(([credentialId, invitation]) => {
+      return this._invitationsManager.createInvitation({
+        type: Invitation.Type.DELEGATED,
+        kind: Invitation.Kind.SPACE,
+        spaceKey: space.key,
+        authMethod: invitation.authMethod,
+        invitationId: invitation.invitationId,
+        swarmKey: invitation.swarmKey,
+        guestKeypair: invitation.guestKey ? { publicKey: invitation.guestKey } : undefined,
+        lifetime: invitation.expiresOn ? invitation.expiresOn.getTime() - Date.now() : undefined,
+        multiUse: invitation.multiUse,
+        delegationCredentialId: credentialId,
+        persistent: false,
+      });
+    });
+    await Promise.all(tasks);
+  }
 }

package/src/packlets/spaces/data-space.ts

@@ -6,7 +6,6 @@ import { Event, asyncTimeout, scheduleTask, sleep, synchronized, trackLeaks } fr
 import { AUTH_TIMEOUT } from '@dxos/client-protocol';
 import { cancelWithContext, Context, ContextDisposedError } from '@dxos/context';
 import { timed, warnAfterTimeout } from '@dxos/debug';
-import { TYPE_PROPERTIES } from '@dxos/echo-db';
 import {
   type MetadataStore,
   type Space,
@@ -15,6 +14,7 @@ import {
   type SpaceDoc,
 } from '@dxos/echo-pipeline';
 import { AutomergeDocumentLoaderImpl } from '@dxos/echo-pipeline';
+import { TYPE_PROPERTIES } from '@dxos/echo-schema';
 import { type FeedStore } from '@dxos/feed-store';
 import { failedInvariant, invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';

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);