@dxos/client-services 0.1.31-next.ea8f0bc → 0.1.32-next.77d513e

package/src/packlets/tests/client-services.test.ts

@@ -7,7 +7,7 @@ import assert from 'node:assert';
 import waitForExpect from 'wait-for-expect';
 
 import { Trigger } from '@dxos/async';
-import { Space } from '@dxos/client';
+import { Client, Space } from '@dxos/client';
 import { raise } from '@dxos/debug';
 import { log } from '@dxos/log';
 import { Invitation, SpaceMember } from '@dxos/protocols/proto/dxos/client/services';
@@ -19,6 +19,19 @@ import { syncItems, TestBuilder } from '../testing';
 // TODO(burdon): Timeouts and progress callback/events.
 
 describe('Client services', () => {
+  test('creates client with local host', async () => {
+    const testBuilder = new TestBuilder();
+
+    const servicesProvider = testBuilder.createLocal();
+    await servicesProvider.open();
+    afterTest(() => servicesProvider.close());
+
+    const client = new Client({ services: servicesProvider });
+    await client.initialize();
+    afterTest(() => client.destroy());
+    expect(client.initialized).to.be.true;
+  });
+
   test('creates client with remote server', async () => {
     const testBuilder = new TestBuilder();
 
@@ -141,16 +154,16 @@ describe('Client services', () => {
     // Check same identity.
     const [invitation1, invitation2] = await Promise.all([success1.wait(), success2.wait()]);
     expect(invitation1.identityKey).not.to.exist;
-    expect(invitation2.identityKey).to.deep.eq(client1.halo.identity!.identityKey);
-    expect(invitation2.identityKey).to.deep.eq(client2.halo.identity!.identityKey);
+    expect(invitation2.identityKey).to.deep.eq(client1.halo.identity.get()!.identityKey);
+    expect(invitation2.identityKey).to.deep.eq(client2.halo.identity.get()!.identityKey);
     expect(invitation1.state).to.eq(Invitation.State.SUCCESS);
     expect(invitation2.state).to.eq(Invitation.State.SUCCESS);
 
     // Check devices.
     // TODO(burdon): Incorrect number of devices.
     await waitForExpect(async () => {
-      expect(client1.halo.getDevices()).to.have.lengthOf(2);
-      expect(client2.halo.getDevices()).to.have.lengthOf(2);
+      expect(client1.halo.devices.get()).to.have.lengthOf(2);
+      expect(client2.halo.devices.get()).to.have.lengthOf(2);
     });
   });
 
@@ -184,13 +197,13 @@ describe('Client services', () => {
     const success1 = new Trigger<Invitation>();
     const success2 = new Trigger<Invitation>();
 
-    const space1 = await client1.echo.createSpace();
+    const space1 = await client1.createSpace();
     log('createSpace', { key: space1.key });
     const observable1 = space1.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
 
     observable1.subscribe({
       onConnecting: (invitation) => {
-        const observable2 = client2.echo.acceptInvitation(invitation);
+        const observable2 = client2.acceptInvitation(invitation);
         observable2.subscribe({
           onSuccess: (invitation: Invitation) => {
             success2.wake(invitation);
@@ -214,7 +227,7 @@ describe('Client services', () => {
     // TODO(burdon): Space should now be available?
     const trigger = new Trigger<Space>();
     await waitForExpect(() => {
-      const space2 = client2.echo.getSpace(invitation2.spaceKey!);
+      const space2 = client2.getSpace(invitation2.spaceKey!);
       assert(space2);
       expect(space2).to.exist;
       trigger.wake(space2);
@@ -224,10 +237,10 @@ describe('Client services', () => {
 
     for (const space of [space1, space2]) {
       await waitForExpect(() => {
-        expect(space.getMembers()).to.deep.equal([
+        expect(space.members.get()).to.deep.equal([
           {
             identity: {
-              identityKey: client1.halo.identity!.identityKey,
+              identityKey: client1.halo.identity.get()!.identityKey,
               profile: {
                 displayName: 'Peer 1'
               }
@@ -236,7 +249,7 @@ describe('Client services', () => {
           },
           {
             identity: {
-              identityKey: client2.halo.identity!.identityKey,
+              identityKey: client2.halo.identity.get()!.identityKey,
               profile: {
                 displayName: 'Peer 2'
               }

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

@@ -61,9 +61,7 @@ describe('Client', () => {
     const client = new Client({ services: testBuilder.createLocal() });
     await client.initialize();
     afterTest(() => client.destroy());
-    await expect(client.echo.createSpace()).to.eventually.be.rejectedWith(
-      'This device has no HALO identity available.'
-    );
+    await expect(client.createSpace()).to.eventually.be.rejectedWith('This device has no HALO identity available.');
   }).timeout(1_000);
 
   // TODO(burdon): Memory store is reset on close (feed store is closed).
@@ -109,13 +107,12 @@ const getNodeConfig = async (reset = false) => {
 const runTest = async (testBuilder: TestBuilder) => {
   const client = new Client({ services: testBuilder.createLocal() });
   const displayName = 'test-user';
-
   {
     // Create identity.
     await client.initialize();
-    expect(client.halo.identity).not.to.exist;
+    expect(client.halo.identity.get()).not.to.exist;
     const identity = await client.halo.createIdentity({ displayName });
-    expect(client.halo.identity).to.deep.eq(identity);
+    expect(client.halo.identity.get()).to.deep.eq(identity);
     await client.destroy();
   }
 

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

@@ -22,8 +22,8 @@ describe('Halo', () => {
     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');
+    expect(await client.halo.devices.get()).to.have.lengthOf(1);
+    expect(client.halo.identity.get()!.profile?.displayName).to.equal('test-user');
   });
 
   test('device invitations', async () => {
@@ -36,7 +36,7 @@ describe('Halo', () => {
     await client1.halo.createIdentity({ displayName: 'test-user' });
     expect(client1.halo.identity).exist;
 
-    expect(await client1.halo.getDevices()).to.have.lengthOf(1);
+    expect(await client1.halo.devices.get()).to.have.lengthOf(1);
 
     const client2 = new Client({ services: testBuilder.createLocal() });
     afterTest(() => client2.destroy());
@@ -68,7 +68,7 @@ describe('Halo', () => {
     await done1.wait();
     await done2.wait();
 
-    expect(await client1.halo.getDevices()).to.have.lengthOf(2);
-    expect(await client2.halo.getDevices()).to.have.lengthOf(2);
+    expect(await client1.halo.devices.get()).to.have.lengthOf(2);
+    expect(await client2.halo.devices.get()).to.have.lengthOf(2);
   });
 });

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

@@ -2,8 +2,13 @@
 // Copyright 2021 DXOS.org
 //
 
-import { Client } from '@dxos/client';
-import { describe, test, afterTest } from '@dxos/test';
+import { expect } from 'chai';
+
+import { Trigger } from '@dxos/async';
+import { Client, Invitation } from '@dxos/client';
+import { raise } from '@dxos/debug';
+import { log } from '@dxos/log';
+import { afterTest, describe, test } from '@dxos/test';
 
 import { TestBuilder, testSpace } from '../testing';
 
@@ -11,13 +16,48 @@ 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 client1 = new Client({ services: testBuilder.createLocal() });
+    const client2 = new Client({ services: testBuilder.createLocal() });
+    await client1.initialize();
+    await client2.initialize();
+    await client1.halo.createIdentity({ displayName: 'Peer 1' });
+    await client2.halo.createIdentity({ displayName: 'Peer 2' });
+
+    log('initialized');
+
+    afterTest(() => Promise.all([client1.destroy()]));
+    afterTest(() => Promise.all([client2.destroy()]));
+
+    const success1 = new Trigger<Invitation>();
+    const success2 = new Trigger<Invitation>();
+
+    const space1 = await client1.createSpace();
+    log('createSpace', { key: space1.key });
+    const observable1 = space1.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
+
+    observable1.subscribe({
+      onConnecting: (invitation) => {
+        const observable2 = client2.acceptInvitation(invitation);
+        observable2.subscribe({
+          onSuccess: (invitation: Invitation) => {
+            success2.wake(invitation);
+          },
+          onError: (err: Error) => raise(err)
+        });
+      },
+      onSuccess: (invitation) => {
+        log('onSuccess');
+        success1.wake(invitation);
+      },
+      onError: (err) => raise(err)
+    });
+
+    const [invitation1, invitation2] = await Promise.all([success1.wait(), success2.wait()]);
+    expect(invitation1.spaceKey).to.deep.eq(invitation2.spaceKey);
+    expect(invitation1.state).to.eq(Invitation.State.SUCCESS);
 
     {
-      const space = await client.echo.createSpace();
+      const space = await client2.getSpace(invitation2.spaceKey!)!.waitUntilReady();
       await testSpace(space.internal.db);
     }
   });

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

@@ -4,8 +4,10 @@
 
 import { expect } from 'chai';
 
-import { Client } from '@dxos/client';
+import { asyncTimeout, Trigger } from '@dxos/async';
+import { Client, Invitation, Space } from '@dxos/client';
 import { Config } from '@dxos/config';
+import { raise } from '@dxos/debug';
 import { log } from '@dxos/log';
 import { createStorage, StorageType } from '@dxos/random-access-storage';
 import { describe, test, afterTest } from '@dxos/test';
@@ -23,10 +25,10 @@ describe('Spaces', () => {
     await client.halo.createIdentity({ displayName: 'test-user' });
 
     // TODO(burdon): Extend basic queries.
-    const space = await client.echo.createSpace();
+    const space = await client.createSpace();
     await testSpace(space.internal.db);
 
-    expect(space.getMembers()).to.be.length(1);
+    expect(space.members.get()).to.be.length(1);
   });
 
   test('creates a space re-opens the client', async () => {
@@ -40,12 +42,12 @@ describe('Spaces', () => {
     let itemId: string;
     {
       // TODO(burdon): API (client.echo/client.halo).
-      const space = await client.echo.createSpace();
+      const space = await client.createSpace();
       const {
-        objectsCreated: [item]
+        objectsUpdated: [item]
       } = await testSpace(space.internal.db);
       itemId = item.id;
-      expect(space.getMembers()).to.be.length(1);
+      expect(space.members.get()).to.be.length(1);
     }
 
     await client.destroy();
@@ -55,9 +57,18 @@ describe('Spaces', () => {
     await client.initialize();
 
     {
-      const result = client.echo.getSpaces();
-      expect(result).to.have.length(1);
-      const space = result[0];
+      // TODO(dmaretskyi): Replace with helper?.
+      const spaceTrigger = new Trigger<Space>();
+      if (client.spaces.get()[0]) {
+        spaceTrigger.wake(client.spaces.get()[0]);
+      }
+      client.spaces.subscribe(() => {
+        if (client.spaces.get()[0]) {
+          spaceTrigger.wake(client.spaces.get()[0]);
+        }
+      });
+      const space = await spaceTrigger.wait({ timeout: 500 });
+      await space.waitUntilReady();
 
       const item = space.internal.db._itemManager.getItem(itemId)!;
       expect(item).to.exist;
@@ -65,4 +76,70 @@ describe('Spaces', () => {
 
     await client.destroy();
   });
+
+  test('post and listen to messages', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client1 = new Client({ services: testBuilder.createLocal() });
+    const client2 = new Client({ services: testBuilder.createLocal() });
+    await client1.initialize();
+    await client2.initialize();
+    await client1.halo.createIdentity({ displayName: 'Peer 1' });
+    await client2.halo.createIdentity({ displayName: 'Peer 2' });
+
+    log('initialized');
+
+    afterTest(() => Promise.all([client1.destroy()]));
+    afterTest(() => Promise.all([client2.destroy()]));
+
+    const success1 = new Trigger<Invitation>();
+    const success2 = new Trigger<Invitation>();
+
+    const space1 = await client1.createSpace();
+    log('createSpace', { key: space1.key });
+    const observable1 = space1.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
+
+    observable1.subscribe({
+      onConnecting: (invitation) => {
+        const observable2 = client2.acceptInvitation(invitation);
+        observable2.subscribe({
+          onSuccess: (invitation: Invitation) => {
+            success2.wake(invitation);
+          },
+          onError: (err: Error) => raise(err)
+        });
+      },
+      onSuccess: (invitation) => {
+        log('onSuccess');
+        success1.wake(invitation);
+      },
+      onError: (err) => raise(err)
+    });
+
+    const [_, invitation2] = await Promise.all([success1.wait(), success2.wait()]);
+
+    const space2 = await client2.getSpace(invitation2.spaceKey!)!.waitUntilReady();
+
+    const hello = new Trigger();
+    {
+      space2.listen('hello', (message) => {
+        expect(message.channelId).to.include('hello');
+        expect(message.payload).to.deep.contain({ data: 'Hello, world!' });
+        hello.wake();
+      });
+      await space1.postMessage('hello', { data: 'Hello, world!' });
+    }
+
+    const goodbye = new Trigger();
+    {
+      space2.listen('goodbye', (message) => {
+        expect(message.channelId).to.include('goodbye');
+        expect(message.payload).to.deep.contain({ data: 'Goodbye' });
+        goodbye.wake();
+      });
+      await space1.postMessage('goodbye', { data: 'Goodbye' });
+    }
+
+    await asyncTimeout(Promise.all([hello.wait(), goodbye.wait()]), 200);
+  });
 });

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

@@ -0,0 +1,206 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as fc from 'fast-check';
+import { ModelRunSetup } from 'fast-check';
+import waitForExpect from 'wait-for-expect';
+
+import { Client, Expando, Text } from '@dxos/client';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { describe, test } from '@dxos/test';
+import { Doc } from '@dxos/text-model';
+import { ComplexMap, ComplexSet, range } from '@dxos/util';
+
+import { joinCommonSpace, TestBuilder } from '../testing';
+
+// log.config({ filter: 'text.test:debug,error' });
+
+const testBuilder = new TestBuilder();
+const initialContent = 'Hello, world!';
+
+type Model = {
+  text: string;
+  peers: ComplexSet<PublicKey>;
+};
+
+type Real = {
+  spaceKey: PublicKey;
+  peers: ComplexMap<PublicKey, Client>;
+};
+
+const assertState = async (model: Model, real: Real) => {
+  // Wait for replication.
+  await waitForExpect(() => {
+    for (const [peerId, peer] of real.peers.entries()) {
+      const space = peer.getSpace(real.spaceKey);
+      if (space) {
+        if (!model.peers.has(peerId)) {
+          throw new Error(`Expected peer to not be in space: ${peerId.truncate()}`);
+        }
+
+        const [document] = space.db.query((obj) => !!obj.content).objects;
+        const text = (document.content.doc as Doc).getText('utf8');
+        if (text.toString() !== model.text) {
+          throw new Error(
+            `Text mismatch for peer ${peerId.truncate()}: ${JSON.stringify({ expected: model.text, actual: text })}`
+          );
+        }
+      } else if (model.peers.has(peerId)) {
+        throw new Error(`Expected peer to be in space: ${peerId.truncate()}`);
+      }
+    }
+  }, 1000);
+};
+
+class CreatePeerCommand implements fc.AsyncCommand<Model, Real> {
+  constructor(readonly peerId: PublicKey) {}
+
+  check(model: Model) {
+    return model.peers.size === 0 || !model.peers.has(this.peerId);
+  }
+
+  async run(model: Model, real: Real) {
+    log.debug('run', { command: this.toString() });
+    model.peers.add(this.peerId);
+
+    // TODO(wittjosiah): Too many steps to creat client.
+    const services = testBuilder.createClientServicesHost();
+    await services.open();
+    const [client, server] = testBuilder.createClientServer(services);
+    void server.open();
+    await client.initialize();
+    await client.halo.createIdentity();
+    if (real.peers.size === 0) {
+      const space = await client.createSpace();
+      const content = new Text();
+      content.doc?.getText('utf8').insert(0, initialContent);
+      await space.db.add(new Expando({ content }));
+      real.spaceKey = space.key;
+    } else {
+      const host = Array.from(real.peers.values())[0];
+      await joinCommonSpace([host!, client], real.spaceKey);
+    }
+    real.peers.set(this.peerId, client);
+
+    await assertState(model, real);
+  }
+
+  toString() {
+    return `CreatePeer(peer=${this.peerId.truncate()})`;
+  }
+}
+
+// TODO(wittjosiah)
+// class OfflineMemberCommand implements fc.AsyncCommand<Model, Real> {
+//   constructor(readonly peer: Client) {}
+// }
+
+// TODO(wittjosiah)
+// class OnlineMemberCommand implements fc.AsyncCommand<Model, Real> {
+//   constructor(readonly peer: Client) {}
+// }
+
+class InsertTextCommand implements fc.AsyncCommand<Model, Real> {
+  constructor(readonly peerId: PublicKey, readonly index: number, readonly text: string) {}
+
+  check(model: Model) {
+    return model.peers.has(this.peerId) && model.text.length >= this.index;
+  }
+
+  async run(model: Model, real: Real) {
+    log.debug('run', { command: this.toString() });
+    model.text = model.text.slice(0, this.index) + this.text + model.text.slice(this.index);
+
+    const peer = real.peers.get(this.peerId);
+    const space = peer!.getSpace(real.spaceKey)!;
+    const [document] = space.db.query((obj) => !!obj.content).objects;
+    const text = (document.content.doc as Doc).getText('utf8');
+    text.insert(this.index, this.text);
+
+    await assertState(model, real);
+  }
+
+  toString() {
+    const text = this.text.length > 10 ? `${this.text.slice(0, 10)}...` : this.text;
+    return `InsertText(peer=${this.peerId.truncate()}, index=${this.index}, text=${text})`;
+  }
+}
+
+class RemoveTextCommand implements fc.AsyncCommand<Model, Real> {
+  constructor(readonly peerId: PublicKey, readonly index: number, readonly length: number) {}
+
+  check(model: Model) {
+    return model.peers.has(this.peerId) && model.text.length > this.index + this.length;
+  }
+
+  async run(model: Model, real: Real) {
+    log.debug('run', { command: this.toString() });
+    model.text = model.text.slice(0, this.index) + model.text.slice(this.index + this.length);
+
+    const peer = real.peers.get(this.peerId);
+    const space = peer!.getSpace(real.spaceKey)!;
+    const [document] = space.db.query((obj) => !!obj.content).objects;
+    const text = (document.content.doc as Doc).getText('utf8');
+    text.delete(this.index, this.length);
+
+    await assertState(model, real);
+  }
+
+  toString() {
+    return `RemoveText(peer=${this.peerId.truncate()}, index=${this.index}, length=${this.length})`;
+  }
+}
+
+describe('Client text replication', () => {
+  test('property-based tests', async () => {
+    // TODO(wittjosiah): Increasing to 5 causes failures.
+    const peerIds = range(3).map(() => PublicKey.random());
+    const peerId = fc.constantFrom(...peerIds);
+
+    const allCommands = [
+      peerId.map((peerId) => new CreatePeerCommand(peerId)),
+      fc
+        .tuple(peerId, fc.integer({ min: 0, max: 100 }), fc.unicodeString())
+        .map(([peerId, index, text]) => new InsertTextCommand(peerId, index, text)),
+      fc
+        .tuple(peerId, fc.integer({ min: 0, max: 100 }), fc.integer({ min: 1, max: 10 }))
+        .map(([peerId, index, length]) => new RemoveTextCommand(peerId, index, length))
+    ];
+    const commands = fc.commands(allCommands, { size: 'medium' });
+
+    const model = fc.asyncProperty(commands, async (commands) => {
+      const peers = new ComplexMap<PublicKey, Client>(PublicKey.hash);
+      const setup: ModelRunSetup<Model, Real> = () => ({
+        model: {
+          text: initialContent,
+          peers: new ComplexSet<PublicKey>(PublicKey.hash)
+        },
+        real: {
+          spaceKey: PublicKey.random(),
+          peers
+        }
+      });
+
+      await fc.asyncModelRun(setup, commands);
+
+      await Promise.all(Array.from(peers.values()).map((peer) => peer.destroy()));
+    });
+
+    const examples: [commands: Iterable<fc.AsyncCommand<Model, Real, boolean>>][] = [
+      [
+        [
+          new CreatePeerCommand(peerIds[0]),
+          new CreatePeerCommand(peerIds[1]),
+          new RemoveTextCommand(peerIds[0], 7, 5),
+          new InsertTextCommand(peerIds[1], 7, 'DXOS')
+        ]
+      ]
+    ];
+
+    await fc.assert(model, { examples });
+  })
+    .onlyEnvironments('node')
+    .timeout(300_000);
+});

package/src/packlets/vault/vault-resource-lock.ts

@@ -3,7 +3,7 @@
 //
 
 import { asyncTimeout, Trigger } from '@dxos/async';
-import { log } from '@dxos/log';
+import { log, logInfo } from '@dxos/log';
 import { MaybePromise } from '@dxos/util';
 
 enum Message {
@@ -30,15 +30,24 @@ export class VaultResourceLock {
     this._broadcastChannel.onmessage = this._onMessage.bind(this);
   }
 
+  @logInfo
+  get lockKey() {
+    return this._lockKey;
+  }
+
   async acquire() {
     this._broadcastChannel.postMessage({
       message: Message.ACQUIRING
     });
 
     try {
+      log('aquiring lock...');
       await asyncTimeout(this._requestLock(), 3_000);
+      log('acquired lock');
     } catch {
+      log('stealing lock...');
       await this._requestLock(true);
+      log('stolen lock');
     }
   }