@dxos/client-services 0.4.10-main.fe71b4c → 0.4.10-next.71cec10

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

@@ -2,43 +2,22 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Event, scheduleTask } from '@dxos/async';
-import { type AuthenticatingInvitation, type CancellableInvitation } from '@dxos/client-protocol';
 import { Stream } from '@dxos/codec-protobuf';
-import { Context } from '@dxos/context';
-import { hasInvitationExpired, type MetadataStore } from '@dxos/echo-pipeline';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
 import {
   type AuthenticationRequest,
   type AcceptInvitationRequest,
-  Invitation,
+  type Invitation,
   type InvitationsService,
   QueryInvitationsResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
 
-import { type InvitationProtocol } from './invitation-protocol';
-import { type InvitationsHandler } from './invitations-handler';
+import { type InvitationsManager } from './invitations-manager';
 
 /**
  * Adapts invitation service observable to client/service stream.
  */
 export class InvitationsServiceImpl implements InvitationsService {
-  private readonly _createInvitations = new Map<string, CancellableInvitation>();
-  private readonly _acceptInvitations = new Map<string, AuthenticatingInvitation>();
-  private readonly _invitationCreated = new Event<Invitation>();
-  private readonly _invitationAccepted = new Event<Invitation>();
-  private readonly _removedCreated = new Event<Invitation>();
-  private readonly _removedAccepted = new Event<Invitation>();
-  private readonly _saved = new Event<Invitation>();
-  private readonly _persistentInvitationsLoadedEvent = new Event();
-  private _persistentInvitationsLoaded = false;
-
-  constructor(
-    private readonly _invitationsHandler: InvitationsHandler,
-    private readonly _getHandler: (invitation: Invitation) => InvitationProtocol,
-    private readonly _metadataStore: MetadataStore,
-  ) {}
+  constructor(private readonly _invitationsManager: InvitationsManager) {}
 
   // TODO(burdon): Guest/host label.
   getLoggingContext() {
@@ -48,148 +27,31 @@ export class InvitationsServiceImpl implements InvitationsService {
   }
 
   createInvitation(options: Invitation): Stream<Invitation> {
-    let invitation: CancellableInvitation;
-
-    const savePersistentInvitationCtx = new Context();
-    const existingInvitation = this._createInvitations.get(options.invitationId);
-    if (existingInvitation) {
-      invitation = existingInvitation;
-    } else {
-      const handler = this._getHandler(options);
-      invitation = this._invitationsHandler.createInvitation(handler, options);
-      this._createInvitations.set(invitation.get().invitationId, invitation);
-      this._invitationCreated.emit(invitation.get());
-    }
-
+    const invitation = this._invitationsManager.createInvitation(options);
     return new Stream<Invitation>(({ next, close }) => {
-      if (invitation.get().persistent) {
-        scheduleTask(savePersistentInvitationCtx, async () => {
-          try {
-            await this._metadataStore.addInvitation(invitation.get());
-            this._saved.emit(invitation.get());
-          } catch (err: any) {
-            close(err);
-          }
-        });
-      }
-      invitation.subscribe(
-        (invitation) => {
-          next(invitation);
-        },
-        async (err: Error) => {
-          await savePersistentInvitationCtx.dispose();
-
-          // TODO(nf): also remove from storage?
-          close(err);
-        },
-        async () => {
-          close();
-          if (invitation.get().persistent) {
-            await savePersistentInvitationCtx.dispose();
-            // TODO(nf): remove on all complete conditions?
-            await this._metadataStore.removeInvitation(invitation.get().invitationId);
-          }
-
-          this._createInvitations.delete(invitation.get().invitationId);
-          if (!invitation.get().multiUse) {
-            this._removedCreated.emit(invitation.get());
-          }
-        },
-      );
-    });
-  }
-
-  async loadPersistentInvitations() {
-    const persistentInvitations = this._metadataStore.getInvitations();
-
-    // get saved persistent invitations, filter and remove from storage those that have expired.
-    const freshInvitations = persistentInvitations.filter(async (invitation) => !hasInvitationExpired(invitation));
-
-    const cInvitations = freshInvitations.map((persistentInvitation) => {
-      invariant(!this._createInvitations.get(persistentInvitation.invitationId), 'invitation already exists');
-
-      const handler = this._getHandler(persistentInvitation);
-      const invitation = this._invitationsHandler.createInvitation(handler, persistentInvitation);
-      this._createInvitations.set(invitation.get().invitationId, invitation);
-      this._invitationCreated.emit(invitation.get());
-      return persistentInvitation;
+      invitation.subscribe(next, close, close);
     });
-    this._persistentInvitationsLoadedEvent.emit();
-    this._persistentInvitationsLoaded = true;
-    return { invitations: cInvitations };
   }
 
-  acceptInvitation({ invitation: options, deviceProfile }: AcceptInvitationRequest): Stream<Invitation> {
-    let invitation: AuthenticatingInvitation;
-
-    // TODO(nf): duplicate check in InvitationHandler
-    if (deviceProfile) {
-      invariant(options.kind === Invitation.Kind.DEVICE, 'deviceProfile provided for non-device invitation');
-    }
-
-    const existingInvitation = this._acceptInvitations.get(options.invitationId);
-    if (existingInvitation) {
-      invitation = existingInvitation;
-    } else {
-      const handler = this._getHandler(options);
-      invitation = this._invitationsHandler.acceptInvitation(handler, options, deviceProfile);
-      this._acceptInvitations.set(invitation.get().invitationId, invitation);
-      this._invitationAccepted.emit(invitation.get());
-    }
-
+  acceptInvitation(request: AcceptInvitationRequest): Stream<Invitation> {
+    const invitation = this._invitationsManager.acceptInvitation(request);
     return new Stream<Invitation>(({ next, close }) => {
-      invitation.subscribe(
-        (invitation) => {
-          next(invitation);
-        },
-        (err: Error) => {
-          close(err);
-        },
-        () => {
-          close();
-          this._acceptInvitations.delete(invitation.get().invitationId);
-          if (!invitation.get().multiUse) {
-            this._removedAccepted.emit(invitation.get());
-          }
-        },
-      );
+      invitation.subscribe(next, close, close);
     });
   }
 
-  async authenticate({ invitationId, authCode }: AuthenticationRequest): Promise<void> {
-    log('authenticating...');
-    invariant(invitationId);
-    const observable = this._acceptInvitations.get(invitationId);
-    if (!observable) {
-      log.warn('invalid invitation', { invitationId });
-    } else {
-      await observable.authenticate(authCode);
-    }
+  async authenticate(request: AuthenticationRequest): Promise<void> {
+    return this._invitationsManager.authenticate(request);
   }
 
-  async cancelInvitation({ invitationId }: { invitationId: string }): Promise<void> {
-    log('cancelInvitation...', { invitationId });
-    invariant(invitationId);
-    const created = this._createInvitations.get(invitationId);
-    const accepted = this._acceptInvitations.get(invitationId);
-    if (created) {
-      await created.cancel();
-      this._createInvitations.delete(invitationId);
-      this._removedCreated.emit(created.get());
-      if (created.get().persistent) {
-        await this._metadataStore.removeInvitation(created.get().invitationId);
-      }
-    } else if (accepted) {
-      await accepted.cancel();
-      this._acceptInvitations.delete(invitationId);
-      this._removedAccepted.emit(accepted.get());
-    }
+  async cancelInvitation(request: { invitationId: string }): Promise<void> {
+    return this._invitationsManager.cancelInvitation(request);
   }
 
   queryInvitations(): Stream<QueryInvitationsResponse> {
     return new Stream<QueryInvitationsResponse>(({ next, ctx }) => {
       // Push added invitations to the stream.
-      this._invitationCreated.on(ctx, (invitation) => {
+      this._invitationsManager.invitationCreated.on(ctx, (invitation) => {
         next({
           action: QueryInvitationsResponse.Action.ADDED,
           type: QueryInvitationsResponse.Type.CREATED,
@@ -197,7 +59,7 @@ export class InvitationsServiceImpl implements InvitationsService {
         });
       });
 
-      this._invitationAccepted.on(ctx, (invitation) => {
+      this._invitationsManager.invitationAccepted.on(ctx, (invitation) => {
         next({
           action: QueryInvitationsResponse.Action.ADDED,
           type: QueryInvitationsResponse.Type.ACCEPTED,
@@ -206,7 +68,7 @@ export class InvitationsServiceImpl implements InvitationsService {
       });
 
       // Push removed invitations to the stream.
-      this._removedCreated.on(ctx, (invitation) => {
+      this._invitationsManager.removedCreated.on(ctx, (invitation) => {
         next({
           action: QueryInvitationsResponse.Action.REMOVED,
           type: QueryInvitationsResponse.Type.CREATED,
@@ -214,7 +76,7 @@ export class InvitationsServiceImpl implements InvitationsService {
         });
       });
 
-      this._removedAccepted.on(ctx, (invitation) => {
+      this._invitationsManager.removedAccepted.on(ctx, (invitation) => {
         next({
           action: QueryInvitationsResponse.Action.REMOVED,
           type: QueryInvitationsResponse.Type.ACCEPTED,
@@ -223,7 +85,7 @@ export class InvitationsServiceImpl implements InvitationsService {
       });
 
       // used only for testing
-      this._saved.on(ctx, (invitation) => {
+      this._invitationsManager.saved.on(ctx, (invitation) => {
         next({
           action: QueryInvitationsResponse.Action.SAVED,
           type: QueryInvitationsResponse.Type.CREATED,
@@ -235,33 +97,24 @@ export class InvitationsServiceImpl implements InvitationsService {
       next({
         action: QueryInvitationsResponse.Action.ADDED,
         type: QueryInvitationsResponse.Type.CREATED,
-        invitations: Array.from(this._createInvitations.values()).map((invitation) => invitation.get()),
+        invitations: this._invitationsManager.getCreatedInvitations(),
         existing: true,
       });
 
       next({
         action: QueryInvitationsResponse.Action.ADDED,
         type: QueryInvitationsResponse.Type.ACCEPTED,
-        invitations: Array.from(this._acceptInvitations.values()).map((invitation) => invitation.get()),
+        invitations: this._invitationsManager.getAcceptedInvitations(),
         existing: true,
       });
 
-      if (this._persistentInvitationsLoaded) {
+      this._invitationsManager.onPersistentInvitationsLoaded(ctx, () => {
         next({
           action: QueryInvitationsResponse.Action.LOAD_COMPLETE,
           type: QueryInvitationsResponse.Type.CREATED,
           // TODO(nf): populate with invitations
         });
-      } else {
-        this._persistentInvitationsLoadedEvent.on(ctx, () => {
-          next({
-            action: QueryInvitationsResponse.Action.LOAD_COMPLETE,
-            type: QueryInvitationsResponse.Type.CREATED,
-            // TODO(nf): populate with invitations
-          });
-        });
-      }
-
+      });
       // TODO(nf): expired invitations?
     });
   }

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

@@ -39,6 +39,7 @@ import {
   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;
@@ -136,6 +138,11 @@ export class ServiceContext extends Resource {
     });
 
     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');
   }

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

@@ -16,7 +16,7 @@ import {
   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';
@@ -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.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/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.4.10-main.fe71b4c";
+export const DXOS_VERSION = "0.4.10-next.71cec10";