@automerge/automerge-repo 2.0.0-alpha.20 → 2.0.0-alpha.22

package/src/Repo.ts

@@ -39,6 +39,8 @@ import type {
   DocumentId,
   PeerId,
 } from "./types.js"
+import { abortable, AbortOptions } from "./helpers/abortable.js"
+import { FindProgress, FindProgressWithMethods } from "./FindProgress.js"
 
 function randomPeerId() {
   return ("peer-" + Math.random().toString(36).slice(4)) as PeerId
@@ -260,18 +262,8 @@ export class Repo extends EventEmitter<RepoEvents> {
       handle.on("heads-changed", throttle(saveFn, this.saveDebounceRate))
     }
 
-    handle.on("unavailable", () => {
-      this.#log("document unavailable", { documentId: handle.documentId })
-      this.emit("unavailable-document", {
-        documentId: handle.documentId,
-      })
-    })
-
     // Register the document with the synchronizer. This advertises our interest in the document.
-    this.synchronizer.addDocument(handle.documentId)
-
-    // Preserve the old event in case anyone was using it.
-    this.emit("document", { handle })
+    this.synchronizer.addDocument(handle)
   }
 
   #receiveMessage(message: RepoMessage) {
@@ -402,8 +394,6 @@ export class Repo extends EventEmitter<RepoEvents> {
    * Any peers this `Repo` is connected to for whom `sharePolicy` returns `true` will
    * be notified of the newly created DocHandle.
    *
-   * @throws if the cloned handle is not yet ready or if
-   * `clonedHandle.docSync()` returns `undefined` (i.e. the handle is unavailable).
    */
   clone<T>(clonedHandle: DocHandle<T>) {
     if (!clonedHandle.isReady()) {
@@ -413,11 +403,7 @@ export class Repo extends EventEmitter<RepoEvents> {
       )
     }
 
-    const sourceDoc = clonedHandle.docSync()
-    if (!sourceDoc) {
-      throw new Error("Cloned handle doesn't have a document.")
-    }
-
+    const sourceDoc = clonedHandle.doc()
     const handle = this.create<T>()
 
     handle.update(() => {
@@ -428,63 +414,196 @@ export class Repo extends EventEmitter<RepoEvents> {
     return handle
   }
 
-  /**
-   * Retrieves a document by id. It gets data from the local system, but also emits a `document`
-   * event to advertise interest in the document.
-   */
-  find<T>(
-    /** The url or documentId of the handle to retrieve */
-    id: AnyDocumentId
-  ): DocHandle<T> {
+  findWithProgress<T>(
+    id: AnyDocumentId,
+    options: AbortOptions = {}
+  ): FindProgressWithMethods<T> | FindProgress<T> {
+    const { signal } = options
+    const abortPromise = abortable(signal)
+
     const { documentId, heads } = isValidAutomergeUrl(id)
       ? parseAutomergeUrl(id)
       : { documentId: interpretAsDocumentId(id), heads: undefined }
 
-    const cachedHandle = this.#handleCache[documentId]
-    if (cachedHandle) {
-      if (cachedHandle.isUnavailable()) {
-        // this ensures that the event fires after the handle has been returned
-        setTimeout(() => {
-          cachedHandle.emit("unavailable", {
-            handle: cachedHandle,
-          })
-        })
+    // Check cache first - return plain FindStep for terminal states
+    if (this.#handleCache[documentId]) {
+      const handle = this.#handleCache[documentId]
+      if (handle.state === UNAVAILABLE) {
+        const result = {
+          state: "unavailable" as const,
+          error: new Error(`Document ${id} is unavailable`),
+          handle,
+        }
+        return result
+      }
+      if (handle.state === DELETED) {
+        return {
+          state: "failed",
+          error: new Error(`Document ${id} was deleted`),
+          handle,
+        }
+      }
+      if (handle.state === READY) {
+        // If we already have the handle, return it immediately (or a view of the handle if heads are specified)
+        return {
+          state: "ready",
+          // TODO: this handle needs to be cached (or at least avoid running clone)
+          handle: heads ? handle.view(heads) : handle,
+        }
       }
-      // If we already have the handle, return it immediately (or a view of the handle if heads are specified)
-      return heads ? cachedHandle.view(heads) : cachedHandle
     }
 
-    // If we don't already have the handle, make an empty one and try loading it
-    const handle = this.#getHandle<T>({
-      documentId,
-    }) as DocHandle<T>
+    // the generator takes over `this`, so we need an alias to the repo this
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const that = this
+    async function* progressGenerator(): AsyncGenerator<FindProgress<T>> {
+      try {
+        const handle = that.#getHandle<T>({ documentId })
+        yield { state: "loading", progress: 25, handle }
 
-    // Loading & network is going to be asynchronous no matter what,
-    // but we want to return the handle immediately.
-    const attemptLoad = this.storageSubsystem
-      ? this.storageSubsystem.loadDoc(handle.documentId)
-      : Promise.resolve(null)
+        const loadingPromise = await (that.storageSubsystem
+          ? that.storageSubsystem.loadDoc(handle.documentId)
+          : Promise.resolve(null))
+
+        const loadedDoc = await Promise.race([loadingPromise, abortPromise])
 
-    attemptLoad
-      .then(async loadedDoc => {
         if (loadedDoc) {
-          // uhhhh, sorry if you're reading this because we were lying to the type system
           handle.update(() => loadedDoc as Automerge.Doc<T>)
           handle.doneLoading()
+          yield { state: "loading", progress: 50, handle }
         } else {
-          // we want to wait for the network subsystem to be ready before
-          // we request the document. this prevents entering unavailable during initialization.
-          await this.networkSubsystem.whenReady()
+          await Promise.race([that.networkSubsystem.whenReady(), abortPromise])
           handle.request()
+          yield { state: "loading", progress: 75, handle }
         }
-        this.#registerHandleWithSubsystems(handle)
-      })
-      .catch(err => {
-        this.#log("error waiting for network", { err })
-      })
 
-    // If we already have the handle, return it immediately (or a view of the handle if heads are specified)
-    return heads ? handle.view(heads) : handle
+        that.#registerHandleWithSubsystems(handle)
+
+        await Promise.race([
+          handle.whenReady([READY, UNAVAILABLE]),
+          abortPromise,
+        ])
+
+        if (handle.state === UNAVAILABLE) {
+          yield { state: "unavailable", handle }
+        }
+        if (handle.state === DELETED) {
+          throw new Error(`Document ${id} was deleted`)
+        }
+
+        yield { state: "ready", handle }
+      } catch (error) {
+        yield {
+          state: "failed",
+          error: error instanceof Error ? error : new Error(String(error)),
+          handle,
+        }
+      }
+    }
+
+    const iterator = progressGenerator()
+
+    const next = async () => {
+      const result = await iterator.next()
+      return { ...result.value, next }
+    }
+
+    const untilReady = async (allowableStates: string[]) => {
+      for await (const state of iterator) {
+        if (allowableStates.includes(state.handle.state)) {
+          return state.handle
+        }
+        if (state.state === "unavailable") {
+          throw new Error(`Document ${id} is unavailable`)
+        }
+        if (state.state === "ready") return state.handle
+        if (state.state === "failed") throw state.error
+      }
+      throw new Error("Iterator completed without reaching ready state")
+    }
+
+    const handle = this.#getHandle<T>({ documentId })
+    const initial = { state: "loading" as const, progress: 0, handle }
+    return { ...initial, next, untilReady }
+  }
+
+  async find<T>(
+    id: AnyDocumentId,
+    options: RepoFindOptions & AbortOptions = {}
+  ): Promise<DocHandle<T>> {
+    const { allowableStates = ["ready"], signal } = options
+    const progress = this.findWithProgress<T>(id, { signal })
+
+    /*if (allowableStates.includes(progress.state)) {
+      console.log("returning early")
+      return progress.handle
+    }*/
+
+    if ("untilReady" in progress) {
+      this.#registerHandleWithSubsystems(progress.handle)
+      return progress.untilReady(allowableStates)
+    } else {
+      return progress.handle
+    }
+  }
+
+  /**
+   * Loads a document without waiting for ready state
+   */
+  async #loadDocument<T>(documentId: DocumentId): Promise<DocHandle<T>> {
+    // If we have the handle cached, return it
+    if (this.#handleCache[documentId]) {
+      return this.#handleCache[documentId]
+    }
+
+    // If we don't already have the handle, make an empty one and try loading it
+    const handle = this.#getHandle<T>({ documentId })
+    const loadedDoc = await (this.storageSubsystem
+      ? this.storageSubsystem.loadDoc(handle.documentId)
+      : Promise.resolve(null))
+
+    if (loadedDoc) {
+      // We need to cast this to <T> because loadDoc operates in <unknowns>.
+      // This is really where we ought to be validating the input matches <T>.
+      handle.update(() => loadedDoc as Automerge.Doc<T>)
+      handle.doneLoading()
+    } else {
+      // Because the network subsystem might still be booting up, we wait
+      // here so that we don't immediately give up loading because we're still
+      // making our initial connection to a sync server.
+      await this.networkSubsystem.whenReady()
+      handle.request()
+    }
+
+    this.#registerHandleWithSubsystems(handle)
+    return handle
+  }
+
+  /**
+   * Retrieves a document by id. It gets data from the local system, but also emits a `document`
+   * event to advertise interest in the document.
+   */
+  async findClassic<T>(
+    /** The url or documentId of the handle to retrieve */
+    id: AnyDocumentId,
+    options: RepoFindOptions & AbortOptions = {}
+  ): Promise<DocHandle<T>> {
+    const documentId = interpretAsDocumentId(id)
+    const { allowableStates, signal } = options
+
+    return Promise.race([
+      (async () => {
+        const handle = await this.#loadDocument<T>(documentId)
+        if (!allowableStates) {
+          await handle.whenReady([READY, UNAVAILABLE])
+          if (handle.state === UNAVAILABLE && !signal?.aborted) {
+            throw new Error(`Document ${id} is unavailable`)
+          }
+        }
+        return handle
+      })(),
+      abortable(signal),
+    ])
   }
 
   delete(
@@ -511,8 +630,7 @@ export class Repo extends EventEmitter<RepoEvents> {
     const documentId = interpretAsDocumentId(id)
 
     const handle = this.#getHandle({ documentId })
-    const doc = await handle.doc()
-    if (!doc) return undefined
+    const doc = handle.doc()
     return Automerge.save(doc)
   }
 
@@ -566,11 +684,7 @@ export class Repo extends EventEmitter<RepoEvents> {
       : Object.values(this.#handleCache)
     await Promise.all(
       handles.map(async handle => {
-        const doc = handle.docSync()
-        if (!doc) {
-          return
-        }
-        return this.storageSubsystem!.saveDoc(handle.documentId, doc)
+        return this.storageSubsystem!.saveDoc(handle.documentId, handle.doc())
       })
     )
   }
@@ -589,7 +703,9 @@ export class Repo extends EventEmitter<RepoEvents> {
       return
     }
     const handle = this.#getHandle({ documentId })
-    const doc = await handle.doc([READY, UNLOADED, DELETED, UNAVAILABLE])
+    await handle.whenReady([READY, UNLOADED, DELETED, UNAVAILABLE])
+    const doc = handle.doc()
+    // because this is an internal-ish function, we'll be extra careful about undefined docs here
     if (doc) {
       if (handle.isReady()) {
         handle.unload()
@@ -677,6 +793,10 @@ export interface RepoEvents {
   "doc-metrics": (arg: DocMetrics) => void
 }
 
+export interface RepoFindOptions {
+  allowableStates?: string[]
+}
+
 export interface DocumentPayload {
   handle: DocHandle<any>
 }

package/src/helpers/abortable.ts

@@ -0,0 +1,61 @@
+/**
+ * Creates a promise that rejects when the signal is aborted.
+ *
+ * @remarks
+ * This utility creates a promise that rejects when the provided AbortSignal is aborted.
+ * It's designed to be used with Promise.race() to make operations abortable.
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController();
+ *
+ * try {
+ *   const result = await Promise.race([
+ *     fetch('https://api.example.com/data'),
+ *     abortable(controller.signal)
+ *   ]);
+ * } catch (err) {
+ *   if (err.name === 'AbortError') {
+ *     console.log('The operation was aborted');
+ *   }
+ * }
+ *
+ * // Later, to abort:
+ * controller.abort();
+ * ```
+ *
+ * @param signal - An AbortSignal that can be used to abort the operation
+ * @param cleanup - Optional cleanup function that will be called if aborted
+ * @returns A promise that rejects with AbortError when the signal is aborted
+ * @throws {DOMException} With name "AbortError" when aborted
+ */
+export function abortable(
+  signal?: AbortSignal,
+  cleanup?: () => void
+): Promise<never> {
+  if (signal?.aborted) {
+    throw new DOMException("Operation aborted", "AbortError")
+  }
+
+  if (!signal) {
+    return new Promise(() => {}) // Never resolves
+  }
+
+  return new Promise((_, reject) => {
+    signal.addEventListener(
+      "abort",
+      () => {
+        cleanup?.()
+        reject(new DOMException("Operation aborted", "AbortError"))
+      },
+      { once: true }
+    )
+  })
+}
+
+/**
+ * Include this type in an options object to pass an AbortSignal to a function.
+ */
+export interface AbortOptions {
+  signal?: AbortSignal
+}

package/src/helpers/tests/network-adapter-tests.ts

@@ -49,9 +49,10 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
         // Alice creates a document
         const aliceHandle = aliceRepo.create<TestDoc>()
 
-        // Bob receives the document
-        await eventPromise(bobRepo, "document")
-        const bobHandle = bobRepo.find<TestDoc>(aliceHandle.url)
+        // TODO: ... let connections complete. this shouldn't be necessary.
+        await pause(50)
+
+        const bobHandle = await bobRepo.find<TestDoc>(aliceHandle.url)
 
         // Alice changes the document
         aliceHandle.change(d => {
@@ -60,7 +61,7 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
 
         // Bob receives the change
         await eventPromise(bobHandle, "change")
-        assert.equal((await bobHandle.doc())?.foo, "bar")
+        assert.equal((await bobHandle).doc()?.foo, "bar")
 
         // Bob changes the document
         bobHandle.change(d => {
@@ -69,7 +70,7 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
 
         // Alice receives the change
         await eventPromise(aliceHandle, "change")
-        assert.equal((await aliceHandle.doc())?.foo, "baz")
+        assert.equal(aliceHandle.doc().foo, "baz")
       }
 
       // Run the test in both directions, in case they're different types of adapters
@@ -100,9 +101,9 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
       const docUrl = aliceHandle.url
 
       // Bob and Charlie receive the document
-      await eventPromises([bobRepo, charlieRepo], "document")
-      const bobHandle = bobRepo.find<TestDoc>(docUrl)
-      const charlieHandle = charlieRepo.find<TestDoc>(docUrl)
+      await pause(50)
+      const bobHandle = await bobRepo.find<TestDoc>(docUrl)
+      const charlieHandle = await charlieRepo.find<TestDoc>(docUrl)
 
       // Alice changes the document
       aliceHandle.change(d => {
@@ -111,8 +112,8 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
 
       // Bob and Charlie receive the change
       await eventPromises([bobHandle, charlieHandle], "change")
-      assert.equal((await bobHandle.doc())?.foo, "bar")
-      assert.equal((await charlieHandle.doc())?.foo, "bar")
+      assert.equal(bobHandle.doc().foo, "bar")
+      assert.equal(charlieHandle.doc().foo, "bar")
 
       // Charlie changes the document
       charlieHandle.change(d => {
@@ -121,8 +122,8 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
 
       // Alice and Bob receive the change
       await eventPromises([aliceHandle, bobHandle], "change")
-      assert.equal((await bobHandle.doc())?.foo, "baz")
-      assert.equal((await charlieHandle.doc())?.foo, "baz")
+      assert.equal(bobHandle.doc().foo, "baz")
+      assert.equal(charlieHandle.doc().foo, "baz")
 
       teardown()
     })
@@ -141,7 +142,7 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
       )
 
       const aliceHandle = aliceRepo.create<TestDoc>()
-      const charlieHandle = charlieRepo.find(aliceHandle.url)
+      const charlieHandle = await charlieRepo.find(aliceHandle.url)
 
       // pause to give charlie a chance to let alice know it wants the doc
       await pause(100)

package/src/synchronizer/CollectionSynchronizer.ts

@@ -1,6 +1,6 @@
 import debug from "debug"
 import { DocHandle } from "../DocHandle.js"
-import { parseAutomergeUrl, stringifyAutomergeUrl } from "../AutomergeUrl.js"
+import { parseAutomergeUrl } from "../AutomergeUrl.js"
 import { Repo } from "../Repo.js"
 import { DocMessage } from "../network/messages.js"
 import { AutomergeUrl, DocumentId, PeerId } from "../types.js"
@@ -29,18 +29,19 @@ export class CollectionSynchronizer extends Synchronizer {
   }
 
   /** Returns a synchronizer for the given document, creating one if it doesn't already exist.  */
-  #fetchDocSynchronizer(documentId: DocumentId) {
-    if (!this.docSynchronizers[documentId]) {
-      const handle = this.repo.find(stringifyAutomergeUrl({ documentId }))
-      this.docSynchronizers[documentId] = this.#initDocSynchronizer(handle)
+  #fetchDocSynchronizer(handle: DocHandle<unknown>) {
+    if (!this.docSynchronizers[handle.documentId]) {
+      this.docSynchronizers[handle.documentId] =
+        this.#initDocSynchronizer(handle)
     }
-    return this.docSynchronizers[documentId]
+    return this.docSynchronizers[handle.documentId]
   }
 
   /** Creates a new docSynchronizer and sets it up to propagate messages */
   #initDocSynchronizer(handle: DocHandle<unknown>): DocSynchronizer {
     const docSynchronizer = new DocSynchronizer({
       handle,
+      peerId: this.repo.networkSubsystem.peerId,
       onLoadSyncState: async peerId => {
         if (!this.repo.storageSubsystem) {
           return
@@ -109,13 +110,16 @@ export class CollectionSynchronizer extends Synchronizer {
 
     this.#docSetUp[documentId] = true
 
-    const docSynchronizer = this.#fetchDocSynchronizer(documentId)
+    const handle = await this.repo.find(documentId, {
+      allowableStates: ["ready", "unavailable", "requesting"],
+    })
+    const docSynchronizer = this.#fetchDocSynchronizer(handle)
 
     docSynchronizer.receiveMessage(message)
 
     // Initiate sync with any new peers
     const peers = await this.#documentGenerousPeers(documentId)
-    docSynchronizer.beginSync(
+    void docSynchronizer.beginSync(
       peers.filter(peerId => !docSynchronizer.hasPeer(peerId))
     )
   }
@@ -123,14 +127,14 @@ export class CollectionSynchronizer extends Synchronizer {
   /**
    * Starts synchronizing the given document with all peers that we share it generously with.
    */
-  addDocument(documentId: DocumentId) {
+  addDocument(handle: DocHandle<unknown>) {
     // HACK: this is a hack to prevent us from adding the same document twice
-    if (this.#docSetUp[documentId]) {
+    if (this.#docSetUp[handle.documentId]) {
       return
     }
-    const docSynchronizer = this.#fetchDocSynchronizer(documentId)
-    void this.#documentGenerousPeers(documentId).then(peers => {
-      docSynchronizer.beginSync(peers)
+    const docSynchronizer = this.#fetchDocSynchronizer(handle)
+    void this.#documentGenerousPeers(handle.documentId).then(peers => {
+      void docSynchronizer.beginSync(peers)
     })
   }
 
@@ -152,7 +156,7 @@ export class CollectionSynchronizer extends Synchronizer {
     for (const docSynchronizer of Object.values(this.docSynchronizers)) {
       const { documentId } = docSynchronizer
       void this.repo.sharePolicy(peerId, documentId).then(okToShare => {
-        if (okToShare) docSynchronizer.beginSync([peerId])
+        if (okToShare) void docSynchronizer.beginSync([peerId])
       })
     }
   }

package/src/synchronizer/DocSynchronizer.ts

@@ -30,6 +30,7 @@ type PendingMessage = {
 
 interface DocSynchronizerConfig {
   handle: DocHandle<unknown>
+  peerId: PeerId
   onLoadSyncState?: (peerId: PeerId) => Promise<A.SyncState | undefined>
 }
 
@@ -56,13 +57,17 @@ export class DocSynchronizer extends Synchronizer {
 
   #pendingSyncMessages: Array<PendingMessage> = []
 
+  // We keep this around at least in part for debugging.
+  // eslint-disable-next-line no-unused-private-class-members
+  #peerId: PeerId
   #syncStarted = false
 
   #handle: DocHandle<unknown>
   #onLoadSyncState: (peerId: PeerId) => Promise<A.SyncState | undefined>
 
-  constructor({ handle, onLoadSyncState }: DocSynchronizerConfig) {
+  constructor({ handle, peerId, onLoadSyncState }: DocSynchronizerConfig) {
     super()
+    this.#peerId = peerId
     this.#handle = handle
     this.#onLoadSyncState =
       onLoadSyncState ?? (() => Promise.resolve(undefined))
@@ -81,7 +86,7 @@ export class DocSynchronizer extends Synchronizer {
 
     // Process pending sync messages immediately after the handle becomes ready.
     void (async () => {
-      await handle.doc([READY, REQUESTING])
+      await handle.whenReady([READY, REQUESTING])
       this.#processAllPendingSyncMessages()
     })()
   }
@@ -97,8 +102,7 @@ export class DocSynchronizer extends Synchronizer {
   /// PRIVATE
 
   async #syncWithPeers() {
-    this.#log(`syncWithPeers`)
-    const doc = await this.#handle.doc()
+    const doc = await this.#handle.legacyAsyncDoc() // XXX THIS ONE IS WEIRD
     if (doc === undefined) return
     this.#peers.forEach(peerId => this.#sendSyncMessage(peerId, doc))
   }
@@ -226,16 +230,15 @@ export class DocSynchronizer extends Synchronizer {
     return this.#peers.includes(peerId)
   }
 
-  beginSync(peerIds: PeerId[]) {
+  async beginSync(peerIds: PeerId[]) {
     const noPeersWithDocument = peerIds.every(
       peerId => this.#peerDocumentStatuses[peerId] in ["unavailable", "wants"]
     )
 
     // At this point if we don't have anything in our storage, we need to use an empty doc to sync
     // with; but we don't want to surface that state to the front end
-
-    const docPromise = this.#handle
-      .doc([READY, REQUESTING, UNAVAILABLE])
+    const docPromise = this.#handle // TODO THIS IS ALSO WEIRD
+      .legacyAsyncDoc([READY, REQUESTING, UNAVAILABLE])
       .then(doc => {
         // we register out peers first, then say that sync has started
         this.#syncStarted = true
@@ -251,7 +254,13 @@ export class DocSynchronizer extends Synchronizer {
         return doc ?? A.init<unknown>()
       })
 
-    this.#log(`beginSync: ${peerIds.join(", ")}`)
+    const peersWithDocument = this.#peers.some(peerId => {
+      return this.#peerDocumentStatuses[peerId] == "has"
+    })
+
+    if (peersWithDocument) {
+      await this.#handle.whenReady()
+    }
 
     peerIds.forEach(peerId => {
       this.#withSyncState(peerId, syncState => {
@@ -352,6 +361,7 @@ export class DocSynchronizer extends Synchronizer {
     this.#withSyncState(message.senderId, syncState => {
       this.#handle.update(doc => {
         const start = performance.now()
+
         const [newDoc, newSyncState] = A.receiveSyncMessage(
           doc,
           syncState,

package/test/CollectionSynchronizer.test.ts

@@ -28,13 +28,13 @@ describe("CollectionSynchronizer", () => {
         done()
       })
 
-      synchronizer.addDocument(handle.documentId)
+      synchronizer.addDocument(handle)
     }))
 
   it("starts synchronizing existing documents when a peer is added", () =>
     new Promise<void>(done => {
       const handle = repo.create()
-      synchronizer.addDocument(handle.documentId)
+      synchronizer.addDocument(handle)
       synchronizer.once("message", event => {
         const { targetId, documentId } = event as SyncMessage
         assert(targetId === "peer1")
@@ -50,7 +50,7 @@ describe("CollectionSynchronizer", () => {
 
       repo.sharePolicy = async (peerId: PeerId) => peerId !== "peer1"
 
-      synchronizer.addDocument(handle.documentId)
+      synchronizer.addDocument(handle)
       synchronizer.once("message", () => {
         reject(new Error("Should not have sent a message"))
       })
@@ -71,7 +71,7 @@ describe("CollectionSynchronizer", () => {
         reject(new Error("Should not have sent a message"))
       })
 
-      synchronizer.addDocument(handle.documentId)
+      synchronizer.addDocument(handle)
 
       setTimeout(done)
     }))