@automerge/automerge-repo 1.0.0-alpha.0 → 1.0.0-alpha.3

package/test/DocSynchronizer.test.ts

@@ -5,16 +5,25 @@ import { DocSynchronizer } from "../src/synchronizer/DocSynchronizer.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
 import { TestDoc } from "./types.js"
 import { parseAutomergeUrl, generateAutomergeUrl } from "../src/DocUrl.js"
+import { SyncMessage } from "../src/index.js"
+import {
+  DocumentUnavailableMessage,
+  DocumentUnavailableMessageContents,
+  MessageContents,
+  RequestMessageContents,
+  SyncMessageContents,
+} from "../src/network/messages.js"
 
 const alice = "alice" as PeerId
 const bob = "bob" as PeerId
+const charlie = "charlie" as PeerId
 
 describe("DocSynchronizer", () => {
   let handle: DocHandle<TestDoc>
   let docSynchronizer: DocSynchronizer
 
   const setup = () => {
-    const docId = parseAutomergeUrl(generateAutomergeUrl()).encodedDocumentId
+    const docId = parseAutomergeUrl(generateAutomergeUrl()).documentId
     handle = new DocHandle<TestDoc>(docId, { isNew: true })
     docSynchronizer = new DocSynchronizer(handle)
     return { handle, docSynchronizer }
@@ -27,19 +36,21 @@ describe("DocSynchronizer", () => {
 
   it("emits a syncMessage when beginSync is called", async () => {
     const { docSynchronizer } = setup()
-    docSynchronizer.beginSync(alice)
-    const { targetId } = await eventPromise(docSynchronizer, "message")
+    docSynchronizer.beginSync([alice])
+    const { targetId, type } = await eventPromise(docSynchronizer, "message")
+    assert.equal(type, "sync")
     assert.equal(targetId, "alice")
   })
 
   it("emits a syncMessage to peers when the handle is updated", async () => {
     const { handle, docSynchronizer } = setup()
-    docSynchronizer.beginSync(alice)
+    docSynchronizer.beginSync([alice])
     handle.change(doc => {
       doc.foo = "bar"
     })
-    const { targetId } = await eventPromise(docSynchronizer, "message")
+    const { targetId, type } = await eventPromise(docSynchronizer, "message")
     assert.equal(targetId, "alice")
+    assert.equal(type, "sync")
   })
 
   it("still syncs with a peer after it disconnects and reconnects", async () => {
@@ -47,23 +58,88 @@ describe("DocSynchronizer", () => {
 
     // first connection
     {
-      await docSynchronizer.beginSync(bob)
+      docSynchronizer.beginSync([bob])
       handle.change(doc => {
         doc.foo = "a change"
       })
-      const { targetId } = await eventPromise(docSynchronizer, "message")
+      const { targetId, type } = await eventPromise(docSynchronizer, "message")
       assert.equal(targetId, "bob")
+      assert.equal(type, "sync")
       docSynchronizer.endSync(bob)
     }
 
     // second connection
     {
-      await docSynchronizer.beginSync(bob)
+      docSynchronizer.beginSync([bob])
       handle.change(doc => {
         doc.foo = "another change"
       })
-      const { targetId } = await eventPromise(docSynchronizer, "message")
+      const { targetId, type } = await eventPromise(docSynchronizer, "message")
       assert.equal(targetId, "bob")
+      assert.equal(type, "sync")
     }
   })
+
+  it("emits a requestMessage if the local handle is being requested", async () => {
+    const docId = parseAutomergeUrl(generateAutomergeUrl()).documentId
+
+    const handle = new DocHandle<TestDoc>(docId, { isNew: false })
+    docSynchronizer = new DocSynchronizer(handle)
+    docSynchronizer.beginSync([alice])
+    handle.request()
+    const message = await eventPromise(docSynchronizer, "message")
+    assert.equal(message.targetId, "alice")
+    assert.equal(message.type, "request")
+  })
+
+  it("emits the correct sequence of messages when a document is not found then not available", async () => {
+    const docId = parseAutomergeUrl(generateAutomergeUrl()).documentId
+
+    const bobHandle = new DocHandle<TestDoc>(docId, { isNew: false })
+    const bobDocSynchronizer = new DocSynchronizer(bobHandle)
+    bobDocSynchronizer.beginSync([alice])
+    bobHandle.request()
+    const message = await eventPromise(bobDocSynchronizer, "message")
+
+    const aliceHandle = new DocHandle<TestDoc>(docId, { isNew: false })
+    const aliceDocSynchronizer = new DocSynchronizer(aliceHandle)
+    aliceHandle.request()
+
+    aliceDocSynchronizer.receiveSyncMessage({ ...message, senderId: bob })
+    aliceDocSynchronizer.beginSync([charlie, bob])
+
+    const [charlieMessage, bobMessage] = await new Promise<MessageContents[]>(
+      resolve => {
+        const messages: MessageContents[] = []
+        aliceDocSynchronizer.on("message", message => {
+          messages.push(message)
+          if (messages.length === 2) {
+            resolve(messages)
+          }
+        })
+      }
+    )
+
+    // the response should be a sync message, not a request message
+    assert.equal(charlieMessage.targetId, "charlie")
+    assert.equal(charlieMessage.type, "request")
+    assert.equal(bobMessage.targetId, "bob")
+    assert.equal(bobMessage.type, "sync")
+
+    const docUnavailableMessage = {
+      type: "doc-unavailable",
+      targetId: alice,
+      senderId: charlie,
+      documentId: docId,
+    } satisfies DocumentUnavailableMessage
+
+    const p = eventPromise(aliceDocSynchronizer, "message")
+
+    aliceDocSynchronizer.receiveMessage(docUnavailableMessage)
+
+    const message2 = await p
+
+    assert.equal(message2.targetId, "bob")
+    assert.equal(message2.type, "doc-unavailable")
+  })
 })

package/test/Repo.test.ts

@@ -1,10 +1,9 @@
 import assert from "assert"
 import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel"
-import * as A from "@automerge/automerge"
+import { BroadcastChannelNetworkAdapter } from "@automerge/automerge-repo-network-broadcastchannel"
 
 import {
   AutomergeUrl,
-  ChannelId,
   DocHandle,
   DocumentId,
   PeerId,
@@ -17,11 +16,8 @@ import { DummyNetworkAdapter } from "./helpers/DummyNetworkAdapter.js"
 import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
 import { getRandomItem } from "./helpers/getRandomItem.js"
 import { TestDoc } from "./types.js"
-import {
-  binaryToDocumentId,
-  generateAutomergeUrl,
-  stringifyAutomergeUrl,
-} from "../src/DocUrl"
+import { generateAutomergeUrl, stringifyAutomergeUrl } from "../src/DocUrl"
+import { READY } from "../src/DocHandle"
 
 describe("Repo", () => {
   describe("single repo", () => {
@@ -57,7 +53,7 @@ describe("Repo", () => {
       const v = await handle.doc()
       assert.equal(handle.isReady(), true)
 
-      assert.equal(v.foo, "bar")
+      assert.equal(v?.foo, "bar")
     })
 
     it("throws an error if we try to find a handle with an invalid AutomergeUrl", async () => {
@@ -74,10 +70,17 @@ describe("Repo", () => {
       const handle = repo.find<TestDoc>(generateAutomergeUrl())
       assert.equal(handle.isReady(), false)
 
-      return assert.rejects(
-        rejectOnTimeout(handle.doc(), 10),
-        "This document should not exist"
-      )
+      const doc = await handle.doc()
+      assert.equal(doc, undefined)
+    })
+
+    it("fires an 'unavailable' event when you don't have the document locally and network to connect to", async () => {
+      const { repo } = setup()
+      const url = generateAutomergeUrl()
+      const handle = repo.find<TestDoc>(url)
+      assert.equal(handle.isReady(), false)
+
+      await eventPromise(handle, "unavailable")
     })
 
     it("can find a created document", async () => {
@@ -94,7 +97,7 @@ describe("Repo", () => {
       assert.equal(handle.isReady(), true)
 
       const v = await bobHandle.doc()
-      assert.equal(v.foo, "bar")
+      assert.equal(v?.foo, "bar")
     })
 
     it("saves the document when changed and can find it again", async () => {
@@ -117,7 +120,7 @@ describe("Repo", () => {
       const bobHandle = repo2.find<TestDoc>(handle.url)
 
       const v = await bobHandle.doc()
-      assert.equal(v.foo, "bar")
+      assert.equal(v?.foo, "bar")
     })
 
     it("can delete an existing document", async () => {
@@ -172,18 +175,93 @@ describe("Repo", () => {
       })
       assert.equal(handle.isReady(), true)
 
-      repo.on("delete-document", ({ encodedDocumentId }) => {
-        assert.equal(encodedDocumentId, handle.documentId)
+      repo.on("delete-document", ({ documentId }) => {
+        assert.equal(documentId, handle.documentId)
 
         done()
       })
 
       repo.delete(handle.documentId)
     })
+
+    it("storage state doesn't change across reloads when the document hasn't changed", async () => {
+      const storage = new DummyStorageAdapter()
+
+      const repo = new Repo({
+        storage,
+        network: [],
+      })
+
+      const handle = repo.create<{ count: number }>()
+
+      handle.change(d => {
+        d.count = 0
+      })
+      handle.change(d => {
+        d.count = 1
+      })
+
+      const initialKeys = storage.keys()
+
+      const repo2 = new Repo({
+        storage,
+        network: [],
+      })
+      const handle2 = repo2.find(handle.url)
+      await handle2.doc()
+
+      assert.deepEqual(storage.keys(), initialKeys)
+    })
+
+    it("doesn't delete a document from storage when we refresh", async () => {
+      const storage = new DummyStorageAdapter()
+
+      const repo = new Repo({
+        storage,
+        network: [],
+      })
+
+      const handle = repo.create<{ count: number }>()
+
+      handle.change(d => {
+        d.count = 0
+      })
+      handle.change(d => {
+        d.count = 1
+      })
+
+      for (let i = 0; i < 3; i++) {
+        const repo2 = new Repo({
+          storage,
+          network: [],
+        })
+        const handle2 = repo2.find(handle.url)
+        await handle2.doc()
+
+        assert(storage.keys().length !== 0)
+      }
+    })
   })
 
   describe("sync", async () => {
-    const setup = async () => {
+    const charlieExcludedDocuments: DocumentId[] = []
+    const bobExcludedDocuments: DocumentId[] = []
+
+    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 bob never gets excluded documents
+      if (bobExcludedDocuments.includes(documentId) && peerId === "bob")
+        return false
+
+      return true
+    }
+
+    const setupRepos = (connectAlice = true) => {
       // Set up three repos; connect Alice to Bob, and Bob to Charlie
 
       const aliceBobChannel = new MessageChannel()
@@ -192,28 +270,10 @@ describe("Repo", () => {
       const { port1: aliceToBob, port2: bobToAlice } = aliceBobChannel
       const { port1: bobToCharlie, port2: charlieToBob } = bobCharlieChannel
 
-      const charlieExcludedDocuments: DocumentId[] = []
-      const bobExcludedDocuments: DocumentId[] = []
-
-      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 (bobExcludedDocuments.includes(documentId) && peerId === "bob")
-          return false
-
-        return true
-      }
+      const aliceNetworkAdapter = new MessageChannelNetworkAdapter(aliceToBob)
 
       const aliceRepo = new Repo({
-        network: [new MessageChannelNetworkAdapter(aliceToBob)],
+        network: connectAlice ? [aliceNetworkAdapter] : [],
         peerId: "alice" as PeerId,
         sharePolicy,
       })
@@ -232,6 +292,24 @@ describe("Repo", () => {
         peerId: "charlie" as PeerId,
       })
 
+      const teardown = () => {
+        aliceBobChannel.port1.close()
+        bobCharlieChannel.port1.close()
+      }
+
+      return {
+        teardown,
+        aliceRepo,
+        bobRepo,
+        charlieRepo,
+        aliceNetworkAdapter,
+      }
+    }
+
+    const setup = async (connectAlice = true) => {
+      const { teardown, aliceRepo, bobRepo, charlieRepo, aliceNetworkAdapter } =
+        setupRepos(connectAlice)
+
       const aliceHandle = aliceRepo.create<TestDoc>()
       aliceHandle.change(d => {
         d.foo = "bar"
@@ -252,16 +330,13 @@ describe("Repo", () => {
       })
 
       await Promise.all([
-        eventPromise(aliceRepo.networkSubsystem, "peer"),
+        ...(connectAlice
+          ? [eventPromise(aliceRepo.networkSubsystem, "peer")]
+          : []),
         eventPromise(bobRepo.networkSubsystem, "peer"),
         eventPromise(charlieRepo.networkSubsystem, "peer"),
       ])
 
-      const teardown = () => {
-        aliceBobChannel.port1.close()
-        bobCharlieChannel.port1.close()
-      }
-
       return {
         aliceRepo,
         bobRepo,
@@ -270,6 +345,7 @@ describe("Repo", () => {
         notForCharlie,
         notForBob,
         teardown,
+        aliceNetworkAdapter,
       }
     }
 
@@ -336,13 +412,59 @@ describe("Repo", () => {
 
     it("doesn't find a document which doesn't exist anywhere on the network", async () => {
       const { charlieRepo } = await setup()
-      const handle = charlieRepo.find<TestDoc>(generateAutomergeUrl())
+      const url = generateAutomergeUrl()
+      const handle = charlieRepo.find<TestDoc>(url)
       assert.equal(handle.isReady(), false)
 
-      return assert.rejects(
-        rejectOnTimeout(handle.doc(), 10),
-        "This document should not exist"
-      )
+      const doc = await handle.doc()
+      assert.equal(doc, undefined)
+    })
+
+    it("fires an 'unavailable' event when a document is not available on the network", async () => {
+      const { charlieRepo } = await setup()
+      const url = generateAutomergeUrl()
+      const handle = charlieRepo.find<TestDoc>(url)
+      assert.equal(handle.isReady(), false)
+
+      await Promise.all([
+        eventPromise(handle, "unavailable"),
+        eventPromise(charlieRepo, "unavailable-document"),
+      ])
+
+      // make sure it fires a second time if the doc is still unavailable
+      const handle2 = charlieRepo.find<TestDoc>(url)
+      assert.equal(handle2.isReady(), false)
+      await eventPromise(handle2, "unavailable")
+    })
+
+    it("a previously unavailable document syncs over the network if a peer with it connects", async () => {
+      const {
+        charlieRepo,
+        notForCharlie,
+        aliceRepo,
+        teardown,
+        aliceNetworkAdapter,
+      } = await setup(false)
+
+      const url = stringifyAutomergeUrl({ documentId: notForCharlie })
+      const handle = charlieRepo.find<TestDoc>(url)
+      assert.equal(handle.isReady(), false)
+
+      await eventPromise(handle, "unavailable")
+
+      aliceRepo.networkSubsystem.addNetworkAdapter(aliceNetworkAdapter)
+
+      await eventPromise(aliceRepo.networkSubsystem, "peer")
+
+      const doc = await handle.doc([READY])
+      assert.deepStrictEqual(doc, { foo: "baz" })
+
+      // an additional find should also return the correct resolved document
+      const handle2 = charlieRepo.find<TestDoc>(url)
+      const doc2 = await handle2.doc()
+      assert.deepStrictEqual(doc2, { foo: "baz" })
+
+      teardown()
     })
 
     it("a deleted document from charlieRepo can be refetched", async () => {
@@ -367,17 +489,40 @@ describe("Repo", () => {
       teardown()
     })
 
-    it("can broadcast a message", async () => {
-      const { aliceRepo, bobRepo, teardown } = await setup()
+    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)
 
-      const channelId = "broadcast" as ChannelId
-      const data = { presence: "bob" }
+      return {
+        aliceRepo,
+        bobRepo,
+        charlieRepo,
+      }
+    }
 
-      bobRepo.ephemeralData.broadcast(channelId, data)
-      const d = await eventPromise(aliceRepo.ephemeralData, "data")
+    it("can emit an 'unavailable' event when it's not found on the network", async () => {
+      const { charlieRepo } = await setupMeshNetwork()
 
-      assert.deepStrictEqual(d.data, data)
-      teardown()
+      const url = generateAutomergeUrl()
+      const handle = charlieRepo.find<TestDoc>(url)
+      assert.equal(handle.isReady(), false)
+
+      await eventPromise(handle, "unavailable")
     })
 
     it("syncs a bunch of changes", async () => {
@@ -393,9 +538,9 @@ describe("Repo", () => {
         const doc =
           Math.random() < 0.5
             ? // heads, create a new doc
-              repo.create<TestDoc>()
+            repo.create<TestDoc>()
             : // tails, pick a random doc
-              (getRandomItem(docs) as DocHandle<TestDoc>)
+            (getRandomItem(docs) as DocHandle<TestDoc>)
 
         // make sure the doc is ready
         if (!doc.isReady()) {
@@ -411,6 +556,81 @@ describe("Repo", () => {
 
       teardown()
     })
-  })
 
+    it("can broadcast a message to peers with the correct document only", async () => {
+      const { aliceRepo, bobRepo, charlieRepo, notForCharlie, teardown } =
+        await setup()
+
+      const data = { presence: "alice" }
+
+      const aliceHandle = aliceRepo.find<TestDoc>(
+        stringifyAutomergeUrl({ documentId: notForCharlie })
+      )
+      const bobHandle = bobRepo.find<TestDoc>(
+        stringifyAutomergeUrl({ documentId: notForCharlie })
+      )
+
+      await pause(50)
+
+      const charliePromise = new Promise<void>((resolve, reject) => {
+        charlieRepo.networkSubsystem.on("message", message => {
+          if (
+            message.type === "ephemeral" &&
+            message.documentId === notForCharlie
+          ) {
+            reject(new Error("Charlie should not receive this message"))
+          }
+        })
+        setTimeout(resolve, 100)
+      })
+
+      aliceHandle.broadcast(data)
+      const { message } = await eventPromise(bobHandle, "ephemeral-message")
+
+      assert.deepStrictEqual(message, data)
+      assert.equal(charlieRepo.handles[notForCharlie], undefined, "charlie no")
+
+      await charliePromise
+      teardown()
+    })
+
+    it("can broadcast a message without entering into an infinite loop", async () => {
+      const { aliceRepo, bobRepo, charlieRepo } = await setupMeshNetwork()
+
+      // pause to let the network set up
+      await pause(50)
+      const message = { presence: "alex" }
+
+      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")
+        })
+      })
+
+      const bobGotIt = eventPromise(bobHandle, "ephemeral-message")
+      const charlieGotIt = eventPromise(charlieHandle, "ephemeral-message")
+
+      // let things get in sync and peers meet one another
+      await pause(50)
+      aliceHandle.broadcast(message)
+
+      const [bob, charlie] = await Promise.all([
+        bobGotIt,
+        charlieGotIt,
+        aliceDoesntGetIt,
+      ])
+
+      assert.deepStrictEqual(bob.message, message)
+      assert.deepStrictEqual(charlie.message, message)
+    })
+  })
 })

package/test/StorageSubsystem.test.ts

@@ -31,12 +31,11 @@ describe("StorageSubsystem", () => {
         })
 
         // save it to storage
-        const key = parseAutomergeUrl(generateAutomergeUrl()).encodedDocumentId
-        await storage.save(key, doc)
+        const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
+        await storage.saveDoc(key, doc)
 
         // reload it from storage
-        const reloadedDocBinary = await storage.loadBinary(key)
-        const reloadedDoc = A.load<TestDoc>(reloadedDocBinary)
+        const reloadedDoc = await storage.loadDoc(key)
 
         // check that it's the same doc
         assert.deepStrictEqual(reloadedDoc, doc)
@@ -53,15 +52,16 @@ describe("StorageSubsystem", () => {
     })
 
     // save it to storage
-    const key = parseAutomergeUrl(generateAutomergeUrl()).encodedDocumentId
-    storage.save(key, doc)
+    const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
+    storage.saveDoc(key, doc)
 
     // create new storage subsystem to simulate a new process
     const storage2 = new StorageSubsystem(adapter)
 
     // reload it from storage
-    const reloadedDocBinary = await storage2.loadBinary(key)
-    const reloadedDoc = A.load<TestDoc>(reloadedDocBinary)
+    const reloadedDoc = await storage2.loadDoc(key)
+
+    assert(reloadedDoc, "doc should be loaded")
 
     // make a change
     const changedDoc = A.change<any>(reloadedDoc, "test 2", d => {
@@ -69,7 +69,7 @@ describe("StorageSubsystem", () => {
     })
 
     // save it to storage
-    storage2.save(key, changedDoc)
+    storage2.saveDoc(key, changedDoc)
 
     // check that the storage adapter contains the correct keys
     assert(adapter.keys().some(k => k.startsWith(`${key}.incremental.`)))

package/test/helpers/DummyNetworkAdapter.ts

@@ -1,7 +1,7 @@
 import { NetworkAdapter } from "../../src"
 
 export class DummyNetworkAdapter extends NetworkAdapter {
-  sendMessage() {}
+  send() {}
   connect(_: string) {}
   join() {}
   leave() {}

package/tsconfig.json

@@ -12,5 +12,6 @@
     "strict": true,
     "skipLibCheck": true
   },
-  "include": ["src/**/*.ts"]
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist"]
 }