@dxos/client-services 0.10.0 → 0.11.1

package/src/packlets/invitations/invitations-handler.ts

@@ -2,15 +2,25 @@
 // Copyright 2022 DXOS.org
 //
 
+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 { type PushStream, TimeoutError, type Trigger, scheduleTask } from '@dxos/async';
 import { INVITATION_TIMEOUT, getExpirationTime } from '@dxos/client-protocol';
 import { type Context, ContextDisposedError } from '@dxos/context';
 import { createKeyPair, sign } from '@dxos/crypto';
-import { type EdgeHttpClient } from '@dxos/edge-client';
+import { type EdgeHttpClient, EdgeHttpClientService } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { type SwarmConnection, type SwarmNetworkManager, createTeleportProtocolFactory } from '@dxos/network-manager';
+import {
+  type SwarmConnection,
+  type SwarmNetworkManager,
+  SwarmNetworkManagerService,
+  createTeleportProtocolFactory,
+} from '@dxos/network-manager';
 import { InvalidInvitationError, InvalidInvitationExtensionRoleError } from '@dxos/protocols';
 import { type AdmissionKeypair, Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type DeviceProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
@@ -64,7 +74,14 @@ export type InvitationConnectionProps = {
  *  TODO: the flow logic should either be contained in invitations-handler or in extensions, not be split across
  *  TODO: potentially re-evaluate host-side API to allow multiple concurrent connection, so that mutex can be removed
  */
-@_trace.resource()
+/**
+ * Effect service tag for {@link InvitationsHandler}.
+ */
+export class InvitationsHandlerService extends EffectContext.Tag('@dxos/client-services/InvitationsHandler')<
+  InvitationsHandlerService,
+  InvitationsHandler
+>() {}
+
 export class InvitationsHandler {
   /**
    * @internal
@@ -564,3 +581,22 @@ export const createAdmissionKeypair = (): AdmissionKeypair => {
   const keypair = createKeyPair();
   return { publicKey: PublicKey.from(keypair.publicKey), privateKey: keypair.secretKey };
 };
+
+export type InvitationsHandlerLayerOptions = {
+  connectionProps?: InvitationConnectionProps;
+};
+
+/**
+ * Effect Layer constructing an {@link InvitationsHandler}.
+ */
+export const InvitationsHandlerLayer = (
+  options: InvitationsHandlerLayerOptions = {},
+): Layer.Layer<InvitationsHandlerService, never, SwarmNetworkManagerService> =>
+  Layer.effect(
+    InvitationsHandlerService,
+    Effect.gen(function* () {
+      const networkManager = yield* SwarmNetworkManagerService;
+      const edgeClient = yield* Effect.serviceOption(EdgeHttpClientService);
+      return new InvitationsHandler(networkManager, Option.getOrUndefined(edgeClient), options.connectionProps);
+    }),
+  );

package/src/packlets/invitations/invitations-manager.ts

@@ -2,6 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import * as EffectContext from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
 import { Event, PushStream, TimeoutError, Trigger } from '@dxos/async';
 import {
   AuthenticatingInvitation,
@@ -11,7 +15,6 @@ import {
 } from '@dxos/client-protocol';
 import { Context } from '@dxos/context';
 import { generatePasscode } from '@dxos/credentials';
-import { type IMetadataStore, hasInvitationExpired } from '@dxos/echo-host';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -23,14 +26,22 @@ import {
 import { SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { trace } from '@dxos/tracing';
 
+import { type IMetadataStore, IMetadataStoreService, hasInvitationExpired } from '../metadata';
 import type { InvitationProtocol } from './invitation-protocol';
-import { type InvitationsHandler, createAdmissionKeypair } from './invitations-handler';
+import { type InvitationsHandler, InvitationsHandlerService, createAdmissionKeypair } from './invitations-handler';
+
+/**
+ * Effect service tag for {@link InvitationsManager}.
+ */
+export class InvitationsManagerService extends EffectContext.Tag('@dxos/client-services/InvitationsManager')<
+  InvitationsManagerService,
+  InvitationsManager
+>() {}
 
 /**
  * Entry point for creating and accepting invitations, keeps track of existing invitation set and
  * emits events when the set changes.
  */
-@trace.resource()
 export class InvitationsManager {
   private readonly _createInvitations = new Map<string, CancellableInvitation>();
   private readonly _acceptInvitations = new Map<string, AuthenticatingInvitation>();
@@ -44,12 +55,29 @@ export class InvitationsManager {
   private readonly _persistentInvitationsLoadedEvent = new Event();
   private _persistentInvitationsLoaded = false;
 
+  private _invitationHandlerFactory?: (
+    invitation: Partial<Invitation> & Pick<Invitation, 'kind'>,
+  ) => InvitationProtocol;
+
   constructor(
     private readonly _invitationsHandler: InvitationsHandler,
-    private readonly _getHandler: (invitation: Partial<Invitation> & Pick<Invitation, 'kind'>) => InvitationProtocol,
     private readonly _metadataStore: IMetadataStore,
   ) {}
 
+  /**
+   * Wires the invitation handler factory after the composing stack is fully constructed.
+   */
+  setInvitationHandlerFactory(
+    getHandler: (invitation: Partial<Invitation> & Pick<Invitation, 'kind'>) => InvitationProtocol,
+  ): void {
+    this._invitationHandlerFactory = getHandler;
+  }
+
+  private _getHandler(invitation: Partial<Invitation> & Pick<Invitation, 'kind'>): InvitationProtocol {
+    invariant(this._invitationHandlerFactory, 'Invitation handler factory not set.');
+    return this._invitationHandlerFactory(invitation);
+  }
+
   @trace.span({ showInBrowserTimeline: true, op: 'lifecycle' })
   async createInvitation(
     ctx: Context,
@@ -354,3 +382,23 @@ export class InvitationsManager {
     );
   }
 }
+
+/**
+ * Effect Layer constructing an {@link InvitationsManager}.
+ *
+ * The invitation handler factory points "up the stack" and is wired via
+ * {@link InvitationsManager.setInvitationHandlerFactory} after composition.
+ */
+export const InvitationsManagerLayer = (): Layer.Layer<
+  InvitationsManagerService,
+  never,
+  InvitationsHandlerService | IMetadataStoreService
+> =>
+  Layer.effect(
+    InvitationsManagerService,
+    Effect.gen(function* () {
+      const invitationsHandler = yield* InvitationsHandlerService;
+      const metadataStore = yield* IMetadataStoreService;
+      return new InvitationsManager(invitationsHandler, metadataStore);
+    }),
+  );

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

@@ -2,14 +2,18 @@
 // Copyright 2022 DXOS.org
 //
 
-import { type RequestOptions, Stream } from '@dxos/codec-protobuf';
+import * as Effect from 'effect/Effect';
+import * as EffectStream from 'effect/Stream';
+
+import { Context } from '@dxos/context';
 import {
   type AcceptInvitationRequest,
   type AuthenticationRequest,
+  type CancelInvitationRequest,
   type Invitation,
-  type InvitationsService,
   QueryInvitationsResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
+import { type InvitationsService } from '@dxos/protocols/rpc';
 import { trace } from '@dxos/tracing';
 
 import { type InvitationsManager } from './invitations-manager';
@@ -17,48 +21,68 @@ import { type InvitationsManager } from './invitations-manager';
 /**
  * Adapts invitation service observable to client/service stream.
  */
-export class InvitationsServiceImpl implements InvitationsService {
-  constructor(private readonly _invitationsManager: InvitationsManager) {}
+export class InvitationsServiceImpl implements InvitationsService.Handlers {
+  'constructor'(private readonly _invitationsManager: InvitationsManager) {}
 
   // TODO(burdon): Guest/host label.
-  getLoggingContext() {
+  'getLoggingContext'() {
     return {
       // deviceKey: this._identityManager.identity?.deviceKey
     };
   }
 
-  createInvitation(request: Invitation, options?: RequestOptions): Stream<Invitation> {
-    return new Stream<Invitation>(({ ctx, next, close }) => {
+  ['InvitationsService.createInvitation'](request: Invitation): EffectStream.Stream<Invitation, Error> {
+    return EffectStream.async<Invitation, Error>((emit) => {
+      const ctx = Context.default();
       void this._invitationsManager
         .createInvitation(ctx, request)
         .then((invitation) => {
           trace.metrics.increment('dxos.invitation.created');
-          invitation.subscribe(next, close, close);
+          invitation.subscribe(
+            (value) => void emit.single(value),
+            (err) => void emit.fail(err),
+            () => void emit.end(),
+          );
         })
-        .catch(close);
-    }, options?.ctx);
+        .catch((err) => void emit.fail(err));
+      return Effect.promise(() => ctx.dispose());
+    });
   }
 
-  acceptInvitation(request: AcceptInvitationRequest, options?: RequestOptions): Stream<Invitation> {
-    return new Stream<Invitation>(({ ctx, next, close }) => {
+  ['InvitationsService.acceptInvitation'](request: AcceptInvitationRequest): EffectStream.Stream<Invitation, Error> {
+    return EffectStream.async<Invitation, Error>((emit) => {
+      const ctx = Context.default();
       const invitation = this._invitationsManager.acceptInvitation(ctx, request);
-      invitation.subscribe(next, close, close);
-    }, options?.ctx);
+      invitation.subscribe(
+        (value) => void emit.single(value),
+        (err) => void emit.fail(err),
+        () => void emit.end(),
+      );
+      return Effect.promise(() => ctx.dispose());
+    });
   }
 
-  async authenticate(request: AuthenticationRequest): Promise<void> {
-    return this._invitationsManager.authenticate(request);
+  ['InvitationsService.authenticate'](request: AuthenticationRequest): Effect.Effect<void, Error> {
+    return Effect.tryPromise({
+      try: () => this._invitationsManager.authenticate(request),
+      catch: (error) => error as Error,
+    });
   }
 
-  async cancelInvitation(request: { invitationId: string }): Promise<void> {
-    return this._invitationsManager.cancelInvitation(request);
+  ['InvitationsService.cancelInvitation'](request: CancelInvitationRequest): Effect.Effect<void, Error> {
+    return Effect.tryPromise({
+      try: () => this._invitationsManager.cancelInvitation(request),
+      catch: (error) => error as Error,
+    });
   }
 
-  queryInvitations(): Stream<QueryInvitationsResponse> {
-    return new Stream<QueryInvitationsResponse>(({ next, ctx }) => {
+  ['InvitationsService.queryInvitations'](): EffectStream.Stream<QueryInvitationsResponse, Error> {
+    return EffectStream.async<QueryInvitationsResponse, Error>((emit) => {
+      const ctx = Context.default();
+
       // Push added invitations to the stream.
       this._invitationsManager.invitationCreated.on(ctx, (invitation) => {
-        next({
+        void emit.single({
           action: QueryInvitationsResponse.Action.ADDED,
           type: QueryInvitationsResponse.Type.CREATED,
           invitations: [invitation],
@@ -66,7 +90,7 @@ export class InvitationsServiceImpl implements InvitationsService {
       });
 
       this._invitationsManager.invitationAccepted.on(ctx, (invitation) => {
-        next({
+        void emit.single({
           action: QueryInvitationsResponse.Action.ADDED,
           type: QueryInvitationsResponse.Type.ACCEPTED,
           invitations: [invitation],
@@ -75,7 +99,7 @@ export class InvitationsServiceImpl implements InvitationsService {
 
       // Push removed invitations to the stream.
       this._invitationsManager.removedCreated.on(ctx, (invitation) => {
-        next({
+        void emit.single({
           action: QueryInvitationsResponse.Action.REMOVED,
           type: QueryInvitationsResponse.Type.CREATED,
           invitations: [invitation],
@@ -83,7 +107,7 @@ export class InvitationsServiceImpl implements InvitationsService {
       });
 
       this._invitationsManager.removedAccepted.on(ctx, (invitation) => {
-        next({
+        void emit.single({
           action: QueryInvitationsResponse.Action.REMOVED,
           type: QueryInvitationsResponse.Type.ACCEPTED,
           invitations: [invitation],
@@ -92,7 +116,7 @@ export class InvitationsServiceImpl implements InvitationsService {
 
       // used only for testing
       this._invitationsManager.saved.on(ctx, (invitation) => {
-        next({
+        void emit.single({
           action: QueryInvitationsResponse.Action.SAVED,
           type: QueryInvitationsResponse.Type.CREATED,
           invitations: [invitation],
@@ -100,14 +124,14 @@ export class InvitationsServiceImpl implements InvitationsService {
       });
 
       // Push existing invitations to the stream.
-      next({
+      void emit.single({
         action: QueryInvitationsResponse.Action.ADDED,
         type: QueryInvitationsResponse.Type.CREATED,
         invitations: this._invitationsManager.getCreatedInvitations(),
         existing: true,
       });
 
-      next({
+      void emit.single({
         action: QueryInvitationsResponse.Action.ADDED,
         type: QueryInvitationsResponse.Type.ACCEPTED,
         invitations: this._invitationsManager.getAcceptedInvitations(),
@@ -115,13 +139,15 @@ export class InvitationsServiceImpl implements InvitationsService {
       });
 
       this._invitationsManager.onPersistentInvitationsLoaded(ctx, () => {
-        next({
+        void emit.single({
           action: QueryInvitationsResponse.Action.LOAD_COMPLETE,
           type: QueryInvitationsResponse.Type.CREATED,
           // TODO(nf): populate with invitations
         });
       });
       // TODO(nf): expired invitations?
+
+      return Effect.promise(() => ctx.dispose());
     });
   }
 }

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

@@ -2,20 +2,23 @@
 // Copyright 2022 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
+import * as EffectStream from 'effect/Stream';
+
 import { Event } from '@dxos/async';
-import { Stream } from '@dxos/codec-protobuf/stream';
+import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { type LogLevel, type LogProcessor, type LogEntry as NaturalLogEntry, log } from '@dxos/log';
 import {
   type ControlMetricsRequest,
   type ControlMetricsResponse,
   type LogEntry,
-  type LoggingService,
   type Metrics,
   QueryLogsRequest,
   type QueryMetricsRequest,
   type QueryMetricsResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
+import { type LoggingService } from '@dxos/protocols/rpc';
 import { numericalValues, tracer } from '@dxos/util';
 
 /**
@@ -25,45 +28,52 @@ import { numericalValues, tracer } from '@dxos/util';
  * seen in the main window console without opening the shared worker DevTools. Shared worker client
  * services is deprecated; dedicated worker logs already show in the main window console.
  */
-export class LoggingServiceImpl implements LoggingService {
-  private readonly _logs = new Event<NaturalLogEntry>();
-  private readonly _started = Date.now();
-  private readonly _sessionId = PublicKey.random().toHex();
+export class LoggingServiceImpl implements LoggingService.Handlers {
+  private readonly '_logs' = new Event<NaturalLogEntry>();
+  private readonly '_started' = Date.now();
+  private readonly '_sessionId' = PublicKey.random().toHex();
 
-  async open(): Promise<void> {
+  async 'open'(): Promise<void> {
     log.runtimeConfig.processors.push(this._logProcessor);
   }
 
-  async close(): Promise<void> {
+  async 'close'(): Promise<void> {
     const index = log.runtimeConfig.processors.findIndex((processor: LogProcessor) => processor === this._logProcessor);
     log.runtimeConfig.processors.splice(index, 1);
   }
 
-  async controlMetrics({ reset, record }: ControlMetricsRequest): Promise<ControlMetricsResponse> {
-    if (reset) {
-      tracer.clear();
-    }
-
-    if (record === true) {
-      tracer.start();
-    } else if (record === false) {
-      tracer.stop();
-    }
-
-    return { recording: tracer.recording };
+  ['LoggingService.controlMetrics']({
+    reset,
+    record,
+  }: ControlMetricsRequest): Effect.Effect<ControlMetricsResponse, Error> {
+    return Effect.sync(() => {
+      if (reset) {
+        tracer.clear();
+      }
+
+      if (record === true) {
+        tracer.start();
+      } else if (record === false) {
+        tracer.stop();
+      }
+
+      return { recording: tracer.recording };
+    });
   }
 
   /**
    * @deprecated (Move to diagnostics).
    */
-  queryMetrics({ interval = 5_000 }: QueryMetricsRequest): Stream<QueryMetricsResponse> {
+  ['LoggingService.queryMetrics']({
+    interval = 5_000,
+  }: QueryMetricsRequest): EffectStream.Stream<QueryMetricsResponse, Error> {
     // TODO(burdon): Map all traces; how to bind to reducer/metrics shape (e.g., numericalValues)?
     const getNumericalValues = (key: string) => {
       const events = tracer.get(key) ?? [];
       return { key, stats: numericalValues(events, 'duration') };
     };
 
-    return new Stream(({ next }) => {
+    return EffectStream.async<QueryMetricsResponse, Error>((emit) => {
       const update = () => {
         const metrics: Metrics = {
           timestamp: new Date(),
@@ -73,7 +83,7 @@ export class LoggingServiceImpl implements LoggingService {
           ].filter(Boolean) as Metrics.KeyPair[],
         };
 
-        next({
+        void emit.single({
           timestamp: new Date(),
           metrics,
         });
@@ -81,14 +91,15 @@ export class LoggingServiceImpl implements LoggingService {
 
       update();
       const i = setInterval(update, Math.max(interval, 1_000));
-      return () => {
+      return Effect.sync(() => {
         clearInterval(i);
-      };
+      });
     });
   }
 
-  queryLogs(request: QueryLogsRequest): Stream<LogEntry> {
-    return new Stream<LogEntry>(({ ctx, next }) => {
+  ['LoggingService.queryLogs'](request: QueryLogsRequest): EffectStream.Stream<LogEntry, Error> {
+    return EffectStream.async<LogEntry, Error>((emit) => {
+      const ctx = Context.default();
       const handler = (entry: NaturalLogEntry) => {
         // This call was caused by the logging service itself.
         if (LOG_PROCESSING > 0) {
@@ -133,17 +144,18 @@ export class LoggingServiceImpl implements LoggingService {
 
         try {
           LOG_PROCESSING++;
-          next(record);
+          void emit.single(record);
         } finally {
           LOG_PROCESSING--;
         }
       };
 
       this._logs.on(ctx, handler);
+      return Effect.promise(() => ctx.dispose());
     });
   }
 
-  private _logProcessor: LogProcessor = (_config, entry) => {
+  private '_logProcessor': LogProcessor = (_config, entry) => {
     this._logs.emit(entry);
   };
 }

package/src/packlets/logging/logging.test.ts

@@ -2,11 +2,14 @@
 // Copyright 2023 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+import * as Option from 'effect/Option';
+import * as Stream from 'effect/Stream';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
-import { Trigger } from '@dxos/async';
+import { EffectEx } from '@dxos/effect';
 import { LogLevel, log } from '@dxos/log';
-import { type LogEntry } from '@dxos/protocols/proto/dxos/client/services';
 
 import { LoggingServiceImpl } from './logging-service';
 
@@ -23,26 +26,36 @@ describe('LoggingService', () => {
   });
 
   test('queryLogs streams logs', async () => {
-    const trigger = new Trigger<LogEntry>();
-    loggingService.queryLogs({}).subscribe((entry) => {
-      trigger.wake(entry);
-    });
     const message = 'Hello World!';
-    log(message);
-    const entry = await trigger.wait();
+    const entry = await EffectEx.runPromise(
+      Effect.gen(function* () {
+        const fiber = yield* Effect.fork(Stream.runHead(loggingService['LoggingService.queryLogs']({})));
+        // Yield so the forked subscription registers its log handler before emitting.
+        yield* Effect.yieldNow();
+        yield* Effect.sync(() => log(message));
+        return Option.getOrThrow(yield* Fiber.join(fiber));
+      }),
+    );
     expect(entry.message).to.eq(message);
     expect(entry.level).to.eq(LogLevel.DEBUG);
   });
 
   test('queryLogs filters logs', async () => {
-    const trigger = new Trigger<LogEntry>();
-    loggingService.queryLogs({ filters: [{ level: LogLevel.ERROR }] }).subscribe((entry) => {
-      trigger.wake(entry);
-    });
-    log('debugging something');
     const message = 'This is a failure';
-    log.error(message);
-    const entry = await trigger.wait();
+    const entry = await EffectEx.runPromise(
+      Effect.gen(function* () {
+        const fiber = yield* Effect.fork(
+          Stream.runHead(loggingService['LoggingService.queryLogs']({ filters: [{ level: LogLevel.ERROR }] })),
+        );
+        // Yield so the forked subscription registers its log handler before emitting.
+        yield* Effect.yieldNow();
+        yield* Effect.sync(() => {
+          log('debugging something');
+          log.error(message);
+        });
+        return Option.getOrThrow(yield* Fiber.join(fiber));
+      }),
+    );
     expect(entry.message).to.eq(message);
     expect(entry.level).to.eq(LogLevel.ERROR);
   });

package/src/packlets/metadata/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export * from './metadata-store';
+export * from './sqlite-metadata-store';

package/src/packlets/metadata/metadata-store.test.ts

@@ -0,0 +1,49 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { PublicKey } from '@dxos/keys';
+import { StorageType, createStorage } from '@dxos/random-access-storage';
+
+import { MetadataStore } from './metadata-store';
+
+describe('MetadataStore', () => {
+  describe('deleted spaces', () => {
+    test('addDeletedSpace records a tombstone', async ({ expect }) => {
+      const store = new MetadataStore(createStorage({ type: StorageType.RAM }).createDirectory());
+      const spaceKey = PublicKey.random();
+
+      expect(store.deletedSpaces).to.have.length(0);
+
+      await store.addDeletedSpace(spaceKey);
+      expect(store.deletedSpaces).to.have.length(1);
+      expect(store.deletedSpaces[0].equals(spaceKey)).to.be.true;
+    });
+
+    test('addDeletedSpace is idempotent', async ({ expect }) => {
+      const store = new MetadataStore(createStorage({ type: StorageType.RAM }).createDirectory());
+      const spaceKey = PublicKey.random();
+
+      await store.addDeletedSpace(spaceKey);
+      await store.addDeletedSpace(spaceKey);
+      expect(store.deletedSpaces).to.have.length(1);
+    });
+
+    test('tombstones survive reload', async ({ expect }) => {
+      const directory = createStorage({ type: StorageType.RAM }).createDirectory();
+      const spaceKey = PublicKey.random();
+
+      const store = new MetadataStore(directory);
+      await store.load();
+      await store.addDeletedSpace(spaceKey);
+      await store.close();
+
+      const reloaded = new MetadataStore(directory);
+      await reloaded.load();
+      expect(reloaded.deletedSpaces).to.have.length(1);
+      expect(reloaded.deletedSpaces[0].equals(spaceKey)).to.be.true;
+    });
+  });
+});