@dxos/echo-pipeline 0.5.8 → 0.5.9-main.0a0e87d

package/src/automerge/automerge-repo.test.ts

@@ -3,16 +3,40 @@
 //
 
 import { expect } from 'chai';
+import waitForExpect from 'wait-for-expect';
 
+import { asyncTimeout, sleep } from '@dxos/async';
 import { type Heads, change, clone, equals, from, getBackend, getHeads } from '@dxos/automerge/automerge';
-import { Repo } from '@dxos/automerge/automerge-repo';
+import { type Message, Repo, type PeerId, type DocumentId, type HandleState } from '@dxos/automerge/automerge-repo';
 import { randomBytes } from '@dxos/crypto';
+import { PublicKey } from '@dxos/keys';
 import { createTestLevel } from '@dxos/kv-store/testing';
-import { describe, openAndClose, test } from '@dxos/test';
+import { TestBuilder as TeleportBuilder, TestPeer as TeleportPeer } from '@dxos/teleport/testing';
+import { afterTest, describe, openAndClose, test } from '@dxos/test';
 
+import { EchoNetworkAdapter } from './echo-network-adapter';
 import { LevelDBStorageAdapter } from './leveldb-storage-adapter';
+import { MeshEchoReplicator } from './mesh-echo-replicator';
+import { TestAdapter } from '../testing';
 
 describe('AutomergeRepo', () => {
+  test('change events', () => {
+    const repo = new Repo({ network: [] });
+    const handle = repo.create<{ field?: string }>();
+
+    let valueDuringChange: string | undefined;
+
+    handle.addListener('change', (doc) => {
+      valueDuringChange = handle.docSync().field;
+    });
+
+    handle.change((doc: any) => {
+      doc.field = 'value';
+    });
+
+    expect(valueDuringChange).to.eq('value');
+  });
+
   test('flush', async () => {
     const level = createTestLevel();
     const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
@@ -67,4 +91,428 @@ describe('AutomergeRepo', () => {
     expect(equals(a, b)).to.be.false;
     expect(equals(a, c)).to.be.true;
   });
+
+  describe('network', () => {
+    test('basic networking', async () => {
+      const hostAdapter: TestAdapter = new TestAdapter({
+        send: (message: Message) => clientAdapter.receive(message),
+      });
+      const clientAdapter: TestAdapter = new TestAdapter({
+        send: (message: Message) => hostAdapter.receive(message),
+      });
+
+      const host = new Repo({
+        network: [hostAdapter],
+      });
+      const client = new Repo({
+        network: [clientAdapter],
+      });
+      hostAdapter.ready();
+      clientAdapter.ready();
+      await hostAdapter.onConnect.wait();
+      await clientAdapter.onConnect.wait();
+      hostAdapter.peerCandidate(clientAdapter.peerId!);
+      clientAdapter.peerCandidate(hostAdapter.peerId!);
+
+      const handle = host.create();
+      const text = 'Hello world';
+      handle.change((doc: any) => {
+        doc.text = text;
+      });
+
+      const docOnClient = client.find(handle.url);
+      expect((await asyncTimeout(docOnClient.doc(), 1000)).text).to.equal(text);
+    });
+
+    test('share policy gets enabled afterwards', async () => {
+      const [hostAdapter, clientAdapter] = TestAdapter.createPair();
+      let sharePolicy = false;
+
+      const host = new Repo({
+        network: [hostAdapter],
+        peerId: 'host' as PeerId,
+        sharePolicy: async () => sharePolicy,
+      });
+      const client = new Repo({
+        network: [clientAdapter],
+        peerId: 'client' as PeerId,
+        sharePolicy: async () => sharePolicy,
+      });
+      hostAdapter.ready();
+      clientAdapter.ready();
+      await hostAdapter.onConnect.wait();
+      await clientAdapter.onConnect.wait();
+      hostAdapter.peerCandidate(clientAdapter.peerId!);
+      clientAdapter.peerCandidate(hostAdapter.peerId!);
+
+      const handle = host.create();
+      const text = 'Hello world';
+      handle.change((doc: any) => {
+        doc.text = text;
+      });
+
+      {
+        const docOnClient = client.find(handle.url);
+        await asyncTimeout(docOnClient.whenReady(['unavailable']), 1000);
+      }
+
+      sharePolicy = true;
+
+      {
+        const docOnClient = client.find(handle.url);
+        // TODO(mykola): We expect the document to be available here, but it's not.
+        await asyncTimeout(docOnClient.whenReady(['unavailable']), 1000);
+      }
+    });
+
+    test('two documents and share policy switching', async () => {
+      const [hostAdapter, clientAdapter] = TestAdapter.createPair();
+      const allowedDocs: DocumentId[] = [];
+
+      const host: Repo = new Repo({
+        network: [hostAdapter],
+        peerId: 'host' as PeerId,
+        sharePolicy: async (_, docId) => (docId ? allowedDocs.includes(docId) && !!host.handles[docId] : false),
+      });
+
+      const client: Repo = new Repo({
+        network: [clientAdapter],
+        peerId: 'client' as PeerId,
+        sharePolicy: async (_, docId) => (docId ? allowedDocs.includes(docId) && !!client.handles[docId] : false),
+      });
+
+      const firstHandle = host.create();
+      firstHandle.change((doc: any) => (doc.text = 'Hello world'));
+      await host.find(firstHandle.url).whenReady();
+      allowedDocs.push(firstHandle.documentId);
+
+      {
+        // Initiate connection.
+        hostAdapter.ready();
+        clientAdapter.ready();
+        await hostAdapter.onConnect.wait();
+        await clientAdapter.onConnect.wait();
+        hostAdapter.peerCandidate(clientAdapter.peerId!);
+        clientAdapter.peerCandidate(hostAdapter.peerId!);
+      }
+
+      {
+        const firstDocOnClient = client.find(firstHandle.url);
+        await asyncTimeout(firstDocOnClient.whenReady(), 1000);
+        expect(firstDocOnClient.docSync().text).to.equal('Hello world');
+      }
+
+      const secondHandle = host.create();
+      secondHandle.change((doc: any) => (doc.text = 'Hello world'));
+      await host.find(secondHandle.url).whenReady();
+      allowedDocs.push(secondHandle.documentId);
+
+      {
+        const secondDocOnClient = client.find(secondHandle.url);
+        await asyncTimeout(secondDocOnClient.whenReady(), 1000);
+        expect(secondDocOnClient.docSync().text).to.equal('Hello world');
+      }
+    });
+
+    test('recovering from a lost connection', async () => {
+      let connectionState: 'on' | 'off' = 'on';
+
+      const hostAdapter: TestAdapter = new TestAdapter({
+        send: (message: Message) => connectionState === 'on' && sleep(10).then(() => clientAdapter.receive(message)),
+      });
+      const clientAdapter: TestAdapter = new TestAdapter({
+        send: (message: Message) => connectionState === 'on' && sleep(10).then(() => hostAdapter.receive(message)),
+      });
+
+      const host = new Repo({
+        network: [hostAdapter],
+      });
+      const client = new Repo({
+        network: [clientAdapter],
+      });
+
+      // Establish connection.
+      hostAdapter.ready();
+      clientAdapter.ready();
+      await hostAdapter.onConnect.wait();
+      await clientAdapter.onConnect.wait();
+      hostAdapter.peerCandidate(clientAdapter.peerId!);
+      clientAdapter.peerCandidate(hostAdapter.peerId!);
+
+      const handle = host.create();
+      const docOnClient = client.find(handle.url);
+      {
+        const sanityText = 'Hello world';
+        handle.change((doc: any) => {
+          doc.sanityText = sanityText;
+        });
+
+        expect((await asyncTimeout(docOnClient.doc(), 1000)).sanityText).to.equal(sanityText);
+      }
+
+      // Disrupt connection.
+      const offlineText = 'This has been written while the connection was off';
+      {
+        connectionState = 'off';
+
+        handle.change((doc: any) => {
+          doc.offlineText = offlineText;
+        });
+
+        await sleep(100);
+        expect((await asyncTimeout(docOnClient.doc(), 1000)).offlineText).to.be.undefined;
+      }
+
+      // Re-establish connection.
+      const onlineText = 'This has been written after the connection was re-established';
+      {
+        connectionState = 'on';
+        hostAdapter.peerDisconnected(clientAdapter.peerId!);
+        clientAdapter.peerDisconnected(hostAdapter.peerId!);
+        hostAdapter.peerCandidate(clientAdapter.peerId!);
+        clientAdapter.peerCandidate(hostAdapter.peerId!);
+
+        handle.change((doc: any) => {
+          doc.onlineText = onlineText;
+        });
+        await sleep(100);
+        expect((await asyncTimeout(docOnClient.doc(), 1000)).onlineText).to.equal(onlineText);
+        expect((await asyncTimeout(docOnClient.doc(), 1000)).offlineText).to.equal(offlineText);
+      }
+    });
+
+    test('integration test with teleport', async () => {
+      const [spaceKey] = PublicKey.randomSequence();
+
+      const createAutomergeRepo = async () => {
+        const meshAdapter = new MeshEchoReplicator();
+        const echoAdapter = new EchoNetworkAdapter({
+          getContainingSpaceForDocument: async () => spaceKey,
+        });
+        const repo = new Repo({
+          network: [echoAdapter],
+        });
+        await echoAdapter.open();
+        await echoAdapter.whenConnected();
+        await echoAdapter.addReplicator(meshAdapter);
+        return { repo, meshAdapter };
+      };
+      const peer1 = await createAutomergeRepo();
+      const peer2 = await createAutomergeRepo();
+
+      const handle = peer1.repo.create();
+
+      const teleportBuilder = new TeleportBuilder();
+      afterTest(() => teleportBuilder.destroy());
+
+      const [teleportPeer1, teleportPeer2] = teleportBuilder.createPeers({ factory: () => new TeleportPeer() });
+      {
+        // Initiate connection.
+        const [connection1, connection2] = await teleportBuilder.connect(teleportPeer1, teleportPeer2);
+        connection1.teleport.addExtension('automerge', peer1.meshAdapter.createExtension());
+        connection2.teleport.addExtension('automerge', peer2.meshAdapter.createExtension());
+
+        // Test connection.
+        const text = 'Hello world';
+        handle.change((doc: any) => {
+          doc.text = text;
+        });
+        await waitForExpect(async () => {
+          const docOnPeer2 = peer2.repo.find(handle.url);
+          const doc = await asyncTimeout(docOnPeer2.doc(), 1000);
+          expect(doc.text).to.eq(text);
+        }, 1000);
+      }
+
+      const offlineText = 'This has been written while the connection was off';
+      {
+        // Disconnect peers.
+        await teleportBuilder.disconnect(teleportPeer1, teleportPeer2);
+
+        // Make offline changes.
+        const offlineText = 'This has been written while the connection was off';
+        handle.change((doc: any) => {
+          doc.offlineText = offlineText;
+        });
+        const docOnPeer2 = peer2.repo.find(handle.url);
+        await sleep(100);
+        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).offlineText).to.be.undefined;
+      }
+
+      {
+        const docOnPeer2 = peer2.repo.find(handle.url);
+        const receivedUpdate = new Promise((resolve, reject) => docOnPeer2.once('heads-changed', resolve));
+
+        // Reconnect peers.
+        const [connection1, connection2] = await teleportBuilder.connect(teleportPeer1, teleportPeer2);
+        connection1.teleport.addExtension('automerge', peer1.meshAdapter.createExtension());
+        connection2.teleport.addExtension('automerge', peer2.meshAdapter.createExtension());
+
+        // Wait for offline changes to be synced.
+        await receivedUpdate;
+        await docOnPeer2.whenReady();
+        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).offlineText).to.eq(offlineText);
+
+        // Test connection.
+        const onlineText = 'This has been written after the connection was re-established';
+        const receivedOnlineUpdate = new Promise((resolve, reject) => docOnPeer2.once('heads-changed', resolve));
+        handle.change((doc: any) => {
+          doc.onlineText = onlineText;
+        });
+        await receivedOnlineUpdate;
+        await docOnPeer2.whenReady();
+        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).onlineText).to.eq(onlineText);
+      }
+    });
+
+    test('replication though a 4 peer chain', async () => {
+      const pairAB = TestAdapter.createPair();
+      const pairBC = TestAdapter.createPair();
+      const pairCD = TestAdapter.createPair();
+
+      const repoA = new Repo({
+        peerId: 'A' as any,
+        network: [pairAB[0]],
+        sharePolicy: async () => true,
+      });
+      const _repoB = new Repo({
+        peerId: 'B' as any,
+        network: [pairAB[1], pairBC[0]],
+        sharePolicy: async () => true,
+      });
+      const _repoC = new Repo({
+        peerId: 'C' as any,
+        network: [pairBC[1], pairCD[0]],
+        sharePolicy: async () => true,
+      });
+      const repoD = new Repo({
+        peerId: 'D' as any,
+        network: [pairCD[1]],
+        sharePolicy: async () => true,
+      });
+
+      for (const pair of [pairAB, pairBC, pairCD]) {
+        pair[0].ready();
+        pair[1].ready();
+        await pair[0].onConnect.wait();
+        await pair[1].onConnect.wait();
+        pair[0].peerCandidate(pair[1].peerId!);
+        pair[1].peerCandidate(pair[0].peerId!);
+      }
+
+      const docA = repoA.create();
+      // NOTE: Doesn't work if the doc is empty.
+      docA.change((doc: any) => {
+        doc.text = 'Hello world';
+      });
+
+      // If we wait here for replication to finish naturally, the test will pass.
+
+      const docD = repoD.find(docA.url);
+
+      await docD.whenReady();
+    });
+
+    test('replication though a 3 peer chain', async () => {
+      const pairAB = TestAdapter.createPair();
+      const pairBC = TestAdapter.createPair();
+
+      const repoA = new Repo({
+        peerId: 'A' as any,
+        network: [pairAB[0]],
+        sharePolicy: async () => true,
+      });
+      const repoB = new Repo({
+        peerId: 'B' as any,
+        network: [pairAB[1], pairBC[0]],
+        sharePolicy: async () => true,
+      });
+      const repoC = new Repo({
+        peerId: 'C' as any,
+        network: [pairBC[1]],
+        sharePolicy: async () => true,
+      });
+
+      for (const pair of [pairAB, pairBC]) {
+        pair[0].ready();
+        pair[1].ready();
+        await pair[0].onConnect.wait();
+        await pair[1].onConnect.wait();
+        pair[0].peerCandidate(pair[1].peerId!);
+        pair[1].peerCandidate(pair[0].peerId!);
+      }
+
+      const docA = repoA.create();
+      // NOTE: Doesn't work if the doc is empty.
+      docA.change((doc: any) => {
+        doc.text = 'Hello world';
+      });
+
+      const _docB = repoB.find(docA.url);
+      const docC = repoC.find(docA.url);
+
+      await docC.whenReady();
+    });
+
+    test('replicate document after request', async () => {
+      const [adapter1, adapter2] = TestAdapter.createPair();
+      const repoA = new Repo({
+        peerId: 'A' as any,
+        network: [adapter1],
+        sharePolicy: async () => true,
+      });
+      const repoB = new Repo({
+        peerId: 'B' as any,
+        network: [adapter2],
+        sharePolicy: async () => true,
+      });
+
+      const unavailable: HandleState = 'unavailable';
+
+      {
+        // Connect repos.
+        adapter1.ready();
+        adapter2.ready();
+        await adapter1.onConnect.wait();
+        await adapter2.onConnect.wait();
+      }
+
+      const docA = repoA.create();
+      // NOTE: Doesn't work if the doc is empty.
+      docA.change((doc: any) => {
+        doc.text = 'Hello world';
+      });
+
+      const docB = repoB.find(docA.url);
+      {
+        // Request document from repoB.
+        await asyncTimeout(docB.whenReady([unavailable]), 1_000);
+      }
+
+      {
+        // Failing to find a document.
+        // await (docB.whenReady([unavailable]), 1_000);
+      }
+
+      {
+        adapter1.peerCandidate(adapter2.peerId!);
+        await sleep(100);
+        adapter2.peerCandidate(adapter1.peerId!);
+      }
+
+      {
+        await asyncTimeout(docB.whenReady([unavailable]), 1_000);
+      }
+
+      {
+        // Note: Retry hack.
+        adapter1.peerDisconnected(adapter2.peerId!);
+        adapter2.peerDisconnected(adapter1.peerId!);
+        adapter1.peerCandidate(adapter2.peerId!);
+        adapter2.peerCandidate(adapter1.peerId!);
+
+        await asyncTimeout(docB.whenReady(), 1_000);
+      }
+    });
+  });
 });

package/src/automerge/echo-network-adapter.ts

@@ -93,6 +93,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
       peerId: this.peerId,
       onConnectionOpen: this._onConnectionOpen.bind(this),
       onConnectionClosed: this._onConnectionClosed.bind(this),
+      onConnectionAuthScopeChanged: this._onConnectionAuthScopeChanged.bind(this),
       getContainingSpaceForDocument: this._params.getContainingSpaceForDocument,
     });
   }
@@ -101,7 +102,6 @@ export class EchoNetworkAdapter extends NetworkAdapter {
   async removeReplicator(replicator: EchoReplicator) {
     invariant(this._lifecycleState === LifecycleState.OPEN);
     invariant(this._replicators.has(replicator));
-    ('');
     await replicator.disconnect();
     this._replicators.delete(replicator);
   }
@@ -142,13 +142,19 @@ export class EchoNetworkAdapter extends NetworkAdapter {
     });
 
     log('emit peer-candidate', { peerId: connection.peerId });
-    this.emit('peer-candidate', {
-      peerId: connection.peerId as PeerId,
-      peerMetadata: {
-        // TODO(dmaretskyi): Refactor this.
-        dxos_peerSource: 'EchoNetworkAdapter',
-      } as any,
-    });
+    this._emitPeerCandidate(connection);
+  }
+
+  /**
+   * Trigger doc-synchronizer shared documents set recalculation. Happens on peer-candidate.
+   * TODO(y): replace with a proper API call when sharePolicy update becomes supported by automerge-repo
+   */
+  private _onConnectionAuthScopeChanged(connection: ReplicatorConnection) {
+    log('Connection auth scope changed', { peerId: connection.peerId });
+    const entry = this._connections.get(connection.peerId as PeerId);
+    invariant(entry);
+    this.emit('peer-disconnected', { peerId: connection.peerId as PeerId });
+    this._emitPeerCandidate(connection);
   }
 
   private _onConnectionClosed(connection: ReplicatorConnection) {
@@ -164,6 +170,16 @@ export class EchoNetworkAdapter extends NetworkAdapter {
 
     this._connections.delete(connection.peerId as PeerId);
   }
+
+  private _emitPeerCandidate(connection: ReplicatorConnection) {
+    this.emit('peer-candidate', {
+      peerId: connection.peerId as PeerId,
+      peerMetadata: {
+        // TODO(dmaretskyi): Refactor this.
+        dxos_peerSource: 'EchoNetworkAdapter',
+      } as any,
+    });
+  }
 }
 
 type ConnectionEntry = {

package/src/automerge/echo-replicator.ts

@@ -27,6 +27,8 @@ export interface EchoReplicatorContext {
 
   onConnectionClosed(connection: ReplicatorConnection): void;
 
+  onConnectionAuthScopeChanged(connection: ReplicatorConnection): void;
+
   getContainingSpaceForDocument(documentId: string): Promise<PublicKey | null>;
 }
 

package/src/automerge/mesh-echo-replicator.ts

@@ -59,7 +59,9 @@ export class MeshEchoReplicator implements EchoReplicator {
         log('onRemoteConnected', { peerId: connection.peerId });
         invariant(this._context);
 
-        if (!this._connectionsPerPeer.has(connection.peerId)) {
+        if (this._connectionsPerPeer.has(connection.peerId)) {
+          this._context.onConnectionAuthScopeChanged(connection);
+        } else {
           this._connectionsPerPeer.set(connection.peerId, connection);
           await connection.enable();
           this._context.onConnectionOpen(connection);

package/src/automerge/migrations.ts

@@ -12,7 +12,7 @@ import { AutomergeStorageAdapter } from './automerge-storage-adapter';
 import { encodingOptions } from './leveldb-storage-adapter';
 
 export const levelMigration = async ({ db, directory }: { db: SublevelDB; directory: Directory }) => {
-  // Note: Make automigration from previous storage to leveldb here.
+  // Note: Make auto-migration from previous storage to leveldb here.
   const isNewLevel = !(await db
     .iterator<StorageKey, Uint8Array>({
       ...encodingOptions,
@@ -32,6 +32,7 @@ export const levelMigration = async ({ db, directory }: { db: SublevelDB; direct
   if (chunks.length === 0) {
     return;
   }
+
   const batch = db.batch();
   log.info('found chunks on old storage adapter', { chunks: chunks.length });
   for (const { key, data } of await oldStorageAdapter.loadRange([])) {