@dxos/echo-pipeline 0.5.0 → 0.5.1-main.2ed734f

package/src/automerge/automerge-host.ts

@@ -2,11 +2,19 @@
 // Copyright 2023 DXOS.org
 //
 
-import { asyncTimeout } from '@dxos/async';
-import { next as automerge } from '@dxos/automerge/automerge';
-import { Repo, type DocumentId, type PeerId, type StorageAdapterInterface } from '@dxos/automerge/automerge-repo';
+import { Event } from '@dxos/async';
+import { type Doc, next as automerge, getBackend, type Heads } from '@dxos/automerge/automerge';
+import {
+  type DocHandle,
+  Repo,
+  type DocumentId,
+  type PeerId,
+  type StorageAdapterInterface,
+  type DocHandleChangePayload,
+} from '@dxos/automerge/automerge-repo';
 import { type Stream } from '@dxos/codec-protobuf';
 import { Context, type Lifecycle } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
@@ -24,7 +32,7 @@ import { LevelDBStorageAdapter, type StorageCallbacks } from './leveldb-storage-
 import { LocalHostNetworkAdapter } from './local-host-network-adapter';
 import { MeshNetworkAdapter } from './mesh-network-adapter';
 import { levelMigration } from './migrations';
-import { type SubLevelDB } from './types';
+import { type SpaceDoc, type SubLevelDB } from './types';
 
 // TODO: Remove
 export type { DocumentId };
@@ -185,16 +193,17 @@ export class AutomergeHost {
   // Methods for client-services.
   //
   @trace.span({ showInBrowserTimeline: true })
-  async flush({ documentIds }: FlushRequest): Promise<void> {
+  async flush({ states }: FlushRequest): Promise<void> {
     // Note: Wait for all requested documents to be loaded/synced from thin-client.
-    await Promise.all(documentIds?.map((id) => this._repo.find(id as DocumentId).whenReady()) ?? []);
-
-    // TODO(dmaretskyi): Workaround until the flush issue gets resolved.
-    try {
-      await asyncTimeout(this._repo.flush(documentIds as DocumentId[]), 500);
-    } catch (err) {
-      log.warn('flush error', { documentIds, err });
-    }
+    await Promise.all(
+      states?.map(async ({ heads, documentId }) => {
+        invariant(heads, 'heads are required for flush');
+        const handle = this.repo.handles[documentId as DocumentId] ?? this._repo.find(documentId as DocumentId);
+        await waitForHeads(handle, heads);
+      }) ?? [],
+    );
+
+    await this._repo.flush(states?.map(({ documentId }) => documentId as DocumentId));
   }
 
   syncRepo(request: SyncRepoRequest): Stream<SyncRepoResponse> {
@@ -232,3 +241,26 @@ export const getSpaceKeyFromDoc = (doc: any): string | null => {
 
   return String(rawSpaceKey);
 };
+
+const waitForHeads = async (handle: DocHandle<SpaceDoc>, heads: Heads) => {
+  await handle.whenReady();
+  const unavailableHeads = new Set(heads);
+
+  await Event.wrap<DocHandleChangePayload<SpaceDoc>>(handle, 'change').waitForCondition(() => {
+    // Check if unavailable heads became available.
+    for (const changeHash of unavailableHeads.values()) {
+      if (changeIsPresentInDoc(handle.docSync(), changeHash)) {
+        unavailableHeads.delete(changeHash);
+      }
+    }
+
+    if (unavailableHeads.size === 0) {
+      return true;
+    }
+    return false;
+  });
+};
+
+const changeIsPresentInDoc = (doc: Doc<any>, changeHash: string): boolean => {
+  return !!getBackend(doc).getChangeByHash(changeHash);
+};

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

@@ -2,19 +2,25 @@
 // Copyright 2024 DXOS.org
 //
 
+import { expect } from 'chai';
+
+import { change, clone, from, getBackend, getHeads } from '@dxos/automerge/automerge';
 import { Repo } from '@dxos/automerge/automerge-repo';
 import { randomBytes } from '@dxos/crypto';
-import { StorageType, createStorage } from '@dxos/random-access-storage';
-import { describe, test } from '@dxos/test';
+import { describe, openAndClose, test } from '@dxos/test';
 
-import { AutomergeStorageAdapter } from './automerge-storage-adapter';
+import { LevelDBStorageAdapter } from './leveldb-storage-adapter';
+import { createTestLevel } from '../testing';
 
 describe('AutomergeRepo', () => {
-  // Currently failing
-  test.skip('flush', async () => {
+  test('flush', async () => {
+    const level = createTestLevel();
+    const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+    await openAndClose(level, storage);
+
     const repo = new Repo({
       network: [],
-      storage: new AutomergeStorageAdapter(createStorage({ type: StorageType.NODE }).createDirectory()),
+      storage,
     });
     const handle = repo.create<{ field?: string }>();
 
@@ -26,4 +32,30 @@ describe('AutomergeRepo', () => {
       await p;
     }
   });
+
+  test('getChangeByHash', async () => {
+    const level = createTestLevel();
+    const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+    await openAndClose(level, storage);
+
+    const doc = from({ foo: 'bar' });
+    const copy = clone(doc);
+    const newDoc = change(copy, 'change', (doc: any) => {
+      doc.foo = 'baz';
+    });
+
+    {
+      const heads = getHeads(newDoc);
+      const changes = heads.map((hash) => getBackend(newDoc).getChangeByHash(hash));
+      expect(changes.length).to.equal(1);
+      expect(changes[0]).to.not.be.null;
+    }
+
+    {
+      const heads = getHeads(newDoc);
+      const changes = heads.map((hash) => getBackend(doc).getChangeByHash(hash));
+      expect(changes.length).to.equal(1);
+      expect(changes[0]).to.be.null;
+    }
+  });
 });

package/src/testing/level.ts

@@ -8,4 +8,5 @@ import { PublicKey } from '@dxos/keys';
 
 import { type LevelDB } from '../automerge/types';
 
-export const createTestLevel = (): LevelDB => new Level<string, string>(`/tmp/dxos-${PublicKey.random().toHex()}`);
+export const createTestLevel = (path = `/tmp/dxos-${PublicKey.random().toHex()}`): LevelDB =>
+  new Level<string, string>(path);