@dxos/echo-pipeline 0.3.9-main.eb5df3b → 0.3.9-main.ee839a8

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

@@ -4,7 +4,10 @@
 
 import expect from 'expect';
 
-import { sleep } from '@dxos/async';
+import { Trigger, asyncTimeout, sleep } from '@dxos/async';
+import { type Message, NetworkAdapter, type PeerId, Repo } from '@dxos/automerge/automerge-repo';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
 import { StorageType, createStorage } from '@dxos/random-access-storage';
 import { describe, test } from '@dxos/test';
 
@@ -39,4 +42,81 @@ describe('AutomergeHost', () => {
     await handle2.whenReady();
     expect(handle2.docSync().text).toEqual('Hello world');
   });
+
+  test('basic networking', async () => {
+    type Context = { client: Trigger<TestAdapter>; host: Trigger<TestAdapter> };
+    const context: Context = {
+      client: new Trigger<TestAdapter>(),
+      host: new Trigger<TestAdapter>(),
+    };
+
+    class TestAdapter extends NetworkAdapter {
+      constructor(public readonly context: Context, public readonly role: 'host' | 'client') {
+        super();
+      }
+
+      // NOTE: Emitting `ready` event in NetworkAdapter`s constructor causes a race condition
+      //       because `Repo` waits for `ready` event (which it never receives) before it starts using the adapter.
+      ready() {
+        this.emit('ready', { network: this });
+      }
+
+      override connect(peerId: PeerId) {
+        this.peerId = peerId;
+        context[this.role].wake(this);
+        context[this.role === 'host' ? 'client' : 'host']
+          .wait()
+          .then((adapter) => {
+            invariant(adapter.peerId, 'Peer id is not set');
+            this.emit('peer-candidate', { peerId: adapter.peerId });
+          })
+          .catch((error) => {
+            log.catch(error);
+          });
+      }
+
+      override send(message: Message) {
+        context[this.role === 'host' ? 'client' : 'host']
+          .wait()
+          .then((adapter) => {
+            adapter.receive(message);
+          })
+          .catch((error) => {
+            log.catch(error);
+          });
+      }
+
+      override disconnect() {
+        this.peerId = undefined;
+        this.context[this.role].reset();
+      }
+
+      receive(message: Message) {
+        invariant(this.peerId, 'Peer id is not set');
+        this.emit('message', message);
+      }
+    }
+
+    const hostAdapter = new TestAdapter(context, 'host');
+    const clientAdapter = new TestAdapter(context, 'client');
+
+    const host = new Repo({
+      network: [hostAdapter],
+    });
+    const client = new Repo({
+      network: [clientAdapter],
+    });
+    hostAdapter.ready();
+    clientAdapter.ready();
+
+    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(), 3_000);
+    expect(docOnClient.docSync().text).toEqual(text);
+  });
 });

package/src/automerge/automerge-host.ts

@@ -14,8 +14,11 @@ import {
 } from '@dxos/automerge/automerge-repo';
 import { Stream } from '@dxos/codec-protobuf';
 import { invariant } from '@dxos/invariant';
-import { type SyncRepoRequest, type SyncRepoResponse } from '@dxos/protocols/proto/dxos/echo/service';
+import { log } from '@dxos/log';
+import { type HostInfo, type SyncRepoRequest, type SyncRepoResponse } from '@dxos/protocols/proto/dxos/echo/service';
+import { type PeerInfo } from '@dxos/protocols/proto/dxos/mesh/teleport/automerge';
 import { type Directory } from '@dxos/random-access-storage';
+import { AutomergeReplicator } from '@dxos/teleport-extension-automerge-replicator';
 import { arrayToBuffer, bufferToArray } from '@dxos/util';
 
 export class AutomergeHost {
@@ -29,22 +32,28 @@ export class AutomergeHost {
     this._clientNetwork = new LocalHostNetworkAdapter();
     this._storage = new AutomergeStorageAdapter(storageDirectory);
     this._repo = new Repo({
-      network: [
-        // this._meshNetwork,
-        this._clientNetwork,
-      ],
-
+      network: [this._clientNetwork, this._meshNetwork],
       storage: this._storage,
 
       // TODO(dmaretskyi): Share based on HALO permissions and space affinity.
       sharePolicy: async (peerId, documentId) => true, // Share everything.
     });
+    this._clientNetwork.ready();
+    this._meshNetwork.ready();
   }
 
   get repo(): Repo {
     return this._repo;
   }
 
+  async close() {
+    await this._clientNetwork.close();
+  }
+
+  //
+  // Methods for client-services.
+  //
+
   syncRepo(request: SyncRepoRequest): Stream<SyncRepoResponse> {
     return this._clientNetwork.syncRepo(request);
   }
@@ -52,6 +61,18 @@ export class AutomergeHost {
   sendSyncMessage(request: SyncRepoRequest): Promise<void> {
     return this._clientNetwork.sendSyncMessage(request);
   }
+
+  getHostInfo(): HostInfo {
+    return this._clientNetwork.getHostInfo();
+  }
+
+  //
+  // Mesh replication.
+  //
+
+  createExtension(): AutomergeReplicator {
+    return this._meshNetwork.createExtension();
+  }
 }
 
 type ClientSyncState = {
@@ -66,15 +87,19 @@ type ClientSyncState = {
 class LocalHostNetworkAdapter extends NetworkAdapter {
   private readonly _peers: Map<PeerId, ClientSyncState> = new Map();
 
-  constructor() {
-    super();
-
+  /**
+   * Emits `ready` event. That signals to `Repo` that it can start using the adapter.
+   */
+  ready() {
+    // NOTE: Emitting `ready` event in NetworkAdapter`s constructor causes a race condition
+    //       because `Repo` waits for `ready` event (which it never receives) before it starts using the adapter.
     this.emit('ready', {
       network: this,
     });
   }
 
   override connect(peerId: PeerId): void {
+    this.peerId = peerId;
     // No-op. Client always connects first
   }
 
@@ -84,8 +109,14 @@ class LocalHostNetworkAdapter extends NetworkAdapter {
     peer.send(message);
   }
 
+  async close() {
+    this._peers.forEach((peer) => peer.disconnect());
+    this.emit('close');
+  }
+
   override disconnect(): void {
-    throw new Error('Method not implemented.');
+    // TODO(mykola): `disconnect` is not used anywhere in `Repo` from `@automerge/automerge-repo`. Should we remove it?
+    // No-op
   }
 
   syncRepo({ id, syncMessage }: SyncRepoRequest): Stream<SyncRepoResponse> {
@@ -120,6 +151,13 @@ class LocalHostNetworkAdapter extends NetworkAdapter {
     this.emit('message', message);
   }
 
+  getHostInfo(): HostInfo {
+    invariant(this.peerId, 'Peer id not set.');
+    return {
+      peerId: this.peerId,
+    };
+  }
+
   private _getPeerId(id: string): PeerId {
     return id as PeerId;
   }
@@ -129,16 +167,64 @@ class LocalHostNetworkAdapter extends NetworkAdapter {
  * Used to replicate with other peers over the network.
  */
 class MeshNetworkAdapter extends NetworkAdapter {
+  private readonly _extensions: Map<string, AutomergeReplicator> = new Map();
+
+  /**
+   * Emits `ready` event. That signals to `Repo` that it can start using the adapter.
+   */
+  ready() {
+    // NOTE: Emitting `ready` event in NetworkAdapter`s constructor causes a race condition
+    //       because `Repo` waits for `ready` event (which it never receives) before it starts using the adapter.
+    this.emit('ready', {
+      network: this,
+    });
+  }
+
   override connect(peerId: PeerId): void {
-    throw new Error('Method not implemented.');
+    this.peerId = peerId;
   }
 
   override send(message: Message): void {
-    throw new Error('Method not implemented.');
+    const receiverId = message.targetId;
+    const extension = this._extensions.get(receiverId);
+    invariant(extension, 'Extension not found.');
+    extension.sendSyncMessage({ payload: cbor.encode(message) }).catch((err) => log.catch(err));
   }
 
   override disconnect(): void {
-    throw new Error('Method not implemented.');
+    // No-op
+  }
+
+  createExtension(): AutomergeReplicator {
+    invariant(this.peerId, 'Peer id not set.');
+
+    let peerInfo: PeerInfo;
+    const extension = new AutomergeReplicator(
+      {
+        peerId: this.peerId,
+      },
+      {
+        onStartReplication: async (info) => {
+          peerInfo = info;
+          // TODO(mykola): Fix race condition?
+          this._extensions.set(info.id, extension);
+          this.emit('peer-candidate', {
+            peerId: info.id as PeerId,
+          });
+        },
+        onSyncMessage: async ({ payload }) => {
+          const message = cbor.decode(payload) as Message;
+          this.emit('message', message);
+        },
+        onClose: async () => {
+          peerInfo &&
+            this.emit('peer-disconnected', {
+              peerId: peerInfo.id as PeerId,
+            });
+        },
+      },
+    );
+    return extension;
   }
 }
 
@@ -151,6 +237,9 @@ class AutomergeStorageAdapter extends StorageAdapter {
     const filename = this._getFilename(key);
     const file = this._directory.getOrCreateFile(filename);
     const { size } = await file.stat();
+    if (!size || size === 0) {
+      return undefined;
+    }
     const buffer = await file.read(0, size);
     return bufferToArray(buffer);
   }

package/src/db-host/data-service-host.ts

@@ -18,6 +18,7 @@ import {
   type MutationReceipt,
   type WriteRequest,
   type SyncRepoResponse,
+  type HostInfo,
 } from '@dxos/protocols/proto/dxos/echo/service';
 import { ComplexMap } from '@dxos/util';
 
@@ -205,6 +206,10 @@ export class DataServiceHost {
     await this._flush();
   }
 
+  getHostInfo(): Promise<HostInfo> {
+    throw new Error('Method not implemented.');
+  }
+
   syncRepo(request: SyncRepoRequest): Stream<SyncRepoResponse> {
     throw new Error('Method not implemented.');
   }

package/src/db-host/data-service.ts

@@ -16,6 +16,7 @@ import {
   type FlushRequest,
   type SyncRepoRequest,
   type SyncRepoResponse,
+  type HostInfo,
 } from '@dxos/protocols/proto/dxos/echo/service';
 import { ComplexMap } from '@dxos/util';
 
@@ -81,11 +82,17 @@ export class DataServiceImpl implements DataService {
     return host.flush();
   }
 
+  // Automerge specific.
+
+  async getHostInfo(request: void): Promise<HostInfo> {
+    return this._automergeHost.getHostInfo();
+  }
+
   syncRepo(request: SyncRepoRequest): Stream<SyncRepoResponse> {
-    throw new Error('Method not implemented.');
+    return this._automergeHost.syncRepo(request);
   }
 
   sendSyncMessage(request: SyncRepoRequest): Promise<void> {
-    throw new Error('Method not implemented.');
+    return this._automergeHost.sendSyncMessage(request);
   }
 }

package/src/space/space-manager.ts

@@ -39,6 +39,9 @@ export type ConstructSpaceParams = {
   metadata: SpaceMetadata;
   swarmIdentity: SwarmIdentity;
   memberKey: PublicKey;
+  /**
+   * Called when connection auth passed successful.
+   */
   onNetworkConnection: (session: Teleport) => void;
   onAuthFailure?: (session: Teleport) => void;
 };