@dxos/echo-pipeline 0.6.2-main.8a232a5 → 0.6.2-main.d41f0d2

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

@@ -6,18 +6,7 @@ import { expect } from 'chai';
 import waitForExpect from 'wait-for-expect';
 
 import { asyncTimeout, sleep } from '@dxos/async';
-import {
-  next as A,
-  type Heads,
-  change,
-  clone,
-  equals,
-  from,
-  getBackend,
-  getHeads,
-  save,
-  saveSince,
-} from '@dxos/automerge/automerge';
+import { type Heads, change, clone, equals, from, getBackend, getHeads } from '@dxos/automerge/automerge';
 import {
   type Message,
   Repo,
@@ -25,8 +14,6 @@ import {
   type DocumentId,
   type HandleState,
   type AutomergeUrl,
-  parseAutomergeUrl,
-  generateAutomergeUrl,
 } from '@dxos/automerge/automerge-repo';
 import { randomBytes } from '@dxos/crypto';
 import { PublicKey } from '@dxos/keys';
@@ -643,115 +630,5 @@ describe('AutomergeRepo', () => {
         expect(peer2.handles[hostHandle.documentId]).to.not.be.undefined;
       });
     });
-
-    test('client cold-starts and syncs doc from a Repo', async () => {
-      const repo = new Repo({ network: [] });
-      const serverHandle = repo.create<{ field?: string }>();
-
-      let clientDoc = A.from<{ field?: string }>({});
-      const receiveByClient = (blob: Uint8Array) => {
-        clientDoc = A.loadIncremental(clientDoc, blob);
-      };
-
-      // Sync handshake.
-      let syncedHeads = getHeads(serverHandle.docSync());
-      receiveByClient(save(serverHandle.docSync()));
-
-      serverHandle.on('change', ({ doc }) => {
-        // Note: This is mock of a sync protocol between client and server.
-        const blob = saveSince(doc, syncedHeads);
-        syncedHeads = getHeads(doc);
-        receiveByClient(blob);
-      });
-
-      {
-        const value = 'text to test if sync works';
-        serverHandle.change((doc: any) => {
-          doc.field = value;
-        });
-        expect(clientDoc.field).to.deep.equal(value);
-      }
-
-      {
-        const value = 'test if updates propagate';
-        serverHandle.change((doc: any) => {
-          doc.field = value;
-        });
-        expect(clientDoc.field).to.deep.equal(value);
-      }
-    });
-
-    test('client creates doc and syncs with a Repo', async () => {
-      const repo = new Repo({ network: [] });
-      const receiveByServer = async (blob: Uint8Array, docId: DocumentId) => {
-        const serverHandle = repo.find(docId);
-        serverHandle.update((doc) => {
-          return A.loadIncremental(doc, blob);
-        });
-      };
-
-      let clientDoc = A.from<{ field?: string }>({});
-      const { documentId } = parseAutomergeUrl(generateAutomergeUrl());
-      // Sync handshake.
-      let sentHeads = getHeads(clientDoc);
-
-      // Sync protocol.
-      const sendDoc = async (doc: A.Doc<any>) => {
-        await receiveByServer(saveSince(doc, sentHeads), documentId);
-        sentHeads = getHeads(doc);
-      };
-
-      {
-        // Change doc and send changes to server.
-        const value = 'text to test if sync works';
-        clientDoc = A.change(clientDoc, (doc: any) => {
-          doc.field = value;
-        });
-        await sendDoc(clientDoc);
-
-        await repo.find(documentId).whenReady();
-        expect(repo.find(documentId).docSync().field).to.deep.equal(value);
-      }
-    });
-
-    test('two repo sync docs on `update` call', 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,
-      });
-
-      {
-        // Connect repos.
-        adapter1.ready();
-        adapter2.ready();
-        await adapter1.onConnect.wait();
-        await adapter2.onConnect.wait();
-        adapter1.peerCandidate(adapter2.peerId!);
-        adapter2.peerCandidate(adapter1.peerId!);
-      }
-
-      const handleA = repoA.create();
-      const handleB = repoB.find(handleA.url);
-
-      const text = 'Hello world';
-      handleA.update((doc: any) => {
-        const newDoc = A.change(doc, (doc: any) => {
-          doc.text = text;
-        });
-        return newDoc;
-      });
-
-      expect(handleA.docSync().text).to.equal(text);
-
-      await asyncTimeout(handleB.whenReady(), 1000);
-      expect(handleB.docSync().text).to.equal(text);
-    });
   });
 });

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

@@ -71,7 +71,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
   @synchronized
   async close() {
     if (this._lifecycleState === LifecycleState.CLOSED) {
-      return this;
+      return;
     }
 
     for (const replicator of this._replicators) {

package/src/automerge/index.ts

@@ -3,6 +3,8 @@
 //
 
 export * from './automerge-host';
+export * from './automerge-doc-loader';
 export * from './leveldb-storage-adapter';
+export * from './local-host-network-adapter';
 export * from './mesh-echo-replicator';
 export * from './echo-replicator';

package/src/automerge/local-host-network-adapter.ts

@@ -0,0 +1,115 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Trigger } from '@dxos/async';
+import { NetworkAdapter, type Message, type PeerId, cbor } from '@dxos/automerge/automerge-repo';
+import { Stream } from '@dxos/codec-protobuf';
+import { invariant } from '@dxos/invariant';
+import { type HostInfo, type SyncRepoRequest, type SyncRepoResponse } from '@dxos/protocols/proto/dxos/echo/service';
+
+type ClientSyncState = {
+  connected: boolean;
+  send: (message: Message) => void;
+  disconnect: () => void;
+};
+
+/**
+ * Used to replicate with apps running on the same device.
+ */
+export class LocalHostNetworkAdapter extends NetworkAdapter {
+  private readonly _peers: Map<PeerId, ClientSyncState> = 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,
+    });
+  }
+
+  private readonly _connected = new Trigger();
+  private _isConnected: boolean = false;
+
+  /**
+   * Called by `Repo` to connect to the network.
+   *
+   * @param peerId Our peer Id.
+   */
+  override connect(peerId: PeerId): void {
+    this.peerId = peerId;
+    this._isConnected = true;
+    this._connected.wake();
+    // No-op. Client always connects first
+  }
+
+  override send(message: Message): void {
+    const peer = this._peers.get(message.targetId);
+    invariant(peer, 'Peer not found.');
+    peer.send(message);
+  }
+
+  async close() {
+    this._peers.forEach((peer) => peer.disconnect());
+    this.emit('close');
+  }
+
+  override disconnect(): void {
+    // TODO(mykola): `disconnect` is not used anywhere in `Repo` from `@automerge/automerge-repo`. Should we remove it?
+    // No-op
+  }
+
+  async whenConnected(): Promise<void> {
+    await this._connected.wait({ timeout: 10_000 });
+  }
+
+  syncRepo({ id, syncMessage }: SyncRepoRequest): Stream<SyncRepoResponse> {
+    const peerId = this._getPeerId(id);
+
+    return new Stream(({ next, close }) => {
+      invariant(!this._peers.has(peerId), 'Peer already connected.');
+      this._peers.set(peerId, {
+        connected: true,
+        send: (message) => {
+          next({
+            syncMessage: cbor.encode(message),
+          });
+        },
+        disconnect: () => {
+          this._peers.delete(peerId);
+          close();
+          this.emit('peer-disconnected', {
+            peerId,
+          });
+        },
+      });
+
+      invariant(this._isConnected);
+      this.emit('peer-candidate', {
+        peerMetadata: {},
+        peerId,
+      });
+    });
+  }
+
+  async sendSyncMessage({ id, syncMessage }: SyncRepoRequest): Promise<void> {
+    invariant(this._isConnected);
+    const message = cbor.decode(syncMessage!) as Message;
+    this.emit('message', message);
+  }
+
+  async getHostInfo(): Promise<HostInfo> {
+    invariant(this._isConnected);
+    invariant(this.peerId, 'Peer id not set.');
+    return {
+      peerId: this.peerId,
+    };
+  }
+
+  private _getPeerId(id: string): PeerId {
+    return id as PeerId;
+  }
+}

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

@@ -10,14 +10,17 @@ import {
   type DataService,
   type DocHeadsList,
   type FlushRequest,
+  type HostInfo,
   type SubscribeRequest,
   type BatchedDocumentUpdates,
   type UpdateSubscriptionRequest,
   type GetDocumentHeadsRequest,
   type GetDocumentHeadsResponse,
   type ReIndexHeadsRequest,
+  type SyncRepoRequest,
+  type SyncRepoResponse,
   type WaitUntilHeadsReplicatedRequest,
-  type UpdateRequest,
+  type WriteRequest,
 } from '@dxos/protocols/proto/dxos/echo/service';
 
 import { DocumentsSynchronizer } from './documents-synchronizer';
@@ -76,20 +79,34 @@ export class DataServiceImpl implements DataService {
     }
   }
 
-  async update(request: UpdateRequest): Promise<void> {
+  async write(request: WriteRequest): Promise<void> {
     if (!request.updates) {
       return;
     }
     const synchronizer = this._subscriptions.get(request.subscriptionId);
     invariant(synchronizer, 'Subscription not found');
 
-    synchronizer.update(request.updates);
+    synchronizer.write(request.updates);
   }
 
   async flush(request: FlushRequest): Promise<void> {
     await this._automergeHost.flush(request);
   }
 
+  // Automerge specific.
+
+  async getHostInfo(request: void): Promise<HostInfo> {
+    return this._automergeHost.getHostInfo();
+  }
+
+  syncRepo(request: SyncRepoRequest): Stream<SyncRepoResponse> {
+    return this._automergeHost.syncRepo(request);
+  }
+
+  sendSyncMessage(request: SyncRepoRequest): Promise<void> {
+    return this._automergeHost.sendSyncMessage(request);
+  }
+
   async getDocumentHeads(request: GetDocumentHeadsRequest): Promise<GetDocumentHeadsResponse> {
     const entries = await Promise.all(
       request.documentIds?.map(async (documentId): Promise<DocHeadsList.Entry> => {

package/src/db-host/documents-synchronizer.test.ts

@@ -23,7 +23,7 @@ describe('DocumentsSynchronizer', () => {
     });
     await openAndClose(synchronizer);
 
-    synchronizer.update([
+    synchronizer.write([
       {
         documentId: parseAutomergeUrl(generateAutomergeUrl()).documentId,
         mutation: A.save(A.from({ text: 'hello' })),

package/src/db-host/documents-synchronizer.ts

@@ -73,7 +73,7 @@ export class DocumentsSynchronizer extends Resource {
     this._syncStates.clear();
   }
 
-  update(updates: DocumentUpdate[]) {
+  write(updates: DocumentUpdate[]) {
     for (const { documentId, mutation, isNew } of updates) {
       if (isNew) {
         const doc = this._params.repo.find(documentId as DocumentId);