@dxos/client-services 0.1.18 → 0.1.20

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

@@ -7,7 +7,7 @@ import assert from 'node:assert';
 import { scheduleTask, sleep, Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { createAdmissionCredentials, generatePasscode, getCredentialAssertion } from '@dxos/credentials';
-import { SigningContext, Space, SpaceManager } from '@dxos/echo-db';
+import { SigningContext } from '@dxos/echo-db';
 import { writeMessages } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
@@ -24,8 +24,10 @@ import {
   SpaceAdmissionRequest,
   SpaceHostService
 } from '@dxos/protocols/proto/dxos/halo/invitations';
-import { ExtensionContext } from '@dxos/teleport';
+import { ExtensionContext, RpcExtension } from '@dxos/teleport';
 
+import { DataSpace } from '../spaces/data-space';
+import { DataSpaceManager } from '../spaces/data-space-manager';
 import {
   AuthenticatingInvitationProvider,
   AUTHENTICATION_CODE_LENGTH,
@@ -35,7 +37,6 @@ import {
   ON_CLOSE_DELAY
 } from './invitations';
 import { AbstractInvitationsHandler, InvitationsOptions } from './invitations-handler';
-import { RpcExtension } from './rpc-extension';
 
 const MAX_OTP_ATTEMPTS = 3;
 
@@ -43,10 +44,10 @@ const MAX_OTP_ATTEMPTS = 3;
  * Handles the life-cycle of Space invitations between peers.
  */
 // TODO(dmaretskyi): Split into Host and Guest parts.
-export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
+export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpace> {
   constructor(
     networkManager: NetworkManager,
-    private readonly _spaceManager: SpaceManager,
+    private readonly _spaceManager: DataSpaceManager,
     private readonly _signingContext: SigningContext,
     private readonly _keyring: Keyring
   ) {
@@ -56,7 +57,7 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
   /**
    * Creates an invitation and listens for a join request from the invited (guest) peer.
    */
-  createInvitation(space: Space, options?: InvitationsOptions): CancellableInvitationObservable {
+  createInvitation(space: DataSpace, options?: InvitationsOptions): CancellableInvitationObservable {
     let swarmConnection: SwarmConnection | undefined;
     const { type, timeout = INVITATION_TIMEOUT, swarmKey } = options ?? {};
     assert(type !== Invitation.Type.OFFLINE);
@@ -141,7 +142,7 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
               space.key,
               controlFeedKey,
               dataFeedKey,
-              space.genesisFeedKey,
+              space.inner.genesisFeedKey,
               guestProfile
             );
 
@@ -150,7 +151,7 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
             const spaceMemberCredential = credentials[0].credential;
             assert(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
 
-            await writeMessages(space.controlPipeline.writer, credentials);
+            await writeMessages(space.inner.controlPipeline.writer, credentials);
 
             // Updating credentials complete.
             complete.wake(deviceKey);

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

@@ -24,23 +24,23 @@ describe('services/space-invitation-service', () => {
   test('creates space and invites peer', async () => {
     const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
-    assert(host.spaceManager);
+    assert(host.dataSpaceManager);
     assert(host.spaceInvitations);
     const service1: SpaceInvitationsService = new SpaceInvitationsServiceImpl(
       host.identityManager,
       () => host.spaceInvitations!,
-      () => host.spaceManager!
+      () => host.dataSpaceManager!
     );
 
-    assert(guest.spaceManager);
+    assert(guest.dataSpaceManager);
     assert(guest.spaceInvitations);
     const service2: SpaceInvitationsService = new SpaceInvitationsServiceImpl(
       guest.identityManager,
       () => guest.spaceInvitations!,
-      () => guest.spaceManager!
+      () => guest.dataSpaceManager!
     );
 
-    const space1 = await host.spaceManager.createSpace();
+    const space1 = await host.dataSpaceManager.createSpace();
 
     const success1 = new Trigger<Invitation>();
     const success2 = new Trigger<Invitation>();
@@ -85,23 +85,23 @@ describe('services/space-invitation-service', () => {
   test('creates space and cancels invitation', async () => {
     const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
-    assert(host.spaceManager);
+    assert(host.dataSpaceManager);
     assert(host.spaceInvitations);
     const service1: SpaceInvitationsService = new SpaceInvitationsServiceImpl(
       host.identityManager,
       () => host.spaceInvitations!,
-      () => host.spaceManager!
+      () => host.dataSpaceManager!
     );
 
-    assert(guest.spaceManager);
+    assert(guest.dataSpaceManager);
     assert(guest.spaceInvitations);
     const service2: SpaceInvitationsService = new SpaceInvitationsServiceImpl(
       guest.identityManager,
       () => guest.spaceInvitations!,
-      () => guest.spaceManager!
+      () => guest.dataSpaceManager!
     );
 
-    const space1 = await host.spaceManager.createSpace();
+    const space1 = await host.dataSpaceManager.createSpace();
     const cancelled = new Trigger();
 
     {

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

@@ -4,28 +4,29 @@
 
 import assert from 'node:assert';
 
-import { Space, SpaceManager } from '@dxos/echo-db';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { Provider } from '@dxos/util';
 
 import { IdentityManager } from '../identity';
+import { DataSpace } from '../spaces/data-space';
+import { DataSpaceManager } from '../spaces/data-space-manager';
 import { InvitationsHandler } from './invitations-handler';
 import { AbstractInvitationsService } from './invitations-service';
 
 /**
  * Adapts invitation service observable to client/service stream.
  */
-export class SpaceInvitationsServiceImpl extends AbstractInvitationsService<Space> {
+export class SpaceInvitationsServiceImpl extends AbstractInvitationsService<DataSpace> {
   // prettier-ignore
   constructor (
     identityManager: IdentityManager,
-    private readonly invitationsHandler: Provider<InvitationsHandler<Space>>,
-    private readonly _getSpaceManager: Provider<SpaceManager>
+    private readonly invitationsHandler: Provider<InvitationsHandler<DataSpace>>,
+    private readonly _getSpaceManager: Provider<DataSpaceManager>
   ) {
     super(identityManager, invitationsHandler);
   }
 
-  override getContext(invitation: Invitation): Space {
+  override getContext(invitation: Invitation): DataSpace {
     assert(invitation.spaceKey);
     const spaceManager = this._getSpaceManager();
     const space = spaceManager.spaces.get(invitation.spaceKey!);

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

@@ -23,6 +23,7 @@ import { Storage } from '@dxos/random-access-storage';
 
 import { CreateIdentityOptions, IdentityManager } from '../identity';
 import { HaloInvitationsHandler, SpaceInvitationsHandler } from '../invitations';
+import { DataSpaceManager } from '../spaces/data-space-manager';
 
 /**
  * Shared backend for all client services.
@@ -35,11 +36,12 @@ export class ServiceContext {
   public readonly metadataStore: MetadataStore;
   public readonly feedStore: FeedStore<FeedMessage>;
   public readonly keyring: Keyring;
+  public readonly spaceManager: SpaceManager;
   public readonly identityManager: IdentityManager;
   public readonly haloInvitations: HaloInvitationsHandler;
 
   // Initialized after identity is initialized.
-  public spaceManager?: SpaceManager;
+  public dataSpaceManager?: DataSpaceManager;
   public spaceInvitations?: SpaceInvitationsHandler;
 
   // prettier-ignore
@@ -60,13 +62,14 @@ export class ServiceContext {
         }
       })
     });
-
+    this.spaceManager = new SpaceManager({
+      feedStore: this.feedStore,
+      networkManager: this.networkManager
+    });
     this.identityManager = new IdentityManager(
       this.metadataStore,
-      this.feedStore,
       this.keyring,
-      networkManager,
-      modelFactory
+      this.spaceManager
     );
 
     // TODO(burdon): _initialize called in multiple places.
@@ -76,6 +79,7 @@ export class ServiceContext {
 
   async open() {
     log('opening...');
+    await this.spaceManager.open();
     await this.identityManager.open();
     if (this.identityManager.identity) {
       await this._initialize();
@@ -85,8 +89,9 @@ export class ServiceContext {
 
   async close() {
     log('closing...');
+    await this.dataSpaceManager?.close();
     await this.identityManager.close();
-    await this.spaceManager?.close();
+    await this.spaceManager.close();
     await this.feedStore.close();
     await this.networkManager.close();
     this.dataServiceSubscriptions.clear();
@@ -103,7 +108,6 @@ export class ServiceContext {
   async createIdentity(params: CreateIdentityOptions = {}) {
     const identity = await this.identityManager.createIdentity(params);
 
-    this.dataServiceSubscriptions.registerSpace(identity.haloSpaceKey, identity.haloDatabase.createDataServiceHost());
     await this._initialize();
     return identity;
   }
@@ -120,22 +124,18 @@ export class ServiceContext {
       profile: identity.profileDocument
     };
 
-    // Create in constructor (avoid all of these private variables).
-    const spaceManager = new SpaceManager({
-      metadataStore: this.metadataStore,
-      feedStore: this.feedStore,
-      networkManager: this.networkManager,
-      keyring: this.keyring,
-      dataServiceSubscriptions: this.dataServiceSubscriptions,
-      modelFactory: this.modelFactory,
-      signingContext
-    });
-
-    await spaceManager.open();
-    this.spaceManager = spaceManager;
+    this.dataSpaceManager = new DataSpaceManager(
+      this.spaceManager,
+      this.metadataStore,
+      this.dataServiceSubscriptions,
+      this.keyring,
+      signingContext,
+      this.modelFactory
+    );
+    await this.dataSpaceManager.open();
     this.spaceInvitations = new SpaceInvitationsHandler(
       this.networkManager,
-      this.spaceManager,
+      this.dataSpaceManager,
       signingContext,
       this.keyring
     );

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

@@ -99,7 +99,7 @@ export class ClientServicesHost implements ClientServicesProvider {
       SpaceInvitationsService: new SpaceInvitationsServiceImpl(
         this._serviceContext.identityManager,
         () => this._serviceContext.spaceInvitations ?? raise(new Error('SpaceInvitations not initialized')),
-        () => this._serviceContext.spaceManager ?? raise(new Error('SpaceManager not initialized'))
+        () => this._serviceContext.dataSpaceManager ?? raise(new Error('SpaceManager not initialized'))
       ),
 
       SpacesService: new SpacesServiceImpl(),

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

@@ -31,15 +31,15 @@ describe('service registry', () => {
     await serviceContext.open();
     await serviceContext.createIdentity();
 
-    assert(serviceContext.spaceManager);
+    assert(serviceContext.dataSpaceManager);
     assert(serviceContext.spaceInvitations);
-    const space = await serviceContext.spaceManager.createSpace();
+    const space = await serviceContext.dataSpaceManager.createSpace();
 
     const serviceRegistry = new ServiceRegistry(serviceBundle, {
       SpaceInvitationsService: new SpaceInvitationsServiceImpl(
         serviceContext.identityManager,
         () => serviceContext.spaceInvitations!,
-        () => serviceContext.spaceManager!
+        () => serviceContext.dataSpaceManager!
       )
     });
 

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

@@ -0,0 +1,118 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Event, synchronized } from '@dxos/async';
+import {
+  AcceptSpaceOptions,
+  DataServiceSubscriptions,
+  MetadataStore,
+  SigningContext,
+  Space,
+  SpaceManager,
+  spaceGenesis
+} from '@dxos/echo-db';
+import { Keyring } from '@dxos/keyring';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { ModelFactory } from '@dxos/model-factory';
+import { SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { Presence } from '@dxos/teleport-extension-presence';
+import { ComplexMap } from '@dxos/util';
+
+import { DataSpace } from './data-space';
+
+export class DataSpaceManager {
+  public readonly updated = new Event();
+
+  private readonly _spaces = new ComplexMap<PublicKey, DataSpace>(PublicKey.hash);
+
+  constructor(
+    private readonly _spaceManager: SpaceManager,
+    private readonly _metadataStore: MetadataStore,
+    private readonly _dataServiceSubscriptions: DataServiceSubscriptions,
+    private readonly _keyring: Keyring,
+    private readonly _signingContext: SigningContext,
+    private readonly _modelFactory: ModelFactory
+  ) {}
+
+  // TODO(burdon): Remove.
+  get spaces() {
+    return this._spaces;
+  }
+
+  @synchronized
+  async open() {
+    await this._metadataStore.load();
+
+    for (const spaceMetadata of this._metadataStore.spaces) {
+      await this._constructSpace(spaceMetadata);
+    }
+  }
+
+  @synchronized
+  async close() {}
+
+  /**
+   * Creates a new space writing the genesis credentials to the control feed.
+   */
+  async createSpace() {
+    const spaceKey = await this._keyring.createKey();
+    const controlFeedKey = await this._keyring.createKey();
+    const dataFeedKey = await this._keyring.createKey();
+    const metadata: SpaceMetadata = {
+      key: spaceKey,
+      genesisFeedKey: controlFeedKey,
+      controlFeedKey,
+      dataFeedKey
+    };
+
+    log('creating space...', { spaceKey });
+    const space = await this._constructSpace(metadata);
+
+    await spaceGenesis(this._keyring, this._signingContext, space.inner);
+    await this._metadataStore.addSpace(metadata);
+
+    this.updated.emit();
+    return space;
+  }
+
+  // TODO(burdon): Rename join space.
+  async acceptSpace(opts: AcceptSpaceOptions): Promise<DataSpace> {
+    const metadata: SpaceMetadata = {
+      key: opts.spaceKey,
+      genesisFeedKey: opts.genesisFeedKey,
+      controlFeedKey: opts.controlFeedKey,
+      dataFeedKey: opts.dataFeedKey
+    };
+
+    const space = await this._constructSpace(metadata);
+    await this._metadataStore.addSpace(metadata);
+    this.updated.emit();
+    return space;
+  }
+
+  private async _constructSpace(metadata: SpaceMetadata) {
+    const presence = new Presence({
+      localPeerId: this._signingContext.deviceKey,
+      announceInterval: 1_000,
+      offlineTimeout: 30_000,
+      identityKey: this._signingContext.identityKey
+    });
+    const space: Space = await this._spaceManager.constructSpace({
+      metadata,
+      swarmIdentity: {
+        peerKey: this._signingContext.deviceKey,
+        credentialProvider: this._signingContext.credentialProvider,
+        credentialAuthenticator: this._signingContext.credentialAuthenticator
+      },
+      dataPipelineControllerProvider: () => dataSpace.dataPipelineController,
+      presence
+    });
+    const dataSpace = new DataSpace(space, this._modelFactory, this._signingContext.identityKey, presence);
+    await space.open();
+    this._dataServiceSubscriptions.registerSpace(space.key, dataSpace.database.createDataServiceHost());
+    this._spaces.set(metadata.key, dataSpace);
+    return dataSpace;
+  }
+}

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

@@ -0,0 +1,66 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { Context } from '@dxos/context';
+import { Database, DataPipelineControllerImpl, ISpace, Space } from '@dxos/echo-db';
+import { PublicKey } from '@dxos/keys';
+import { ModelFactory } from '@dxos/model-factory';
+import { Presence } from '@dxos/teleport-extension-presence';
+
+export class DataSpace implements ISpace {
+  private readonly _ctx = new Context();
+  private readonly _dataPipelineController: DataPipelineControllerImpl;
+
+  constructor(
+    private readonly _inner: Space,
+    private readonly _modelFactory: ModelFactory,
+    private readonly _memberKey: PublicKey,
+    private readonly _presence: Presence
+  ) {
+    this._dataPipelineController = new DataPipelineControllerImpl(_modelFactory, _memberKey, (feedKey) =>
+      _inner.spaceState.feeds.get(feedKey)
+    );
+  }
+
+  get key() {
+    return this._inner.key;
+  }
+
+  get inner() {
+    return this._inner;
+  }
+
+  get isOpen() {
+    return this._inner.isOpen;
+  }
+
+  get dataPipelineController(): DataPipelineControllerImpl {
+    return this._dataPipelineController;
+  }
+
+  get database(): Database {
+    assert(this._dataPipelineController.database);
+    return this._dataPipelineController.database;
+  }
+
+  get stateUpdate() {
+    return this._inner.stateUpdate;
+  }
+
+  get presence() {
+    return this._presence;
+  }
+
+  async open() {
+    await this._inner.open();
+  }
+
+  async close() {
+    await this._ctx.dispose();
+    await this._inner.close();
+    await this._presence.destroy();
+  }
+}

package/dist/types/src/packlets/invitations/rpc-extension.d.ts

@@ -1,17 +0,0 @@
-import { ProtoRpcPeerOptions } from '@dxos/rpc';
-import { ExtensionContext, TeleportExtension } from '@dxos/teleport';
-export declare abstract class RpcExtension<Client, Server> implements TeleportExtension {
-    private readonly _params;
-    private _extensionContext;
-    private _rpc;
-    constructor(_params: Omit<ProtoRpcPeerOptions<Client, Server>, 'port' | 'handlers'>);
-    get initiator(): boolean;
-    get localPeerId(): import("@dxos/keys").PublicKey;
-    get remotePeerId(): import("@dxos/keys").PublicKey;
-    get rpc(): Client;
-    protected abstract getHandlers(): Promise<Server>;
-    onOpen(context: ExtensionContext): Promise<void>;
-    onClose(err?: Error | undefined): Promise<void>;
-    close(): void;
-}
-//# sourceMappingURL=rpc-extension.d.ts.map

package/dist/types/src/packlets/invitations/rpc-extension.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rpc-extension.d.ts","sourceRoot":"","sources":["../../../../../src/packlets/invitations/rpc-extension.ts"],"names":[],"mappings":"AAIA,OAAO,EAAoC,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAClF,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAErE,8BAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAE,YAAW,iBAAiB;IAIjE,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,IAAI,CAAwB;gBAEP,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAEpG,IAAI,SAAS,YAEZ;IAED,IAAI,WAAW,mCAEd;IAED,IAAI,YAAY,mCAEf;IAED,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED,SAAS,CAAC,QAAQ,CAAC,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;IAE3C,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBhD,OAAO,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrD,KAAK;CAGN"}

package/src/packlets/invitations/rpc-extension.ts

@@ -1,56 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import { createProtoRpcPeer, ProtoRpcPeer, ProtoRpcPeerOptions } from '@dxos/rpc';
-import { ExtensionContext, TeleportExtension } from '@dxos/teleport';
-
-export abstract class RpcExtension<Client, Server> implements TeleportExtension {
-  private _extensionContext!: ExtensionContext;
-  private _rpc!: ProtoRpcPeer<Client>;
-
-  constructor(private readonly _params: Omit<ProtoRpcPeerOptions<Client, Server>, 'port' | 'handlers'>) {}
-
-  get initiator() {
-    return this._extensionContext.initiator;
-  }
-
-  get localPeerId() {
-    return this._extensionContext.localPeerId;
-  }
-
-  get remotePeerId() {
-    return this._extensionContext.remotePeerId;
-  }
-
-  get rpc(): Client {
-    return this._rpc.rpc;
-  }
-
-  protected abstract getHandlers(): Promise<Server>;
-
-  async onOpen(context: ExtensionContext): Promise<void> {
-    this._extensionContext = context;
-
-    const handlers = await this.getHandlers();
-
-    const port = context.createPort('rpc', {
-      contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
-    });
-    this._rpc = createProtoRpcPeer({
-      ...this._params,
-      handlers,
-      port
-    });
-
-    await this._rpc.open();
-  }
-
-  async onClose(err?: Error | undefined): Promise<void> {
-    await this._rpc.close();
-  }
-
-  close() {
-    this._extensionContext.close();
-  }
-}