@dxos/client-services 0.10.0 → 0.11.1

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

@@ -4,6 +4,10 @@
 
 import { type Doc } from '@automerge/automerge';
 import { type AutomergeUrl, type DocumentId, interpretAsDocumentId } from '@automerge/automerge-repo';
+import * as EffectContext from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { SpaceProperties } from '@dxos/client-protocol';
@@ -17,24 +21,25 @@ import {
 } from '@dxos/credentials';
 import { Type } from '@dxos/echo';
 import {
-  AuthStatus,
-  CredentialServerExtension,
   DatabaseRoot,
   type EchoHost,
+  EchoHostService,
   type EdgeAutomergeReplicator,
-  type IMetadataStore,
+  EdgeAutomergeReplicatorService,
   type MeshEchoReplicator,
-  type Space,
-  type SpaceManager,
-  type SpaceProtocol,
-  type SpaceProtocolSession,
+  MeshEchoReplicatorService,
   findInlineObjectOfType,
 } from '@dxos/echo-host';
 import { type DatabaseDirectory, createIdFromSpaceKey } from '@dxos/echo-protocol';
-import type { EdgeConnection, EdgeHttpClient } from '@dxos/edge-client';
-import { type FeedStore, writeMessages } from '@dxos/feed-store';
+import {
+  type EdgeConnection,
+  EdgeConnectionService,
+  type EdgeHttpClient,
+  EdgeHttpClientService,
+} from '@dxos/edge-client';
+import { type FeedStore, FeedStoreService, writeMessages } from '@dxos/feed-store';
 import { assertArgument, assertState, failedInvariant, invariant } from '@dxos/invariant';
-import { type KeyringApi } from '@dxos/keyring';
+import { type KeyringApi, KeyringApiService } from '@dxos/keyring';
 import { PublicKey, type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { AlreadyJoinedError } from '@dxos/protocols';
@@ -56,8 +61,18 @@ import { type Timeframe } from '@dxos/timeframe';
 import { trace } from '@dxos/tracing';
 import { ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
 
-import { createAuthProvider } from '../identity';
-import { type InvitationsManager } from '../invitations';
+import { type Identity, IdentityProviderService, createAuthProvider } from '../identity';
+import { type InvitationsManager, InvitationsManagerService } from '../invitations';
+import { type IMetadataStore, IMetadataStoreService } from '../metadata';
+import {
+  AuthStatus,
+  CredentialServerExtension,
+  type Space,
+  type SpaceManager,
+  SpaceManagerService,
+  type SpaceProtocol,
+  type SpaceProtocolSession,
+} from '../space';
 import { DataSpace } from './data-space';
 import { spaceGenesis } from './genesis';
 
@@ -73,6 +88,48 @@ export interface SigningContext {
   getProfile: () => ProfileDocument | undefined;
 }
 
+/**
+ * Resolves signing context when identity becomes available.
+ */
+export type SigningContextProvider = () => SigningContext;
+
+/**
+ * Effect service tag for {@link SigningContextProvider}.
+ */
+export class SigningContextProviderService extends EffectContext.Tag('@dxos/client-services/SigningContextProvider')<
+  SigningContextProviderService,
+  SigningContextProvider
+>() {}
+
+/**
+ * Builds a {@link SigningContextProvider} from an identity resolver.
+ */
+export const createSigningContextProvider =
+  (getIdentity: () => Identity): SigningContextProvider =>
+  () => {
+    const identity = getIdentity();
+    return {
+      credentialSigner: identity.getIdentityCredentialSigner(),
+      identityKey: identity.identityKey,
+      deviceKey: identity.deviceKey,
+      getProfile: () => identity.profileDocument,
+      recordCredential: async (credential) => {
+        await identity.controlPipeline.writer.write({ credential: { credential } });
+      },
+    };
+  };
+
+/**
+ * Effect Layer providing {@link SigningContextProvider} from {@link IdentityProviderService}.
+ */
+export const SigningContextProviderLayer = Layer.effect(
+  SigningContextProviderService,
+  Effect.gen(function* () {
+    const identityProvider = yield* IdentityProviderService;
+    return createSigningContextProvider(identityProvider);
+  }),
+);
+
 export type AcceptSpaceOptions = {
   spaceKey: PublicKey;
   genesisFeedKey: PublicKey;
@@ -106,7 +163,7 @@ export type DataSpaceManagerProps = {
   spaceManager: SpaceManager;
   metadataStore: IMetadataStore;
   keyring: KeyringApi;
-  signingContext: SigningContext;
+  signingContextProvider: SigningContextProvider;
   feedStore: FeedStore<FeedMessage>;
   echoHost: EchoHost;
   invitationsManager: InvitationsManager;
@@ -138,7 +195,6 @@ export type CreateSpaceOptions = {
 };
 
 @trackLeaks('open', 'close')
-@trace.resource({ lifecycle: true })
 export class DataSpaceManager extends Resource {
   public readonly updated = new Event();
 
@@ -147,7 +203,7 @@ export class DataSpaceManager extends Resource {
   private readonly _spaceManager: SpaceManager;
   private readonly _metadataStore: IMetadataStore;
   private readonly _keyring: KeyringApi;
-  private readonly _signingContext: SigningContext;
+  private readonly _signingContextProvider: SigningContextProvider;
   private readonly _feedStore: FeedStore<FeedMessage>;
   private readonly _echoHost: EchoHost;
   private readonly _invitationsManager: InvitationsManager;
@@ -164,7 +220,7 @@ export class DataSpaceManager extends Resource {
     this._spaceManager = params.spaceManager;
     this._metadataStore = params.metadataStore;
     this._keyring = params.keyring;
-    this._signingContext = params.signingContext;
+    this._signingContextProvider = params.signingContextProvider;
     this._feedStore = params.feedStore;
     this._echoHost = params.echoHost;
     this._meshReplicator = params.meshReplicator;
@@ -205,6 +261,10 @@ export class DataSpaceManager extends Resource {
     });
   }
 
+  private get signingContext(): SigningContext {
+    return this._signingContextProvider();
+  }
+
   // TODO(burdon): Remove.
   get spaces() {
     return this._spaces;
@@ -328,7 +388,7 @@ export class DataSpaceManager extends Resource {
       invariant(rootDocHandle, 'Root document must be available after import.');
       DatabaseRoot.mapLinks(rootDocHandle, documentIdMapping);
 
-      root = await this._echoHost.openSpaceRoot(ctx, spaceId, `automerge:${newRootDocId}` as AutomergeUrl);
+      root = await this._echoHost.updateSpaceRoot(ctx, spaceId, `automerge:${newRootDocId}` as AutomergeUrl);
     } else {
       root = await this._echoHost.createSpaceRoot(ctx, spaceKey);
     }
@@ -343,7 +403,7 @@ export class DataSpaceManager extends Resource {
 
     const credentials = await spaceGenesis(
       this._keyring,
-      this._signingContext,
+      this.signingContext,
       space.inner,
       root.url,
       tags,
@@ -353,7 +413,7 @@ export class DataSpaceManager extends Resource {
 
     const memberCredential = credentials[1];
     invariant(getCredentialAssertion(memberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
-    await this._signingContext.recordCredential(memberCredential);
+    await this.signingContext.recordCredential(memberCredential);
 
     await space.initializeDataPipeline(ctx);
 
@@ -424,7 +484,7 @@ export class DataSpaceManager extends Resource {
     }
 
     // Replicates to the user's other devices via the HALO control feed.
-    const credential = await this._signingContext.credentialSigner.createCredential({
+    const credential = await this.signingContext.credentialSigner.createCredential({
       subject: spaceKey,
       assertion: {
         '@type': 'dxos.halo.credentials.SpaceDeleted',
@@ -432,7 +492,7 @@ export class DataSpaceManager extends Resource {
         'deletedAt': new Date(),
       },
     });
-    await this._signingContext.recordCredential(credential);
+    await this.signingContext.recordCredential(credential);
 
     await this._tombstoneSpace(ctx, spaceKey);
   }
@@ -480,7 +540,7 @@ export class DataSpaceManager extends Resource {
 
     // TODO(burdon): Check if already admitted.
     const credentials: FeedMessage.Payload[] = await createAdmissionCredentials(
-      this._signingContext.credentialSigner,
+      this.signingContext.credentialSigner,
       options.identityKey,
       space.key,
       space.genesisFeedKey,
@@ -518,12 +578,12 @@ export class DataSpaceManager extends Resource {
   public async requestSpaceAdmissionCredential(ctx: Context, spaceKey: PublicKey): Promise<Credential> {
     return this._spaceManager.requestSpaceAdmissionCredential(ctx, {
       spaceKey,
-      identityKey: this._signingContext.identityKey,
+      identityKey: this.signingContext.identityKey,
       timeout: 15_000,
       swarmIdentity: {
-        identityKey: this._signingContext.identityKey,
-        peerKey: this._signingContext.deviceKey,
-        credentialProvider: createAuthProvider(this._signingContext.credentialSigner),
+        identityKey: this.signingContext.identityKey,
+        peerKey: this.signingContext.deviceKey,
+        credentialProvider: createAuthProvider(this.signingContext.credentialSigner),
         credentialAuthenticator: async () => true,
       },
     });
@@ -556,12 +616,12 @@ export class DataSpaceManager extends Resource {
   private async _constructSpace(ctx: Context, metadata: SpaceMetadata): Promise<DataSpace> {
     log('construct space', { metadata });
     const gossip = new Gossip({
-      localPeerId: this._signingContext.deviceKey,
+      localPeerId: this.signingContext.deviceKey,
     });
     const presence = new Presence({
       announceInterval: this._runtimeProps?.spaceMemberPresenceAnnounceInterval ?? PRESENCE_ANNOUNCE_INTERVAL,
       offlineTimeout: this._runtimeProps?.spaceMemberPresenceOfflineTimeout ?? PRESENCE_OFFLINE_TIMEOUT,
-      identityKey: this._signingContext.identityKey,
+      identityKey: this.signingContext.identityKey,
       gossip,
     });
 
@@ -577,9 +637,9 @@ export class DataSpaceManager extends Resource {
     const space: Space = await this._spaceManager.constructSpace({
       metadata,
       swarmIdentity: {
-        identityKey: this._signingContext.identityKey,
-        peerKey: this._signingContext.deviceKey,
-        credentialProvider: createAuthProvider(this._signingContext.credentialSigner),
+        identityKey: this.signingContext.identityKey,
+        peerKey: this.signingContext.deviceKey,
+        credentialProvider: createAuthProvider(this.signingContext.credentialSigner),
         credentialAuthenticator: deferFunction(() => dataSpace.authVerifier.verifier),
       },
       onAuthorizedConnection: (session) =>
@@ -608,7 +668,7 @@ export class DataSpaceManager extends Resource {
           this._handleMemberRoleChanges(presence, space.protocol, members);
         }
       },
-      memberKey: this._signingContext.identityKey,
+      memberKey: this.signingContext.identityKey,
       onDelegatedInvitationStatusChange: (invitation, isActive) => {
         return this._handleInvitationStatusChange(dataSpace, invitation, isActive);
       },
@@ -625,7 +685,7 @@ export class DataSpaceManager extends Resource {
       keyring: this._keyring,
       feedStore: this._feedStore,
       echoHost: this._echoHost,
-      signingContext: this._signingContext,
+      signingContext: this.signingContext,
       callbacks: {
         beforeReady: async () => {
           log('before space ready', { space: space.key });
@@ -767,3 +827,58 @@ export class DataSpaceManager extends Resource {
     await Promise.all(tasks);
   }
 }
+
+export class DataSpaceManagerService extends EffectContext.Tag('@dxos/client-services/DataSpaceManager')<
+  DataSpaceManagerService,
+  DataSpaceManager
+>() {}
+
+export type DataSpaceManagerLayerOptions = Pick<DataSpaceManagerProps, 'runtimeProps' | 'edgeFeatures'>;
+
+/**
+ * Effect Layer constructing a dormant {@link DataSpaceManager}.
+ */
+export const DataSpaceManagerLayer = (
+  options: DataSpaceManagerLayerOptions = {},
+): Layer.Layer<
+  DataSpaceManagerService,
+  never,
+  | SpaceManagerService
+  | IMetadataStoreService
+  | KeyringApiService
+  | SigningContextProviderService
+  | FeedStoreService
+  | EchoHostService
+  | InvitationsManagerService
+> =>
+  Layer.effect(
+    DataSpaceManagerService,
+    Effect.gen(function* () {
+      const spaceManager = yield* SpaceManagerService;
+      const metadataStore = yield* IMetadataStoreService;
+      const keyring = yield* KeyringApiService;
+      const signingContextProvider = yield* SigningContextProviderService;
+      const feedStore = yield* FeedStoreService;
+      const echoHost = yield* EchoHostService;
+      const invitationsManager = yield* InvitationsManagerService;
+      const edgeConnection = yield* Effect.serviceOption(EdgeConnectionService);
+      const edgeHttpClient = yield* Effect.serviceOption(EdgeHttpClientService);
+      const meshReplicator = yield* Effect.serviceOption(MeshEchoReplicatorService);
+      const echoEdgeReplicator = yield* Effect.serviceOption(EdgeAutomergeReplicatorService);
+
+      return new DataSpaceManager({
+        spaceManager,
+        metadataStore,
+        keyring,
+        signingContextProvider,
+        feedStore,
+        echoHost,
+        invitationsManager,
+        edgeConnection: Option.getOrUndefined(edgeConnection),
+        edgeHttpClient: Option.getOrUndefined(edgeHttpClient),
+        meshReplicator: Option.getOrUndefined(meshReplicator),
+        echoEdgeReplicator: Option.getOrUndefined(echoEdgeReplicator),
+        ...options,
+      });
+    }),
+  );

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

@@ -10,13 +10,7 @@ import { AUTH_TIMEOUT } from '@dxos/client-protocol';
 import { Context, ContextDisposedError, cancelWithContext } from '@dxos/context';
 import type { SpecificCredential } from '@dxos/credentials';
 import { timed, warnAfterTimeout } from '@dxos/debug';
-import {
-  type DatabaseRoot,
-  type EchoHost,
-  type IMetadataStore,
-  type Space,
-  createMappedFeedWriter,
-} from '@dxos/echo-host';
+import { type DatabaseRoot, type EchoHost } from '@dxos/echo-host';
 import { type DatabaseDirectory, SpaceDocVersion } from '@dxos/echo-protocol';
 import type { EdgeConnection, EdgeHttpClient } from '@dxos/edge-client';
 import { type FeedStore, type FeedWrapper } from '@dxos/feed-store';
@@ -48,6 +42,9 @@ import { trace } from '@dxos/tracing';
 import { type AsyncCallback, CallbackCollection, ComplexSet } from '@dxos/util';
 
 import { TrustedKeySetAuthVerifier } from '../identity';
+import { type IMetadataStore } from '../metadata';
+import { createMappedFeedWriter } from '../pipeline';
+import { type Space } from '../space';
 import { AutomergeSpaceState } from './automerge-space-state';
 import { type SigningContext } from './data-space-manager';
 import { EdgeFeedReplicator } from './edge-feed-replicator';
@@ -96,10 +93,8 @@ export type CreateEpochOptions = {
 };
 
 @trackLeaks('open', 'close')
-@trace.resource()
 export class DataSpace {
   private _ctx = new Context();
-  @trace.info()
   private readonly _inner: Space;
 
   private readonly _gossip: Gossip;
@@ -181,12 +176,10 @@ export class DataSpace {
     log('new state', { state: SpaceState[this._state] });
   }
 
-  @trace.info()
   get id() {
     return this._inner.id;
   }
 
-  @trace.info()
   get key() {
     return this._inner.key;
   }
@@ -195,7 +188,6 @@ export class DataSpace {
     return this._inner.isOpen;
   }
 
-  @trace.info({ enum: SpaceState })
   get state(): SpaceState {
     return this._state;
   }
@@ -230,7 +222,6 @@ export class DataSpace {
     return this._databaseRoot;
   }
 
-  @trace.info({ depth: null })
   private get _automergeInfo() {
     return {
       rootUrl: this._automergeSpaceState.rootUrl,
@@ -359,6 +350,23 @@ export class DataSpace {
     const ready = this.stateUpdate.waitForCondition(() => this._state === SpaceState.SPACE_READY);
 
     log('initializing automerge root');
+    const isPersisted = this._echoHost.spaces.some((s) => s.spaceId === this.id);
+    if (isPersisted) {
+      try {
+        log('opening persisted space root', { spaceId: this.id });
+        const root = await this._echoHost.openSpaceRoot(ctx, this.id);
+        this._databaseRoot = root;
+        if (root.getVersion() !== SpaceDocVersion.CURRENT) {
+          this._state = SpaceState.SPACE_REQUIRES_MIGRATION;
+          this.stateUpdate.emit();
+        } else {
+          await this._enterReadyState();
+        }
+      } catch (err) {
+        log.warn('failed to open persisted space root, will wait for credentials', { spaceId: this.id, err });
+      }
+    }
+
     this._automergeSpaceState.startProcessingRootDocs();
 
     // TODO(dmaretskyi): Change so `initializeDataPipeline` doesn't wait for the space to be READY, but rather any state with a valid root.
@@ -511,17 +519,20 @@ export class DataSpace {
         // Ensure only one root is processed at a time.
         using _guard = await this._epochProcessingMutex.acquire();
 
-        // Attaching space keys to legacy documents.
+        // Attaching space identifiers to legacy documents.
         const doc = handle.doc();
-        if (!doc.access?.spaceKey) {
-          handle.change((doc: any) => {
-            doc.access = { spaceKey: this.key.toHex() };
+        if (!doc.access?.spaceId || !doc.access?.spaceKey) {
+          handle.change((doc: DatabaseDirectory) => {
+            doc.access ??= {};
+            doc.access.spaceId ??= this.id;
+            // spaceKey is deprecated but still written so older clients can resolve the owning space.
+            doc.access.spaceKey ??= this.key.toHex();
           });
         }
 
         // TODO(dmaretskyi): Close roots.
         // TODO(dmaretskyi): How do we handle changing to the next EPOCH?
-        const root = await this._echoHost.openSpaceRoot(this._ctx, this.id, handle.url);
+        const root = await this._echoHost.updateSpaceRoot(this._ctx, this.id, handle.url);
 
         // NOTE: Make sure this assignment happens synchronously together with the state change.
         this._databaseRoot = root;

package/src/packlets/spaces/edge-feed-replicator.test.ts

@@ -8,7 +8,6 @@ import { describe, expect, onTestFinished, test, vi } from 'vitest';
 
 import { Trigger, sleep } from '@dxos/async';
 import { Context } from '@dxos/context';
-import { valueEncoding } from '@dxos/echo-host';
 import { EdgeClient, EdgeIdentityChangedError, createEphemeralEdgeIdentity } from '@dxos/edge-client';
 import { createTestEdgeWsServer } from '@dxos/edge-client/testing';
 import { FeedFactory, FeedStore, type FeedWrapper } from '@dxos/feed-store';
@@ -21,6 +20,7 @@ import { openAndClose } from '@dxos/test-utils';
 import { Timeframe } from '@dxos/timeframe';
 import { range } from '@dxos/util';
 
+import { valueEncoding } from '../pipeline';
 import { EdgeFeedReplicator } from './edge-feed-replicator';
 
 describe('EdgeFeedReplicator', () => {

package/src/packlets/spaces/genesis.ts

@@ -4,11 +4,11 @@
 
 import { createCredential } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
-import { type Space } from '@dxos/echo-host';
 import { type KeyringApi } from '@dxos/keyring';
 import { AdmittedFeed, MembershipPolicy, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { Timeframe } from '@dxos/timeframe';
 
+import { type Space } from '../space';
 import { type SigningContext } from './data-space-manager';
 
 export const spaceGenesis = async (

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

@@ -2,12 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
+import * as Runtime from 'effect/Runtime';
 import { afterEach, beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
+import { EffectEx } from '@dxos/effect';
 import { PublicKey } from '@dxos/keys';
-import { type Space, type SpacesService } from '@dxos/protocols/proto/dxos/client/services';
+import { subscribeStream } from '@dxos/protocols';
+import { type Space } from '@dxos/protocols/proto/dxos/client/services';
 import { MembershipPolicy } from '@dxos/protocols/proto/dxos/halo/credentials';
 
 import { type ServiceContext } from '../services';
@@ -16,7 +19,7 @@ import { SpacesServiceImpl } from './spaces-service';
 
 describe('SpacesService', () => {
   let serviceContext: ServiceContext;
-  let spacesService: SpacesService;
+  let spacesService: SpacesServiceImpl;
 
   beforeEach(async () => {
     serviceContext = await createServiceContext();
@@ -38,14 +41,16 @@ describe('SpacesService', () => {
 
   describe('createSpace', () => {
     test('fails if no identity is available', async () => {
-      await expect(spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE })).rejects.toBeInstanceOf(
-        Error,
-      );
+      await expect(
+        EffectEx.runPromise(spacesService['SpacesService.createSpace']({ membershipPolicy: MembershipPolicy.INVITE })),
+      ).rejects.toBeInstanceOf(Error);
     });
 
     test('creates a new space', async () => {
       await serviceContext.createIdentity();
-      const space = await spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE });
+      const space = await EffectEx.runPromise(
+        spacesService['SpacesService.createSpace']({ membershipPolicy: MembershipPolicy.INVITE }),
+      );
       expect(space).to.exist;
       expect(space.spaceKey).to.be.instanceof(PublicKey);
     });
@@ -55,29 +60,35 @@ describe('SpacesService', () => {
 
   describe('querySpaces', () => {
     test('returns empty list if no identity is available', async () => {
-      const query = spacesService.querySpaces();
+      const query = spacesService['SpacesService.querySpaces']();
       const result = new Trigger<Space[] | undefined>();
-      query.subscribe(({ spaces }) => {
-        result.wake(spaces);
+      const unsubscribe = subscribeStream(Runtime.defaultRuntime, query, {
+        onData: ({ spaces }) => result.wake(spaces),
       });
-      onTestFinished(() => query.close());
+      onTestFinished(() => unsubscribe());
       expect(await result.wait()).to.be.length(0);
     });
 
     test('returns list of existing spaces', async () => {
       await serviceContext.createIdentity();
       const existingSpaces = [
-        await spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE }),
-        await spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE }),
-        await spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE }),
+        await EffectEx.runPromise(
+          spacesService['SpacesService.createSpace']({ membershipPolicy: MembershipPolicy.INVITE }),
+        ),
+        await EffectEx.runPromise(
+          spacesService['SpacesService.createSpace']({ membershipPolicy: MembershipPolicy.INVITE }),
+        ),
+        await EffectEx.runPromise(
+          spacesService['SpacesService.createSpace']({ membershipPolicy: MembershipPolicy.INVITE }),
+        ),
       ];
 
-      const query = spacesService.querySpaces();
+      const query = spacesService['SpacesService.querySpaces']();
       const result = new Trigger<Space[] | undefined>();
-      query.subscribe(({ spaces }) => {
-        result.wake(spaces);
+      const unsubscribe = subscribeStream(Runtime.defaultRuntime, query, {
+        onData: ({ spaces }) => result.wake(spaces),
       });
-      onTestFinished(() => query.close());
+      onTestFinished(() => unsubscribe());
 
       const spaces = await result.wait();
       expect(spaces).to.be.length(3);
@@ -86,16 +97,18 @@ describe('SpacesService', () => {
 
     test('updates when new space is added', async () => {
       await serviceContext.createIdentity();
-      const query = spacesService.querySpaces();
+      const query = spacesService['SpacesService.querySpaces']();
       const result = new Trigger<Space[] | undefined>();
-      query.subscribe(({ spaces }) => {
-        result.wake(spaces);
+      const unsubscribe = subscribeStream(Runtime.defaultRuntime, query, {
+        onData: ({ spaces }) => result.wake(spaces),
       });
-      onTestFinished(() => query.close());
+      onTestFinished(() => unsubscribe());
       expect(await result.wait()).to.be.length(0);
 
       result.reset();
-      const space = await spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE });
+      const space = await EffectEx.runPromise(
+        spacesService['SpacesService.createSpace']({ membershipPolicy: MembershipPolicy.INVITE }),
+      );
       const spaces = await result.wait();
       expect(spaces).to.be.length(1);
       expect(spaces?.[0].spaceKey.equals(space.spaceKey)).to.be.true;