@dxos/echo-pipeline 0.8.4-main.ae835ea → 0.8.4-main.bc674ce

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

@@ -19,6 +19,7 @@ import {
   type DocHandle,
   type DocumentId,
   type HandleState,
+  type Message,
   type PeerId,
   Repo,
   type SharePolicy,
@@ -32,6 +33,7 @@ import { asyncTimeout, sleep } from '@dxos/async';
 import { randomBytes } from '@dxos/crypto';
 import { PublicKey } from '@dxos/keys';
 import { createTestLevel } from '@dxos/kv-store/testing';
+import { log } from '@dxos/log';
 import { TestBuilder as TeleportBuilder, TestPeer as TeleportPeer } from '@dxos/teleport/testing';
 import { openAndClose } from '@dxos/test-utils';
 import { isNonNullable, range } from '@dxos/util';
@@ -162,32 +164,6 @@ describe('AutomergeRepo', () => {
       expect((await asyncTimeout(client.find<any>(handle.url), 1000))!.doc().text).to.equal(text);
     });
 
-    test('share policy gets enabled afterwards', async () => {
-      let sharePolicy = false;
-
-      const { repos, adapters } = await createHostClientRepoTopology({
-        sharePolicy: async () => sharePolicy,
-      });
-      const [host, client] = repos;
-      await connectAdapters(adapters);
-
-      const handle = host.create();
-      const text = 'Hello world';
-      handle.change((doc: any) => {
-        doc.text = text;
-      });
-
-      {
-        await client.find(handle.url, { allowableStates: ['unavailable'] });
-      }
-
-      sharePolicy = true;
-
-      {
-        await client.find(handle.url, { allowableStates: ['unavailable'] });
-      }
-    });
-
     test('two documents and share policy switching', async () => {
       const allowedDocs: DocumentId[] = [];
 
@@ -510,6 +486,139 @@ describe('AutomergeRepo', () => {
       await asyncTimeout(handleB.whenReady(), 1000);
       expect(handleB.doc()!.text).to.equal(text);
     });
+
+    test('retry share config', async () => {
+      let announce = false;
+
+      const { repos, adapters } = await createRepoTopology({
+        peers: ['A', 'B'],
+        connections: [['A', 'B']],
+        options: {
+          shareConfig: {
+            access: async () => true,
+            announce: async () => announce,
+          },
+        },
+        onMessage: (message) => {
+          console.log(`${message.senderId} -> ${message.targetId}: ${message.type} ${message.documentId ?? ''}`);
+        },
+      });
+      const [repoA, repoB] = repos;
+      await connectAdapters(adapters);
+      console.log({ peersA: repoA.peers, peersB: repoB.peers });
+
+      const docA = repoA.create({ text: 'Hello world' });
+
+      const docB = await repoB.find(docA.url, { allowableStates: ['ready', 'unavailable'] });
+      expect(docB.state).to.equal('unavailable');
+      log.info('unavailable');
+
+      announce = true;
+      repoB.shareConfigChanged();
+      await docB.whenReady();
+    });
+  });
+
+  describe('create2 tests', () => {
+    test('basic document creation', async () => {
+      const repo = new Repo({ network: [] });
+
+      const handle = await repo.create2<{ text: string }>();
+      expect(handle.doc()).to.deep.equal({});
+
+      handle.change((doc: any) => {
+        doc.text = 'Hello World';
+      });
+
+      expect(handle.doc()?.text).to.equal('Hello World');
+    });
+
+    test('document mutation', async () => {
+      const repo = new Repo({ network: [] });
+
+      const handle = await repo.create2<{ counter: number }>({ counter: 0 });
+
+      for (let i = 1; i <= 10; i++) {
+        handle.change((doc: any) => {
+          doc.counter = i;
+        });
+      }
+
+      expect(handle.doc()?.counter).to.equal(10);
+    });
+
+    test('import document and mutate', async () => {
+      const repo = new Repo({ network: [] });
+
+      const original = await repo.create2<{ text: string }>({ text: 'original' });
+      const blob = A.save(original.doc()!);
+
+      const imported = repo.import<{ text: string }>(blob);
+      expect(imported.doc()?.text).to.equal('original');
+
+      imported.change((doc: any) => {
+        doc.text = 'mutated';
+      });
+      expect(imported.doc()?.text).to.equal('mutated');
+    });
+
+    test('reload document with flush', async () => {
+      const path = createTmpPath();
+      const text = 'Hello World!';
+      let url: AutomergeUrl;
+
+      {
+        const level = createTestLevel(path);
+        const storage = await createLevelAdapter(level);
+        const repo = new Repo({ network: [], storage });
+        const handle = await repo.create2<{ text: string }>();
+        url = handle.url;
+        handle.change((doc: any) => {
+          doc.text = text;
+        });
+        await repo.flush([handle.documentId]);
+        await level.close();
+      }
+
+      {
+        const level = createTestLevel(path);
+        const storage = await createLevelAdapter(level);
+        const repo = new Repo({ network: [], storage });
+        const handle = await repo.find<{ text: string }>(url);
+        await handle.whenReady();
+        expect(handle.doc()?.text).to.equal(text);
+        await level.close();
+      }
+    });
+
+    test('reload document without flush', async () => {
+      const path = createTmpPath();
+      const text = 'Hello World!';
+      let url: AutomergeUrl;
+
+      {
+        const level = createTestLevel(path);
+        const storage = await createLevelAdapter(level);
+        const repo = new Repo({ network: [], storage });
+        const handle = await repo.create2<{ text: string }>();
+        url = handle.url;
+        handle.change((doc: any) => {
+          doc.text = text;
+        });
+        // No explicit flush - rely on auto-save.
+        await sleep(200);
+        await level.close();
+      }
+
+      {
+        const level = createTestLevel(path);
+        const storage = await createLevelAdapter(level);
+        const repo = new Repo({ network: [], storage });
+        const handle = await repo.find<{ text: string }>(url);
+        await handle.whenReady();
+        expect(handle.doc()?.text).to.equal(text);
+      }
+    });
   });
 
   describe('teleport', () => {
@@ -730,8 +839,7 @@ describe('AutomergeRepo', () => {
     });
   });
 
-  const createLevelAdapter = async () => {
-    const level = createTestLevel();
+  const createLevelAdapter = async (level = createTestLevel()) => {
     const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
     await openAndClose(level, storage);
     return storage;
@@ -753,19 +861,23 @@ describe('AutomergeRepo', () => {
   };
 });
 
+type ShareConfig = Exclude<ConstructorParameters<typeof Repo>[0], undefined>['shareConfig'];
+
 type ConnectedRepoOptions = {
   storages?: StorageAdapterInterface[];
   connectionStateProvider?: TestConnectionStateProvider;
   sharePolicy?: SharePolicy;
+  shareConfig?: ShareConfig;
 };
 
 const createRepoTopology = async <Peers extends string[], Peer extends string = Peers[number]>(args: {
   peers: Peers;
   connections: [Peer, Peer][];
   options?: ConnectedRepoOptions;
+  onMessage?: (message: Message) => void;
 }) => {
   const adapters = args.connections.map(
-    () => TestAdapter.createPair(args.options?.connectionStateProvider) as [TestAdapter, TestAdapter],
+    () => TestAdapter.createPair(args.options?.connectionStateProvider, args.onMessage) as [TestAdapter, TestAdapter],
   );
   const repos = args.peers.map((peerId, peerIndex) => {
     const network = adapters
@@ -781,7 +893,8 @@ const createRepoTopology = async <Peers extends string[], Peer extends string =
       peerId: peerId as PeerId,
       storage: args.options?.storages?.[peerIndex],
       network,
-      sharePolicy: args.options?.sharePolicy ?? (async () => true),
+      sharePolicy: (args.options?.sharePolicy ?? args.options?.shareConfig) ? undefined : async () => true,
+      shareConfig: args.options?.shareConfig,
     });
   });
   return { repos, adapters };
@@ -867,3 +980,7 @@ const connectPeers = async (
 };
 
 type TeleportTestPeer = { repo: Repo; meshAdapter: MeshEchoReplicator; teleport: TeleportPeer };
+
+export const createTmpPath = (): string => {
+  return `/tmp/dxos-${PublicKey.random().toHex()}`;
+};

package/src/automerge/collection-synchronizer.test.ts

@@ -3,10 +3,12 @@
 //
 
 import { type Heads } from '@automerge/automerge';
+import * as Automerge from '@automerge/automerge';
 import type { DocumentId, PeerId } from '@automerge/automerge-repo';
 import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { sleep } from '@dxos/async';
+import { range } from '@dxos/util';
 
 import { type CollectionState, CollectionSynchronizer, diffCollectionState } from './collection-synchronizer';
 
@@ -54,16 +56,18 @@ describe('CollectionSynchronizer', () => {
     peer1.onConnectionOpen(peerId2);
     peer2.onConnectionOpen(peerId1);
 
+    const updated = Promise.all([
+      peer1.remoteStateUpdated.waitFor((ev) => ev.collectionId === collectionId && ev.peerId === peerId2),
+      peer2.remoteStateUpdated.waitFor((ev) => ev.collectionId === collectionId && ev.peerId === peerId1),
+    ]);
+
     peer1.setLocalCollectionState(collectionId, STATE_1);
     peer2.setLocalCollectionState(collectionId, STATE_2);
 
     peer1.refreshCollection(collectionId);
     peer2.refreshCollection(collectionId);
 
-    await Promise.all([
-      peer1.remoteStateUpdated.waitFor((ev) => ev.collectionId === collectionId && ev.peerId === peerId2),
-      peer2.remoteStateUpdated.waitFor((ev) => ev.collectionId === collectionId && ev.peerId === peerId1),
-    ]);
+    await updated;
 
     expect(peer1.getRemoteCollectionStates(collectionId).get(peerId2)).to.deep.equal(STATE_2);
     expect(peer2.getRemoteCollectionStates(collectionId).get(peerId1)).to.deep.equal(STATE_1);
@@ -80,18 +84,20 @@ describe('CollectionSynchronizer', () => {
   });
 });
 
+const TEST_HEADS = range(4).map((i) => Automerge.getHeads(Automerge.from({ i: i.toString() })));
+
 const STATE_1: CollectionState = {
   documents: {
-    a: ['1'],
-    b: ['2'],
-    c: ['3'],
+    a: TEST_HEADS[0],
+    b: TEST_HEADS[1],
+    c: TEST_HEADS[2],
   } as Record<DocumentId, Heads>,
 };
 
 const STATE_2: CollectionState = {
   documents: {
-    a: ['1'],
-    b: ['4'],
-    d: ['3'],
+    a: TEST_HEADS[0],
+    b: TEST_HEADS[3],
+    d: TEST_HEADS[2],
   } as Record<DocumentId, Heads>,
 };

package/src/automerge/collection-synchronizer.ts

@@ -15,9 +15,9 @@ import { defaultMap } from '@dxos/util';
 
 const MIN_QUERY_INTERVAL = 5_000;
 
-const POLL_INTERVAL = 30_000;
+const POLL_INTERVAL = 10_000;
 
-export type CollectionSynchronizerParams = {
+export type CollectionSynchronizerProps = {
   sendCollectionState: (collectionId: string, peerId: PeerId, state: CollectionState) => void;
   queryCollectionState: (collectionId: string, peerId: PeerId) => void;
   shouldSyncCollection: (collectionId: string, peerId: PeerId) => boolean;
@@ -28,9 +28,9 @@ export type CollectionSynchronizerParams = {
  */
 @trace.resource()
 export class CollectionSynchronizer extends Resource {
-  private readonly _sendCollectionState: CollectionSynchronizerParams['sendCollectionState'];
-  private readonly _queryCollectionState: CollectionSynchronizerParams['queryCollectionState'];
-  private readonly _shouldSyncCollection: CollectionSynchronizerParams['shouldSyncCollection'];
+  private readonly _sendCollectionState: CollectionSynchronizerProps['sendCollectionState'];
+  private readonly _queryCollectionState: CollectionSynchronizerProps['queryCollectionState'];
+  private readonly _shouldSyncCollection: CollectionSynchronizerProps['shouldSyncCollection'];
 
   /**
    * CollectionId -> State.
@@ -42,7 +42,7 @@ export class CollectionSynchronizer extends Resource {
 
   public readonly remoteStateUpdated = new Event<{ collectionId: string; peerId: PeerId; newDocsAppeared: boolean }>();
 
-  constructor(params: CollectionSynchronizerParams) {
+  constructor(params: CollectionSynchronizerProps) {
     super();
     this._sendCollectionState = params.sendCollectionState;
     this._queryCollectionState = params.queryCollectionState;
@@ -78,6 +78,10 @@ export class CollectionSynchronizer extends Resource {
     log('setLocalCollectionState', { collectionId, state });
     this._getOrCreatePerCollectionState(collectionId).localState = state;
 
+    for (const peerId of this._connectedPeers) {
+      this._diffCollectionState(collectionId, peerId);
+    }
+
     queueMicrotask(async () => {
       if (!this._ctx.disposed && this._activeCollections.has(collectionId)) {
         this._refreshInterestedPeers(collectionId);
@@ -119,6 +123,7 @@ export class CollectionSynchronizer extends Resource {
    * Callback when a connection to a peer is established.
    */
   onConnectionOpen(peerId: PeerId): void {
+    log('onConnectionOpen', { peerId });
     const spanId = getSpanName(peerId);
     trace.spanStart({
       id: spanId,
@@ -148,6 +153,8 @@ export class CollectionSynchronizer extends Resource {
    * Callback when a connection to a peer is closed.
    */
   onConnectionClosed(peerId: PeerId): void {
+    log('onConnectionClosed', { peerId });
+
     this._connectedPeers.delete(peerId);
 
     for (const perCollectionState of this._perCollectionStates.values()) {
@@ -173,8 +180,20 @@ export class CollectionSynchronizer extends Resource {
     log('onRemoteStateReceived', { collectionId, peerId, state });
     validateCollectionState(state);
     const perCollectionState = this._getOrCreatePerCollectionState(collectionId);
-    const existingState = perCollectionState.remoteStates.get(peerId) ?? { documents: {} };
-    const diff = diffCollectionState(existingState, state);
+    perCollectionState.remoteStates.set(peerId, state);
+    this._diffCollectionState(collectionId, peerId);
+  }
+
+  private _diffCollectionState(collectionId: string, peerId: PeerId) {
+    const perCollectionState = this._getOrCreatePerCollectionState(collectionId);
+    const remoteState = perCollectionState.remoteStates.get(peerId);
+    if (!remoteState) {
+      return;
+    }
+
+    log('diffCollectionState', { collectionId, peerId });
+    const localState = perCollectionState.localState ?? { documents: {} };
+    const diff = diffCollectionState(localState, remoteState);
     const spanId = getSpanName(peerId);
     if (diff.different.length === 0) {
       trace.spanEnd(spanId);
@@ -188,9 +207,20 @@ export class CollectionSynchronizer extends Resource {
         attributes: { peerId },
       });
     }
-    if (diff.missingOnLocal.length > 0 || diff.different.length > 0) {
-      perCollectionState.remoteStates.set(peerId, state);
-      this.remoteStateUpdated.emit({ peerId, collectionId, newDocsAppeared: diff.missingOnLocal.length > 0 });
+    log('diff', {
+      localState: localState.documents,
+      remoteState: remoteState.documents,
+      missingOnLocal: diff.missingOnLocal,
+      missingOnRemote: diff.missingOnRemote,
+      different: diff.different,
+    });
+    if (diff.missingOnLocal.length > 0 || diff.different.length > 0 || diff.missingOnRemote.length > 0) {
+      log('emit remote state update');
+      this.remoteStateUpdated.emit({
+        peerId,
+        collectionId,
+        newDocsAppeared: diff.missingOnLocal.length > 0,
+      });
     }
   }
 

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

@@ -11,7 +11,7 @@ import {
   type PeerMetadata,
 } from '@automerge/automerge-repo';
 
-import { Trigger, synchronized } from '@dxos/async';
+import { Event, Trigger, synchronized } from '@dxos/async';
 import { LifecycleState } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { type PublicKey } from '@dxos/keys';
@@ -23,10 +23,10 @@ import { createIdFromSpaceKey } from '../common/space-id';
 
 import {
   type EchoReplicator,
-  type RemoteDocumentExistenceCheckParams,
+  type RemoteDocumentExistenceCheckProps,
   type ReplicatorConnection,
-  type ShouldAdvertiseParams,
-  type ShouldSyncCollectionParams,
+  type ShouldAdvertiseProps,
+  type ShouldSyncCollectionProps,
 } from './echo-replicator';
 import {
   type CollectionQueryMessage,
@@ -43,9 +43,9 @@ export interface NetworkDataMonitor {
   recordMessageSendingFailed(message: Message): void;
 }
 
-export type EchoNetworkAdapterParams = {
+export type EchoNetworkAdapterProps = {
   getContainingSpaceForDocument: (documentId: string) => Promise<PublicKey | null>;
-  isDocumentInRemoteCollection: (params: RemoteDocumentExistenceCheckParams) => Promise<boolean>;
+  isDocumentInRemoteCollection: (params: RemoteDocumentExistenceCheckProps) => Promise<boolean>;
   onCollectionStateQueried: (collectionId: string, peerId: PeerId) => void;
   onCollectionStateReceived: (collectionId: string, peerId: PeerId, state: unknown) => void;
   monitor?: NetworkDataMonitor;
@@ -56,6 +56,7 @@ type ConnectionEntry = {
   connection: ReplicatorConnection;
   reader: ReadableStreamDefaultReader<AutomergeProtocolMessage>;
   writer: WritableStreamDefaultWriter<AutomergeProtocolMessage>;
+  requestedDocuments: Set<DocumentId>;
 };
 
 /**
@@ -71,7 +72,9 @@ export class EchoNetworkAdapter extends NetworkAdapter {
   private readonly _connected = new Trigger();
   private readonly _ready = new Trigger();
 
-  constructor(private readonly _params: EchoNetworkAdapterParams) {
+  public readonly documentRequested = new Event<{ documentId: DocumentId; peerId: PeerId }>();
+
+  constructor(private readonly _params: EchoNetworkAdapterProps) {
     super();
   }
 
@@ -161,7 +164,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
     this._replicators.delete(replicator);
   }
 
-  async shouldAdvertise(peerId: PeerId, params: ShouldAdvertiseParams): Promise<boolean> {
+  async shouldAdvertise(peerId: PeerId, params: ShouldAdvertiseProps): Promise<boolean> {
     const connection = this._connections.get(peerId);
     if (!connection) {
       return false;
@@ -170,7 +173,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
     return connection.connection.shouldAdvertise(params);
   }
 
-  shouldSyncCollection(peerId: PeerId, params: ShouldSyncCollectionParams): boolean {
+  shouldSyncCollection(peerId: PeerId, params: ShouldSyncCollectionProps): boolean {
     const connection = this._connections.get(peerId);
     if (!connection) {
       return false;
@@ -265,6 +268,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
       connection,
       reader: connection.readable.getReader(),
       writer: connection.writable.getWriter(),
+      requestedDocuments: new Set(),
     };
 
     this._connections.set(connection.peerId as PeerId, connectionEntry);
@@ -279,7 +283,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
             break;
           }
 
-          this._onMessage(value as Message);
+          this._onMessage(connectionEntry, value as Message);
         }
       } catch (err) {
         if (connectionEntry.isOpen) {
@@ -293,7 +297,15 @@ export class EchoNetworkAdapter extends NetworkAdapter {
     this._params.monitor?.recordPeerConnected(connection.peerId);
   }
 
-  private _onMessage(message: Message): void {
+  private _onMessage(connectionEntry: ConnectionEntry, message: Message): void {
+    const amMessage = message as AutomergeProtocolMessage;
+    if (amMessage.type === 'request') {
+      this.documentRequested.emit({
+        documentId: amMessage.documentId as DocumentId,
+        peerId: connectionEntry.connection.peerId as PeerId,
+      });
+    }
+
     if (isCollectionQueryMessage(message)) {
       this._params.onCollectionStateQueried(message.collectionId, message.senderId);
     } else if (isCollectionStateMessage(message)) {

package/src/automerge/echo-replicator.ts

@@ -32,7 +32,11 @@ export interface EchoReplicatorContext {
    */
   getContainingSpaceForDocument(documentId: string): Promise<PublicKey | null>;
   getContainingSpaceIdForDocument(documentId: string): Promise<SpaceId | null>;
-  isDocumentInRemoteCollection(params: RemoteDocumentExistenceCheckParams): Promise<boolean>;
+
+  /**
+   * Returns false if collection sync hasn't happened yet.
+   */
+  isDocumentInRemoteCollection(params: RemoteDocumentExistenceCheckProps): Promise<boolean>;
 
   onConnectionOpen(connection: ReplicatorConnection): void;
   onConnectionClosed(connection: ReplicatorConnection): void;
@@ -59,12 +63,12 @@ export interface ReplicatorConnection {
    * @returns true if the document should be advertised to this peer.
    * The remote peer can still request the document by its id bypassing this check.
    */
-  shouldAdvertise(params: ShouldAdvertiseParams): Promise<boolean>;
+  shouldAdvertise(params: ShouldAdvertiseProps): Promise<boolean>;
 
   /**
    * @returns true if the collection should be synced to this peer.
    */
-  shouldSyncCollection(params: ShouldSyncCollectionParams): boolean;
+  shouldSyncCollection(params: ShouldSyncCollectionProps): boolean;
 
   /**
    * Batch syncing considered enabled if ReplicatorConnection implements `pushBatch` and `pullBatch` methods.
@@ -84,15 +88,15 @@ export interface ReplicatorConnection {
   pullBundle?(docHeads: Record<DocumentId, Heads>): Promise<Record<DocumentId, Uint8Array>>;
 }
 
-export type ShouldAdvertiseParams = {
+export type ShouldAdvertiseProps = {
   documentId: string;
 };
 
-export type ShouldSyncCollectionParams = {
+export type ShouldSyncCollectionProps = {
   collectionId: string;
 };
 
-export type RemoteDocumentExistenceCheckParams = {
+export type RemoteDocumentExistenceCheckProps = {
   peerId: string;
   documentId: string;
 };

package/src/automerge/heads-store.ts

@@ -8,14 +8,14 @@ import type { DocumentId } from '@automerge/automerge-repo';
 import { headsEncoding } from '@dxos/indexing';
 import type { BatchLevel, SublevelDB } from '@dxos/kv-store';
 
-export type HeadsStoreParams = {
+export type HeadsStoreProps = {
   db: SublevelDB;
 };
 
 export class HeadsStore {
   private readonly _db: SublevelDB;
 
-  constructor({ db }: HeadsStoreParams) {
+  constructor({ db }: HeadsStoreProps) {
     this._db = db;
   }
 
@@ -34,4 +34,16 @@ export class HeadsStore {
       valueEncoding: headsEncoding,
     });
   }
+
+  /**
+   * Iterate over all document IDs and their heads.
+   */
+  async *iterateAll(): AsyncGenerator<{ documentId: DocumentId; heads: Heads }> {
+    for await (const [documentId, heads] of this._db.iterator<DocumentId, Heads>({
+      keyEncoding: 'utf8',
+      valueEncoding: headsEncoding,
+    })) {
+      yield { documentId, heads };
+    }
+  }
 }

package/src/automerge/leveldb-storage-adapter.ts

@@ -16,21 +16,21 @@ export interface StorageAdapterDataMonitor {
   recordStoreDuration(durationMs: number): void;
 }
 
-export type LevelDBStorageAdapterParams = {
+export type LevelDBStorageAdapterProps = {
   db: SublevelDB;
   callbacks?: StorageCallbacks;
   monitor?: StorageAdapterDataMonitor;
 };
 
-export type BeforeSaveParams = { path: StorageKey; batch: BatchLevel };
+export type BeforeSaveProps = { path: StorageKey; batch: BatchLevel };
 
 export interface StorageCallbacks {
-  beforeSave(params: BeforeSaveParams): MaybePromise<void>;
+  beforeSave(params: BeforeSaveProps): MaybePromise<void>;
   afterSave(path: StorageKey): MaybePromise<void>;
 }
 
 export class LevelDBStorageAdapter extends Resource implements StorageAdapterInterface {
-  constructor(private readonly _params: LevelDBStorageAdapterParams) {
+  constructor(private readonly _params: LevelDBStorageAdapterProps) {
     super();
   }
 

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

@@ -12,16 +12,16 @@ import { log } from '@dxos/log';
 import type { AutomergeProtocolMessage } from '@dxos/protocols';
 import { AutomergeReplicator, type AutomergeReplicatorFactory } from '@dxos/teleport-extension-automerge-replicator';
 
-import type { ReplicatorConnection, ShouldAdvertiseParams, ShouldSyncCollectionParams } from './echo-replicator';
+import type { ReplicatorConnection, ShouldAdvertiseProps, ShouldSyncCollectionProps } from './echo-replicator';
 
 const DEFAULT_FACTORY: AutomergeReplicatorFactory = (params) => new AutomergeReplicator(...params);
 
-export type MeshReplicatorConnectionParams = {
+export type MeshReplicatorConnectionProps = {
   ownPeerId: string;
   onRemoteConnected: () => void;
   onRemoteDisconnected: () => void;
-  shouldAdvertise: (params: ShouldAdvertiseParams) => Promise<boolean>;
-  shouldSyncCollection: (params: ShouldSyncCollectionParams) => boolean;
+  shouldAdvertise: (params: ShouldAdvertiseProps) => Promise<boolean>;
+  shouldSyncCollection: (params: ShouldSyncCollectionProps) => boolean;
   replicatorFactory?: AutomergeReplicatorFactory;
 };
 
@@ -35,7 +35,7 @@ export class MeshReplicatorConnection extends Resource implements ReplicatorConn
   private _remotePeerId: string | null = null;
   private _isEnabled = false;
 
-  constructor(private readonly _params: MeshReplicatorConnectionParams) {
+  constructor(private readonly _params: MeshReplicatorConnectionProps) {
     super();
 
     let readableStreamController!: ReadableStreamDefaultController<AutomergeProtocolMessage>;
@@ -115,11 +115,11 @@ export class MeshReplicatorConnection extends Resource implements ReplicatorConn
     return false;
   }
 
-  async shouldAdvertise(params: ShouldAdvertiseParams): Promise<boolean> {
+  async shouldAdvertise(params: ShouldAdvertiseProps): Promise<boolean> {
     return this._params.shouldAdvertise(params);
   }
 
-  shouldSyncCollection(params: ShouldSyncCollectionParams): boolean {
+  shouldSyncCollection(params: ShouldSyncCollectionProps): boolean {
     return this._params.shouldSyncCollection(params);
   }
 

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

@@ -14,7 +14,7 @@ import { ComplexSet, defaultMap } from '@dxos/util';
 
 import { createIdFromSpaceKey } from '../common/space-id';
 
-import { type EchoReplicator, type EchoReplicatorContext, type ShouldAdvertiseParams } from './echo-replicator';
+import { type EchoReplicator, type EchoReplicatorContext, type ShouldAdvertiseProps } from './echo-replicator';
 import { MeshReplicatorConnection } from './mesh-echo-replicator-connection';
 import { getSpaceIdFromCollectionId } from './space-collection';
 
@@ -111,7 +111,7 @@ export class MeshEchoReplicator implements EchoReplicator {
           }
         }
       },
-      shouldAdvertise: async (params: ShouldAdvertiseParams) => {
+      shouldAdvertise: async (params: ShouldAdvertiseProps) => {
         log('shouldAdvertise', { peerId: connection.peerId, documentId: params.documentId });
         invariant(this._context);
         try {