@dxos/echo-pipeline 0.8.3 → 0.8.4-main.1da679c

package/src/automerge/collection-synchronizer.ts

@@ -5,8 +5,8 @@
 import { next as am } from '@automerge/automerge';
 import type { DocumentId, PeerId } from '@automerge/automerge-repo';
 
-import { asyncReturn, Event, scheduleTask, scheduleTaskInterval } from '@dxos/async';
-import { Resource, type Context } from '@dxos/context';
+import { Event, asyncReturn, scheduleTask, scheduleTaskInterval } from '@dxos/async';
+import { type Context, Resource } from '@dxos/context';
 import { log } from '@dxos/log';
 import { trace } from '@dxos/tracing';
 import { defaultMap } from '@dxos/util';
@@ -239,9 +239,9 @@ export const diffCollectionState = (local: CollectionState, remote: CollectionSt
   const missingOnLocal: DocumentId[] = [];
   const different: DocumentId[] = [];
   for (const documentId of allDocuments) {
-    if (!local.documents[documentId]) {
+    if (!local.documents[documentId] || local.documents[documentId].length === 0) {
       missingOnLocal.push(documentId as DocumentId);
-    } else if (!remote.documents[documentId]) {
+    } else if (!remote.documents[documentId] || remote.documents[documentId].length === 0) {
       missingOnRemote.push(documentId as DocumentId);
     } else if (!am.equals(local.documents[documentId], remote.documents[documentId])) {
       different.push(documentId as DocumentId);

package/src/automerge/echo-data-monitor.ts

@@ -5,7 +5,7 @@
 import { type Message } from '@automerge/automerge-repo';
 
 import { type TimeAware, trace } from '@dxos/tracing';
-import { CircularBuffer, mapValues, SlidingWindowSummary, type SlidingWindowSummaryConfig } from '@dxos/util';
+import { CircularBuffer, SlidingWindowSummary, type SlidingWindowSummaryConfig, mapValues } from '@dxos/util';
 
 import { type NetworkDataMonitor } from './echo-network-adapter';
 import { type StorageAdapterDataMonitor } from './leveldb-storage-adapter';

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

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { cbor, type PeerId } from '@automerge/automerge-repo';
-import { onTestFinished, describe, expect, test } from 'vitest';
+import { type PeerId, cbor } from '@automerge/automerge-repo';
+import { describe, expect, onTestFinished, test } from 'vitest';
 
-import { sleep, Trigger, waitForCondition } from '@dxos/async';
+import { Trigger, sleep, waitForCondition } from '@dxos/async';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { type SyncMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/automerge';

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

@@ -2,9 +2,16 @@
 // Copyright 2024 DXOS.org
 //
 
-import { NetworkAdapter, type Message, type PeerId, type PeerMetadata } from '@automerge/automerge-repo';
-
-import { synchronized, Trigger } from '@dxos/async';
+import {
+  type DocumentId,
+  type Heads,
+  type Message,
+  NetworkAdapter,
+  type PeerId,
+  type PeerMetadata,
+} from '@automerge/automerge-repo';
+
+import { Trigger, synchronized } from '@dxos/async';
 import { LifecycleState } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { type PublicKey } from '@dxos/keys';
@@ -12,6 +19,8 @@ import { log } from '@dxos/log';
 import type { AutomergeProtocolMessage } from '@dxos/protocols';
 import { isNonNullable } from '@dxos/util';
 
+import { createIdFromSpaceKey } from '../common/space-id';
+
 import {
   type EchoReplicator,
   type RemoteDocumentExistenceCheckParams,
@@ -20,12 +29,11 @@ import {
   type ShouldSyncCollectionParams,
 } from './echo-replicator';
 import {
-  isCollectionQueryMessage,
-  isCollectionStateMessage,
   type CollectionQueryMessage,
   type CollectionStateMessage,
+  isCollectionQueryMessage,
+  isCollectionStateMessage,
 } from './network-protocol';
-import { createIdFromSpaceKey } from '../common/space-id';
 
 export interface NetworkDataMonitor {
   recordPeerConnected(peerId: string): void;
@@ -203,6 +211,30 @@ export class EchoNetworkAdapter extends NetworkAdapter {
       .filter(isNonNullable);
   }
 
+  bundleSyncEnabledForPeer(peerId: PeerId): boolean {
+    const connection = this._connections.get(peerId);
+    if (!connection) {
+      return false;
+    }
+    return connection.connection.bundleSyncEnabled;
+  }
+
+  async pushBundle(peerId: PeerId, bundle: { documentId: DocumentId; data: Uint8Array; heads: Heads }[]) {
+    const connection = this._connections.get(peerId);
+    if (!connection) {
+      throw new Error('Connection not found.');
+    }
+    return connection.connection.pushBundle!(bundle);
+  }
+
+  async pullBundle(peerId: PeerId, docHeads: Record<DocumentId, Heads>) {
+    const connection = this._connections.get(peerId);
+    if (!connection) {
+      throw new Error('Connection not found.');
+    }
+    return connection.connection.pullBundle!(docHeads);
+  }
+
   private _send(message: Message): void {
     const connectionEntry = this._connections.get(message.targetId);
     if (!connectionEntry) {
@@ -281,8 +313,9 @@ export class EchoNetworkAdapter extends NetworkAdapter {
     this.emit('peer-disconnected', { peerId: connection.peerId as PeerId });
     this._params.monitor?.recordPeerDisconnected(connection.peerId);
 
-    void entry.reader.cancel().catch((err) => log.catch(err));
     void entry.writer.abort().catch((err) => log.catch(err));
+    void entry.reader.cancel().catch((err) => log.catch(err));
+
     this._connections.delete(connection.peerId as PeerId);
   }
 

package/src/automerge/echo-replicator.ts

@@ -2,9 +2,13 @@
 // Copyright 2024 DXOS.org
 //
 
+import { type Heads } from '@automerge/automerge';
+import { type DocumentId } from '@automerge/automerge-repo';
+
 import { type PublicKey, type SpaceId } from '@dxos/keys';
-import type { AutomergeProtocolMessage } from '@dxos/protocols';
+import { type AutomergeProtocolMessage } from '@dxos/protocols';
 
+// TODO(burdon): Rename AutomergeReplicator?
 export interface EchoReplicator {
   /**
    * Called on when replicator is added to EchoHost.
@@ -37,7 +41,7 @@ export interface EchoReplicatorContext {
 
 export interface ReplicatorConnection {
   /**
-   * Remove peer id.
+   * Remote peer id.
    */
   get peerId(): string;
 
@@ -61,6 +65,23 @@ export interface ReplicatorConnection {
    * @returns true if the collection should be synced to this peer.
    */
   shouldSyncCollection(params: ShouldSyncCollectionParams): boolean;
+
+  /**
+   * Batch syncing considered enabled if ReplicatorConnection implements `pushBatch` and `pullBatch` methods.
+   * @returns true if the batch syncing is enabled.
+   */
+  get bundleSyncEnabled(): boolean;
+
+  /**
+   * Pushes the batch of documents to the remote peer.
+   */
+  pushBundle?(bundle: { documentId: DocumentId; data: Uint8Array; heads: Heads }[]): Promise<void>;
+
+  /**
+   * Pulls the batch of documents from the remote peer.
+   */
+  // TODO(mykola): Use automerge-repo-bundles Bundle type here.
+  pullBundle?(docHeads: Record<DocumentId, Heads>): Promise<Record<DocumentId, Uint8Array>>;
 }
 
 export type ShouldAdvertiseParams = {

package/src/automerge/index.ts

@@ -5,7 +5,7 @@
 export * from './automerge-host';
 export * from './leveldb-storage-adapter';
 export * from './mesh-echo-replicator';
-export * from './echo-replicator';
+export type * from './echo-replicator';
 export { diffCollectionState } from './collection-synchronizer';
 export * from './space-collection';
 export * from './echo-data-monitor';

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

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 // s
 
-import { type StorageAdapterInterface, type Chunk, type StorageKey } from '@automerge/automerge-repo';
+import { type Chunk, type StorageAdapterInterface, type StorageKey } from '@automerge/automerge-repo';
 import { type MixedEncoding } from 'level-transcoder';
 
-import { LifecycleState, Resource } from '@dxos/context';
+import { Resource } from '@dxos/context';
 import { type BatchLevel, type SublevelDB } from '@dxos/kv-store';
 import { type MaybePromise } from '@dxos/util';
 
@@ -36,7 +36,7 @@ export class LevelDBStorageAdapter extends Resource implements StorageAdapterInt
 
   async load(keyArray: StorageKey): Promise<Uint8Array | undefined> {
     try {
-      if (this._lifecycleState !== LifecycleState.OPEN) {
+      if (!this.isOpen) {
         // TODO(mykola): this should be an error.
         return undefined;
       }
@@ -54,7 +54,7 @@ export class LevelDBStorageAdapter extends Resource implements StorageAdapterInt
   }
 
   async save(keyArray: StorageKey, binary: Uint8Array): Promise<void> {
-    if (this._lifecycleState !== LifecycleState.OPEN) {
+    if (!this.isOpen) {
       return undefined;
     }
     const startMs = Date.now();
@@ -72,14 +72,14 @@ export class LevelDBStorageAdapter extends Resource implements StorageAdapterInt
   }
 
   async remove(keyArray: StorageKey): Promise<void> {
-    if (this._lifecycleState !== LifecycleState.OPEN) {
+    if (!this.isOpen) {
       return undefined;
     }
     await this._params.db.del<StorageKey>(keyArray, { ...encodingOptions });
   }
 
   async loadRange(keyPrefix: StorageKey): Promise<Chunk[]> {
-    if (this._lifecycleState !== LifecycleState.OPEN) {
+    if (!this.isOpen) {
       return [];
     }
     const startMs = Date.now();
@@ -100,7 +100,7 @@ export class LevelDBStorageAdapter extends Resource implements StorageAdapterInt
   }
 
   async removeRange(keyPrefix: StorageKey): Promise<void> {
-    if (this._lifecycleState !== LifecycleState.OPEN) {
+    if (!this.isOpen) {
       return undefined;
     }
     const batch = this._params.db.batch();

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

@@ -111,6 +111,10 @@ export class MeshReplicatorConnection extends Resource implements ReplicatorConn
     return this._isEnabled;
   }
 
+  get bundleSyncEnabled(): boolean {
+    return false;
+  }
+
   async shouldAdvertise(params: ShouldAdvertiseParams): Promise<boolean> {
     return this._params.shouldAdvertise(params);
   }

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

@@ -12,10 +12,11 @@ import {
 } from '@dxos/teleport-extension-automerge-replicator';
 import { ComplexSet, defaultMap } from '@dxos/util';
 
+import { createIdFromSpaceKey } from '../common/space-id';
+
 import { type EchoReplicator, type EchoReplicatorContext, type ShouldAdvertiseParams } from './echo-replicator';
 import { MeshReplicatorConnection } from './mesh-echo-replicator-connection';
 import { getSpaceIdFromCollectionId } from './space-collection';
-import { createIdFromSpaceKey } from '../common/space-id';
 
 // TODO(dmaretskyi): Move out of @dxos/echo-pipeline.
 

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

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { onTestFinished, describe, expect, test } from 'vitest';
+import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { randomBytes } from '@dxos/crypto';
 import { PublicKey } from '@dxos/keys';

package/src/common/space-id.ts

@@ -18,7 +18,7 @@ export const createIdFromSpaceKey = async (spaceKey: PublicKey): Promise<SpaceId
     return cachedValue;
   }
 
-  const digest = await subtleCrypto.digest('SHA-256', spaceKey.asUint8Array());
+  const digest = await subtleCrypto.digest('SHA-256', spaceKey.asUint8Array() as Uint8Array<ArrayBuffer>);
 
   const bytes = new Uint8Array(digest).slice(0, SpaceId.byteLength);
   const spaceId = SpaceId.encode(bytes);

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

@@ -11,23 +11,24 @@ import { invariant } from '@dxos/invariant';
 import { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
+  type BatchedDocumentUpdates,
   type DataService,
   type FlushRequest,
-  type SubscribeRequest,
-  type BatchedDocumentUpdates,
-  type UpdateSubscriptionRequest,
   type GetDocumentHeadsRequest,
   type GetDocumentHeadsResponse,
-  type ReIndexHeadsRequest,
-  type WaitUntilHeadsReplicatedRequest,
-  type UpdateRequest,
   type GetSpaceSyncStateRequest,
+  type ReIndexHeadsRequest,
   type SpaceSyncState,
+  type SubscribeRequest,
+  type UpdateRequest,
+  type UpdateSubscriptionRequest,
+  type WaitUntilHeadsReplicatedRequest,
 } from '@dxos/protocols/proto/dxos/echo/service';
 
+import { type AutomergeHost, deriveCollectionIdFromSpaceId } from '../automerge';
+
 import { DocumentsSynchronizer } from './documents-synchronizer';
 import { type SpaceStateManager } from './space-state-manager';
-import { deriveCollectionIdFromSpaceId, type AutomergeHost } from '../automerge';
 
 export type DataServiceParams = {
   automergeHost: AutomergeHost;
@@ -145,16 +146,7 @@ export class DataServiceImpl implements DataService {
       const scheduler = new UpdateScheduler(ctx, async () => {
         const state = collectionId ? await this._automergeHost.getCollectionSyncState(collectionId) : { peers: [] };
 
-        next({
-          peers: state.peers.map((peer) => ({
-            peerId: peer.peerId,
-            missingOnRemote: peer.missingOnRemote,
-            missingOnLocal: peer.missingOnLocal,
-            differentDocuments: peer.differentDocuments,
-            localDocumentCount: peer.localDocumentCount,
-            remoteDocumentCount: peer.remoteDocumentCount,
-          })),
-        });
+        next({ peers: state.peers });
       });
 
       this._automergeHost.collectionStateUpdated.on(ctx, (e) => {

package/src/db-host/database-root.ts

@@ -3,12 +3,12 @@
 //
 
 import type * as A from '@automerge/automerge';
-import { interpretAsDocumentId, type AutomergeUrl, type DocHandle, type DocumentId } from '@automerge/automerge-repo';
+import { type AutomergeUrl, type DocHandle, type DocumentId, interpretAsDocumentId } from '@automerge/automerge-repo';
 
 import { DatabaseDirectory, SpaceDocVersion } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
 
-import { measureDocMetrics, type DocMetrics } from './automerge-metrics';
+import { type DocMetrics, measureDocMetrics } from './automerge-metrics';
 
 export class DatabaseRoot {
   static mapLinks(doc: DocHandle<DatabaseDirectory>, mapping: Record<DocumentId, DocumentId>): void {

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

@@ -3,7 +3,7 @@
 //
 
 import { next as A } from '@automerge/automerge';
-import { generateAutomergeUrl, parseAutomergeUrl, Repo } from '@automerge/automerge-repo';
+import { Repo, generateAutomergeUrl, parseAutomergeUrl } from '@automerge/automerge-repo';
 import { describe, expect, test } from 'vitest';
 
 import { sleep } from '@dxos/async';

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

@@ -3,17 +3,15 @@
 //
 
 import { next as A, type Heads } from '@automerge/automerge';
-import { type Repo, type DocHandle, type DocumentId } from '@automerge/automerge-repo';
+import { type DocHandle, type DocumentId, type Repo } from '@automerge/automerge-repo';
 
-import { UpdateScheduler } from '@dxos/async';
-import { Resource } from '@dxos/context';
+import { UpdateScheduler, sleep } from '@dxos/async';
+import { LifecycleState, Resource, cancelWithContext } from '@dxos/context';
 import { type DatabaseDirectory } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { type BatchedDocumentUpdates, type DocumentUpdate } from '@dxos/protocols/proto/dxos/echo/service';
 
-import { FIND_PARAMS } from '../automerge';
-
 const MAX_UPDATE_FREQ = 10; // [updates/sec]
 
 export type DocumentsSynchronizerParams = {
@@ -27,6 +25,9 @@ interface DocSyncState {
   clearSubscriptions?: () => void;
 }
 
+const WRAP_AROUND_RETRY_LIMIT = 3;
+const WRAP_AROUND_RETRY_INITIAL_DELAY = 100; // [ms]
+
 /**
  * Manages a connection and replication between worker's Automerge Repo and the client's Repo.
  */
@@ -47,8 +48,12 @@ export class DocumentsSynchronizer extends Resource {
     super();
   }
 
-  addDocuments(documentIds: DocumentId[], retryCounter = 0): void {
-    if (retryCounter > 3) {
+  addDocuments(
+    documentIds: DocumentId[],
+    retryCounter = 0,
+    wrapAroundRetryDelay = WRAP_AROUND_RETRY_INITIAL_DELAY,
+  ): void {
+    if (retryCounter > WRAP_AROUND_RETRY_LIMIT) {
       log.warn('Failed to load document, retry limit reached', { documentIds });
       return;
     }
@@ -64,7 +69,9 @@ export class DocumentsSynchronizer extends Resource {
         })
         .catch((error) => {
           log.warn('Failed to load document, wraparound', { documentId, error });
-          this.addDocuments([documentId], retryCounter + 1);
+          void cancelWithContext(this._ctx, sleep(wrapAroundRetryDelay)).then(() =>
+            this.addDocuments([documentId], retryCounter + 1, wrapAroundRetryDelay * 2),
+          );
         });
     }
   }
@@ -90,17 +97,13 @@ export class DocumentsSynchronizer extends Resource {
 
   async update(updates: DocumentUpdate[]): Promise<void> {
     for (const { documentId, mutation, isNew } of updates) {
-      if (isNew) {
-        const doc = await this._params.repo.find<DatabaseDirectory>(documentId as DocumentId, FIND_PARAMS);
-        doc.update((doc) => A.loadIncremental(doc, mutation));
-        this._startSync(doc);
-      } else {
-        this._writeMutation(documentId as DocumentId, mutation);
-      }
+      this._writeMutation(documentId as DocumentId, mutation, isNew);
     }
+    // TODO(mykola): This should not be required.
+    await this._params.repo.flush(updates.map(({ documentId }) => documentId as DocumentId));
   }
 
-  private _startSync(doc: DocHandle<DatabaseDirectory>): void {
+  private _startSync(doc: DocHandle<DatabaseDirectory>) {
     if (this._syncStates.has(doc.documentId)) {
       log('Document already being synced', { documentId: doc.documentId });
       return;
@@ -109,6 +112,7 @@ export class DocumentsSynchronizer extends Resource {
     const syncState: DocSyncState = { handle: doc };
     this._subscribeForChanges(syncState);
     this._syncStates.set(doc.documentId, syncState);
+    return syncState;
   }
 
   _subscribeForChanges(syncState: DocSyncState): void {
@@ -157,16 +161,25 @@ export class DocumentsSynchronizer extends Resource {
     return mutation;
   }
 
-  private _writeMutation(documentId: DocumentId, mutation: Uint8Array): void {
-    const syncState = this._syncStates.get(documentId);
-    invariant(syncState, 'Sync state for document not found');
-    syncState.handle.update((doc) => {
-      const headsBefore = A.getHeads(doc);
-      const newDoc = A.loadIncremental(doc, mutation);
-      if (A.equals(headsBefore, syncState.lastSentHead)) {
-        syncState.lastSentHead = A.getHeads(newDoc);
+  private _writeMutation(documentId: DocumentId, mutation: Uint8Array, isNew?: boolean): void {
+    if (this._lifecycleState === LifecycleState.CLOSED) {
+      return;
+    }
+    if (isNew) {
+      const newHandle = this._params.repo.import<DatabaseDirectory>(mutation, { docId: documentId });
+      const syncState = this._startSync(newHandle);
+      syncState!.lastSentHead = A.getHeads(newHandle.doc());
+    } else {
+      const syncState = this._syncStates.get(documentId);
+      invariant(syncState, 'Sync state for document not found');
+      const headsBefore = A.getHeads(syncState.handle.doc());
+      // This will update corresponding handle in the repo.
+      this._params.repo.import(mutation, { docId: documentId });
+
+      if (A.equals(headsBefore, syncState!.lastSentHead)) {
+        // No new mutations were discovered on network, so we do not need to send updates from worker to client.
+        syncState!.lastSentHead = A.getHeads(syncState.handle.doc());
       }
-      return newDoc;
-    });
+    }
   }
 }

package/src/db-host/echo-host.ts

@@ -10,9 +10,9 @@ import {
   type Repo,
 } from '@automerge/automerge-repo';
 
-import { LifecycleState, Resource, type Context } from '@dxos/context';
+import { type Context, LifecycleState, Resource } from '@dxos/context';
 import { todo } from '@dxos/debug';
-import { createIdFromSpaceKey, SpaceDocVersion, type DatabaseDirectory } from '@dxos/echo-protocol';
+import { type DatabaseDirectory, SpaceDocVersion, createIdFromSpaceKey } from '@dxos/echo-protocol';
 import { IndexMetadataStore, IndexStore, Indexer } from '@dxos/indexing';
 import { invariant } from '@dxos/invariant';
 import { type PublicKey, type SpaceId } from '@dxos/keys';
@@ -20,24 +20,25 @@ import { type LevelDB } from '@dxos/kv-store';
 import { IndexKind } from '@dxos/protocols/proto/dxos/echo/indexing';
 import { trace } from '@dxos/tracing';
 
-import { DataServiceImpl } from './data-service';
-import { type DatabaseRoot } from './database-root';
-import { createSelectedDocumentsIterator } from './documents-iterator';
-import { QueryServiceImpl } from './query-service';
-import { SpaceStateManager } from './space-state-manager';
 import {
   AutomergeHost,
-  FIND_PARAMS,
-  EchoDataMonitor,
-  deriveCollectionIdFromSpaceId,
-  type LoadDocOptions,
   type CreateDocOptions,
-  type EchoReplicator,
+  EchoDataMonitor,
   type EchoDataStats,
+  type EchoReplicator,
+  FIND_PARAMS,
+  type LoadDocOptions,
   type PeerIdProvider,
   type RootDocumentSpaceKeyProvider,
+  deriveCollectionIdFromSpaceId,
 } from '../automerge';
 
+import { DataServiceImpl } from './data-service';
+import { type DatabaseRoot } from './database-root';
+import { createSelectedDocumentsIterator } from './documents-iterator';
+import { QueryServiceImpl } from './query-service';
+import { SpaceStateManager } from './space-state-manager';
+
 export interface EchoHostIndexingConfig {
   /**
    * @default true
@@ -197,8 +198,6 @@ export class EchoHost extends Resource {
       if (e.previousRootId) {
         void this._automergeHost.clearLocalCollectionState(deriveCollectionIdFromSpaceId(e.spaceId, e.previousRootId));
       }
-      // TODO(yaroslav): remove collection without spaceRootId after release (production<->staging interop)
-      void this._automergeHost.updateLocalCollectionState(deriveCollectionIdFromSpaceId(e.spaceId), e.documentIds);
       void this._automergeHost.updateLocalCollectionState(
         deriveCollectionIdFromSpaceId(e.spaceId, e.spaceRootId),
         e.documentIds,

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

@@ -23,10 +23,11 @@ import {
 } from '@dxos/protocols/proto/dxos/echo/query';
 import { trace } from '@dxos/tracing';
 
-import type { SpaceStateManager } from './space-state-manager';
 import { type AutomergeHost } from '../automerge';
 import { QueryExecutor } from '../query';
 
+import type { SpaceStateManager } from './space-state-manager';
+
 export type QueryServiceParams = {
   indexer: Indexer;
   automergeHost: AutomergeHost;
@@ -96,6 +97,12 @@ export class QueryServiceImpl extends Resource implements QueryService {
 
   execQuery(request: QueryRequest): Stream<QueryResponse> {
     return new Stream<QueryResponse>(({ next, close, ctx }) => {
+      if (this._params.indexer.config?.enabled !== true) {
+        log.error('indexer is disabled', { config: this._params.indexer.config });
+        close();
+        return;
+      }
+
       const queryEntry = this._createQuery(ctx, request, next, close, close);
       scheduleMicroTask(ctx, async () => {
         await queryEntry.executor.open();

package/src/db-host/space-state-manager.ts

@@ -2,11 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
-import { interpretAsDocumentId, type DocHandle, type DocumentId } from '@automerge/automerge-repo';
+import { type DocHandle, type DocumentId, interpretAsDocumentId } from '@automerge/automerge-repo';
 import isEqual from 'lodash.isequal';
 
 import { Event, UpdateScheduler } from '@dxos/async';
-import { Resource, Context, LifecycleState } from '@dxos/context';
+import { Context, LifecycleState, Resource } from '@dxos/context';
 import { type DatabaseDirectory } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
 import { type SpaceId } from '@dxos/keys';

package/src/edge/echo-edge-replicator.test.ts

@@ -7,7 +7,7 @@ import { getRandomPort } from 'get-port-please';
 import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { Event } from '@dxos/async';
-import { createEphemeralEdgeIdentity, EdgeClient, MessageSchema } from '@dxos/edge-client';
+import { EdgeClient, type EdgeHttpClient, MessageSchema, createEphemeralEdgeIdentity } from '@dxos/edge-client';
 import { createTestEdgeWsServer } from '@dxos/edge-client/testing';
 import { PublicKey, SpaceId } from '@dxos/keys';
 import { EdgeService } from '@dxos/protocols';
@@ -16,9 +16,10 @@ import { createBuf } from '@dxos/protocols/buf';
 import type { Peer } from '@dxos/protocols/proto/dxos/edge/messenger';
 import { openAndClose } from '@dxos/test-utils';
 
-import { EchoEdgeReplicator } from './echo-edge-replicator';
 import type { EchoReplicatorContext, ReplicatorConnection } from '../automerge';
 
+import { EchoEdgeReplicator } from './echo-edge-replicator';
+
 describe('EchoEdgeReplicator', () => {
   test('reconnects', async () => {
     const { client, server } = await createClientServer();
@@ -79,7 +80,8 @@ describe('EchoEdgeReplicator', () => {
   });
 
   const connectReplicator = async (client: EdgeClient, context: EchoReplicatorContext) => {
-    const replicator = new EchoEdgeReplicator({ edgeConnection: client });
+    // EdgeHttpClient functionality is not tested here.
+    const replicator = new EchoEdgeReplicator({ edgeConnection: client, edgeHttpClient: {} as EdgeHttpClient });
     await replicator.connect(context);
     onTestFinished(() => replicator.disconnect());
     return replicator;