@dxos/client-services 0.1.28 → 0.1.29-next.1bc50d4

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

@@ -0,0 +1,96 @@
+//
+// 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 { TestBuilder } from '../testing';
+import { IFrameProxyRuntime, WorkerRuntime } from '../vault';
+
+chai.use(chaiAsPromised);
+
+describe('Shared worker', () => {
+  test('client connects to the worker', async () => {
+    const workerRuntime = new WorkerRuntime(() => new Config({}));
+
+    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])
+    });
+
+    await Promise.all([workerRuntime.start(), clientProxy.open('*'), client.initialize()]);
+
+    await client.halo.createIdentity();
+  });
+
+  test('initialization errors get propagated to the client', async () => {
+    const workerRuntime = new WorkerRuntime(async () => {
+      await sleep(1);
+      throw new Error('Test error');
+    });
+
+    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])
+    });
+
+    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;
+  });
+
+  // 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

@@ -3,6 +3,7 @@
 //
 
 import { Trigger } from '@dxos/async';
+import { clientServiceBundle, ClientServices } from '@dxos/client';
 import { Config } from '@dxos/config';
 import { log, logInfo } from '@dxos/log';
 import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
@@ -10,7 +11,7 @@ import { createWebRTCTransportFactory, NetworkManager } from '@dxos/network-mana
 import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
 import { getAsyncValue, Provider } from '@dxos/util';
 
-import { clientServiceBundle, ClientServices, ClientServicesHost } from '../services';
+import { LocalClientServices } from '../services';
 import { ShellRuntime, ShellRuntimeImpl } from './shell-runtime';
 
 const LOCK_KEY = 'DXOS_RESOURCE_LOCK';
@@ -38,7 +39,9 @@ export class IFrameHostRuntime {
   private readonly _appPort: RpcPort;
   private readonly _shellPort?: RpcPort;
   private _config!: Config;
-  private _clientServices!: ClientServicesHost;
+
+  // TODO(dmaretskyi):  Replace with host and figure out how to return services provider here.
+  private _clientServices!: LocalClientServices;
   private _clientRpc!: ProtoRpcPeer<ClientServices>;
   private _shellRuntime?: ShellRuntimeImpl;
 
@@ -82,7 +85,7 @@ export class IFrameHostRuntime {
     try {
       this._config = await getAsyncValue(this._configProvider);
       const signalServer = this._config.get('runtime.services.signal.server');
-      this._clientServices = new ClientServicesHost({
+      this._clientServices = new LocalClientServices({
         lockKey: LOCK_KEY,
         config: this._config,
         networkManager: new NetworkManager({

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-session.ts

@@ -5,14 +5,18 @@
 import assert from 'node:assert';
 
 import { asyncTimeout, Trigger } from '@dxos/async';
+import {
+  clientServiceBundle,
+  ClientServices,
+  iframeServiceBundle,
+  IframeServiceBundle,
+  workerServiceBundle
+} from '@dxos/client';
 import { log, logInfo } from '@dxos/log';
 import { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
 import { Callback } from '@dxos/util';
 
-import { clientServiceBundle, ClientServices } from '../services';
-import { IframeServiceBundle, iframeServiceBundle, workerServiceBundle } from './services';
-
 export type WorkerSessionParams = {
   getService: <Service>(find: (services: Partial<ClientServices>) => Service | undefined) => Promise<Service>;
   systemPort: RpcPort;