@dxos/echo-pipeline 0.8.2-staging.7ac8446 → 0.8.2

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

@@ -8,15 +8,16 @@ import {
   type DocHandle,
   type DocumentId,
   type Repo,
-} from '@dxos/automerge/automerge-repo';
+} from '@automerge/automerge-repo';
+
 import { LifecycleState, Resource, type Context } from '@dxos/context';
 import { todo } from '@dxos/debug';
-import { createIdFromSpaceKey, SpaceDocVersion, type SpaceDoc } from '@dxos/echo-protocol';
+import { createIdFromSpaceKey, SpaceDocVersion, type DatabaseDirectory } from '@dxos/echo-protocol';
 import { IndexMetadataStore, IndexStore, Indexer } from '@dxos/indexing';
 import { invariant } from '@dxos/invariant';
 import { type PublicKey, type SpaceId } from '@dxos/keys';
 import { type LevelDB } from '@dxos/kv-store';
-import { IndexKind, type IndexConfig } from '@dxos/protocols/proto/dxos/echo/indexing';
+import { IndexKind } from '@dxos/protocols/proto/dxos/echo/indexing';
 import { trace } from '@dxos/tracing';
 
 import { DataServiceImpl } from './data-service';
@@ -26,6 +27,7 @@ import { QueryServiceImpl } from './query-service';
 import { SpaceStateManager } from './space-state-manager';
 import {
   AutomergeHost,
+  FIND_PARAMS,
   EchoDataMonitor,
   deriveCollectionIdFromSpaceId,
   type LoadDocOptions,
@@ -36,15 +38,30 @@ import {
   type RootDocumentSpaceKeyProvider,
 } from '../automerge';
 
-const INDEXER_CONFIG: IndexConfig = {
-  enabled: true,
-  indexes: [{ kind: IndexKind.Kind.SCHEMA_MATCH }],
+export interface EchoHostIndexingConfig {
+  /**
+   * @default true
+   */
+  fullText: boolean;
+
+  /**
+   * @default false
+   */
+  vector: boolean;
+}
+
+const DEFAULT_INDEXING_CONFIG: EchoHostIndexingConfig = {
+  // TODO(dmaretskyi): Disabled by default since embedding generation is expensive.
+  fullText: false,
+  vector: false,
 };
 
 export type EchoHostParams = {
   kv: LevelDB;
   peerIdProvider?: PeerIdProvider;
   getSpaceKeyByRootDocumentId?: RootDocumentSpaceKeyProvider;
+
+  indexing?: Partial<EchoHostIndexingConfig>;
 };
 
 /**
@@ -62,13 +79,13 @@ export class EchoHost extends Resource {
   private readonly _spaceStateManager = new SpaceStateManager();
   private readonly _echoDataMonitor: EchoDataMonitor;
 
-  constructor({ kv, peerIdProvider, getSpaceKeyByRootDocumentId }: EchoHostParams) {
+  constructor({ kv, indexing = {}, peerIdProvider, getSpaceKeyByRootDocumentId }: EchoHostParams) {
     super();
 
-    this._indexMetadataStore = new IndexMetadataStore({ db: kv.sublevel('index-metadata') });
+    const indexingConfig = { ...DEFAULT_INDEXING_CONFIG, ...indexing };
 
+    this._indexMetadataStore = new IndexMetadataStore({ db: kv.sublevel('index-metadata') });
     this._echoDataMonitor = new EchoDataMonitor();
-
     this._automergeHost = new AutomergeHost({
       db: kv,
       dataMonitor: this._echoDataMonitor,
@@ -84,11 +101,22 @@ export class EchoHost extends Resource {
       loadDocuments: createSelectedDocumentsIterator(this._automergeHost),
       indexCooldownTime: process.env.NODE_ENV === 'test' ? 0 : undefined,
     });
-    this._indexer.setConfig(INDEXER_CONFIG);
+    void this._indexer.setConfig({
+      enabled: true,
+      indexes: [
+        //
+        { kind: IndexKind.Kind.SCHEMA_MATCH },
+        { kind: IndexKind.Kind.GRAPH },
+
+        ...(indexingConfig.fullText ? [{ kind: IndexKind.Kind.FULL_TEXT }] : []),
+        ...(indexingConfig.vector ? [{ kind: IndexKind.Kind.VECTOR }] : []),
+      ],
+    });
 
     this._queryService = new QueryServiceImpl({
       automergeHost: this._automergeHost,
       indexer: this._indexer,
+      spaceStateManager: this._spaceStateManager,
     });
 
     this._dataService = new DataServiceImpl({
@@ -179,8 +207,8 @@ export class EchoHost extends Resource {
   }
 
   protected override async _close(ctx: Context): Promise<void> {
-    await this._spaceStateManager.close();
     await this._queryService.close(ctx);
+    await this._spaceStateManager.close(ctx);
     await this._indexer.close(ctx);
     await this._automergeHost.close();
   }
@@ -188,14 +216,14 @@ export class EchoHost extends Resource {
   /**
    * Flush all pending writes to the underlying storage.
    */
-  async flush() {
+  async flush(): Promise<void> {
     await this._automergeHost.repo.flush();
   }
 
   /**
    * Perform any pending index updates.
    */
-  async updateIndexes() {
+  async updateIndexes(): Promise<void> {
     await this._indexer.updateIndexes();
   }
 
@@ -224,7 +252,7 @@ export class EchoHost extends Resource {
     invariant(this._lifecycleState === LifecycleState.OPEN);
     const spaceId = await createIdFromSpaceKey(spaceKey);
 
-    const automergeRoot = this._automergeHost.createDoc<SpaceDoc>({
+    const automergeRoot = this._automergeHost.createDoc<DatabaseDirectory>({
       version: SpaceDocVersion.CURRENT,
       access: { spaceKey: spaceKey.toHex() },
 
@@ -241,7 +269,8 @@ export class EchoHost extends Resource {
   // TODO(dmaretskyi): Change to document id.
   async openSpaceRoot(spaceId: SpaceId, automergeUrl: AutomergeUrl): Promise<DatabaseRoot> {
     invariant(this._lifecycleState === LifecycleState.OPEN);
-    const handle = this._automergeHost.repo.find<SpaceDoc>(automergeUrl);
+    const handle = await this._automergeHost.repo.find<DatabaseDirectory>(automergeUrl, FIND_PARAMS);
+    await handle.whenReady();
 
     return this._spaceStateManager.assignRootToSpace(spaceId, handle);
   }

package/src/db-host/index.ts

@@ -6,6 +6,5 @@ export * from './data-service';
 export * from './documents-synchronizer';
 export * from './echo-host';
 export * from './database-root';
-export * from './query-state';
 export * from './query-service';
 export * from './space-state-manager';

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

@@ -2,12 +2,15 @@
 // Copyright 2024 DXOS.org
 //
 
+import { getHeads } from '@automerge/automerge';
+import { type DocHandle, type DocumentId } from '@automerge/automerge-repo';
+import { Schema } from 'effect';
+
 import { DeferredTask } from '@dxos/async';
-import { getHeads } from '@dxos/automerge/automerge';
-import { type DocHandle, type DocumentId } from '@dxos/automerge/automerge-repo';
 import { Stream } from '@dxos/codec-protobuf/stream';
 import { Context, Resource } from '@dxos/context';
-import { type SpaceDoc } from '@dxos/echo-protocol';
+import { raise } from '@dxos/debug';
+import { DatabaseDirectory, QueryAST } from '@dxos/echo-protocol';
 import { type IdToHeads, type Indexer, type ObjectSnapshot } from '@dxos/indexing';
 import { log } from '@dxos/log';
 import { objectPointerCodec } from '@dxos/protocols';
@@ -20,19 +23,21 @@ import {
 } from '@dxos/protocols/proto/dxos/echo/query';
 import { trace } from '@dxos/tracing';
 
-import { QueryState } from './query-state';
-import { getSpaceKeyFromDoc, type AutomergeHost } from '../automerge';
+import type { SpaceStateManager } from './space-state-manager';
+import { type AutomergeHost } from '../automerge';
+import { QueryExecutor } from '../query';
 
 export type QueryServiceParams = {
   indexer: Indexer;
   automergeHost: AutomergeHost;
+  spaceStateManager: SpaceStateManager;
 };
 
 /**
  * Represents an active query (stream and query state connected to that stream).
  */
 type ActiveQuery = {
-  state: QueryState;
+  executor: QueryExecutor;
   sendResults: (results: QueryResult[]) => void;
   close: () => Promise<void>;
 };
@@ -44,9 +49,9 @@ export class QueryServiceImpl extends Resource implements QueryService {
     await Promise.all(
       Array.from(this._queries).map(async (query) => {
         try {
-          const { changed } = await query.state.execQuery();
+          const { changed } = await query.executor.execQuery();
           if (changed) {
-            query.sendResults(query.state.getResults());
+            query.sendResults(query.executor.getResults());
           }
         } catch (err) {
           log.catch(err);
@@ -65,37 +70,39 @@ export class QueryServiceImpl extends Resource implements QueryService {
       fetch: () => {
         return Array.from(this._queries).map((query) => {
           return {
-            filter: JSON.stringify(query.state.filter),
-            metrics: query.state.metrics,
+            query: JSON.stringify(query.executor.query),
+            plan: JSON.stringify(query.executor.plan),
+            trace: JSON.stringify(query.executor.trace),
           };
         });
       },
     });
   }
 
-  override async _open() {
+  override async _open(): Promise<void> {
     this._params.indexer.updated.on(this._ctx, () => this._updateQueries.schedule());
   }
 
-  override async _close() {
+  override async _close(): Promise<void> {
     await Promise.all(Array.from(this._queries).map((query) => query.close()));
   }
 
   async setConfig(config: IndexConfig): Promise<void> {
-    if (this._params.indexer.initialized) {
-      log.warn('Indexer already initialized.');
-      return;
-    }
-    this._params.indexer.setConfig(config);
+    await this._params.indexer.setConfig(config);
   }
 
   execQuery(request: QueryRequest): Stream<QueryResponse> {
     return new Stream<QueryResponse>(({ next, close, ctx }) => {
-      const query: ActiveQuery = {
-        state: new QueryState({
+      const parsedQuery = QueryAST.Query.pipe(Schema.decodeUnknownSync)(JSON.parse(request.query));
+
+      const queryEntry: ActiveQuery = {
+        executor: new QueryExecutor({
           indexer: this._params.indexer,
           automergeHost: this._params.automergeHost,
-          request,
+          queryId: request.queryId ?? raise(new Error('query id required')),
+          query: parsedQuery,
+          reactivity: request.reactivity,
+          spaceStateManager: this._params.spaceStateManager,
         }),
         sendResults: (results) => {
           if (ctx.disposed) {
@@ -105,33 +112,32 @@ export class QueryServiceImpl extends Resource implements QueryService {
         },
         close: async () => {
           close();
-          await query.state.close();
-          this._queries.delete(query);
+          await queryEntry.executor.close();
+          this._queries.delete(queryEntry);
         },
       };
-      this._queries.add(query);
+      this._queries.add(queryEntry);
 
       queueMicrotask(async () => {
-        await query.state.open();
+        await queryEntry.executor.open();
 
         try {
-          const { changed } = await query.state.execQuery();
-          if (changed) {
-            query.sendResults(query.state.getResults());
-          }
-        } catch (error) {
-          log.catch(error);
+          await queryEntry.executor.execQuery();
+          // Always send first result set.
+          queryEntry.sendResults(queryEntry.executor.getResults());
+        } catch (error: any) {
+          close(error);
         }
       });
 
-      return query.close;
+      return queryEntry.close;
     });
   }
 
   /**
    * Re-index all loaded documents.
    */
-  async reindex() {
+  async reindex(): Promise<void> {
     log.info('Reindexing all documents...');
     const iterator = createDocumentsIterator(this._params.automergeHost);
     const ids: IdToHeads = new Map();
@@ -162,13 +168,13 @@ const createDocumentsIterator = (automergeHost: AutomergeHost) =>
     /** visited automerge handles */
     const visited = new Set<string>();
 
-    async function* getObjectsFromHandle(handle: DocHandle<SpaceDoc>): AsyncGenerator<ObjectSnapshot[]> {
-      if (visited.has(handle.documentId)) {
+    async function* getObjectsFromHandle(handle: DocHandle<DatabaseDirectory>): AsyncGenerator<ObjectSnapshot[]> {
+      if (visited.has(handle.documentId) || !handle.isReady()) {
         return;
       }
-      const doc = handle.docSync()!;
+      const doc = handle.doc()!;
 
-      const spaceKey = getSpaceKeyFromDoc(doc) ?? undefined;
+      const spaceKey = DatabaseDirectory.getSpaceKey(doc) ?? undefined;
 
       if (doc.objects) {
         yield Object.entries(doc.objects as { [key: string]: any }).map(([objectId, object]) => {
@@ -186,7 +192,7 @@ const createDocumentsIterator = (automergeHost: AutomergeHost) =>
           if (visited.has(urlString)) {
             continue;
           }
-          const linkHandle = await automergeHost.loadDoc<SpaceDoc>(Context.default(), urlString as DocumentId);
+          const linkHandle = await automergeHost.loadDoc<DatabaseDirectory>(Context.default(), urlString as DocumentId);
           for await (const result of getObjectsFromHandle(linkHandle)) {
             yield result;
           }

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

@@ -2,12 +2,13 @@
 // Copyright 2024 DXOS.org
 //
 
+import { interpretAsDocumentId, type DocHandle, type DocumentId } from '@automerge/automerge-repo';
 import isEqual from 'lodash.isequal';
 
 import { Event, UpdateScheduler } from '@dxos/async';
-import { interpretAsDocumentId, type DocHandle, type DocumentId } from '@dxos/automerge/automerge-repo';
-import { Resource, Context } from '@dxos/context';
-import { type SpaceDoc } from '@dxos/echo-protocol';
+import { Resource, Context, LifecycleState } from '@dxos/context';
+import { type DatabaseDirectory } from '@dxos/echo-protocol';
+import { invariant } from '@dxos/invariant';
 import { type SpaceId } from '@dxos/keys';
 
 import { DatabaseRoot } from './database-root';
@@ -39,7 +40,16 @@ export class SpaceStateManager extends Resource {
     return this._rootBySpace.get(spaceId);
   }
 
-  async assignRootToSpace(spaceId: SpaceId, handle: DocHandle<SpaceDoc>): Promise<DatabaseRoot> {
+  getRootBySpaceId(spaceId: SpaceId): DatabaseRoot | undefined {
+    invariant(this._lifecycleState === LifecycleState.OPEN);
+    const documentId = this._rootBySpace.get(spaceId);
+    if (!documentId) {
+      return undefined;
+    }
+    return this._roots.get(documentId);
+  }
+
+  async assignRootToSpace(spaceId: SpaceId, handle: DocHandle<DatabaseDirectory>): Promise<DatabaseRoot> {
     let root: DatabaseRoot;
     if (this._roots.has(handle.documentId)) {
       root = this._roots.get(handle.documentId)!;

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

@@ -2,11 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
+import { cbor } from '@automerge/automerge-repo';
 import { getRandomPort } from 'get-port-please';
 import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { Event } from '@dxos/async';
-import { cbor } from '@dxos/automerge/automerge-repo';
 import { createEphemeralEdgeIdentity, EdgeClient, MessageSchema } from '@dxos/edge-client';
 import { createTestEdgeWsServer } from '@dxos/edge-client/testing';
 import { PublicKey, SpaceId } from '@dxos/keys';
@@ -33,12 +33,12 @@ describe('EchoEdgeReplicator', () => {
     await connectionOpen.waitForCount(1);
 
     const forbidden = createForbiddenMessage({ identityKey: client.identityKey, peerKey: client.peerKey }, spaceId);
-    server.sendMessage(forbidden);
+    await server.sendMessage(forbidden);
     await connectionOpen.waitForCount(1);
 
     // Double restart to check for race conditions.
     client.setIdentity(await createEphemeralEdgeIdentity());
-    server.sendMessage(forbidden);
+    await server.sendMessage(forbidden);
     await connectionOpen.waitForCount(1);
 
     await replicator.disconnect();

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

@@ -2,8 +2,9 @@
 // Copyright 2024 DXOS.org
 //
 
+import { cbor } from '@automerge/automerge-repo';
+
 import { Mutex, scheduleTask, scheduleMicroTask } from '@dxos/async';
-import { cbor } from '@dxos/automerge/automerge-repo';
 import { Context, Resource } from '@dxos/context';
 import { randomUUID } from '@dxos/crypto';
 import type { CollectionId } from '@dxos/echo-protocol';
@@ -68,7 +69,7 @@ export class EchoEdgeReplicator implements EchoReplicator {
     );
   }
 
-  private async _handleReconnect() {
+  private async _handleReconnect(): Promise<void> {
     using _guard = await this._mutex.acquire();
 
     const spaces = [...this._connectedSpaces];
@@ -94,7 +95,7 @@ export class EchoEdgeReplicator implements EchoReplicator {
     this._connections.clear();
   }
 
-  async connectToSpace(spaceId: SpaceId) {
+  async connectToSpace(spaceId: SpaceId): Promise<void> {
     using _guard = await this._mutex.acquire();
 
     if (this._connectedSpaces.has(spaceId)) {
@@ -108,7 +109,7 @@ export class EchoEdgeReplicator implements EchoReplicator {
     }
   }
 
-  async disconnectFromSpace(spaceId: SpaceId) {
+  async disconnectFromSpace(spaceId: SpaceId): Promise<void> {
     using _guard = await this._mutex.acquire();
 
     this._connectedSpaces.delete(spaceId);
@@ -120,7 +121,7 @@ export class EchoEdgeReplicator implements EchoReplicator {
     }
   }
 
-  private async _openConnection(spaceId: SpaceId, reconnects: number = 0) {
+  private async _openConnection(spaceId: SpaceId, reconnects: number = 0): Promise<void> {
     invariant(this._context);
     invariant(!this._connections.has(spaceId));
 
@@ -310,7 +311,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     return spaceId === this._spaceId && params.collectionId.split(':').length === 3;
   }
 
-  private _onMessage(message: RouterMessage) {
+  private _onMessage(message: RouterMessage): void {
     if (message.serviceId !== this._targetServiceId) {
       return;
     }
@@ -327,7 +328,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     this._processMessage(payload);
   }
 
-  private _processMessage(message: AutomergeProtocolMessage) {
+  private _processMessage(message: AutomergeProtocolMessage): void {
     // There's a race between the credentials being replicated that are needed for access control and the data replication.
     // AutomergeReplicator might return a Forbidden error if the credentials are not yet replicated.
     // We restart the connection with some delay to account for that.
@@ -341,7 +342,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     this._readableStreamController.enqueue(message);
   }
 
-  private async _sendMessage(message: AutomergeProtocolMessage) {
+  private async _sendMessage(message: AutomergeProtocolMessage): Promise<void> {
     // Fix the peer id.
     (message as any).targetId = this._targetServiceId as PeerId;
 

package/src/edge/inflight-request-limiter.ts

@@ -26,19 +26,19 @@ export class InflightRequestLimiter extends Resource {
     super();
   }
 
-  protected override async _open() {
+  protected override async _open(): Promise<void> {
     this._inflightRequestBalance = 0;
     this._requestBarrier.reset();
     this._requestBarrier.wake();
   }
 
-  protected override async _close() {
+  protected override async _close(): Promise<void> {
     this._inflightRequestBalance = 0;
     this._requestBarrier.throw(new Error('Rate limiter closed.'));
     clearTimeout(this._resetBalanceTimeout);
   }
 
-  public async rateLimit(message: AutomergeProtocolMessage) {
+  public async rateLimit(message: AutomergeProtocolMessage): Promise<void> {
     if (message.type !== 'sync') {
       return;
     }
@@ -56,7 +56,7 @@ export class InflightRequestLimiter extends Resource {
     }
   }
 
-  public handleResponse(message: AutomergeProtocolMessage) {
+  public handleResponse(message: AutomergeProtocolMessage): void {
     if (message.type !== 'sync') {
       return;
     }

package/src/filter/filter-match.test.ts

@@ -0,0 +1,101 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { ObjectStructure } from '@dxos/echo-protocol';
+import { Expando, EXPANDO_TYPENAME, Filter, Ref } from '@dxos/echo-schema';
+import { DXN, ObjectId, SpaceId } from '@dxos/keys';
+
+import { filterMatchObject, type MatchedObject } from './filter-match';
+
+describe('filterMatch', () => {
+  test('properties', () => {
+    expect(filterMatchObject(Filter.type(Expando, { title: 'test' }).ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(Filter.type(Expando, { value: 100 }).ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(Filter.type(Expando, { complete: false }).ast, OBJECT_1)).to.be.false;
+    expect(filterMatchObject(Filter.type(Expando, { missing: undefined }).ast, OBJECT_1)).to.be.true;
+  });
+
+  test('and', () => {
+    const filter1 = Filter.type(Expando, { title: 'test' });
+    const filter2 = Filter.type(Expando, { value: 100 });
+    const filter3 = Filter.type(Expando, { complete: true });
+
+    expect(filterMatchObject(Filter.and(filter1, filter2, filter3).ast, OBJECT_1)).to.be.true;
+  });
+
+  test('or', () => {
+    const filter1 = Filter.type(Expando, { value: 200 });
+    const filter2 = Filter.type(Expando, { title: 'test' });
+    const filter3 = Filter.type(Expando, { complete: false });
+
+    expect(filterMatchObject(Filter.or(filter1, filter2, filter3).ast, OBJECT_1)).to.be.true;
+  });
+
+  test('not', () => {
+    const filter1 = Filter.type(Expando, { title: 'test' });
+    const filter2 = Filter.not(filter1);
+
+    expect(filterMatchObject(filter1.ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(filter2.ast, OBJECT_1)).to.be.false;
+  });
+
+  test('complex', () => {
+    const filter1 = Filter.type(Expando, { title: 'bad' });
+    const filter2 = Filter.type(Expando, { value: 0 });
+    expect(filterMatchObject(Filter.not(Filter.or(filter1, filter2)).ast, OBJECT_1)).to.be.true;
+  });
+
+  test('ids', () => {
+    const filter = Filter.ids(OBJECT_1.id);
+    expect(filterMatchObject(filter.ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(filter.ast, OBJECT_2)).to.be.false;
+  });
+
+  test('everything', () => {
+    expect(filterMatchObject(Filter.everything().ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(Filter.everything().ast, OBJECT_2)).to.be.true;
+  });
+
+  test('nothing', () => {
+    expect(filterMatchObject(Filter.nothing().ast, OBJECT_1)).to.be.false;
+    expect(filterMatchObject(Filter.nothing().ast, OBJECT_2)).to.be.false;
+  });
+
+  test('refs', () => {
+    const filter = Filter.type(Expando, { parent: Ref.fromDXN(DXN.fromLocalObjectId(OBJECT_1.id)) });
+    expect(filterMatchObject(filter.ast, OBJECT_1)).to.be.false;
+    expect(filterMatchObject(filter.ast, OBJECT_2)).to.be.false;
+    expect(filterMatchObject(filter.ast, OBJECT_3)).to.be.true;
+  });
+});
+
+const OBJECT_1: MatchedObject = {
+  id: ObjectId.make('01JVS9YYT5VMVJW0GGTM1YHCCH'),
+  spaceId: SpaceId.make('B2NJDFNVZIW77OQSXUBNAD7BUMBD3G5PO'),
+  doc: ObjectStructure.makeObject({
+    type: DXN.fromTypenameAndVersion(EXPANDO_TYPENAME, '0.1.0').toString(),
+    data: { title: 'test', value: 100, complete: true },
+  }),
+};
+
+const OBJECT_2: MatchedObject = {
+  id: ObjectId.make('01JT5TD6K9FFJ3VNM5FGMS5C0Q'),
+  spaceId: SpaceId.make('B2NJDFNVZIW77OQSXUBNAD7BUMBD3G5PO'),
+  doc: ObjectStructure.makeObject({
+    type: DXN.fromTypenameAndVersion(EXPANDO_TYPENAME, '0.1.0').toString(),
+    data: { title: 'test', value: 100, complete: true },
+    deleted: true,
+  }),
+};
+
+const OBJECT_3: MatchedObject = {
+  id: ObjectId.make('01JT5TD6K9FFJ3VNM5FGMS5C0Q'),
+  spaceId: SpaceId.make('B2NJDFNVZIW77OQSXUBNAD7BUMBD3G5PO'),
+  doc: ObjectStructure.makeObject({
+    type: DXN.fromTypenameAndVersion(EXPANDO_TYPENAME, '0.1.0').toString(),
+    data: { title: 'test', value: 100, complete: true, parent: { '/': DXN.fromLocalObjectId(OBJECT_1.id).toString() } },
+  }),
+};