@dxos/client-services 0.5.9-main.bdf733d → 0.5.9-main.bf0ae3e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/client-services",
-  "version": "0.5.9-main.bdf733d",
+  "version": "0.5.9-main.bf0ae3e",
   "description": "DXOS client services implementation",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -23,45 +23,45 @@
   ],
   "dependencies": {
     "platform": "^1.3.6",
-    "@dxos/async": "0.5.9-main.bdf733d",
-    "@dxos/client-protocol": "0.5.9-main.bdf733d",
-    "@dxos/codec-protobuf": "0.5.9-main.bdf733d",
-    "@dxos/config": "0.5.9-main.bdf733d",
-    "@dxos/automerge": "0.5.9-main.bdf733d",
-    "@dxos/context": "0.5.9-main.bdf733d",
-    "@dxos/credentials": "0.5.9-main.bdf733d",
-    "@dxos/debug": "0.5.9-main.bdf733d",
-    "@dxos/crypto": "0.5.9-main.bdf733d",
-    "@dxos/echo-db": "0.5.9-main.bdf733d",
-    "@dxos/echo-pipeline": "0.5.9-main.bdf733d",
-    "@dxos/echo-protocol": "0.5.9-main.bdf733d",
-    "@dxos/echo-schema": "0.5.9-main.bdf733d",
-    "@dxos/feed-store": "0.5.9-main.bdf733d",
-    "@dxos/indexing": "0.5.9-main.bdf733d",
-    "@dxos/keyring": "0.5.9-main.bdf733d",
-    "@dxos/invariant": "0.5.9-main.bdf733d",
-    "@dxos/keys": "0.5.9-main.bdf733d",
-    "@dxos/kv-store": "0.5.9-main.bdf733d",
-    "@dxos/lock-file": "0.5.9-main.bdf733d",
-    "@dxos/log": "0.5.9-main.bdf733d",
-    "@dxos/messaging": "0.5.9-main.bdf733d",
-    "@dxos/network-manager": "0.5.9-main.bdf733d",
-    "@dxos/node-std": "0.5.9-main.bdf733d",
-    "@dxos/protocols": "0.5.9-main.bdf733d",
-    "@dxos/random-access-storage": "0.5.9-main.bdf733d",
-    "@dxos/teleport": "0.5.9-main.bdf733d",
-    "@dxos/rpc": "0.5.9-main.bdf733d",
-    "@dxos/teleport-extension-gossip": "0.5.9-main.bdf733d",
-    "@dxos/teleport-extension-object-sync": "0.5.9-main.bdf733d",
-    "@dxos/timeframe": "0.5.9-main.bdf733d",
-    "@dxos/util": "0.5.9-main.bdf733d",
-    "@dxos/tracing": "0.5.9-main.bdf733d",
-    "@dxos/websocket-rpc": "0.5.9-main.bdf733d"
+    "@dxos/async": "0.5.9-main.bf0ae3e",
+    "@dxos/client-protocol": "0.5.9-main.bf0ae3e",
+    "@dxos/codec-protobuf": "0.5.9-main.bf0ae3e",
+    "@dxos/config": "0.5.9-main.bf0ae3e",
+    "@dxos/context": "0.5.9-main.bf0ae3e",
+    "@dxos/credentials": "0.5.9-main.bf0ae3e",
+    "@dxos/automerge": "0.5.9-main.bf0ae3e",
+    "@dxos/debug": "0.5.9-main.bf0ae3e",
+    "@dxos/crypto": "0.5.9-main.bf0ae3e",
+    "@dxos/echo-pipeline": "0.5.9-main.bf0ae3e",
+    "@dxos/echo-db": "0.5.9-main.bf0ae3e",
+    "@dxos/echo-protocol": "0.5.9-main.bf0ae3e",
+    "@dxos/echo-schema": "0.5.9-main.bf0ae3e",
+    "@dxos/feed-store": "0.5.9-main.bf0ae3e",
+    "@dxos/indexing": "0.5.9-main.bf0ae3e",
+    "@dxos/invariant": "0.5.9-main.bf0ae3e",
+    "@dxos/keyring": "0.5.9-main.bf0ae3e",
+    "@dxos/keys": "0.5.9-main.bf0ae3e",
+    "@dxos/kv-store": "0.5.9-main.bf0ae3e",
+    "@dxos/lock-file": "0.5.9-main.bf0ae3e",
+    "@dxos/log": "0.5.9-main.bf0ae3e",
+    "@dxos/messaging": "0.5.9-main.bf0ae3e",
+    "@dxos/network-manager": "0.5.9-main.bf0ae3e",
+    "@dxos/node-std": "0.5.9-main.bf0ae3e",
+    "@dxos/protocols": "0.5.9-main.bf0ae3e",
+    "@dxos/random-access-storage": "0.5.9-main.bf0ae3e",
+    "@dxos/rpc": "0.5.9-main.bf0ae3e",
+    "@dxos/teleport": "0.5.9-main.bf0ae3e",
+    "@dxos/teleport-extension-gossip": "0.5.9-main.bf0ae3e",
+    "@dxos/teleport-extension-object-sync": "0.5.9-main.bf0ae3e",
+    "@dxos/timeframe": "0.5.9-main.bf0ae3e",
+    "@dxos/tracing": "0.5.9-main.bf0ae3e",
+    "@dxos/util": "0.5.9-main.bf0ae3e",
+    "@dxos/websocket-rpc": "0.5.9-main.bf0ae3e"
   },
   "devDependencies": {
     "@types/platform": "^1.3.4",
     "@types/readable-stream": "^2.3.9",
-    "@dxos/signal": "0.5.9-main.bdf733d"
+    "@dxos/signal": "0.5.9-main.bf0ae3e"
   },
   "publishConfig": {
     "access": "public"

package/src/packlets/identity/default-space-state-machine.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { type CredentialProcessor, getCredentialAssertion } from '@dxos/credentials';
+import { SpaceId, type PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+
+type DefaultSpaceStateMachineParams = {
+  identityKey: PublicKey;
+  onUpdate?: () => void;
+};
+
+/**
+ * Processes device invitation credentials.
+ */
+export class DefaultSpaceStateMachine implements CredentialProcessor {
+  private _spaceId: SpaceId | undefined;
+
+  constructor(private readonly _params: DefaultSpaceStateMachineParams) {}
+
+  public get spaceId(): SpaceId | undefined {
+    return this._spaceId;
+  }
+
+  async processCredential(credential: Credential) {
+    const assertion = getCredentialAssertion(credential);
+    switch (assertion['@type']) {
+      case 'dxos.halo.credentials.DefaultSpace': {
+        if (!credential.subject.id.equals(this._params.identityKey)) {
+          log.warn('Invalid default space credential', { expectedIdentity: this._params.identityKey, credential });
+          return;
+        }
+        if (!SpaceId.isValid(assertion.spaceId)) {
+          log.warn('Invalid default space id', { id: assertion.spaceId });
+          return;
+        }
+        this._spaceId = assertion.spaceId;
+        break;
+      }
+    }
+  }
+}

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

@@ -24,11 +24,7 @@ describe('IdentityService', () => {
   beforeEach(async () => {
     serviceContext = await createServiceContext();
     await serviceContext.open(new Context());
-    identityService = new IdentityServiceImpl(
-      (options) => serviceContext.createIdentity(options),
-      serviceContext.identityManager,
-      serviceContext.keyring,
-    );
+    identityService = createIdentityService(serviceContext);
   });
 
   afterEach(async () => {
@@ -95,3 +91,37 @@ describe('IdentityService', () => {
     });
   });
 });
+
+describe('open', () => {
+  test('identity without default space fixed', async () => {
+    const serviceContext = await createServiceContext();
+    await serviceContext.open(new Context());
+    const identity = await serviceContext.createIdentity();
+    const identityService = createIdentityService(serviceContext);
+    const getDataSpaces = () => [...(serviceContext.dataSpaceManager?.spaces?.values() ?? [])];
+    expect(getDataSpaces().length).to.eq(0);
+    expect(identity.defaultSpaceId).to.be.undefined;
+    await identityService.open();
+    expect(getDataSpaces()[0].id === identity.defaultSpaceId).to.be.true;
+  });
+
+  test('identity without default space credential fixed', async () => {
+    const serviceContext = await createServiceContext();
+    await serviceContext.open(new Context());
+    const identity = await serviceContext.createIdentity();
+    const space = await serviceContext.dataSpaceManager!.createDefaultSpace();
+    const identityService = createIdentityService(serviceContext);
+    expect(identity.defaultSpaceId).to.be.undefined;
+    await identityService.open();
+    expect(identity.defaultSpaceId === space.id).to.be.true;
+  });
+});
+
+const createIdentityService = (serviceContext: ServiceContext) => {
+  return new IdentityServiceImpl(
+    serviceContext.identityManager,
+    serviceContext.keyring,
+    () => serviceContext.dataSpaceManager!,
+    (options) => serviceContext.createIdentity(options),
+  );
+};

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

@@ -3,36 +3,59 @@
 //
 
 import { Stream } from '@dxos/codec-protobuf';
+import { Resource } from '@dxos/context';
 import { signPresentation } from '@dxos/credentials';
 import { todo } from '@dxos/debug';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import {
   type CreateIdentityRequest,
-  type Identity,
+  type Identity as IdentityProto,
   type IdentityService,
   type QueryIdentityResponse,
   type RecoverIdentityRequest,
   type SignPresentationRequest,
+  SpaceState,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Presentation, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 
+import { type Identity } from './identity';
 import { type CreateIdentityOptions, type IdentityManager } from './identity-manager';
+import { type DataSpaceManager } from '../spaces';
 
-export class IdentityServiceImpl implements IdentityService {
+export class IdentityServiceImpl extends Resource implements IdentityService {
   constructor(
-    private readonly _createIdentity: (params: CreateIdentityOptions) => Promise<Identity>,
     private readonly _identityManager: IdentityManager,
     private readonly _keyring: Keyring,
+    private readonly _dataSpaceManagerProvider: () => DataSpaceManager,
+    private readonly _createIdentity: (params: CreateIdentityOptions) => Promise<Identity>,
     private readonly _onProfileUpdate?: (profile: ProfileDocument | undefined) => Promise<void>,
-  ) {}
+  ) {
+    super();
+  }
+
+  protected override async _open() {
+    const identity = this._identityManager.identity;
+    if (identity && !identity.defaultSpaceId) {
+      await this._fixIdentityWithoutDefaultSpace(identity);
+    }
+  }
 
-  async createIdentity(request: CreateIdentityRequest): Promise<Identity> {
+  async createIdentity(request: CreateIdentityRequest): Promise<IdentityProto> {
     await this._createIdentity({ displayName: request.profile?.displayName, deviceProfile: request.deviceProfile });
+    const dataSpaceManager = this._dataSpaceManagerProvider();
+    await this._createDefaultSpace(dataSpaceManager);
     return this._getIdentity()!;
   }
 
-  async recoverIdentity(request: RecoverIdentityRequest): Promise<Identity> {
+  private async _createDefaultSpace(dataSpaceManager: DataSpaceManager) {
+    const space = await dataSpaceManager!.createDefaultSpace();
+    const identity = this._identityManager.identity;
+    invariant(identity);
+    await identity.updateDefaultSpace(space.id);
+  }
+
+  async recoverIdentity(request: RecoverIdentityRequest): Promise<IdentityProto> {
     return todo();
   }
 
@@ -45,7 +68,7 @@ export class IdentityServiceImpl implements IdentityService {
     });
   }
 
-  private _getIdentity(): Identity | undefined {
+  private _getIdentity(): IdentityProto | undefined {
     if (!this._identityManager.identity) {
       return undefined;
     }
@@ -57,7 +80,7 @@ export class IdentityServiceImpl implements IdentityService {
     };
   }
 
-  async updateProfile(profile: ProfileDocument): Promise<Identity> {
+  async updateProfile(profile: ProfileDocument): Promise<IdentityProto> {
     invariant(this._identityManager.identity, 'Identity not initialized.');
     await this._identityManager.updateProfile(profile);
     await this._onProfileUpdate?.(this._identityManager.identity.profileDocument);
@@ -75,4 +98,23 @@ export class IdentityServiceImpl implements IdentityService {
       nonce,
     });
   }
+
+  private async _fixIdentityWithoutDefaultSpace(identity: Identity) {
+    let hasDefaultSpace = false;
+    const dataSpaceManager = this._dataSpaceManagerProvider();
+    for (const space of dataSpaceManager.spaces.values()) {
+      if (space.state === SpaceState.CLOSED) {
+        await space.open();
+        await space.initializeDataPipeline();
+      }
+      if (await dataSpaceManager.isDefaultSpace(space)) {
+        await identity.updateDefaultSpace(space.id);
+        hasDefaultSpace = true;
+        break;
+      }
+    }
+    if (!hasDefaultSpace) {
+      await this._createDefaultSpace(dataSpaceManager);
+    }
+  }
 }

package/src/packlets/identity/identity.ts

@@ -16,7 +16,7 @@ import { type Signer } from '@dxos/crypto';
 import { type Space } from '@dxos/echo-pipeline';
 import { writeMessages } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
-import { PublicKey } from '@dxos/keys';
+import { PublicKey, type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import {
@@ -26,10 +26,12 @@ import {
 } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type DeviceAdmissionRequest } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { type Presence } from '@dxos/teleport-extension-gossip';
+import { Timeframe } from '@dxos/timeframe';
 import { trace } from '@dxos/tracing';
 import { type ComplexMap, ComplexSet } from '@dxos/util';
 
 import { TrustedKeySetAuthVerifier } from './authenticator';
+import { DefaultSpaceStateMachine } from './default-space-state-machine';
 
 export type IdentityParams = {
   identityKey: PublicKey;
@@ -49,6 +51,7 @@ export class Identity {
   private readonly _presence?: Presence;
   private readonly _deviceStateMachine: DeviceStateMachine;
   private readonly _profileStateMachine: ProfileStateMachine;
+  private readonly _defaultSpaceStateMachine: DefaultSpaceStateMachine;
   public readonly authVerifier: TrustedKeySetAuthVerifier;
 
   public readonly identityKey: PublicKey;
@@ -75,6 +78,10 @@ export class Identity {
       identityKey: this.identityKey,
       onUpdate: () => this.stateUpdate.emit(),
     });
+    this._defaultSpaceStateMachine = new DefaultSpaceStateMachine({
+      identityKey: this.identityKey,
+      onUpdate: () => this.stateUpdate.emit(),
+    });
 
     this.authVerifier = new TrustedKeySetAuthVerifier({
       trustedKeysProvider: () => new ComplexSet(PublicKey.hash, this.authorizedDeviceKeys.keys()),
@@ -88,17 +95,24 @@ export class Identity {
     return this._deviceStateMachine.authorizedDeviceKeys;
   }
 
+  get defaultSpaceId(): SpaceId | undefined {
+    return this._defaultSpaceStateMachine.spaceId;
+  }
+
   @trace.span()
   async open(ctx: Context) {
+    await this._presence?.open();
     await this.space.spaceState.addCredentialProcessor(this._deviceStateMachine);
     await this.space.spaceState.addCredentialProcessor(this._profileStateMachine);
+    await this.space.spaceState.addCredentialProcessor(this._defaultSpaceStateMachine);
     await this.space.open(ctx);
   }
 
   @trace.span()
   async close(ctx: Context) {
-    await this._presence?.destroy();
+    await this._presence?.close();
     await this.authVerifier.close();
+    await this.space.spaceState.removeCredentialProcessor(this._defaultSpaceStateMachine);
     await this.space.spaceState.removeCredentialProcessor(this._profileStateMachine);
     await this.space.spaceState.removeCredentialProcessor(this._deviceStateMachine);
     await this.space.close();
@@ -157,6 +171,15 @@ export class Identity {
     return createCredentialSignerWithKey(this._signer, this.deviceKey);
   }
 
+  async updateDefaultSpace(spaceId: SpaceId) {
+    const credential = await this.getDeviceCredentialSigner().createCredential({
+      subject: this.identityKey,
+      assertion: { '@type': 'dxos.halo.credentials.DefaultSpace', spaceId },
+    });
+    const receipt = await this.controlPipeline.writer.write({ credential: { credential } });
+    await this.controlPipeline.state.waitUntilTimeframe(new Timeframe([[receipt.feedKey, receipt.seq]]));
+  }
+
   async admitDevice({ deviceKey, controlFeedKey, dataFeedKey }: DeviceAdmissionRequest) {
     log('Admitting device:', {
       identityKey: this.identityKey,

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

@@ -120,10 +120,7 @@ export class ServiceContext extends Resource {
       this._runtimeParams as IdentityManagerRuntimeParams,
     );
 
-    this.echoHost = new EchoHost({
-      kv: this.level,
-      storage: this.storage,
-    });
+    this.echoHost = new EchoHost({ kv: this.level });
 
     this.invitations = new InvitationsHandler(this.networkManager, _runtimeParams?.invitationConnectionDefaultParams);
     this.invitationsManager = new InvitationsManager(

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

@@ -3,11 +3,9 @@
 //
 
 import { Event, synchronized } from '@dxos/async';
-import { clientServiceBundle, defaultKey, type ClientServices, PropertiesType } from '@dxos/client-protocol';
+import { clientServiceBundle, type ClientServices } from '@dxos/client-protocol';
 import { type Config } from '@dxos/config';
 import { Context } from '@dxos/context';
-import { type ObjectStructure, encodeReference, type SpaceDoc } from '@dxos/echo-protocol';
-import { getTypeReference } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { type LevelDB } from '@dxos/kv-store';
@@ -18,7 +16,6 @@ import { trace } from '@dxos/protocols';
 import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { type Storage } from '@dxos/random-access-storage';
 import { TRACE_PROCESSOR, trace as Trace } from '@dxos/tracing';
-import { assignDeep } from '@dxos/util';
 import { WebsocketRpcClient } from '@dxos/websocket-rpc';
 
 import { ServiceContext, type ServiceContextRuntimeParams } from './service-context';
@@ -86,7 +83,7 @@ export class ClientServicesHost {
   private _devtoolsProxy?: WebsocketRpcClient<{}, ClientServices>;
 
   private _serviceContext!: ServiceContext;
-  private readonly _runtimeParams?: ServiceContextRuntimeParams;
+  private readonly _runtimeParams: ServiceContextRuntimeParams;
   private diagnosticsBroadcastHandler: CollectDiagnosticsBroadcastHandler;
 
   @Trace.info()
@@ -109,7 +106,7 @@ export class ClientServicesHost {
     this._storage = storage;
     this._level = level;
     this._callbacks = callbacks;
-    this._runtimeParams = runtimeParams;
+    this._runtimeParams = runtimeParams ?? {};
 
     if (config) {
       this.initialize({ config, transportFactory, signalManager });
@@ -254,15 +251,17 @@ export class ClientServicesHost {
       this._runtimeParams,
     );
 
+    const identityService = new IdentityServiceImpl(
+      this._serviceContext.identityManager,
+      this._serviceContext.keyring,
+      () => this._serviceContext.dataSpaceManager!,
+      (params) => this._createIdentity(params),
+      (profile) => this._serviceContext.broadcastProfileUpdate(profile),
+    );
+
     this._serviceRegistry.setServices({
       SystemService: this._systemService,
-
-      IdentityService: new IdentityServiceImpl(
-        (params) => this._createIdentity(params),
-        this._serviceContext.identityManager,
-        this._serviceContext.keyring,
-        (profile) => this._serviceContext.broadcastProfileUpdate(profile),
-      ),
+      IdentityService: identityService,
 
       InvitationsService: new InvitationsServiceImpl(this._serviceContext.invitationsManager),
 
@@ -294,6 +293,7 @@ export class ClientServicesHost {
     });
 
     await this._serviceContext.open(ctx);
+    await identityService.open();
 
     const devtoolsProxy = this._config?.get('runtime.client.devtoolsProxy');
     if (devtoolsProxy) {
@@ -349,34 +349,7 @@ export class ClientServicesHost {
 
   private async _createIdentity(params: CreateIdentityOptions) {
     const identity = await this._serviceContext.createIdentity(params);
-
-    // Setup default space.
     await this._serviceContext.initialized.wait();
-    const space = await this._serviceContext.dataSpaceManager!.createSpace();
-
-    const automergeIndex = space.automergeSpaceState.rootUrl;
-    invariant(automergeIndex);
-    const document = this._serviceContext.echoHost.automergeRepo.find<SpaceDoc>(automergeIndex as any);
-    await document.whenReady();
-
-    // TODO(dmaretskyi): Better API for low-level data access.
-    const properties: ObjectStructure = {
-      system: {
-        type: encodeReference(getTypeReference(PropertiesType)!),
-      },
-      data: {
-        [defaultKey]: identity.identityKey.toHex(),
-      },
-      meta: {
-        keys: [],
-      },
-    };
-    const propertiesId = PublicKey.random().toHex();
-    document.change((doc: SpaceDoc) => {
-      assignDeep(doc, ['objects', propertiesId], properties);
-    });
-
-    await this._serviceContext.echoHost.flush();
     return identity;
   }
 }

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

@@ -12,7 +12,7 @@ import { log } from '@dxos/log';
 import { SpaceState } from '@dxos/protocols/proto/dxos/client/services';
 import { describe, openAndClose, test } from '@dxos/test';
 
-import { TestBuilder } from '../testing';
+import { TestBuilder, type TestPeer } from '../testing';
 
 describe('DataSpaceManager', () => {
   test('create space', async () => {
@@ -168,5 +168,50 @@ describe('DataSpaceManager', () => {
         500,
       );
     });
+
+    test('activate opens a lazily loaded space', async () => {
+      const builder = new TestBuilder();
+
+      const peer = builder.createPeer();
+      await peer.createIdentity();
+      await openAndClose(peer.echoHost, peer.dataSpaceManager);
+
+      await peer.dataSpaceManager.createSpace();
+      await reloadDataSpaces(peer);
+
+      const space = getFirstSpace(peer);
+      expect(space.state).to.equal(SpaceState.CLOSED);
+      await space.activate();
+      await asyncTimeout(
+        space.stateUpdate.waitForCondition(() => space.state === SpaceState.READY),
+        500,
+      );
+    });
+
+    test('deactivate lazily loaded space ', async () => {
+      const builder = new TestBuilder();
+
+      const peer = builder.createPeer();
+      await peer.createIdentity();
+      await openAndClose(peer.echoHost, peer.dataSpaceManager);
+
+      await peer.dataSpaceManager.createSpace();
+      await reloadDataSpaces(peer);
+
+      await getFirstSpace(peer).deactivate();
+
+      await reloadDataSpaces(peer);
+
+      expect(getFirstSpace(peer).state).to.eq(SpaceState.INACTIVE);
+    });
   });
+
+  const reloadDataSpaces = async (peer: TestPeer) => {
+    await peer.dataSpaceManager.close();
+    await peer.dataSpaceManager.open();
+  };
+
+  const getFirstSpace = (peer: TestPeer) => {
+    return Array.from(peer.dataSpaceManager.spaces.values())[0];
+  };
 });