@automerge/automerge-repo 1.0.6 → 1.0.8

package/test/Repo.test.ts

@@ -1,7 +1,13 @@
-import assert from "assert"
 import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel"
-import { BroadcastChannelNetworkAdapter } from "@automerge/automerge-repo-network-broadcastchannel"
-
+import assert from "assert"
+import * as Uuid from "uuid"
+import { describe, it } from "vitest"
+import { parseAutomergeUrl } from "../dist/DocUrl.js"
+import { READY } from "../src/DocHandle.js"
+import { generateAutomergeUrl, stringifyAutomergeUrl } from "../src/DocUrl.js"
+import { Repo } from "../src/Repo.js"
+import { eventPromise } from "../src/helpers/eventPromise.js"
+import { pause } from "../src/helpers/pause.js"
 import {
   AutomergeUrl,
   DocHandle,
@@ -9,28 +15,20 @@ import {
   PeerId,
   SharePolicy,
 } from "../src/index.js"
-import { eventPromise } from "../src/helpers/eventPromise.js"
-import { pause, rejectOnTimeout } from "../src/helpers/pause.js"
-import { Repo } from "../src/Repo.js"
 import { DummyNetworkAdapter } from "./helpers/DummyNetworkAdapter.js"
 import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
-import { getRandomItem } from "./helpers/getRandomItem.js"
-import { TestDoc } from "./types.js"
-import { generateAutomergeUrl, stringifyAutomergeUrl } from "../src/DocUrl.js"
-import { READY, AWAITING_NETWORK } from "../src/DocHandle.js"
 import {
-  generateLargeObject,
   LargeObject,
+  generateLargeObject,
 } from "./helpers/generate-large-object.js"
-import { parseAutomergeUrl } from "../dist/DocUrl.js"
-
-import * as Uuid from "uuid"
+import { getRandomItem } from "./helpers/getRandomItem.js"
+import { TestDoc } from "./types.js"
 
 describe("Repo", () => {
-  describe("single repo", () => {
-    const setup = (networkReady = true) => {
+  describe("local only", () => {
+    const setup = ({ startReady = true } = {}) => {
       const storageAdapter = new DummyStorageAdapter()
-      const networkAdapter = new DummyNetworkAdapter(networkReady)
+      const networkAdapter = new DummyNetworkAdapter({ startReady })
 
       const repo = new Repo({
         storage: storageAdapter,
@@ -66,6 +64,8 @@ describe("Repo", () => {
     })
 
     it("can find a document using a legacy UUID (for now)", () => {
+      disableConsoleWarn()
+
       const { repo } = setup()
       const handle = repo.create<TestDoc>()
       handle.change((d: TestDoc) => {
@@ -79,6 +79,8 @@ describe("Repo", () => {
       const handle2 = repo.find(legacyDocumentId)
       assert.equal(handle, handle2)
       assert.deepEqual(handle2.docSync(), { foo: "bar" })
+
+      reenableConsoleWarn()
     })
 
     it("can change a document", async () => {
@@ -180,7 +182,7 @@ describe("Repo", () => {
     })
 
     it("doesn't mark a document as unavailable until network adapters are ready", async () => {
-      const { repo, networkAdapter } = setup(false)
+      const { repo, networkAdapter } = setup({ startReady: false })
       const url = generateAutomergeUrl()
       const handle = repo.find<TestDoc>(url)
 
@@ -236,7 +238,7 @@ describe("Repo", () => {
 
       assert.equal(handle.isReady(), true)
 
-      await pause()
+      await pause(150)
 
       const repo2 = new Repo({
         storage: storageAdapter,
@@ -257,19 +259,14 @@ describe("Repo", () => {
       })
       // we now have a snapshot and an incremental change in storage
       assert.equal(handle.isReady(), true)
-      await handle.doc()
+      const foo = await handle.doc()
+      assert.equal(foo?.foo, "bar")
+
+      await pause()
       repo.delete(handle.documentId)
 
       assert(handle.isDeleted())
       assert.equal(repo.handles[handle.documentId], undefined)
-
-      const bobHandle = repo.find<TestDoc>(handle.url)
-      await assert.rejects(
-        rejectOnTimeout(bobHandle.doc(), 10),
-        "document should have been deleted"
-      )
-
-      assert(!bobHandle.isReady())
     })
 
     it("can delete an existing document by url", async () => {
@@ -280,36 +277,31 @@ describe("Repo", () => {
       })
       assert.equal(handle.isReady(), true)
       await handle.doc()
+
+      await pause()
       repo.delete(handle.url)
 
       assert(handle.isDeleted())
       assert.equal(repo.handles[handle.documentId], undefined)
-
-      const bobHandle = repo.find<TestDoc>(handle.url)
-      await assert.rejects(
-        rejectOnTimeout(bobHandle.doc(), 10),
-        "document should have been deleted"
-      )
-
-      assert(!bobHandle.isReady())
     })
 
-    it("deleting a document emits an event", async done => {
-      const { repo } = setup()
-      const handle = repo.create<TestDoc>()
-      handle.change(d => {
-        d.foo = "bar"
-      })
-      assert.equal(handle.isReady(), true)
+    it("deleting a document emits an event", async () =>
+      new Promise<void>(done => {
+        const { repo } = setup()
+        const handle = repo.create<TestDoc>()
+        handle.change(d => {
+          d.foo = "bar"
+        })
+        assert.equal(handle.isReady(), true)
 
-      repo.on("delete-document", ({ documentId }) => {
-        assert.equal(documentId, handle.documentId)
+        repo.on("delete-document", ({ documentId }) => {
+          assert.equal(documentId, handle.documentId)
 
-        done()
-      })
+          done()
+        })
 
-      repo.delete(handle.documentId)
-    })
+        repo.delete(handle.documentId)
+      }))
 
     it("storage state doesn't change across reloads when the document hasn't changed", async () => {
       const storage = new DummyStorageAdapter()
@@ -385,34 +377,37 @@ describe("Repo", () => {
     })
   })
 
-  describe("sync", async () => {
-    const charlieExcludedDocuments: DocumentId[] = []
-    const bobExcludedDocuments: DocumentId[] = []
+  describe("with peers (linear network)", async () => {
+    const setup = async ({ connectAlice = true } = {}) => {
+      const charlieExcludedDocuments: DocumentId[] = []
+      const bobExcludedDocuments: DocumentId[] = []
 
-    const sharePolicy: SharePolicy = async (peerId, documentId) => {
-      if (documentId === undefined) return false
+      const sharePolicy: SharePolicy = async (peerId, documentId) => {
+        if (documentId === undefined) return false
 
-      // make sure that charlie never gets excluded documents
-      if (charlieExcludedDocuments.includes(documentId) && peerId === "charlie")
-        return false
+        // make sure that charlie never gets excluded documents
+        if (
+          charlieExcludedDocuments.includes(documentId) &&
+          peerId === "charlie"
+        )
+          return false
 
-      // make sure that bob never gets excluded documents
-      if (bobExcludedDocuments.includes(documentId) && peerId === "bob")
-        return false
+        // make sure that bob never gets excluded documents
+        if (bobExcludedDocuments.includes(documentId) && peerId === "bob")
+          return false
 
-      return true
-    }
+        return true
+      }
 
-    const setupRepos = (connectAlice = true) => {
       // Set up three repos; connect Alice to Bob, and Bob to Charlie
 
-      const aliceBobChannel = new MessageChannel()
-      const bobCharlieChannel = new MessageChannel()
+      const abChannel = new MessageChannel()
+      const bcChannel = new MessageChannel()
 
-      const { port1: aliceToBob, port2: bobToAlice } = aliceBobChannel
-      const { port1: bobToCharlie, port2: charlieToBob } = bobCharlieChannel
+      const { port1: ab, port2: ba } = abChannel
+      const { port1: bc, port2: cb } = bcChannel
 
-      const aliceNetworkAdapter = new MessageChannelNetworkAdapter(aliceToBob)
+      const aliceNetworkAdapter = new MessageChannelNetworkAdapter(ab)
 
       const aliceRepo = new Repo({
         network: connectAlice ? [aliceNetworkAdapter] : [],
@@ -422,46 +417,32 @@ describe("Repo", () => {
 
       const bobRepo = new Repo({
         network: [
-          new MessageChannelNetworkAdapter(bobToAlice),
-          new MessageChannelNetworkAdapter(bobToCharlie),
+          new MessageChannelNetworkAdapter(ba),
+          new MessageChannelNetworkAdapter(bc),
         ],
         peerId: "bob" as PeerId,
         sharePolicy,
       })
 
       const charlieRepo = new Repo({
-        network: [new MessageChannelNetworkAdapter(charlieToBob)],
+        network: [new MessageChannelNetworkAdapter(cb)],
         peerId: "charlie" as PeerId,
       })
 
       const teardown = () => {
-        aliceBobChannel.port1.close()
-        bobCharlieChannel.port1.close()
+        abChannel.port1.close()
+        bcChannel.port1.close()
       }
 
-      function doConnectAlice() {
+      function connectAliceToBob() {
         aliceRepo.networkSubsystem.addNetworkAdapter(
-          new MessageChannelNetworkAdapter(aliceToBob)
+          new MessageChannelNetworkAdapter(ab)
         )
-        //bobRepo.networkSubsystem.addNetworkAdapter(new MessageChannelNetworkAdapter(bobToAlice))
       }
 
       if (connectAlice) {
-        doConnectAlice()
-      }
-
-      return {
-        teardown,
-        aliceRepo,
-        bobRepo,
-        charlieRepo,
-        connectAliceToBob: doConnectAlice,
+        connectAliceToBob()
       }
-    }
-
-    const setup = async (connectAlice = true) => {
-      const { teardown, aliceRepo, bobRepo, charlieRepo, connectAliceToBob } =
-        setupRepos(connectAlice)
 
       const aliceHandle = aliceRepo.create<TestDoc>()
       aliceHandle.change(d => {
@@ -564,17 +545,19 @@ describe("Repo", () => {
     })
 
     it("doesn't find a document which doesn't exist anywhere on the network", async () => {
-      const { charlieRepo } = await setup()
+      const { charlieRepo, teardown } = await setup()
       const url = generateAutomergeUrl()
       const handle = charlieRepo.find<TestDoc>(url)
       assert.equal(handle.isReady(), false)
 
       const doc = await handle.doc()
       assert.equal(doc, undefined)
+
+      teardown()
     })
 
     it("fires an 'unavailable' event when a document is not available on the network", async () => {
-      const { charlieRepo } = await setup()
+      const { charlieRepo, teardown } = await setup()
       const url = generateAutomergeUrl()
       const handle = charlieRepo.find<TestDoc>(url)
       assert.equal(handle.isReady(), false)
@@ -588,6 +571,8 @@ describe("Repo", () => {
       const handle2 = charlieRepo.find<TestDoc>(url)
       assert.equal(handle2.isReady(), false)
       await eventPromise(handle2, "unavailable")
+
+      teardown()
     })
 
     it("a previously unavailable document syncs over the network if a peer with it connects", async () => {
@@ -597,7 +582,7 @@ describe("Repo", () => {
         aliceRepo,
         teardown,
         connectAliceToBob,
-      } = await setup(false)
+      } = await setup({ connectAlice: false })
 
       const url = stringifyAutomergeUrl({ documentId: notForCharlie })
       const handle = charlieRepo.find<TestDoc>(url)
@@ -620,6 +605,55 @@ describe("Repo", () => {
       teardown()
     })
 
+    it("a previously unavailable document becomes available if the network adapter initially has no peers", async () => {
+      // It is possible for a network adapter to be ready without any peer
+      // being announced (e.g. the BroadcastChannelNetworkAdapter). In this
+      // case attempting to `Repo.find` a document which is not in the storage
+      // will result in an unavailable document. If a peer is later announced
+      // on the NetworkAdapter we should attempt to sync with the new peer and
+      // if the new peer has the document, the DocHandle should eventually
+      // transition to "ready"
+
+      // first create a repo with no network adapter and add a document so that
+      // we have a storage containing the document to pass to a new repo later
+      const storage = new DummyStorageAdapter()
+      const isolatedRepo = new Repo({
+        network: [],
+        storage,
+      })
+      const unsyncedHandle = isolatedRepo.create<TestDoc>()
+      const url = unsyncedHandle.url
+
+      // Now create a message channel to connect two repos
+      const abChannel = new MessageChannel()
+      const { port1: ab, port2: ba } = abChannel
+
+      // Create an empty repo to request the document from
+      const a = new Repo({
+        network: [new MessageChannelNetworkAdapter(ab)],
+        peerId: "a" as PeerId,
+        sharePolicy: async () => true,
+      })
+
+      const handle = a.find(url)
+
+      // We expect this to be unavailable as there is no connected peer and
+      // the repo has no storage.
+      await eventPromise(handle, "unavailable")
+
+      // Now create a repo pointing at the storage containing the document and
+      // connect it to the other end of the MessageChannel
+      const b = new Repo({
+        storage,
+        peerId: "b" as PeerId,
+        network: [new MessageChannelNetworkAdapter(ba)],
+      })
+
+      // The empty repo should be notified of the new peer, send it a request
+      // and eventually resolve the handle to "READY"
+      await handle.whenReady()
+    })
+
     it("a deleted document from charlieRepo can be refetched", async () => {
       const { charlieRepo, aliceHandle, teardown } = await setup()
 
@@ -642,40 +676,15 @@ describe("Repo", () => {
       teardown()
     })
 
-    const setupMeshNetwork = async () => {
-      const aliceRepo = new Repo({
-        network: [new BroadcastChannelNetworkAdapter()],
-        peerId: "alice" as PeerId,
-      })
-
-      const bobRepo = new Repo({
-        network: [new BroadcastChannelNetworkAdapter()],
-        peerId: "bob" as PeerId,
-      })
-
-      const charlieRepo = new Repo({
-        network: [new BroadcastChannelNetworkAdapter()],
-        peerId: "charlie" as PeerId,
-      })
-
-      // pause to let the network set up
-      await pause(50)
-
-      return {
-        aliceRepo,
-        bobRepo,
-        charlieRepo,
-      }
-    }
-
     it("can emit an 'unavailable' event when it's not found on the network", async () => {
-      const { charlieRepo } = await setupMeshNetwork()
+      const { charlieRepo, teardown } = await setup()
 
       const url = generateAutomergeUrl()
       const handle = charlieRepo.find<TestDoc>(url)
       assert.equal(handle.isReady(), false)
 
       await eventPromise(handle, "unavailable")
+      teardown()
     })
 
     it("syncs a bunch of changes", async () => {
@@ -705,7 +714,6 @@ describe("Repo", () => {
           d.foo = Math.random().toString()
         })
       }
-      await pause(500)
 
       teardown()
     })
@@ -723,8 +731,6 @@ describe("Repo", () => {
         stringifyAutomergeUrl({ documentId: notForCharlie })
       )
 
-      await pause(50)
-
       const charliePromise = new Promise<void>((resolve, reject) => {
         charlieRepo.networkSubsystem.on("message", message => {
           if (
@@ -746,55 +752,104 @@ describe("Repo", () => {
       await charliePromise
       teardown()
     })
+  })
 
-    it("can broadcast a message without entering into an infinite loop", async () => {
-      const { aliceRepo, bobRepo, charlieRepo } = await setupMeshNetwork()
+  describe("with peers (mesh network)", () => {
+    const setup = async () => {
+      // Set up three repos; connect Alice to Bob, Bob to Charlie, and Alice to Charlie
 
-      // pause to let the network set up
-      await pause(50)
-      const message = { presence: "alex" }
+      const abChannel = new MessageChannel()
+      const bcChannel = new MessageChannel()
+      const acChannel = new MessageChannel()
+
+      const { port1: ab, port2: ba } = abChannel
+      const { port1: bc, port2: cb } = bcChannel
+      const { port1: ac, port2: ca } = acChannel
+
+      const aliceRepo = new Repo({
+        network: [
+          new MessageChannelNetworkAdapter(ab),
+          new MessageChannelNetworkAdapter(ac),
+        ],
+        peerId: "alice" as PeerId,
+      })
+
+      const bobRepo = new Repo({
+        network: [
+          new MessageChannelNetworkAdapter(ba),
+          new MessageChannelNetworkAdapter(bc),
+        ],
+        peerId: "bob" as PeerId,
+      })
+
+      const charlieRepo = new Repo({
+        network: [
+          new MessageChannelNetworkAdapter(ca),
+          new MessageChannelNetworkAdapter(cb),
+        ],
+        peerId: "charlie" as PeerId,
+      })
+
+      const teardown = () => {
+        abChannel.port1.close()
+        bcChannel.port1.close()
+        acChannel.port1.close()
+      }
+
+      await Promise.all([
+        eventPromise(aliceRepo.networkSubsystem, "peer"),
+        eventPromise(bobRepo.networkSubsystem, "peer"),
+        eventPromise(charlieRepo.networkSubsystem, "peer"),
+      ])
+
+      return {
+        teardown,
+        aliceRepo,
+        bobRepo,
+        charlieRepo,
+      }
+    }
+
+    it("can broadcast a message without entering into an infinite loop", async () => {
+      const { aliceRepo, bobRepo, charlieRepo, teardown } = await setup()
 
       const aliceHandle = aliceRepo.create<TestDoc>()
 
       const bobHandle = bobRepo.find(aliceHandle.url)
       const charlieHandle = charlieRepo.find(aliceHandle.url)
 
-      const aliceDoesntGetIt = new Promise<void>((resolve, reject) => {
-        setTimeout(() => {
-          resolve()
-        }, 100)
-
-        aliceHandle.on("ephemeral-message", () => {
-          reject("alice got the message")
-        })
+      // Alice should not receive her own ephemeral message
+      aliceHandle.on("ephemeral-message", () => {
+        throw new Error("Alice should not receive her own ephemeral message")
       })
 
+      // Bob and Charlie should receive Alice's ephemeral message
       const bobGotIt = eventPromise(bobHandle, "ephemeral-message")
       const charlieGotIt = eventPromise(charlieHandle, "ephemeral-message")
 
-      // let things get in sync and peers meet one another
+      // let peers meet and sync up
       await pause(50)
+
+      // Alice sends an ephemeral message
+      const message = { foo: "bar" }
       aliceHandle.broadcast(message)
 
-      const [bob, charlie] = await Promise.all([
-        bobGotIt,
-        charlieGotIt,
-        aliceDoesntGetIt,
-      ])
+      const [bob, charlie] = await Promise.all([bobGotIt, charlieGotIt])
 
       assert.deepStrictEqual(bob.message, message)
       assert.deepStrictEqual(charlie.message, message)
+
+      teardown()
     })
 
     it("notifies peers when a document is cloned", async () => {
-      const { bobRepo, charlieRepo } = await setupMeshNetwork()
-
-      // pause to let the network set up
-      await pause(50)
+      const { bobRepo, charlieRepo, teardown } = await setup()
 
       const handle = bobRepo.create<TestDoc>()
-      handle.change(d => { d.foo = "bar" })
-      const handle2 = bobRepo.clone(handle) 
+      handle.change(d => {
+        d.foo = "bar"
+      })
+      const handle2 = bobRepo.clone(handle)
 
       // pause to let the sync happen
       await pause(50)
@@ -802,17 +857,18 @@ describe("Repo", () => {
       const charlieHandle = charlieRepo.find(handle2.url)
       await charlieHandle.doc()
       assert.deepStrictEqual(charlieHandle.docSync(), { foo: "bar" })
+
+      teardown()
     })
 
     it("notifies peers when a document is merged", async () => {
-      const { bobRepo, charlieRepo } = await setupMeshNetwork()
-
-      // pause to let the network set up
-      await pause(50)
+      const { bobRepo, charlieRepo, teardown } = await setup()
 
       const handle = bobRepo.create<TestDoc>()
-      handle.change(d => { d.foo = "bar" })
-      const handle2 = bobRepo.clone(handle) 
+      handle.change(d => {
+        d.foo = "bar"
+      })
+      const handle2 = bobRepo.clone(handle)
 
       // pause to let the sync happen
       await pause(50)
@@ -822,14 +878,29 @@ describe("Repo", () => {
       assert.deepStrictEqual(charlieHandle.docSync(), { foo: "bar" })
 
       // now make a change to doc2 on bobs side and merge it into doc1
-      handle2.change(d => { d.foo = "baz" })
+      handle2.change(d => {
+        d.foo = "baz"
+      })
       handle.merge(handle2)
-      
+
       // wait for the network to do it's thang
-      await pause(50)
+      await pause(350)
 
-      await charlieHandle.doc() 
+      await charlieHandle.doc()
       assert.deepStrictEqual(charlieHandle.docSync(), { foo: "baz" })
+
+      teardown()
     })
   })
 })
+
+const warn = console.warn
+const NO_OP = () => {}
+
+const disableConsoleWarn = () => {
+  console.warn = NO_OP
+}
+
+const reenableConsoleWarn = () => {
+  console.warn = warn
+}

package/test/StorageSubsystem.test.ts

@@ -1,16 +1,13 @@
+import { NodeFSStorageAdapter } from "@automerge/automerge-repo-storage-nodefs"
+import * as A from "@automerge/automerge/next"
+import assert from "assert"
 import fs from "fs"
 import os from "os"
 import path from "path"
-
-import assert from "assert"
-
-import * as A from "@automerge/automerge/next"
-
-import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
-import { NodeFSStorageAdapter } from "@automerge/automerge-repo-storage-nodefs"
-
-import { StorageSubsystem } from "../src/storage/StorageSubsystem.js"
+import { describe, it } from "vitest"
 import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
+import { StorageSubsystem } from "../src/storage/StorageSubsystem.js"
+import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
 
 const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "automerge-repo-tests"))
 

package/test/helpers/DummyNetworkAdapter.ts

@@ -1,16 +1,21 @@
 import { NetworkAdapter } from "../../src/index.js"
 
 export class DummyNetworkAdapter extends NetworkAdapter {
-  #startReady = true
-  constructor(startReady: boolean) {
+  #startReady: boolean
+
+  constructor({ startReady = true }: Options = {}) {
     super()
     this.#startReady = startReady
   }
-  send() { }
+  send() {}
   connect(_: string) {
     if (this.#startReady) {
       this.emit("ready", { network: this })
     }
   }
-  disconnect() { }
+  disconnect() {}
+}
+
+type Options = {
+  startReady?: boolean
 }

package/test/helpers/DummyStorageAdapter.ts

@@ -11,10 +11,12 @@ export class DummyStorageAdapter implements StorageAdapter {
     return key.split(".")
   }
 
-  async loadRange(keyPrefix: StorageKey): Promise<{data: Uint8Array, key: StorageKey}[]> {
+  async loadRange(
+    keyPrefix: StorageKey
+  ): Promise<{ data: Uint8Array; key: StorageKey }[]> {
     const range = Object.entries(this.#data)
       .filter(([key, _]) => key.startsWith(this.#keyToString(keyPrefix)))
-      .map(([key, data]) => ({key: this.#stringToKey(key), data}))
+      .map(([key, data]) => ({ key: this.#stringToKey(key), data }))
     return Promise.resolve(range)
   }
 

package/test/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "Node16",
+    "noEmit": true
+  },
+  "include": ["**/*.ts"]
+}