@dxos/client-services 0.1.23 → 0.1.24

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

@@ -7,14 +7,15 @@ import assert from 'node:assert';
 
 import { asyncChain, latch, Trigger } from '@dxos/async';
 import { raise } from '@dxos/debug';
+import { testLocalDatabase } from '@dxos/echo-db/testing';
 import { PublicKey } from '@dxos/keys';
-import { ObjectModel } from '@dxos/object-model';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { describe, test, afterTest } from '@dxos/test';
+import { afterTest, describe, test } from '@dxos/test';
 import { range } from '@dxos/util';
 
 import { ServiceContext } from '../services';
 import { createIdentity, createPeers, syncItems } from '../testing';
+import { performInvitation } from '../testing/invitation-utils';
 
 const closeAfterTest = async (peer: ServiceContext) => {
   afterTest(() => peer.close());
@@ -26,7 +27,6 @@ describe('services/space-invitations-handler', () => {
     const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
 
     const space = await peer.dataSpaceManager!.createSpace();
-    expect(space.database).not.to.be.undefined;
     expect(peer.dataSpaceManager!.spaces.has(space.key)).to.be.true;
     await space.close();
   });
@@ -34,18 +34,30 @@ describe('services/space-invitations-handler', () => {
   test('genesis with database mutations', async () => {
     const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
     const space = await peer.dataSpaceManager!.createSpace();
+    afterTest(() => space.close());
 
-    {
-      const item = await space.database!.createItem<ObjectModel>({ type: 'test' });
-      await item.model.set('name', 'test');
-    }
+    await testLocalDatabase(space.dataPipelineController);
+  });
+
+  test('invitation with no auth', async () => {
+    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+
+    const space1 = await host.dataSpaceManager!.createSpace();
+    const spaceKey = space1.key;
+
+    await performInvitation(host.spaceInvitations!, guest.spaceInvitations!, space1);
 
     {
-      const [item] = space.database!.select({ type: 'test' }).exec().entities;
-      expect(item.model.get('name')).to.eq('test');
-    }
+      const space1 = host.dataSpaceManager!.spaces.get(spaceKey)!;
+      const space2 = guest.dataSpaceManager!.spaces.get(spaceKey)!;
+      expect(space1).not.to.be.undefined;
+      expect(space2).not.to.be.undefined;
 
-    await space.close();
+      await syncItems(space1.dataPipelineController, space2.dataPipelineController);
+
+      await space1.close();
+      await space2.close();
+    }
   });
 
   test('creates and accepts invitation with retry', async () => {
@@ -79,8 +91,8 @@ describe('services/space-invitations-handler', () => {
             complete2.wake(invitation.spaceKey!);
           },
           onCancelled: () => raise(new Error()),
-          onTimeout: (err: Error) => raise(new Error(err.message)),
-          onError: (err: Error) => raise(new Error(err.message))
+          onTimeout: (err: Error) => raise(err),
+          onError: (err: Error) => raise(err)
         });
       },
       onConnected: (invitation: Invitation) => {
@@ -91,8 +103,8 @@ describe('services/space-invitations-handler', () => {
         complete1.wake(invitation.spaceKey!);
       },
       onCancelled: () => raise(new Error()),
-      onTimeout: (err: Error) => raise(new Error(err.message)),
-      onError: (err: Error) => raise(new Error(err.message))
+      onTimeout: (err: Error) => raise(err),
+      onError: (err: Error) => raise(err)
     });
 
     const [spaceKey1, spaceKey2] = await Promise.all([complete1.wait(), complete2.wait()]);
@@ -104,11 +116,15 @@ describe('services/space-invitations-handler', () => {
       expect(space1).not.to.be.undefined;
       expect(space2).not.to.be.undefined;
 
-      await syncItems(space1, space2);
+      await syncItems(space1.dataPipelineController, space2.dataPipelineController);
 
       await space1.close();
       await space2.close();
     }
+
+    expect(
+      guest.identityManager.identity?.space.spaceState.getCredentialsOfType('dxos.halo.credentials.SpaceMember').length
+    ).to.equal(2); // own halo + newly joined space.
   });
 
   test('cancels invitation', async () => {
@@ -133,8 +149,8 @@ describe('services/space-invitations-handler', () => {
           onConnected: async (invitation2: Invitation) => {},
           onSuccess: () => {},
           onCancelled: () => raise(new Error()),
-          onTimeout: (err: Error) => raise(new Error(err.message)),
-          onError: (err: Error) => raise(new Error(err.message))
+          onTimeout: (err: Error) => raise(err),
+          onError: (err: Error) => raise(err)
         });
       },
       onConnected: async (invitation1: Invitation) => {},
@@ -142,13 +158,13 @@ describe('services/space-invitations-handler', () => {
         cancelled.wake();
       },
       onSuccess: () => raise(new Error()),
-      onTimeout: (err: Error) => raise(new Error(err.message)),
-      onError: (err: Error) => raise(new Error(err.message))
+      onTimeout: (err: Error) => raise(err),
+      onError: (err: Error) => raise(err)
     });
 
     const invitation1 = await connecting1.wait();
     const invitation2 = await connecting2.wait();
-    expect(invitation1.swarmKey).to.eq(invitation2.swarmKey);
+    expect(invitation1.swarmKey).to.eq(invitation2.swarmKey); // TODO(burdon): Normalize to use to.deep.eq.
 
     // TODO(burdon): Simulate network latency.
     setTimeout(async () => {
@@ -159,7 +175,8 @@ describe('services/space-invitations-handler', () => {
     await space1.close();
   });
 
-  test('test multi-use invitation', async () => {
+  // TODO(burdon): Flaky.
+  test.skip('test multi-use invitation', async () => {
     const GUEST_COUNT = 3;
     const [host, ...guests] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(
       createPeers(GUEST_COUNT + 1)
@@ -180,8 +197,8 @@ describe('services/space-invitations-handler', () => {
         count();
       },
       onCancelled: () => {},
-      onTimeout: (err: Error) => raise(new Error(err.message)),
-      onError: (err: Error) => raise(new Error(err.message))
+      onTimeout: (err: Error) => raise(err),
+      onError: (err: Error) => raise(err)
     });
 
     await Promise.all(
@@ -198,8 +215,8 @@ describe('services/space-invitations-handler', () => {
             success.wake();
           },
           onCancelled: () => raise(new Error()),
-          onTimeout: (err: Error) => raise(new Error(err.message)),
-          onError: (err: Error) => raise(new Error(err.message))
+          onTimeout: (err: Error) => raise(err),
+          onError: (err: Error) => raise(err)
         });
         await success.wait({ timeout: 300 });
       })

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

@@ -15,6 +15,7 @@ import { log } from '@dxos/log';
 import { createTeleportProtocolFactory, NetworkManager, StarTopology, SwarmConnection } from '@dxos/network-manager';
 import { schema } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
   AuthenticationRequest,
@@ -137,20 +138,17 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
 
             log('writing guest credentials', { host: this._signingContext.deviceKey, guest: deviceKey });
             // TODO(burdon): Check if already admitted.
-            const credentials = await createAdmissionCredentials(
+            const credentials: FeedMessage.Payload[] = await createAdmissionCredentials(
               this._signingContext.credentialSigner,
               identityKey,
-              deviceKey,
               space.key,
-              controlFeedKey,
-              dataFeedKey,
               space.inner.genesisFeedKey,
               guestProfile
             );
 
             // TODO(dmaretskyi): Refactor.
-            assert(credentials[0]['@type'] === 'dxos.echo.feed.CredentialsMessage');
-            const spaceMemberCredential = credentials[0].credential;
+            assert(credentials[0].credential);
+            const spaceMemberCredential = credentials[0].credential.credential;
             assert(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
 
             await writeMessages(space.inner.controlPipeline.writer, credentials);
@@ -295,8 +293,6 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
                 dataFeedKey
               });
 
-              // TODO(dmaretskyi): Record credential in our HALO.
-
               // 4. Create local space.
               const assertion = getCredentialAssertion(credential);
               assert(assertion['@type'] === 'dxos.halo.credentials.SpaceMember', 'Invalid credential');
@@ -304,11 +300,12 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
 
               const space = await this._spaceManager.acceptSpace({
                 spaceKey: assertion.spaceKey,
-                genesisFeedKey: assertion.genesisFeedKey,
-                controlFeedKey,
-                dataFeedKey
+                genesisFeedKey: assertion.genesisFeedKey
               });
 
+              // Record credential in our HALO.
+              await this._signingContext.recordCredential(credential);
+
               // 5. Success.
               log('admitted by host', { guest: this._signingContext.deviceKey, spaceKey: space.key });
               complete.wake();

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

@@ -0,0 +1,56 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { MemorySignalManagerContext } from '@dxos/messaging';
+import { describe, test } from '@dxos/test';
+
+import { createServiceContext, syncItems } from '../testing';
+import { performInvitation } from '../testing/invitation-utils';
+
+describe('services/ServiceContext', () => {
+  test('existing space is synchronized on device invitations', async () => {
+    const networkContext = new MemorySignalManagerContext();
+    const device1 = createServiceContext({ signalContext: networkContext });
+    await device1.createIdentity();
+    const space1 = await device1.dataSpaceManager!.createSpace();
+
+    const device2 = createServiceContext({ signalContext: networkContext });
+    await performInvitation(device1.haloInvitations, device2.haloInvitations, undefined);
+
+    const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
+    await syncItems(space1.dataPipelineController, space2!.dataPipelineController);
+  });
+
+  test('new space is synchronized on device invitations', async () => {
+    const networkContext = new MemorySignalManagerContext();
+    const device1 = createServiceContext({ signalContext: networkContext });
+    await device1.createIdentity();
+
+    const device2 = createServiceContext({ signalContext: networkContext });
+    await performInvitation(device1.haloInvitations, device2.haloInvitations, undefined);
+
+    const space1 = await device1.dataSpaceManager!.createSpace();
+    await device2.dataSpaceManager?.updated.waitForCondition(() => !!device2.dataSpaceManager!.spaces.get(space1.key));
+    const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
+    await syncItems(space1.dataPipelineController, space2!.dataPipelineController);
+  });
+
+  test('joined space is synchronized on device invitations', async () => {
+    const networkContext = new MemorySignalManagerContext();
+    const device1 = createServiceContext({ signalContext: networkContext });
+    await device1.createIdentity();
+
+    const device2 = createServiceContext({ signalContext: networkContext });
+    await performInvitation(device1.haloInvitations, device2.haloInvitations, undefined);
+
+    const identity2 = createServiceContext({ signalContext: networkContext });
+    await identity2.createIdentity();
+    const space1 = await identity2.dataSpaceManager!.createSpace();
+    await performInvitation(identity2.spaceInvitations!, device1.spaceInvitations!, space1);
+
+    await device2.dataSpaceManager?.updated.waitForCondition(() => !!device2.dataSpaceManager!.spaces.get(space1.key));
+    const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
+    await syncItems(space1.dataPipelineController, space2!.dataPipelineController);
+  });
+});

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

@@ -3,6 +3,7 @@
 //
 
 import { Trigger } from '@dxos/async';
+import { CredentialConsumer, getCredentialAssertion } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
 import {
   valueEncoding,
@@ -18,16 +19,16 @@ import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
+import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { Storage } from '@dxos/random-access-storage';
 
-import { CreateIdentityOptions, IdentityManager } from '../identity';
+import { CreateIdentityOptions, IdentityManager, JoinIdentityParams } from '../identity';
 import { HaloInvitationsHandler, SpaceInvitationsHandler } from '../invitations';
 import { DataSpaceManager } from '../spaces/data-space-manager';
 
 /**
  * Shared backend for all client services.
  */
-
 // TODO(burdon): Rename/break-up into smaller components. And/or make members private.
 export class ServiceContext {
   public readonly initialized = new Trigger();
@@ -40,6 +41,8 @@ export class ServiceContext {
   public readonly identityManager: IdentityManager;
   public readonly haloInvitations: HaloInvitationsHandler;
 
+  private _deviceSpaceSync?: CredentialConsumer<any>;
+
   // Initialized after identity is initialized.
   public dataSpaceManager?: DataSpaceManager;
   public spaceInvitations?: SpaceInvitationsHandler;
@@ -64,19 +67,27 @@ export class ServiceContext {
         }
       })
     });
+
     this.spaceManager = new SpaceManager({
       feedStore: this.feedStore,
       networkManager: this.networkManager
     });
+
     this.identityManager = new IdentityManager(
       this.metadataStore,
       this.keyring,
+      this.feedStore,
       this.spaceManager
     );
 
     // TODO(burdon): _initialize called in multiple places.
     // TODO(burdon): Call _initialize on success.
-    this.haloInvitations = new HaloInvitationsHandler(this.networkManager, this.identityManager);
+    this.haloInvitations = new HaloInvitationsHandler({
+      networkManager: this.networkManager,
+      getIdentity: () => this.identityManager.identity ?? failUndefined(),
+      acceptIdentity: this._acceptIdentity.bind(this),
+      keyring: this.keyring
+    });
   }
 
   async open() {
@@ -92,6 +103,7 @@ export class ServiceContext {
 
   async close() {
     log('closing...');
+    await this._deviceSpaceSync?.close();
     await this.dataSpaceManager?.close();
     await this.identityManager.close();
     await this.spaceManager.close();
@@ -115,6 +127,13 @@ export class ServiceContext {
     return identity;
   }
 
+  private async _acceptIdentity(params: JoinIdentityParams) {
+    const identity = await this.identityManager.acceptIdentity(params);
+
+    await this._initialize();
+    return identity;
+  }
+
   // Called when identity is created.
   private async _initialize() {
     log('initializing spaces...');
@@ -123,7 +142,10 @@ export class ServiceContext {
       credentialSigner: identity.getIdentityCredentialSigner(),
       identityKey: identity.identityKey,
       deviceKey: identity.deviceKey,
-      profile: identity.profileDocument
+      profile: identity.profileDocument,
+      recordCredential: async (credential) => {
+        await identity.controlPipeline.writer.write({ credential: { credential } });
+      }
     };
 
     this.dataSpaceManager = new DataSpaceManager(
@@ -133,9 +155,11 @@ export class ServiceContext {
       this.keyring,
       signingContext,
       this.modelFactory,
+      this.feedStore,
       this.snapshotStore
     );
     await this.dataSpaceManager.open();
+
     this.spaceInvitations = new SpaceInvitationsHandler(
       this.networkManager,
       this.dataSpaceManager,
@@ -143,5 +167,37 @@ export class ServiceContext {
       this.keyring
     );
     this.initialized.wake();
+
+    this._deviceSpaceSync = identity.space.spaceState.registerProcessor({
+      process: async (credential: Credential) => {
+        const assertion = getCredentialAssertion(credential);
+        if (assertion['@type'] !== 'dxos.halo.credentials.SpaceMember') {
+          return;
+        }
+        if (assertion.spaceKey.equals(identity.space.key)) {
+          // ignore halo space
+          return;
+        }
+        if (!this.dataSpaceManager) {
+          log('dataSpaceManager not initialized yet, ignoring space admission', { details: assertion });
+          return;
+        }
+        if (this.dataSpaceManager.spaces.has(assertion.spaceKey)) {
+          log('space already exists, ignoring space admission', { details: assertion });
+          return;
+        }
+
+        try {
+          log('accepting space recorded in halo', { details: assertion });
+          await this.dataSpaceManager.acceptSpace({
+            spaceKey: assertion.spaceKey,
+            genesisFeedKey: assertion.genesisFeedKey
+          });
+        } catch (err) {
+          log.catch(err);
+        }
+      }
+    });
+    await this._deviceSpaceSync.open();
   }
 }

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

@@ -42,7 +42,7 @@ export type ClientServices = {
  */
 export interface ClientServicesProvider {
   descriptors: ServiceBundle<ClientServices>;
-  services: ClientServices;
+  services: Partial<ClientServices>;
 
   open(): Promise<void>;
   close(): Promise<void>;

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

@@ -2,12 +2,17 @@
 // Copyright 2023 DXOS.org
 //
 
-import { latch } from '@dxos/async';
+import { expect } from 'chai';
+
+import { latch, Trigger } from '@dxos/async';
 import { Config } from '@dxos/config';
+import { verifyPresentation } from '@dxos/credentials';
+import { PublicKey } from '@dxos/keys';
 import { MemorySignalManagerContext } from '@dxos/messaging';
+import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { afterTest, describe, test } from '@dxos/test';
 
-import { createServiceHost } from '../testing';
+import { createMockCredential, createServiceHost } from '../testing';
 
 describe('ClientServicesHost', () => {
   test('queryCredentials', async () => {
@@ -15,10 +20,10 @@ describe('ClientServicesHost', () => {
     await host.open();
     afterTest(() => host.close());
 
-    await host.services.ProfileService.createProfile({});
-    const { publicKey: spaceKey } = await host.services.SpaceService.createSpace();
+    await host.services.ProfileService!.createProfile({});
+    const { publicKey: spaceKey } = await host.services.SpaceService!.createSpace();
 
-    const stream = host.services.SpacesService.queryCredentials({ spaceKey });
+    const stream = host.services.SpacesService!.queryCredentials({ spaceKey });
     const [done, tick] = latch({ count: 3 });
     stream.subscribe((credential) => {
       tick();
@@ -28,4 +33,68 @@ describe('ClientServicesHost', () => {
 
     await done();
   });
+
+  test('write and query credentials', async () => {
+    const host = createServiceHost(new Config(), new MemorySignalManagerContext());
+    await host.open();
+    afterTest(() => host.close());
+
+    await host.services.ProfileService!.createProfile({});
+
+    const testCredential = await createMockCredential({
+      signer: host._serviceContext.keyring,
+      issuer: host._serviceContext.identityManager.identity!.deviceKey
+    });
+
+    // Test if Profile exposes haloSpace key.
+    const haloSpace = new Trigger<PublicKey>();
+    host.services.ProfileService!.subscribeProfile()!.subscribe(({ profile }) => {
+      if (profile?.haloSpace) {
+        haloSpace.wake(profile.haloSpace);
+      }
+    });
+
+    await host.services.SpacesService?.writeCredentials({
+      spaceKey: await haloSpace.wait(),
+      credentials: [testCredential]
+    });
+
+    const credentials = host.services.SpacesService!.queryCredentials({ spaceKey: await haloSpace.wait() });
+    const queriedCredential = new Trigger<Credential>();
+    credentials.subscribe((credential) => {
+      if (credential.subject.id.equals(testCredential.subject.id)) {
+        queriedCredential.wake(credential);
+      }
+    });
+    afterTest(() => credentials.close());
+
+    await queriedCredential.wait();
+  });
+
+  test('sign presentation', async () => {
+    const host = createServiceHost(new Config(), new MemorySignalManagerContext());
+    await host.open();
+    afterTest(() => host.close());
+
+    await host.services.ProfileService!.createProfile({});
+
+    const testCredential = await createMockCredential({
+      signer: host._serviceContext.keyring,
+      issuer: host._serviceContext.identityManager.identity!.deviceKey
+    });
+
+    const nonce = new Uint8Array([0, 0, 0, 0]);
+
+    const presentation = await host.services.ProfileService!.signPresentation({
+      presentation: {
+        credentials: [testCredential]
+      },
+      nonce
+    });
+
+    expect(presentation.proofs?.[0].nonce).to.deep.equal(nonce);
+    expect(await verifyPresentation(presentation)).to.deep.equal({
+      kind: 'pass'
+    });
+  });
 });