@dxos/echo-pipeline 0.8.3 → 0.8.4-main.1068cf700f

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,8 +16,9 @@ import { createBuf } from '@dxos/protocols/buf';
 import type { Peer } from '@dxos/protocols/proto/dxos/edge/messenger';
 import { openAndClose } from '@dxos/test-utils';
 
+import type { AutomergeReplicatorConnection, AutomergeReplicatorContext } from '../automerge';
+
 import { EchoEdgeReplicator } from './echo-edge-replicator';
-import type { EchoReplicatorContext, ReplicatorConnection } from '../automerge';
 
 describe('EchoEdgeReplicator', () => {
   test('reconnects', async () => {
@@ -78,8 +79,9 @@ describe('EchoEdgeReplicator', () => {
     });
   });
 
-  const connectReplicator = async (client: EdgeClient, context: EchoReplicatorContext) => {
-    const replicator = new EchoEdgeReplicator({ edgeConnection: client });
+  const connectReplicator = async (client: EdgeClient, context: AutomergeReplicatorContext) => {
+    // EdgeHttpClient functionality is not tested here.
+    const replicator = new EchoEdgeReplicator({ edgeConnection: client, edgeHttpClient: {} as EdgeHttpClient });
     await replicator.connect(context);
     onTestFinished(() => replicator.disconnect());
     return replicator;
@@ -99,7 +101,7 @@ const createMockContext = (args?: {
   documentSpaceId?: { [documentId: string]: SpaceId };
 }) => {
   const connectionOpen = new Event();
-  const openConnections: ReplicatorConnection[] = [];
+  const openConnections: AutomergeReplicatorConnection[] = [];
   return {
     context: {
       getContainingSpaceIdForDocument: async (documentId) => args?.documentSpaceId?.[documentId] ?? null,
@@ -119,7 +121,7 @@ const createMockContext = (args?: {
       },
 
       peerId: PublicKey.random().toHex(),
-    } satisfies EchoReplicatorContext,
+    } satisfies AutomergeReplicatorContext,
 
     openConnections,
     connectionOpen,

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

@@ -2,34 +2,44 @@
 // Copyright 2024 DXOS.org
 //
 
-import { cbor } from '@automerge/automerge-repo';
+import * as Automerge from '@automerge/automerge';
+import { type DocumentId, type Heads, cbor } from '@automerge/automerge-repo';
 
-import { Mutex, scheduleTask, scheduleMicroTask } from '@dxos/async';
+import { Mutex, scheduleMicroTask, scheduleTask } from '@dxos/async';
 import { Context, Resource } from '@dxos/context';
 import { randomUUID } from '@dxos/crypto';
 import type { CollectionId } from '@dxos/echo-protocol';
-import { type EdgeConnection } from '@dxos/edge-client';
+import { type EdgeConnection, type EdgeHttpClient } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
 import type { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { EdgeService, type AutomergeProtocolMessage, type PeerId } from '@dxos/protocols';
+import {
+  type AutomergeProtocolMessage,
+  DocumentCodec,
+  EdgeService,
+  type ErrorProtocolMessage,
+  type ExportBundleRequest,
+  type ImportBundleRequest,
+  type PeerId,
+} from '@dxos/protocols';
 import { buf } from '@dxos/protocols/buf';
 import {
   type Message as RouterMessage,
   MessageSchema as RouterMessageSchema,
 } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
-import { bufferToArray } from '@dxos/util';
+import { bufferToArray, setDeep } from '@dxos/util';
 
-import { InflightRequestLimiter } from './inflight-request-limiter';
 import {
+  type AutomergeReplicator,
+  type AutomergeReplicatorConnection,
+  type AutomergeReplicatorContext,
+  type ShouldAdvertiseProps,
+  type ShouldSyncCollectionProps,
   getSpaceIdFromCollectionId,
-  type EchoReplicator,
-  type EchoReplicatorContext,
-  type ReplicatorConnection,
-  type ShouldAdvertiseParams,
-  type ShouldSyncCollectionParams,
 } from '../automerge';
 
+import { InflightRequestLimiter } from './inflight-request-limiter';
+
 /**
  * Delay before restarting the connection after receiving a forbidden error.
  */
@@ -37,27 +47,30 @@ const INITIAL_RESTART_DELAY = 500;
 const RESTART_DELAY_JITTER = 250;
 const MAX_RESTART_DELAY = 5000;
 
-export type EchoEdgeReplicatorParams = {
+export type EchoEdgeReplicatorProps = {
   edgeConnection: EdgeConnection;
+  edgeHttpClient: EdgeHttpClient;
   disableSharePolicy?: boolean;
 };
 
-export class EchoEdgeReplicator implements EchoReplicator {
+export class EchoEdgeReplicator implements AutomergeReplicator {
   private readonly _edgeConnection: EdgeConnection;
+  private readonly _edgeHttpClient: EdgeHttpClient;
   private readonly _mutex = new Mutex();
 
   private _ctx?: Context = undefined;
-  private _context: EchoReplicatorContext | null = null;
+  private _context: AutomergeReplicatorContext | null = null;
   private _connectedSpaces = new Set<SpaceId>();
   private _connections = new Map<SpaceId, EdgeReplicatorConnection>();
   private _sharePolicyEnabled = true;
 
-  constructor({ edgeConnection, disableSharePolicy }: EchoEdgeReplicatorParams) {
+  constructor({ edgeConnection, edgeHttpClient, disableSharePolicy }: EchoEdgeReplicatorProps) {
     this._edgeConnection = edgeConnection;
+    this._edgeHttpClient = edgeHttpClient;
     this._sharePolicyEnabled = !disableSharePolicy;
   }
 
-  async connect(context: EchoReplicatorContext): Promise<void> {
+  async connect(context: AutomergeReplicatorContext): Promise<void> {
     log('connecting...', { peerId: context.peerId, connectedSpaces: this._connectedSpaces.size });
     this._context = context;
     this._ctx = Context.default();
@@ -95,6 +108,7 @@ export class EchoEdgeReplicator implements EchoReplicator {
   }
 
   async connectToSpace(spaceId: SpaceId): Promise<void> {
+    log('connectToSpace', { spaceId });
     using _guard = await this._mutex.acquire();
 
     if (this._connectedSpaces.has(spaceId)) {
@@ -127,14 +141,17 @@ export class EchoEdgeReplicator implements EchoReplicator {
     let restartScheduled = false;
 
     const connection = new EdgeReplicatorConnection({
+      edgeHttpClient: this._edgeHttpClient,
       edgeConnection: this._edgeConnection,
       spaceId,
       context: this._context,
       sharedPolicyEnabled: this._sharePolicyEnabled,
       onRemoteConnected: async () => {
+        log.trace('dxos.echo.edge.replicator.onRemoteConnected', { spaceId });
         this._context?.onConnectionOpen(connection);
       },
       onRemoteDisconnected: async () => {
+        log.trace('dxos.echo.edge.replicator.onRemoteDisconnected', { spaceId });
         this._context?.onConnectionClosed(connection);
       },
       onRestartRequested: async () => {
@@ -162,6 +179,7 @@ export class EchoEdgeReplicator implements EchoReplicator {
             if (ctx?.disposed) {
               return;
             }
+            log.trace('dxos.echo.edge.replicator.restart', { spaceId, reconnects, restartDelay });
             await this._openConnection(spaceId, reconnects + 1);
           },
           restartDelay,
@@ -174,10 +192,11 @@ export class EchoEdgeReplicator implements EchoReplicator {
   }
 }
 
-type EdgeReplicatorConnectionsParams = {
+type EdgeReplicatorConnectionsProps = {
   edgeConnection: EdgeConnection;
+  edgeHttpClient: EdgeHttpClient;
   spaceId: SpaceId;
-  context: EchoReplicatorContext;
+  context: AutomergeReplicatorContext;
   sharedPolicyEnabled: boolean;
   onRemoteConnected: () => Promise<void>;
   onRemoteDisconnected: () => Promise<void>;
@@ -187,16 +206,19 @@ type EdgeReplicatorConnectionsParams = {
 const MAX_INFLIGHT_REQUESTS = 5;
 const MAX_RATE_LIMIT_WAIT_TIME_MS = 3000;
 
-class EdgeReplicatorConnection extends Resource implements ReplicatorConnection {
+class EdgeReplicatorConnection extends Resource implements AutomergeReplicatorConnection {
+  private readonly _connectionId = randomUUID();
   private readonly _edgeConnection: EdgeConnection;
+  private readonly _edgeHttpClient: EdgeHttpClient;
   private readonly _remotePeerId: string | null = null;
   private readonly _targetServiceId: string;
   private readonly _spaceId: SpaceId;
-  private readonly _context: EchoReplicatorContext;
+  private readonly _context: AutomergeReplicatorContext;
   private readonly _sharedPolicyEnabled: boolean;
   private readonly _onRemoteConnected: () => Promise<void>;
   private readonly _onRemoteDisconnected: () => Promise<void>;
   private readonly _onRestartRequested: () => void;
+  private _sequence = 0;
 
   private _requestLimiter = new InflightRequestLimiter({
     maxInflightRequests: MAX_INFLIGHT_REQUESTS,
@@ -210,22 +232,24 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
 
   constructor({
     edgeConnection,
+    edgeHttpClient,
     spaceId,
     context,
     sharedPolicyEnabled,
     onRemoteConnected,
     onRemoteDisconnected,
     onRestartRequested,
-  }: EdgeReplicatorConnectionsParams) {
+  }: EdgeReplicatorConnectionsProps) {
     super();
     this._edgeConnection = edgeConnection;
+    this._edgeHttpClient = edgeHttpClient;
     this._spaceId = spaceId;
     this._context = context;
     // Generate a unique peer id for every connection.
     // This way automerge-repo will have separate sync states for every connection.
     // This is important because the previous connection might have had some messages that failed to deliver
     // abd if we don't clear the sync-state, automerge will not attempt to deliver them again.
-    this._remotePeerId = `${EdgeService.AUTOMERGE_REPLICATOR}:${spaceId}-${randomUUID()}`;
+    this._remotePeerId = `${EdgeService.AUTOMERGE_REPLICATOR}:${spaceId}-${this._connectionId}`;
     this._targetServiceId = `${EdgeService.AUTOMERGE_REPLICATOR}:${spaceId}`;
     this._sharedPolicyEnabled = sharedPolicyEnabled;
     this._onRemoteConnected = onRemoteConnected;
@@ -252,13 +276,26 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
 
     await this._requestLimiter.open();
 
-    // TODO: handle reconnects
     this._ctx.onDispose(
       this._edgeConnection.onMessage((msg: RouterMessage) => {
         this._onMessage(msg);
       }),
     );
 
+    let firstReconnect = true;
+    this._ctx.onDispose(
+      // NOTE: This will fire immediately if the connection is already open.
+      this._edgeConnection.onReconnected(async () => {
+        if (firstReconnect) {
+          log.verbose('first reconnect skipped');
+          firstReconnect = false;
+          return;
+        }
+
+        this._onRestartRequested();
+      }),
+    );
+
     await this._onRemoteConnected();
   }
 
@@ -276,7 +313,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     return this._remotePeerId;
   }
 
-  async shouldAdvertise(params: ShouldAdvertiseParams): Promise<boolean> {
+  async shouldAdvertise(params: ShouldAdvertiseProps): Promise<boolean> {
     if (!this._sharedPolicyEnabled) {
       return true;
     }
@@ -301,7 +338,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     return spaceId === this._spaceId;
   }
 
-  shouldSyncCollection(params: ShouldSyncCollectionParams): boolean {
+  shouldSyncCollection(params: ShouldSyncCollectionProps): boolean {
     if (!this._sharedPolicyEnabled) {
       return true;
     }
@@ -317,8 +354,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
 
     const payload = cbor.decode(message.payload!.value) as AutomergeProtocolMessage;
     log.verbose('received', {
-      type: payload.type,
-      documentId: payload.type === 'sync' && payload.documentId,
+      ...getMessageInfo(payload),
       remoteId: this._remotePeerId,
     });
 
@@ -327,11 +363,33 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     this._processMessage(payload);
   }
 
+  get bundleSyncEnabled(): boolean {
+    return true;
+  }
+
+  async pushBundle(bundle: { documentId: DocumentId; data: Uint8Array; heads: Heads }[]) {
+    const request: ImportBundleRequest = {
+      bundle: bundle.map(({ documentId, data, heads }) => ({
+        documentId,
+        mutation: DocumentCodec.encode(data),
+        heads,
+      })),
+    };
+    await this._edgeHttpClient.importBundle(this._spaceId, request);
+  }
+
+  async pullBundle(docHeads: Record<DocumentId, Heads>): Promise<Record<DocumentId, Uint8Array>> {
+    const request: ExportBundleRequest = { docHeads };
+    const response = await this._edgeHttpClient.exportBundle(this._spaceId, request);
+    return Object.fromEntries(response.bundle.map((doc) => [doc.documentId, DocumentCodec.decode(doc.mutation)]));
+  }
+
   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.
-    if (isForbiddenErrorMessage(message)) {
+    if (isErrorMessage(message)) {
+      log.verbose('stream error', { error: (message as ErrorProtocolMessage).message });
       this._onRestartRequested();
       return;
     }
@@ -345,29 +403,53 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     // Fix the peer id.
     (message as any).targetId = this._targetServiceId as PeerId;
 
+    // Note: This is used on EDGE to detect out-of-order messages per connection.
+    setDeep(message, ['metadata', 'dxos_sequence'], this._getSequence());
+    setDeep(message, ['metadata', 'dxos_connectionId'], this._connectionId);
+
     log.verbose('sending...', {
-      type: message.type,
-      documentId: message.type === 'sync' && message.documentId,
+      ...getMessageInfo(message),
       remoteId: this._remotePeerId,
     });
 
     const encoded = cbor.encode(message);
 
-    await this._edgeConnection.send(
-      buf.create(RouterMessageSchema, {
-        serviceId: this._targetServiceId,
-        source: {
-          identityKey: this._edgeConnection.identityKey,
-          peerKey: this._edgeConnection.peerKey,
-        },
-        payload: { value: bufferToArray(encoded) },
-      }),
-    );
+    try {
+      await this._edgeConnection.send(
+        buf.create(RouterMessageSchema, {
+          serviceId: this._targetServiceId,
+          source: {
+            identityKey: this._edgeConnection.identityKey,
+            peerKey: this._edgeConnection.peerKey,
+          },
+          payload: { value: bufferToArray(encoded) },
+        }),
+      );
+    } catch (err) {
+      log.error('failed to send message', { err });
+    }
+  }
+
+  private _getSequence(): number {
+    return this._sequence++;
   }
 }
 
 /**
  * This message is sent by EDGE AutomergeReplicator when the authorization is denied.
  */
-const isForbiddenErrorMessage = (message: AutomergeProtocolMessage) =>
-  message.type === 'error' && message.message === 'Forbidden';
+const isErrorMessage = (message: AutomergeProtocolMessage) => message.type === 'error';
+
+const getMessageInfo = (msg: AutomergeProtocolMessage) => {
+  const { have, heads, need, changes } = msg.type === 'sync' ? Automerge.decodeSyncMessage(msg.data) : {};
+  return {
+    type: msg.type,
+    documentId: 'documentId' in msg ? msg.documentId : undefined,
+    collectionId: 'collectionId' in msg ? msg.collectionId : undefined,
+    have,
+    heads,
+    need,
+    changes: changes?.length,
+    sequence: msg.metadata?.dxos_sequence,
+  };
+};

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

@@ -4,69 +4,88 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { Filter } from '@dxos/echo';
+import { Filter, Ref } from '@dxos/echo';
+import { TestSchema } from '@dxos/echo/testing';
 import { ObjectStructure } from '@dxos/echo-protocol';
-import { Expando, EXPANDO_TYPENAME, Ref } from '@dxos/echo-schema';
 import { DXN, ObjectId, SpaceId } from '@dxos/keys';
 
-import { filterMatchObject, type MatchedObject } from './filter-match';
+import { type MatchedObject, filterMatchObject } from './filter-match';
 
 describe('filterMatch', () => {
+  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('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;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { title: 'test' }).ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { value: 100 }).ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { complete: false }).ast, OBJECT_1)).to.be.false;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { missing: undefined }).ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { properties: { subject: 'test' } }).ast, OBJECT_1)).to.be
+      .true;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { array: Filter.contains('two') }).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 });
+    const filter1 = Filter.type(TestSchema.Expando, { title: 'test' });
+    const filter2 = Filter.type(TestSchema.Expando, { value: 100 });
+    const filter3 = Filter.type(TestSchema.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 });
+    const filter1 = Filter.type(TestSchema.Expando, { value: 200 });
+    const filter2 = Filter.type(TestSchema.Expando, { title: 'test' });
+    const filter3 = Filter.type(TestSchema.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 filter1 = Filter.type(TestSchema.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('contains', () => {
+    expect(
+      filterMatchObject(
+        Filter.type(TestSchema.Expando, { properties: { label: Filter.contains('test') } }).ast,
+        OBJECT_1,
+      ),
+    ).to.be.true;
+    expect(
+      filterMatchObject(
+        Filter.type(TestSchema.Expando, { fields: Filter.contains({ label: 'label', value: 'test' }) }).ast,
+        OBJECT_1,
+      ),
+    ).to.be.true;
+  });
+
   test('complex', () => {
-    const filter1 = Filter.type(Expando, { title: 'bad' });
-    const filter2 = Filter.type(Expando, { value: 0 });
+    const filter1 = Filter.type(TestSchema.Expando, { title: 'bad' });
+    const filter2 = Filter.type(TestSchema.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);
+    const filter = Filter.id(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)) });
+    const filter = Filter.type(TestSchema.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;
@@ -77,8 +96,15 @@ 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 },
+    type: DXN.fromTypenameAndVersion(TestSchema.Expando.typename, '0.1.0').toString(),
+    data: {
+      title: 'test',
+      value: 100,
+      complete: true,
+      array: ['one', 'two', 'three'],
+      properties: { label: ['test'], subject: 'test' },
+      fields: [{ label: 'label', value: 'test' }],
+    },
   }),
 };
 
@@ -86,7 +112,7 @@ const OBJECT_2: MatchedObject = {
   id: ObjectId.make('01JT5TD6K9FFJ3VNM5FGMS5C0Q'),
   spaceId: SpaceId.make('B2NJDFNVZIW77OQSXUBNAD7BUMBD3G5PO'),
   doc: ObjectStructure.makeObject({
-    type: DXN.fromTypenameAndVersion(EXPANDO_TYPENAME, '0.1.0').toString(),
+    type: DXN.fromTypenameAndVersion(TestSchema.Expando.typename, '0.1.0').toString(),
     data: { title: 'test', value: 100, complete: true },
     deleted: true,
   }),
@@ -96,7 +122,7 @@ const OBJECT_3: MatchedObject = {
   id: ObjectId.make('01JT5TD6K9FFJ3VNM5FGMS5C0Q'),
   spaceId: SpaceId.make('B2NJDFNVZIW77OQSXUBNAD7BUMBD3G5PO'),
   doc: ObjectStructure.makeObject({
-    type: DXN.fromTypenameAndVersion(EXPANDO_TYPENAME, '0.1.0').toString(),
+    type: DXN.fromTypenameAndVersion(TestSchema.Expando.typename, '0.1.0').toString(),
     data: { title: 'test', value: 100, complete: true, parent: { '/': DXN.fromLocalObjectId(OBJECT_1.id).toString() } },
   }),
 };