@dxos/client-services 0.1.41 → 0.1.45-next.45667d4

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

@@ -5,12 +5,14 @@
 import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
-import { clientServiceBundle, ClientServices, createDefaultModelFactory, PublicKey } from '@dxos/client';
+import { clientServiceBundle, ClientServices, createDefaultModelFactory } from '@dxos/client-protocol';
 import { Config } from '@dxos/config';
 import { DataServiceImpl } from '@dxos/echo-pipeline';
+import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
+import { SignalManager, WebsocketSignalManager } from '@dxos/messaging';
 import { ModelFactory } from '@dxos/model-factory';
-import { NetworkManager } from '@dxos/network-manager';
+import { createWebRTCTransportFactory, NetworkManager, TransportFactory } from '@dxos/network-manager';
 import { trace } from '@dxos/protocols';
 import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { Storage } from '@dxos/random-access-storage';
@@ -34,14 +36,18 @@ export type ClientServicesHostParams = {
    */
   config?: Config;
   modelFactory?: ModelFactory;
-  networkManager?: NetworkManager;
+  transportFactory?: TransportFactory;
+  signalManager?: SignalManager;
+  connectionLog?: boolean;
   storage?: Storage;
   lockKey?: string;
 };
 
 export type InitializeOptions = {
   config?: Config;
-  networkManager?: NetworkManager;
+  transportFactory?: TransportFactory;
+  signalManager?: SignalManager;
+  connectionLog?: boolean;
 };
 
 /**
@@ -56,41 +62,41 @@ export class ClientServicesHost {
   private _config?: Config;
   private readonly _statusUpdate = new Event<void>();
   private readonly _modelFactory: ModelFactory;
+  private _signalManager?: SignalManager;
   private _networkManager?: NetworkManager;
   private _storage?: Storage;
 
-  /**
-   * @internal
-   */
   _serviceContext!: ServiceContext;
   private _opening = false;
   private _open = false;
 
-  private readonly _instanceId = PublicKey.random().toHex();
-
   constructor({
     config,
     modelFactory = createDefaultModelFactory(),
     // TODO(burdon): Create ApolloLink abstraction (see Client).
-    networkManager,
+    transportFactory,
+    signalManager,
+    connectionLog,
     storage,
     // TODO(wittjosiah): Turn this on by default.
-    lockKey
+    lockKey,
   }: ClientServicesHostParams = {}) {
     this._storage = storage;
     this._modelFactory = modelFactory;
 
     if (config) {
-      this.initialize({ config, networkManager });
+      this.initialize({ config, transportFactory, signalManager });
     }
 
     this._resourceLock = lockKey
       ? new VaultResourceLock({
           lockKey,
           onAcquire: () => {
-            this._opening || this.open();
+            if (!this._opening) {
+              void this.open();
+            }
           },
-          onRelease: () => this.close()
+          onRelease: () => this.close(),
         })
       : undefined;
 
@@ -111,14 +117,14 @@ export class ClientServicesHost {
 
       onReset: async () => {
         await this.reset();
-      }
+      },
     });
 
     this._loggingService = new LoggingServiceImpl();
 
     // TODO(burdon): Start to think of DMG (dynamic services).
     this._serviceRegistry = new ServiceRegistry<ClientServices>(clientServiceBundle, {
-      SystemService: this._systemService
+      SystemService: this._systemService,
     });
   }
 
@@ -143,7 +149,7 @@ export class ClientServicesHost {
    * Config can also be provided in the constructor.
    * Can only be called once.
    */
-  initialize({ config, networkManager }: InitializeOptions) {
+  initialize({ config, ...options }: InitializeOptions) {
     assert(!this._open, 'service host is open');
 
     if (config) {
@@ -155,21 +161,33 @@ export class ClientServicesHost {
       }
     }
 
-    if (networkManager) {
-      assert(!this._networkManager, 'network manager already set');
-      this._networkManager = networkManager;
-    }
+    const {
+      connectionLog = true,
+      transportFactory = createWebRTCTransportFactory({
+        iceServers: this._config?.get('runtime.services.ice'),
+      }),
+      signalManager = new WebsocketSignalManager(this._config?.get('runtime.services.signaling') ?? []),
+    } = options;
+    this._signalManager = signalManager;
+
+    assert(!this._networkManager, 'network manager already set');
+    this._networkManager = new NetworkManager({
+      log: connectionLog,
+      transportFactory,
+      signalManager,
+    });
   }
 
   async open() {
     if (this._open) {
       return;
     }
-
-    log.trace('dxos.sdk.client-services-host', trace.begin({ id: this._instanceId }));
+    const traceId = PublicKey.random().toHex();
+    log.trace('dxos.sdk.client-services-host.open', trace.begin({ id: traceId }));
 
     assert(this._config, 'config not set');
     assert(this._storage, 'storage not set');
+    assert(this._signalManager, 'signal manager not set');
     assert(this._networkManager, 'network manager not set');
 
     this._opening = true;
@@ -180,7 +198,12 @@ export class ClientServicesHost {
 
     // TODO(wittjosiah): Make re-entrant.
     // TODO(burdon): Break into components.
-    this._serviceContext = new ServiceContext(this._storage, this._networkManager, this._modelFactory);
+    this._serviceContext = new ServiceContext(
+      this._storage,
+      this._networkManager,
+      this._signalManager,
+      this._modelFactory,
+    );
 
     // TODO(burdon): Start to think of DMG (dynamic services).
     this._serviceRegistry.setServices({
@@ -189,7 +212,7 @@ export class ClientServicesHost {
       IdentityService: new IdentityServiceImpl(this._serviceContext),
 
       InvitationsService: new InvitationsServiceImpl(this._serviceContext.invitations, (invitation) =>
-        this._serviceContext.getInvitationHandler(invitation)
+        this._serviceContext.getInvitationHandler(invitation),
       ),
 
       DevicesService: new DevicesServiceImpl(this._serviceContext.identityManager),
@@ -201,12 +224,12 @@ export class ClientServicesHost {
         async () => {
           await this._serviceContext.initialized.wait();
           return this._serviceContext.dataSpaceManager!;
-        }
+        },
       ),
 
       DataService: new DataServiceImpl(this._serviceContext.dataServiceSubscriptions),
 
-      NetworkService: new NetworkServiceImpl(this._serviceContext.networkManager),
+      NetworkService: new NetworkServiceImpl(this._serviceContext.networkManager, this._serviceContext.signalManager),
 
       LoggingService: this._loggingService,
 
@@ -214,8 +237,8 @@ export class ClientServicesHost {
       DevtoolsHost: new DevtoolsServiceImpl({
         events: new DevtoolsHostEvents(),
         config: this._config,
-        context: this._serviceContext
-      })
+        context: this._serviceContext,
+      }),
     });
 
     await this._serviceContext.open();
@@ -224,6 +247,7 @@ export class ClientServicesHost {
     this._statusUpdate.emit();
     const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
     log('opened', { deviceKey });
+    log.trace('dxos.sdk.client-services-host.open', trace.end({ id: traceId }));
   }
 
   async close() {
@@ -239,14 +263,16 @@ export class ClientServicesHost {
     this._open = false;
     this._statusUpdate.emit();
     log('closed', { deviceKey });
-
-    log.trace('dxos.sdk.client-services-host', trace.end({ id: this._instanceId }));
   }
 
   async reset() {
+    const traceId = PublicKey.random().toHex();
+    log.trace('dxos.sdk.client-services-host.reset', trace.begin({ id: traceId }));
+
     log('resetting...');
     await this._serviceContext?.close();
     await this._storage!.reset();
     log('reset');
+    log.trace('dxos.sdk.client-services-host.reset', trace.end({ id: traceId }));
   }
 }

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

@@ -2,43 +2,45 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'node:assert';
+import { expect } from 'chai';
 
-import { Trigger } from '@dxos/async';
-import { ClientServices, InvitationsProxy } from '@dxos/client';
+import { Event } from '@dxos/async';
+import { ClientServices } from '@dxos/client-protocol';
+import { Config } from '@dxos/config';
 import { log } from '@dxos/log';
 import { schema } from '@dxos/protocols';
-import { Invitation, InvitationsService } from '@dxos/protocols/proto/dxos/client/services';
+import { SystemService, SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { createLinkedPorts, createProtoRpcPeer, createServiceBundle } from '@dxos/rpc';
 import { describe, test } from '@dxos/test';
 
-import { InvitationsServiceImpl } from '../invitations';
+import { SystemServiceImpl } from '../system';
 import { createServiceContext } from '../testing';
 import { ServiceRegistry } from './service-registry';
 
 // TODO(burdon): Create TestService (that doesn't require peers).
 
 type TestServices = {
-  InvitationsService: InvitationsService;
+  SystemService: SystemService;
 };
 
 const serviceBundle = createServiceBundle<TestServices>({
-  InvitationsService: schema.getService('dxos.client.services.InvitationsService')
+  SystemService: schema.getService('dxos.client.services.SystemService'),
 });
 
 describe('service registry', () => {
   test('builds a service registry', async () => {
+    const remoteSource = 'https://remote.source';
     const serviceContext = createServiceContext();
     await serviceContext.open();
-    await serviceContext.createIdentity();
-
-    assert(serviceContext.dataSpaceManager);
-    const space = await serviceContext.dataSpaceManager.createSpace();
 
     const serviceRegistry = new ServiceRegistry(serviceBundle, {
-      InvitationsService: new InvitationsServiceImpl(serviceContext.invitations, (invitation) =>
-        serviceContext.getInvitationHandler(invitation)
-      )
+      SystemService: new SystemServiceImpl({
+        config: new Config({ runtime: { client: { remoteSource } } }),
+        getCurrentStatus: () => SystemStatus.ACTIVE,
+        onReset: () => {},
+        onUpdateStatus: () => {},
+        statusUpdate: new Event(),
+      }),
     });
 
     const [proxyPort, serverPort] = createLinkedPorts();
@@ -47,44 +49,24 @@ describe('service registry', () => {
       requested: serviceRegistry.descriptors,
       exposed: {},
       handlers: {},
-      port: proxyPort
+      port: proxyPort,
     });
 
     const server = createProtoRpcPeer({
       exposed: serviceRegistry.descriptors,
       handlers: serviceRegistry.services as ClientServices,
-      port: serverPort
+      port: serverPort,
     });
 
     log('opening...');
     await Promise.all([proxy.open(), server.open()]);
     log('open');
 
-    const done = new Trigger(); // createRpcServer
-
     {
-      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();
-          }
-        }
-      });
+      const config = await proxy.rpc.SystemService.getConfig();
+      expect(config.runtime?.client?.remoteSource).to.equal(remoteSource);
     }
 
-    await done.wait();
-
     // TODO(burdon): Error handling (create tests).
     //  Uncaught Error: Request was terminated because the RPC endpoint is closed.
     // log('closing...');

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

@@ -6,19 +6,17 @@ import { expect } from 'chai';
 
 import { latch } from '@dxos/async';
 import { createAdmissionCredentials } from '@dxos/credentials';
-import { DocumentModel } from '@dxos/document-model';
 import { AuthStatus, DataServiceSubscriptions } from '@dxos/echo-pipeline';
 import { writeMessages } from '@dxos/feed-store';
 import { log } from '@dxos/log';
-import { ModelFactory } from '@dxos/model-factory';
-import { test, describe, afterTest } from '@dxos/test';
+import { afterTest, describe, test } from '@dxos/test';
 
-import { createSigningContext, HostTestBuilder, syncItemsLocal } from '../testing';
+import { createSigningContext, TestBuilder, syncItemsLocal } from '../testing';
 import { DataSpaceManager } from './data-space-manager';
 
 describe('DataSpaceManager', () => {
   test('create space', async () => {
-    const builder = new HostTestBuilder();
+    const builder = new TestBuilder();
 
     const peer = builder.createPeer();
     const identity = await createSigningContext(peer.keyring);
@@ -28,9 +26,7 @@ describe('DataSpaceManager', () => {
       new DataServiceSubscriptions(),
       peer.keyring,
       identity,
-      new ModelFactory().registerModel(DocumentModel),
       peer.feedStore,
-      peer.snapshotStore
     );
     await dataSpaceManager.open();
     afterTest(() => dataSpaceManager.close());
@@ -46,7 +42,7 @@ describe('DataSpaceManager', () => {
   });
 
   test('sync between peers', async () => {
-    const builder = new HostTestBuilder();
+    const builder = new TestBuilder();
 
     const peer1 = builder.createPeer();
     const identity1 = await createSigningContext(peer1.keyring);
@@ -56,9 +52,7 @@ describe('DataSpaceManager', () => {
       new DataServiceSubscriptions(),
       peer1.keyring,
       identity1,
-      new ModelFactory().registerModel(DocumentModel),
       peer1.feedStore,
-      peer1.snapshotStore
     );
     await dataSpaceManager1.open();
     afterTest(() => dataSpaceManager1.close());
@@ -71,9 +65,7 @@ describe('DataSpaceManager', () => {
       new DataServiceSubscriptions(),
       peer2.keyring,
       identity2,
-      new ModelFactory().registerModel(DocumentModel),
       peer2.feedStore,
-      peer1.snapshotStore
     );
     await dataSpaceManager2.open();
     afterTest(() => dataSpaceManager2.close());
@@ -88,14 +80,14 @@ describe('DataSpaceManager', () => {
         identity1.credentialSigner,
         identity2.identityKey,
         space1.key,
-        space1.inner.genesisFeedKey
-      )
+        space1.inner.genesisFeedKey,
+      ),
     );
 
     // Accept must be called after admission so that the peer can authenticate for notarization.
     const space2 = await dataSpaceManager2.acceptSpace({
       spaceKey: space1.key,
-      genesisFeedKey: space1.inner.genesisFeedKey
+      genesisFeedKey: space1.inner.genesisFeedKey,
     });
     await dataSpaceManager2.waitUntilSpaceReady(space2.key);
 
@@ -104,14 +96,14 @@ describe('DataSpaceManager', () => {
         identity: identity1.identityKey,
         device: identity1.deviceKey,
         control: space1.inner.controlFeedKey,
-        data: space1.inner.dataFeedKey
+        data: space1.inner.dataFeedKey,
       },
       peer2: {
         identity: identity2.identityKey,
         device: identity2.deviceKey,
         control: space2.inner.controlFeedKey,
-        data: space2.inner.dataFeedKey
-      }
+        data: space2.inner.dataFeedKey,
+      },
     });
 
     await space1.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.endTimeframe);
@@ -120,12 +112,12 @@ describe('DataSpaceManager', () => {
     log('', {
       space1: {
         timeframe: space1.inner.controlPipeline.state.timeframe,
-        endTimeframe: space1.inner.controlPipeline.state.endTimeframe
+        endTimeframe: space1.inner.controlPipeline.state.endTimeframe,
       },
       space2: {
         timeframe: space2.inner.controlPipeline.state.timeframe,
-        endTimeframe: space2.inner.controlPipeline.state.endTimeframe
-      }
+        endTimeframe: space2.inner.controlPipeline.state.endTimeframe,
+      },
     });
     log.break();
 
@@ -138,7 +130,7 @@ describe('DataSpaceManager', () => {
   });
 
   test('pub/sub API', async () => {
-    const builder = new HostTestBuilder();
+    const builder = new TestBuilder();
 
     const peer1 = builder.createPeer();
     const identity1 = await createSigningContext(peer1.keyring);
@@ -148,9 +140,7 @@ describe('DataSpaceManager', () => {
       new DataServiceSubscriptions(),
       peer1.keyring,
       identity1,
-      new ModelFactory().registerModel(DocumentModel),
       peer1.feedStore,
-      peer1.snapshotStore
     );
     await dataSpaceManager1.open();
     afterTest(() => dataSpaceManager1.close());
@@ -163,9 +153,7 @@ describe('DataSpaceManager', () => {
       new DataServiceSubscriptions(),
       peer2.keyring,
       identity2,
-      new ModelFactory().registerModel(DocumentModel),
       peer2.feedStore,
-      peer1.snapshotStore
     );
     await dataSpaceManager2.open();
     afterTest(() => dataSpaceManager2.close());
@@ -180,14 +168,14 @@ describe('DataSpaceManager', () => {
         identity1.credentialSigner,
         identity2.identityKey,
         space1.key,
-        space1.inner.genesisFeedKey
-      )
+        space1.inner.genesisFeedKey,
+      ),
     );
 
     // Accept must be called after admission so that the peer can authenticate for notarization.
     const space2 = await dataSpaceManager2.acceptSpace({
       spaceKey: space1.key,
-      genesisFeedKey: space1.inner.genesisFeedKey
+      genesisFeedKey: space1.inner.genesisFeedKey,
     });
 
     // Coincidentally, this also waits until a P2P connection is established between peers.

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

@@ -5,33 +5,33 @@
 import assert from 'node:assert';
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
-import { SpaceState } from '@dxos/client';
 import { cancelWithContext, Context } from '@dxos/context';
-import { getCredentialAssertion } from '@dxos/credentials';
-import {
-  DataServiceSubscriptions,
-  MetadataStore,
-  SigningContext,
-  SnapshotManager,
-  SnapshotStore,
-  Space,
-  spaceGenesis,
-  SpaceManager
-} from '@dxos/echo-pipeline';
+import { CredentialSigner, getCredentialAssertion } from '@dxos/credentials';
+import { DataServiceSubscriptions, MetadataStore, Space, SpaceManager } from '@dxos/echo-pipeline';
 import { FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { ModelFactory } from '@dxos/model-factory';
 import { trace } from '@dxos/protocols';
+import { SpaceState } from '@dxos/protocols/proto/dxos/client/services';
 import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { Credential, ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
 import { Timeframe } from '@dxos/timeframe';
 import { ComplexMap, deferFunction } from '@dxos/util';
 
 import { createAuthProvider } from '../identity';
 import { DataSpace } from './data-space';
+import { spaceGenesis } from './genesis';
+
+export interface SigningContext {
+  identityKey: PublicKey;
+  deviceKey: PublicKey;
+  credentialSigner: CredentialSigner; // TODO(burdon): Already has keyring.
+  recordCredential: (credential: Credential) => Promise<void>;
+  profile?: ProfileDocument;
+}
 
 export type AcceptSpaceOptions = {
   spaceKey: PublicKey;
@@ -60,7 +60,6 @@ export class DataSpaceManager {
 
   private _isOpen = false;
   private readonly _instanceId = PublicKey.random().toHex();
-  public _traceParent?: string;
 
   constructor(
     private readonly _spaceManager: SpaceManager,
@@ -68,9 +67,7 @@ export class DataSpaceManager {
     private readonly _dataServiceSubscriptions: DataServiceSubscriptions,
     private readonly _keyring: Keyring,
     private readonly _signingContext: SigningContext,
-    private readonly _modelFactory: ModelFactory,
     private readonly _feedStore: FeedStore<FeedMessage>,
-    private readonly _snapshotStore: SnapshotStore
   ) {}
 
   // TODO(burdon): Remove.
@@ -81,7 +78,7 @@ export class DataSpaceManager {
   @synchronized
   async open() {
     log('open');
-    log.trace('dxos.echo.data-space-manager', trace.begin({ id: this._instanceId, parentId: this._traceParent }));
+    log.trace('dxos.echo.data-space-manager.open', trace.begin({ id: this._instanceId }));
     await this._metadataStore.load();
     log('metadata loaded', { spaces: this._metadataStore.spaces.length });
 
@@ -97,6 +94,7 @@ export class DataSpaceManager {
 
     this._isOpen = true;
     this.updated.emit();
+    log.trace('dxos.echo.data-space-manager.open', trace.end({ id: this._instanceId }));
   }
 
   @synchronized
@@ -107,7 +105,6 @@ export class DataSpaceManager {
     for (const space of this._spaces.values()) {
       await space.close();
     }
-    log.trace('dxos.echo.data-space-manager', trace.end({ id: this._instanceId }));
   }
 
   /**
@@ -123,7 +120,7 @@ export class DataSpaceManager {
       key: spaceKey,
       genesisFeedKey: controlFeedKey,
       controlFeedKey,
-      dataFeedKey
+      dataFeedKey,
     };
 
     log('creating space...', { spaceKey });
@@ -153,7 +150,7 @@ export class DataSpaceManager {
       key: opts.spaceKey,
       genesisFeedKey: opts.genesisFeedKey,
       controlTimeframe: opts.controlTimeframe,
-      dataTimeframe: opts.dataTimeframe
+      dataTimeframe: opts.dataTimeframe,
     };
 
     const space = await this._constructSpace(metadata);
@@ -176,22 +173,21 @@ export class DataSpaceManager {
       this.updated.waitForCondition(() => {
         const space = this._spaces.get(spaceKey);
         return !!space && space.state === SpaceState.READY;
-      })
+      }),
     );
   }
 
   private async _constructSpace(metadata: SpaceMetadata) {
     log('construct space', { metadata });
     const gossip = new Gossip({
-      localPeerId: this._signingContext.deviceKey
+      localPeerId: this._signingContext.deviceKey,
     });
     const presence = new Presence({
       announceInterval: 500,
       offlineTimeout: 5_000, // TODO(burdon): Config.
       identityKey: this._signingContext.identityKey,
-      gossip
+      gossip,
     });
-    const snapshotManager = new SnapshotManager(this._snapshotStore);
 
     const controlFeed =
       metadata.controlFeedKey && (await this._feedStore.openFeed(metadata.controlFeedKey, { writable: true }));
@@ -202,38 +198,35 @@ export class DataSpaceManager {
       swarmIdentity: {
         peerKey: this._signingContext.deviceKey,
         credentialProvider: createAuthProvider(this._signingContext.credentialSigner),
-        credentialAuthenticator: deferFunction(() => dataSpace.authVerifier.verifier)
+        credentialAuthenticator: deferFunction(() => dataSpace.authVerifier.verifier),
       },
       onNetworkConnection: (session) => {
         session.addExtension(
           'dxos.mesh.teleport.gossip',
-          gossip.createExtension({ remotePeerId: session.remotePeerId })
+          gossip.createExtension({ remotePeerId: session.remotePeerId }),
         );
-        session.addExtension('dxos.mesh.teleport.objectsync', snapshotManager.objectSync.createExtension());
+        session.addExtension('dxos.mesh.teleport.objectsync', space.snapshotManager.objectSync.createExtension());
         session.addExtension('dxos.mesh.teleport.notarization', dataSpace.notarizationPlugin.createExtension());
-      }
+      },
+      memberKey: this._signingContext.identityKey,
     });
     controlFeed && space.setControlFeed(controlFeed);
     dataFeed && space.setDataFeed(dataFeed);
 
     const dataSpace = new DataSpace({
       inner: space,
-      modelFactory: this._modelFactory,
       metadataStore: this._metadataStore,
-      snapshotManager,
       gossip,
       presence,
-      memberKey: this._signingContext.identityKey,
       keyring: this._keyring,
       feedStore: this._feedStore,
       signingContext: this._signingContext,
-      snapshotId: metadata.snapshot,
       callbacks: {
         beforeReady: async () => {
           log('before space ready', { space: space.key });
           this._dataServiceSubscriptions.registerSpace(
             space.key,
-            dataSpace.dataPipeline.databaseBackend!.createDataServiceHost()
+            dataSpace.dataPipeline.databaseHost!.createDataServiceHost(),
           );
         },
         afterReady: async () => {
@@ -241,8 +234,9 @@ export class DataSpaceManager {
           if (this._isOpen) {
             this.updated.emit();
           }
-        }
-      }
+        },
+      },
+      cache: metadata.cache,
     });
 
     await dataSpace.open();