@dxos/client-services 0.10.0 → 0.11.0

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

@@ -2,16 +2,22 @@
 // Copyright 2023 DXOS.org
 //
 
-import { beforeEach, describe, expect, test } from 'vitest';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import * as Runtime from 'effect/Runtime';
+import * as Stream from 'effect/Stream';
+import { beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 import { Event, Trigger } from '@dxos/async';
 import { Config } from '@dxos/config';
-import { type QueryStatusResponse, type SystemService, SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
+import { EffectEx } from '@dxos/effect';
+import { subscribeStream } from '@dxos/protocols';
+import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 
 import { SystemServiceImpl } from './system-service';
 
 describe('SystemService', () => {
-  let systemService: SystemService;
+  let systemService: SystemServiceImpl;
   let config: Config;
   let statusUpdate: Event<void>;
   let currentStatus: SystemStatus;
@@ -45,35 +51,47 @@ describe('SystemService', () => {
   });
 
   test('getConfig returns config', async () => {
-    expect(await systemService.getConfig()).to.deep.equal(config.values);
+    expect(await EffectEx.runPromise(systemService['SystemService.getConfig']())).to.deep.equal(config.values);
   });
 
   test('updateStatus triggers callback', async () => {
-    await systemService.updateStatus({ status: SystemStatus.INACTIVE });
+    await EffectEx.runPromise(systemService['SystemService.updateStatus']({ status: SystemStatus.INACTIVE }));
     const result = await updateStatus.wait();
     expect(result).to.equal(SystemStatus.INACTIVE);
   });
 
   test('queryStatus returns initial status', async () => {
-    const status = new Trigger<QueryStatusResponse>();
-    systemService.queryStatus({}).subscribe((response) => {
-      status.wake(response);
-    });
-    expect(await status.wait()).to.deep.equal({ status: SystemStatus.ACTIVE });
+    const response = await EffectEx.runPromise(
+      systemService['SystemService.queryStatus']({}).pipe(Stream.runHead, Effect.map(Option.getOrThrow)),
+    );
+    expect(response).to.deep.equal({ status: SystemStatus.ACTIVE });
   });
 
   test('queryStatus streams status changes', async () => {
     const statuses: SystemStatus[] = [];
-    systemService.queryStatus({}).subscribe(({ status }) => {
-      statuses.push(status);
+    const first = new Trigger();
+    const done = new Trigger();
+    const cleanup = subscribeStream(Runtime.defaultRuntime, systemService['SystemService.queryStatus']({}), {
+      onData: ({ status }) => {
+        statuses.push(status);
+        first.wake();
+        if (statuses.length === 3) {
+          done.wake();
+        }
+      },
     });
+    onTestFinished(cleanup);
+
+    // Wait for the initial emission so the status subscription is active before mutating.
+    await first.wait();
     changeStatus(SystemStatus.INACTIVE);
     changeStatus(SystemStatus.ACTIVE);
+    await done.wait();
     expect(statuses).to.deep.equal([SystemStatus.ACTIVE, SystemStatus.INACTIVE, SystemStatus.ACTIVE]);
   });
 
   test('reset triggers callback', async () => {
-    await systemService.reset();
+    await EffectEx.runPromise(systemService['SystemService.reset']());
     const result = await reset.wait();
     expect(result).to.be.true;
   });

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

@@ -2,18 +2,22 @@
 // Copyright 2022 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
+import * as EffectStream from 'effect/Stream';
+
 import { type Event } from '@dxos/async';
-import { Stream } from '@dxos/codec-protobuf/stream';
 import { type Config } from '@dxos/config';
 import {
   GetDiagnosticsRequest,
+  type GetDiagnosticsResponse,
   type Platform,
   type QueryStatusRequest,
   type QueryStatusResponse,
-  type SystemService,
   type SystemStatus,
   type UpdateStatusRequest,
 } from '@dxos/protocols/proto/dxos/client/services';
+import { type Config as ConfigProto } from '@dxos/protocols/proto/dxos/config';
+import { type SystemService } from '@dxos/protocols/rpc';
 import { type MaybePromise, jsonKeyReplacer } from '@dxos/util';
 
 import { type Diagnostics } from '../diagnostics';
@@ -28,15 +32,15 @@ export type SystemServiceOptions = {
   onReset: () => MaybePromise<void>;
 };
 
-export class SystemServiceImpl implements SystemService {
-  private readonly _config?: SystemServiceOptions['config'];
-  private readonly _statusUpdate: SystemServiceOptions['statusUpdate'];
-  private readonly _getCurrentStatus: SystemServiceOptions['getCurrentStatus'];
-  private readonly _onUpdateStatus: SystemServiceOptions['onUpdateStatus'];
-  private readonly _onReset: SystemServiceOptions['onReset'];
-  private readonly _getDiagnostics: SystemServiceOptions['getDiagnostics'];
+export class SystemServiceImpl implements SystemService.Handlers {
+  private readonly '_config'?: SystemServiceOptions['config'];
+  private readonly '_statusUpdate': SystemServiceOptions['statusUpdate'];
+  private readonly '_getCurrentStatus': SystemServiceOptions['getCurrentStatus'];
+  private readonly '_onUpdateStatus': SystemServiceOptions['onUpdateStatus'];
+  private readonly '_onReset': SystemServiceOptions['onReset'];
+  private readonly '_getDiagnostics': SystemServiceOptions['getDiagnostics'];
 
-  constructor({
+  'constructor'({
     config,
     statusUpdate,
     getDiagnostics,
@@ -52,55 +56,79 @@ export class SystemServiceImpl implements SystemService {
     this._onReset = onReset;
   }
 
-  async getConfig() {
-    return (await this._config?.())?.values ?? {};
+  ['SystemService.getConfig'](): Effect.Effect<ConfigProto, Error> {
+    return Effect.tryPromise({
+      try: async () => (await this._config?.())?.values ?? {},
+      catch: (error) => error as Error,
+    });
   }
 
   /**
    * NOTE: Since this is serialized as a JSON object, we allow the option to serialize keys.
    */
-  async getDiagnostics({ keys }: GetDiagnosticsRequest = {}) {
-    const diagnostics = await this._getDiagnostics();
-    return {
-      timestamp: new Date(),
-      diagnostics: JSON.parse(
-        JSON.stringify(
-          diagnostics,
-          jsonKeyReplacer({
-            truncate: keys === GetDiagnosticsRequest.KEY_OPTION.TRUNCATE,
-            humanize: keys === GetDiagnosticsRequest.KEY_OPTION.HUMANIZE,
-          }),
-        ),
-      ),
-    };
+  ['SystemService.getDiagnostics']({ keys }: GetDiagnosticsRequest = {}): Effect.Effect<GetDiagnosticsResponse, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const diagnostics = await this._getDiagnostics();
+        return {
+          timestamp: new Date(),
+          diagnostics: JSON.parse(
+            JSON.stringify(
+              diagnostics,
+              jsonKeyReplacer({
+                truncate: keys === GetDiagnosticsRequest.KEY_OPTION.TRUNCATE,
+                humanize: keys === GetDiagnosticsRequest.KEY_OPTION.HUMANIZE,
+              }),
+            ),
+          ),
+        };
+      },
+      catch: (error) => error as Error,
+    });
   }
 
-  async getPlatform(): Promise<Platform> {
-    return getPlatform();
+  ['SystemService.getPlatform'](): Effect.Effect<Platform, Error> {
+    return Effect.tryPromise({
+      try: async () => getPlatform(),
+      catch: (error) => error as Error,
+    });
   }
 
-  async updateStatus({ status }: UpdateStatusRequest): Promise<void> {
-    await this._onUpdateStatus(status);
+  ['SystemService.updateStatus']({ status }: UpdateStatusRequest): Effect.Effect<void, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        await this._onUpdateStatus(status);
+      },
+      catch: (error) => error as Error,
+    });
   }
 
   // TODO(burdon): Standardize interval option in stream request?
-  queryStatus({ interval = 3_000 }: QueryStatusRequest = {}): Stream<QueryStatusResponse> {
-    return new Stream(({ next }) => {
+  ['SystemService.queryStatus']({ interval = 3_000 }: QueryStatusRequest = {}): EffectStream.Stream<
+    QueryStatusResponse,
+    Error
+  > {
+    return EffectStream.async<QueryStatusResponse, Error>((emit) => {
       const update = () => {
-        next({ status: this._getCurrentStatus() });
+        void emit.single({ status: this._getCurrentStatus() });
       };
 
       update();
       const unsubscribe = this._statusUpdate.on(() => update());
       const i = setInterval(update, interval);
-      return () => {
+      return Effect.sync(() => {
         clearInterval(i);
         unsubscribe();
-      };
+      });
     });
   }
 
-  async reset(): Promise<void> {
-    await this._onReset();
+  ['SystemService.reset'](): Effect.Effect<void, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        await this._onReset();
+      },
+      catch: (error) => error as Error,
+    });
   }
 }

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

@@ -9,7 +9,7 @@ import { invariant } from '@dxos/invariant';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type DeviceProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 
-import { ServiceContext } from '../services';
+import { ClientServicesHost, type ServiceContext } from '../services';
 
 /**
  * Strip secrets from invitation before giving it to the peer.
@@ -229,7 +229,7 @@ export const createInvitation = async (
     ...(options ?? {}),
   };
 
-  if (host instanceof ServiceContext) {
+  if (host instanceof ClientServicesHost) {
     return host.invitationsManager.createInvitation(new Context(), {
       kind: Invitation.Kind.SPACE,
       ...options,
@@ -246,7 +246,7 @@ export const acceptInvitation = (
 ): AuthenticatingInvitation => {
   invitation = sanitizeInvitation(invitation);
 
-  if (guest instanceof ServiceContext) {
+  if (guest instanceof ClientServicesHost) {
     return guest.invitationsManager.acceptInvitation(new Context(), {
       invitation,
       deviceProfile: guestDeviceProfile,

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

@@ -7,12 +7,11 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as ManagedRuntime from 'effect/ManagedRuntime';
 
-import { type Config } from '@dxos/config';
+import { Config } from '@dxos/config';
 import { Context } from '@dxos/context';
 import { CredentialGenerator, createCredentialSignerWithChain } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
-import { EchoHost, MeshEchoReplicator, SpaceManager, valueEncoding } from '@dxos/echo-host';
-import { SqliteMetadataStore } from '@dxos/echo-host';
+import { EchoHost, MeshEchoReplicator } from '@dxos/echo-host';
 import { RuntimeProvider } from '@dxos/effect';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { SqliteKeyring } from '@dxos/keyring';
@@ -25,8 +24,11 @@ import * as SqlTransaction from '@dxos/sql-sqlite/SqlTransaction';
 import { SqliteBlobStore } from '@dxos/teleport-extension-object-sync';
 
 import { InvitationsHandler, InvitationsManager, SpaceInvitationProtocol } from '../invitations';
-import { ClientServicesHost, ServiceContext, type ServiceContextRuntimeProps } from '../services';
+import { SqliteMetadataStore } from '../metadata';
+import { valueEncoding } from '../pipeline';
+import { ClientServicesHost, type ServiceContext, type ServiceContextRuntimeProps } from '../services';
 import { SqliteStorage } from '../services/sqlite-storage';
+import { SpaceManager } from '../space';
 import { DataSpaceManager, type DataSpaceManagerRuntimeProps, type SigningContext } from '../spaces';
 
 //
@@ -55,23 +57,35 @@ export const createServiceContext = async ({
 }: {
   signalManagerFactory?: () => Promise<SignalManager>;
   runtimeProps?: ServiceContextRuntimeProps;
-} = {}) => {
+} = {}): Promise<ServiceContext> => {
   const signalManager = await signalManagerFactory();
-  const networkManager = new SwarmNetworkManager({
-    signalManager,
-    transportFactory: MemoryTransportFactory,
-  });
 
+  // The host builds its component stack over this SQLite runtime; dispose it once the host closes so
+  // the layer-scoped finalizers (e.g. EchoHost) do not leak across tests.
   const runtime = ManagedRuntime.make(
     SqlTransaction.layer
       .pipe(Layer.provideMerge(sqliteLayerMemory), Layer.provideMerge(Reactivity.layer))
       .pipe(Layer.orDie),
-  ).runtimeEffect;
+  );
 
-  return new ServiceContext(networkManager, signalManager, undefined, undefined, runtime, {
-    invitationConnectionDefaultProps: { teleport: { controlHeartbeatInterval: 200 } },
-    ...runtimeProps,
+  const host = new ClientServicesHost({
+    config: new Config(),
+    signalManager,
+    transportFactory: MemoryTransportFactory,
+    runtime: runtime.runtimeEffect,
+    runtimeProps: {
+      invitationConnectionDefaultProps: { teleport: { controlHeartbeatInterval: 200 } },
+      ...runtimeProps,
+    },
   });
+
+  const closeHost = host.close.bind(host);
+  host.close = async (ctx = new Context()) => {
+    await closeHost(ctx);
+    await runtime.dispose();
+  };
+
+  return host;
 };
 
 export const createPeers = async (numPeers: number, signalManagerFactory?: () => Promise<SignalManager>) => {
@@ -204,7 +218,7 @@ export class TestPeer {
       spaceManager: this.spaceManager,
       metadataStore: this.metadataStore,
       keyring: this.keyring,
-      signingContext: this.identity,
+      signingContextProvider: () => this.identity,
       feedStore: this.feedStore,
       echoHost: this.echoHost,
       invitationsManager: this.invitationsManager,
@@ -216,17 +230,18 @@ export class TestPeer {
   }
 
   get invitationsManager() {
-    return (this._props.invitationsManager ??= new InvitationsManager(
-      new InvitationsHandler(this.networkManager),
-      (invitation) => {
+    if (!this._props.invitationsManager) {
+      const manager = new InvitationsManager(new InvitationsHandler(this.networkManager), this.metadataStore);
+      manager.setInvitationHandlerFactory((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,
-    ));
+      });
+      this._props.invitationsManager = manager;
+    }
+    return this._props.invitationsManager;
   }
 
   async createIdentity(): Promise<void> {