@dxos/client-services 0.1.30-next.7c60cd3 → 0.1.31-next.ea8f0bc

package/src/packlets/tests/halo-credentials.test.ts

@@ -0,0 +1,94 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+// @dxos/test platform=nodejs
+
+import { expect } from 'chai';
+
+import { asyncTimeout, Trigger } from '@dxos/async';
+import { Client } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { verifyPresentation } from '@dxos/credentials';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { describe, test, afterTest } from '@dxos/test';
+
+import { TestBuilder } from '../testing';
+
+describe('Halo', () => {
+  test('presentation', async () => {
+    const config = new Config({
+      version: 1,
+      runtime: {
+        client: {
+          storage: {
+            persistent: true, // TODO(burdon): Note required if path set.
+            path: `/tmp/dxos/client/${PublicKey.random().toHex()}`
+          }
+        }
+      }
+    });
+
+    const testBuilder = new TestBuilder(config);
+
+    {
+      const client = new Client({ config, services: testBuilder.createLocal() });
+      afterTest(() => client.destroy());
+      await client.initialize();
+
+      await client.halo.createIdentity({ displayName: 'test-user' });
+      expect(client.halo.identity).exist;
+
+      const credentials = client.halo.queryCredentials({ type: 'dxos.halo.credentials.AdmittedFeed' });
+      const trigger = new Trigger();
+      credentials.subscribe({
+        onUpdate: (credentials) => {
+          if (credentials.length >= 2) {
+            trigger.wake();
+          }
+        },
+        onError: (err) => log.catch(err)
+      });
+      await asyncTimeout(trigger.wait(), 500);
+
+      const nonce = new Uint8Array([0, 0, 0, 0]);
+      const presentation = await client.halo.presentCredentials({
+        ids: credentials.value!.map(({ id }) => id!),
+        nonce: new Uint8Array([0, 0, 0, 0])
+      });
+      expect(presentation.credentials?.length).to.equal(2);
+      expect(await verifyPresentation(presentation)).to.deep.equal({ kind: 'pass' });
+      expect(presentation.proofs![0].nonce).to.deep.equal(nonce);
+    }
+  });
+
+  test('query credentials', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client = new Client({ services: testBuilder.createLocal() });
+    afterTest(() => client.destroy());
+    await client.initialize();
+
+    await client.halo.createIdentity({ displayName: 'test-user' });
+    expect(client.halo.identity).exist;
+
+    const credentials = client.halo.queryCredentials({ type: 'dxos.halo.credentials.AdmittedFeed' });
+
+    const trigger = new Trigger();
+    credentials.subscribe({
+      onUpdate: () => {
+        if (credentials.value?.length === 2) {
+          trigger.wake();
+        }
+      },
+      onError: (error) => {
+        throw error;
+      }
+    });
+    await asyncTimeout(trigger.wait(), 500);
+
+    expect(credentials.value!.every((cred) => cred.subject.assertion['@type'] === 'dxos.halo.credentials.AdmittedFeed'))
+      .to.be.true;
+  });
+});

package/src/packlets/tests/halo-persistent.test.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+// @dxos/test platform=nodejs
+
+import { expect } from 'chai';
+
+import { waitForCondition } from '@dxos/async';
+import { Client } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { PublicKey } from '@dxos/keys';
+import { describe, test, afterTest } from '@dxos/test';
+
+import { TestBuilder } from '../testing';
+
+describe('Halo', () => {
+  test('reopens with persistent storage', async () => {
+    const config = new Config({
+      version: 1,
+      runtime: {
+        client: {
+          storage: {
+            persistent: true, // TODO(burdon): Note required if path set.
+            path: `/tmp/dxos/client/${PublicKey.random().toHex()}`
+          }
+        }
+      }
+    });
+
+    const testBuilder = new TestBuilder(config);
+
+    {
+      const client = new Client({ config, services: testBuilder.createLocal() });
+      afterTest(() => client.destroy());
+      await client.initialize();
+
+      await client.halo.createIdentity({ displayName: 'test-user' });
+      expect(client.halo.identity).exist;
+    }
+
+    {
+      const client = new Client({ config, services: testBuilder.createLocal() });
+      afterTest(() => client.destroy());
+      await client.initialize();
+
+      await waitForCondition(() => !!client.halo.identity);
+      expect(client.halo.identity).exist;
+      // TODO(burdon): Not working.
+      // expect(client.halo.identity!.displayName).to.eq('test-user');
+    }
+  });
+});

package/src/packlets/tests/halo-profile.test.ts

@@ -0,0 +1,74 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { Trigger } from '@dxos/async';
+import { Client } from '@dxos/client';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { describe, test, afterTest } from '@dxos/test';
+
+import { TestBuilder } from '../testing';
+
+describe('Halo', () => {
+  test('creates a identity', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client = new Client({ services: testBuilder.createLocal() });
+    afterTest(() => client.destroy());
+    await client.initialize();
+
+    await client.halo.createIdentity({ displayName: 'test-user' });
+    expect(client.halo.identity).exist;
+
+    expect(await client.halo.getDevices()).to.have.lengthOf(1);
+    expect(client.halo.identity!.profile?.displayName).to.equal('test-user');
+  });
+
+  test('device invitations', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client1 = new Client({ services: testBuilder.createLocal() });
+    afterTest(() => client1.destroy());
+    await client1.initialize();
+
+    await client1.halo.createIdentity({ displayName: 'test-user' });
+    expect(client1.halo.identity).exist;
+
+    expect(await client1.halo.getDevices()).to.have.lengthOf(1);
+
+    const client2 = new Client({ services: testBuilder.createLocal() });
+    afterTest(() => client2.destroy());
+    await client2.initialize();
+
+    const done1 = new Trigger();
+    const done2 = new Trigger();
+    const invitation = client1.halo.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
+    invitation.subscribe({
+      onConnecting: (invitation) => {
+        const invitation2 = client2.halo.acceptInvitation(invitation, { type: Invitation.Type.INTERACTIVE_TESTING });
+        invitation2.subscribe({
+          onSuccess: () => {
+            done2.wake();
+          },
+          onError: (error) => {
+            throw error;
+          }
+        });
+      },
+      onSuccess: async (invitation) => {
+        done1.wake();
+      },
+      onError: (error) => {
+        throw error;
+      }
+    });
+
+    await done1.wait();
+    await done2.wait();
+
+    expect(await client1.halo.getDevices()).to.have.lengthOf(2);
+    expect(await client2.halo.getDevices()).to.have.lengthOf(2);
+  });
+});

package/src/packlets/tests/shared-worker.test.ts

@@ -0,0 +1,93 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+
+import { sleep } from '@dxos/async';
+import { Client, ClientServicesProxy, fromIFrame } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { createLinkedPorts } from '@dxos/rpc';
+import { describe, test, afterTest } from '@dxos/test';
+import { MaybePromise } from '@dxos/util';
+
+import { TestBuilder } from '../testing';
+import { IFrameProxyRuntime, WorkerRuntime } from '../vault';
+
+chai.use(chaiAsPromised);
+
+const setup = (getConfig: () => MaybePromise<Config>) => {
+  const workerRuntime = new WorkerRuntime(getConfig);
+
+  const systemPorts = createLinkedPorts();
+  const workerProxyPorts = createLinkedPorts();
+  const proxyWindowPorts = createLinkedPorts();
+  const shellPorts = createLinkedPorts();
+  void workerRuntime.createSession({
+    systemPort: systemPorts[1],
+    appPort: workerProxyPorts[1],
+    shellPort: shellPorts[1]
+  });
+  const clientProxy = new IFrameProxyRuntime({
+    systemPort: systemPorts[0],
+    windowAppPort: proxyWindowPorts[0],
+    workerAppPort: workerProxyPorts[0],
+    shellPort: shellPorts[0]
+  });
+  const client = new Client({
+    services: new ClientServicesProxy(proxyWindowPorts[1])
+  });
+
+  return { workerRuntime, clientProxy, client };
+};
+
+describe('Shared worker', () => {
+  test('client connects to the worker', async () => {
+    const { workerRuntime, clientProxy, client } = setup(() => new Config({}));
+
+    await Promise.all([workerRuntime.start(), clientProxy.open('*'), client.initialize()]);
+
+    await client.halo.createIdentity();
+  });
+
+  test('initialization errors get propagated to the client', async () => {
+    const { workerRuntime, clientProxy, client } = setup(async () => {
+      await sleep(1);
+      throw new Error('Test error');
+    });
+
+    const promise = Promise.all([
+      workerRuntime.start().catch(() => {}), // This error should be propagated to client.initialize() call.
+      clientProxy.open('*')
+    ]);
+
+    await expect(client.initialize()).to.be.rejectedWith('Test error');
+
+    await promise;
+  });
+
+  test('host can be initialized after client', async () => {
+    const { workerRuntime, clientProxy, client } = setup(async () => {
+      await sleep(5);
+      return new Config({});
+    });
+
+    await Promise.all([workerRuntime.start(), clientProxy.open('*'), client.initialize()]);
+
+    await client.halo.createIdentity();
+  });
+
+  // TODO(burdon): Browser-only.
+  test.skip('creates client with remote iframe', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client = new Client({
+      services: fromIFrame(testBuilder.config)
+    });
+
+    await client.initialize();
+    afterTest(() => client.destroy());
+    expect(client.initialized).to.be.true;
+  });
+});

package/src/packlets/tests/spaces-invitations.test.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { Client } from '@dxos/client';
+import { describe, test, afterTest } from '@dxos/test';
+
+import { TestBuilder, testSpace } from '../testing';
+
+describe('Spaces/invitations', () => {
+  test('creates a space and invites a peer', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client = new Client({ services: testBuilder.createLocal() });
+    afterTest(() => client.destroy());
+    await client.initialize();
+    await client.halo.createIdentity({ displayName: 'test-user' });
+
+    {
+      const space = await client.echo.createSpace();
+      await testSpace(space.internal.db);
+    }
+  });
+});

package/src/packlets/tests/spaces.test.ts

@@ -0,0 +1,68 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { Client } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { log } from '@dxos/log';
+import { createStorage, StorageType } from '@dxos/random-access-storage';
+import { describe, test, afterTest } from '@dxos/test';
+
+import { TestBuilder, testSpace } from '../testing';
+
+describe('Spaces', () => {
+  test('creates a space', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client = new Client({ services: testBuilder.createLocal() });
+    afterTest(() => client.destroy());
+
+    await client.initialize();
+    await client.halo.createIdentity({ displayName: 'test-user' });
+
+    // TODO(burdon): Extend basic queries.
+    const space = await client.echo.createSpace();
+    await testSpace(space.internal.db);
+
+    expect(space.getMembers()).to.be.length(1);
+  });
+
+  test('creates a space re-opens the client', async () => {
+    const testBuilder = new TestBuilder(new Config({ version: 1 }));
+    testBuilder.storage = createStorage({ type: StorageType.RAM });
+
+    const client = new Client({ services: testBuilder.createLocal() });
+    await client.initialize();
+    await client.halo.createIdentity({ displayName: 'test-user' });
+
+    let itemId: string;
+    {
+      // TODO(burdon): API (client.echo/client.halo).
+      const space = await client.echo.createSpace();
+      const {
+        objectsCreated: [item]
+      } = await testSpace(space.internal.db);
+      itemId = item.id;
+      expect(space.getMembers()).to.be.length(1);
+    }
+
+    await client.destroy();
+
+    log.break();
+
+    await client.initialize();
+
+    {
+      const result = client.echo.getSpaces();
+      expect(result).to.have.length(1);
+      const space = result[0];
+
+      const item = space.internal.db._itemManager.getItem(itemId)!;
+      expect(item).to.exist;
+    }
+
+    await client.destroy();
+  });
+});

package/src/packlets/vault/iframe-host-runtime.ts

@@ -7,10 +7,11 @@ import { Config } from '@dxos/config';
 import { log, logInfo } from '@dxos/log';
 import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
 import { createWebRTCTransportFactory, NetworkManager } from '@dxos/network-manager';
-import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
+import { RpcPort } from '@dxos/rpc';
 import { getAsyncValue, Provider } from '@dxos/util';
 
-import { clientServiceBundle, ClientServices, LocalClientServices } from '../services';
+import { LocalClientServices } from '../services';
+import { ClientRpcServer, ClientRpcServerParams } from '../services/client-rpc-server';
 import { ShellRuntime, ShellRuntimeImpl } from './shell-runtime';
 
 const LOCK_KEY = 'DXOS_RESOURCE_LOCK';
@@ -31,9 +32,6 @@ export class IFrameHostRuntime {
   private readonly _configProvider: Config | Provider<Promise<Config>>;
   private readonly _transportFactory = createWebRTCTransportFactory();
   private readonly _ready = new Trigger<Error | undefined>();
-  private readonly _getService: <Service>(
-    find: (services: Partial<ClientServices>) => Service | undefined
-  ) => Promise<Service>;
 
   private readonly _appPort: RpcPort;
   private readonly _shellPort?: RpcPort;
@@ -41,7 +39,7 @@ export class IFrameHostRuntime {
 
   // TODO(dmaretskyi):  Replace with host and figure out how to return services provider here.
   private _clientServices!: LocalClientServices;
-  private _clientRpc!: ProtoRpcPeer<ClientServices>;
+  private _clientRpc!: ClientRpcServer;
   private _shellRuntime?: ShellRuntimeImpl;
 
   @logInfo
@@ -52,20 +50,6 @@ export class IFrameHostRuntime {
     this._appPort = appPort;
     this._shellPort = shellPort;
 
-    this._getService = async (find) => {
-      const error = await this._ready.wait();
-      if (error) {
-        throw error;
-      }
-
-      const service = await find(this._clientServices.services);
-      if (!service) {
-        throw new Error('Service not found');
-      }
-
-      return service;
-    };
-
     if (this._shellPort) {
       this._shellRuntime = new ShellRuntimeImpl(this._shellPort);
     }
@@ -96,21 +80,29 @@ export class IFrameHostRuntime {
         })
       });
 
-      this._clientRpc = createProtoRpcPeer({
-        exposed: clientServiceBundle,
-        handlers: {
-          DataService: async () => await this._getService((services) => services.DataService),
-          DeviceInvitationsService: async () => await this._getService((services) => services.DeviceInvitationsService),
-          DevicesService: async () => await this._getService((services) => services.DevicesService),
-          DevtoolsHost: async () => await this._getService((services) => services.DevtoolsHost),
-          NetworkService: async () => await this._getService((services) => services.NetworkService),
-          IdentityService: async () => await this._getService((services) => services.IdentityService),
-          SpaceInvitationsService: async () => await this._getService((services) => services.SpaceInvitationsService),
-          SpacesService: async () => await this._getService((services) => services.SpacesService),
-          SystemService: async () => await this._getService((services) => services.SystemService),
-          TracingService: async () => await this._getService((services) => services.TracingService)
+      const middleware: Pick<ClientRpcServerParams, 'handleCall' | 'handleStream'> = {
+        handleCall: async (method, params, handler) => {
+          const error = await this._ready.wait({ timeout: 3_000 });
+          if (error) {
+            throw error;
+          }
+
+          return handler(method, params);
         },
-        port: this._appPort
+        handleStream: async (method, params, handler) => {
+          const error = await this._ready.wait({ timeout: 3_000 });
+          if (error) {
+            throw error;
+          }
+
+          return handler(method, params);
+        }
+      };
+
+      this._clientRpc = new ClientRpcServer({
+        serviceRegistry: this._clientServices.host.serviceRegistry,
+        port: this._appPort,
+        ...middleware
       });
 
       await Promise.all([this._clientServices.open(), this._clientRpc.open(), this._shellRuntime?.open()]);

package/src/packlets/vault/iframe-proxy-runtime.ts

@@ -2,11 +2,11 @@
 // Copyright 2022 DXOS.org
 //
 
+import { iframeServiceBundle, workerServiceBundle, WorkerServiceBundle } from '@dxos/client';
 import { WebRTCTransportService } from '@dxos/network-manager';
 import { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
 
-import { iframeServiceBundle, WorkerServiceBundle, workerServiceBundle } from './services';
 import { ShellRuntime, ShellRuntimeImpl } from './shell-runtime';
 
 // NOTE: Keep as RpcPorts to avoid dependency on @dxos/rpc-tunnel so we don't depend on browser-specific apis.

package/src/packlets/vault/index.ts

@@ -4,8 +4,6 @@
 
 export * from './iframe-host-runtime';
 export * from './iframe-proxy-runtime';
-export * from './services';
-export * from './shell-controller';
 export * from './shell-runtime';
 export * from './vault-resource-lock';
 export * from './worker-runtime';

package/src/packlets/vault/shell-runtime.ts

@@ -5,12 +5,11 @@
 import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
+import { appServiceBundle, AppServiceBundle, shellServiceBundle } from '@dxos/client';
 import { PublicKey } from '@dxos/keys';
 import { AppContextRequest, LayoutRequest, ShellLayout } from '@dxos/protocols/proto/dxos/iframe';
 import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
 
-import { AppServiceBundle, appServiceBundle, shellServiceBundle } from './services';
-
 export interface ShellRuntime {
   layoutUpdate: Event<LayoutRequest>;
   layout: ShellLayout;

package/src/packlets/vault/worker-runtime.ts

@@ -36,14 +36,16 @@ export class WorkerRuntime {
   // prettier-ignore
   constructor(
     private readonly _configProvider: () => MaybePromise<Config>
-  ) { }
+  ) {
+    this._clientServices = new ClientServicesHost();
+  }
 
   async start() {
     log('starting...');
     try {
       this._config = await this._configProvider();
       const signalServer = this._config.get('runtime.services.signal.server');
-      this._clientServices = new ClientServicesHost({
+      this._clientServices.initialize({
         config: this._config,
         networkManager: new NetworkManager({
           log: true,
@@ -73,19 +75,7 @@ export class WorkerRuntime {
    */
   async createSession({ appPort, systemPort, shellPort }: CreateSessionParams) {
     const session = new WorkerSession({
-      getService: async (find) => {
-        const error = await this._ready.wait();
-        if (error) {
-          throw error;
-        }
-
-        const service = find(this._clientServices.services);
-        if (!service) {
-          throw new Error('Service not found');
-        }
-
-        return service;
-      },
+      serviceHost: this._clientServices,
       appPort,
       systemPort,
       shellPort,