@automerge/automerge-repo 1.0.19 → 1.1.0-alpha.2

package/test/Repo.test.ts

@@ -3,7 +3,7 @@ import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-
 import assert from "assert"
 import * as Uuid from "uuid"
 import { describe, it } from "vitest"
-import { DocHandleRemoteHeadsPayload, READY } from "../src/DocHandle.js"
+import { READY } from "../src/DocHandle.js"
 import { parseAutomergeUrl } from "../src/AutomergeUrl.js"
 import {
   generateAutomergeUrl,
@@ -28,6 +28,7 @@ import {
 } from "./helpers/generate-large-object.js"
 import { getRandomItem } from "./helpers/getRandomItem.js"
 import { TestDoc } from "./types.js"
+import { StorageId } from "../src/storage/types.js"
 
 describe("Repo", () => {
   describe("local only", () => {
@@ -337,6 +338,9 @@ describe("Repo", () => {
         d.count = 1
       })
 
+      // wait because storage id is not initialized immediately
+      await pause()
+
       const initialKeys = storage.keys()
 
       const repo2 = new Repo({
@@ -395,7 +399,10 @@ describe("Repo", () => {
   })
 
   describe("with peers (linear network)", async () => {
-    const setup = async ({ connectAlice = true } = {}) => {
+    const setup = async ({
+      connectAlice = true,
+      isCharlieEphemeral = false,
+    } = {}) => {
       const charlieExcludedDocuments: DocumentId[] = []
       const bobExcludedDocuments: DocumentId[] = []
 
@@ -451,6 +458,7 @@ describe("Repo", () => {
         storage: charlieStorage,
         network: [new MessageChannelNetworkAdapter(cb)],
         peerId: charlie,
+        isEphemeral: isCharlieEphemeral,
       })
 
       const teardown = () => {
@@ -789,7 +797,7 @@ describe("Repo", () => {
     })
 
     it("should save sync state of other peers", async () => {
-      const { bobRepo, teardown, charlie } = await setup({
+      const { bobRepo, teardown, charlieRepo } = await setup({
         connectAlice: false,
       })
 
@@ -803,7 +811,7 @@ describe("Repo", () => {
       // bob should store the sync state of charlie
       const storedSyncState = await bobRepo.storageSubsystem.loadSyncState(
         bobHandle.documentId,
-        charlie
+        await charlieRepo!.storageSubsystem.id()
       )
       const docHeads = A.getHeads(bobHandle.docSync())
       assert.deepStrictEqual(storedSyncState.sharedHeads, docHeads)
@@ -811,6 +819,29 @@ describe("Repo", () => {
       teardown()
     })
 
+    it("should not save sync state of ephemeral peers", async () => {
+      const { bobRepo, teardown, charlieRepo } = await setup({
+        connectAlice: false,
+        isCharlieEphemeral: true,
+      })
+
+      const bobHandle = bobRepo.create<TestDoc>()
+      bobHandle.change(d => {
+        d.foo = "bar"
+      })
+
+      await pause(200)
+
+      // bob should not store the sync state for charlie because charly is an ephemeral peer
+      const storedSyncState = await bobRepo.storageSubsystem.loadSyncState(
+        bobHandle.documentId,
+        await charlieRepo!.storageSubsystem.id()
+      )
+      assert.deepStrictEqual(storedSyncState, undefined)
+
+      teardown()
+    })
+
     it("should load sync state from storage", async () => {
       const { bobRepo, teardown, charlie, charlieRepo, bobStorage, bob } =
         await setup({
@@ -823,13 +854,15 @@ describe("Repo", () => {
         d.foo = "bar"
       })
       let bobSyncMessages = 0
-      bobRepo.networkSubsystem.on("message", () => {
-        bobSyncMessages++
+      bobRepo.networkSubsystem.on("message", message => {
+        if (message.type === "sync") {
+          bobSyncMessages++
+        }
       })
       await pause(500)
 
-      // repo has no stored sync state for charlie so we should see two sync messages
-      assert.strictEqual(bobSyncMessages, 2)
+      // repo has no stored sync state for charlie so we should see 3 sync messages
+      assert.strictEqual(bobSyncMessages, 3)
 
       // setup new repo which uses bob's storage
       const bob2Repo = new Repo({
@@ -850,8 +883,10 @@ describe("Repo", () => {
       // lookup doc we've previously created and count the messages
       bob2Repo.find(bobHandle.documentId)
       let bob2SyncMessages = 0
-      bob2Repo.networkSubsystem.on("message", m => {
-        bob2SyncMessages++
+      bob2Repo.networkSubsystem.on("message", message => {
+        if (message.type === "sync") {
+          bob2SyncMessages++
+        }
       })
       await pause(100)
 
@@ -866,6 +901,7 @@ describe("Repo", () => {
       const { bobRepo, charlieRepo, teardown } = await setup({
         connectAlice: false,
       })
+      const charliedStorageId = await charlieRepo.storageSubsystem.id()
 
       const handle = bobRepo.create<TestDoc>()
       handle.change(d => {
@@ -876,11 +912,11 @@ describe("Repo", () => {
       await pause(50)
 
       const nextRemoteHeadsPromise = new Promise<{
-        peerId: PeerId
+        storageId: StorageId
         heads: A.Heads
       }>(resolve => {
-        handle.on("remote-heads", ({ peerId, heads }) => {
-          resolve({ peerId, heads })
+        handle.on("remote-heads", ({ storageId, heads }) => {
+          resolve({ storageId, heads })
         })
       })
 
@@ -901,11 +937,11 @@ describe("Repo", () => {
       assert.deepStrictEqual(charlieHeads, bobHeads)
 
       const nextRemoteHeads = await nextRemoteHeadsPromise
-      assert.deepStrictEqual(nextRemoteHeads.peerId, "charlie")
+      assert.deepStrictEqual(nextRemoteHeads.storageId, charliedStorageId)
       assert.deepStrictEqual(nextRemoteHeads.heads, charlieHeads)
 
       assert.deepStrictEqual(
-        handle.getRemoteHeads("charlie" as PeerId),
+        handle.getRemoteHeads(charliedStorageId),
         A.getHeads(charlieHandle.docSync())
       )
 

package/test/StorageSubsystem.test.ts

@@ -8,7 +8,9 @@ import { describe, it } from "vitest"
 import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
 import { PeerId, cbor } from "../src/index.js"
 import { StorageSubsystem } from "../src/storage/StorageSubsystem.js"
+import { StorageId } from "../src/storage/types.js"
 import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
+import * as Uuid from "uuid"
 
 const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "automerge-repo-tests"))
 
@@ -182,12 +184,15 @@ describe("StorageSubsystem", () => {
 
           const { documentId } = parseAutomergeUrl(generateAutomergeUrl())
           const syncState = A.initSyncState()
-          const bob = "bob" as PeerId
+          const bobStorageId = Uuid.v4() as StorageId
 
           const rawSyncState = A.decodeSyncState(A.encodeSyncState(syncState))
 
-          await storage.saveSyncState(documentId, bob, syncState)
-          const loadedSyncState = await storage.loadSyncState(documentId, bob)
+          await storage.saveSyncState(documentId, bobStorageId, syncState)
+          const loadedSyncState = await storage.loadSyncState(
+            documentId,
+            bobStorageId
+          )
           assert.deepStrictEqual(loadedSyncState, rawSyncState)
         })
 
@@ -196,14 +201,31 @@ describe("StorageSubsystem", () => {
 
           const { documentId } = parseAutomergeUrl(generateAutomergeUrl())
           const syncState = A.initSyncState()
-          const bob = "bob" as PeerId
+          const bobStorageId = Uuid.v4() as StorageId
 
-          await storage.saveSyncState(documentId, bob, syncState)
+          await storage.saveSyncState(documentId, bobStorageId, syncState)
           await storage.removeDoc(documentId)
-          const loadedSyncState = await storage.loadSyncState(documentId, bob)
+          const loadedSyncState = await storage.loadSyncState(
+            documentId,
+            bobStorageId
+          )
           assert.strictEqual(loadedSyncState, undefined)
         })
       })
+
+      describe("storage id", () => {
+        it("generates a unique id", async () => {
+          const storage = new StorageSubsystem(adapter)
+
+          // generate unique id and return same id on subsequence calls
+          const id1 = await storage.id()
+          const id2 = await storage.id()
+
+          assert.strictEqual(Uuid.validate(id1), true)
+          assert.strictEqual(Uuid.validate(id2), true)
+          assert.strictEqual(id1, id2)
+        })
+      })
     })
   })
 })

package/test/remoteHeads.test.ts

@@ -0,0 +1,135 @@
+import * as A from "@automerge/automerge/next"
+import assert from "assert"
+import { decode } from "cbor-x"
+import { describe, it } from "vitest"
+import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
+import { eventPromise } from "../src/helpers/eventPromise.js"
+import { pause } from "../src/helpers/pause.js"
+import {
+  DocHandle,
+  DocHandleRemoteHeadsPayload,
+  PeerId,
+  Repo,
+} from "../src/index.js"
+import { TestDoc } from "./types.js"
+import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel"
+import { setTimeout } from "timers/promises"
+import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
+
+describe("DocHandle.remoteHeads", () => {
+  const TEST_ID = parseAutomergeUrl(generateAutomergeUrl()).documentId
+
+  it("should allow to listen for remote head changes and manually read remote heads", async () => {
+    const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
+    const bobRepo = new Repo({
+      peerId: "bob" as PeerId,
+      network: [],
+      storage: new DummyStorageAdapter(),
+    })
+    const bobStorageId = await bobRepo.storageId()
+
+    const remoteHeadsMessagePromise = eventPromise(handle, "remote-heads")
+    handle.setRemoteHeads(bobStorageId, [])
+
+    const remoteHeadsMessage = await remoteHeadsMessagePromise
+
+    assert.strictEqual(remoteHeadsMessage.storageId, bobStorageId)
+    assert.deepStrictEqual(remoteHeadsMessage.heads, [])
+
+    // read remote heads manually
+    assert.deepStrictEqual(handle.getRemoteHeads(bobStorageId), [])
+  })
+
+  it("should report remoteHeads for peers who are several hops away", async () => {
+    // replicates a tab -> service worker -> sync server <- service worker <- tab scenario
+    const leftTab = new Repo({
+      peerId: "left-tab" as PeerId,
+      network: [],
+      sharePolicy: async () => true,
+    })
+    const leftServiceWorker = new Repo({
+      peerId: "left-service-worker" as PeerId,
+      network: [],
+      sharePolicy: async peer => peer === "sync-server",
+      storage: new DummyStorageAdapter(),
+      isEphemeral: false,
+    })
+    const syncServer = new Repo({
+      peerId: "sync-server" as PeerId,
+      network: [],
+      isEphemeral: false,
+      sharePolicy: async () => false,
+      storage: new DummyStorageAdapter(),
+    })
+    const rightServiceWorker = new Repo({
+      peerId: "right-service-worker" as PeerId,
+      network: [],
+      sharePolicy: async peer => peer === "sync-server",
+      isEphemeral: false,
+      storage: new DummyStorageAdapter(),
+    })
+    const rightTab = new Repo({
+      peerId: "right-tab" as PeerId,
+      network: [],
+      sharePolicy: async () => true,
+    })
+
+    // connect them all up
+    connectRepos(leftTab, leftServiceWorker)
+    connectRepos(leftServiceWorker, syncServer)
+    connectRepos(syncServer, rightServiceWorker)
+    connectRepos(rightServiceWorker, rightTab)
+
+    await setTimeout(100)
+
+    // subscribe to the left service worker storage ID on the right tab
+    rightTab.subscribeToRemotes([await leftServiceWorker.storageId()!])
+
+    await setTimeout(100)
+
+    // create a doc in the left tab
+    const leftTabDoc = leftTab.create<TestDoc>()
+    leftTabDoc.change(d => (d.foo = "bar"))
+
+    // wait for the document to arrive on the right tab
+    const rightTabDoc = rightTab.find<TestDoc>(leftTabDoc.url)
+    await rightTabDoc.whenReady()
+
+    // wait for the document to arrive in the left service worker
+    const leftServiceWorkerDoc = leftServiceWorker.find(leftTabDoc.documentId)
+    await leftServiceWorkerDoc.whenReady()
+
+    const leftServiceWorkerStorageId = await leftServiceWorker.storageId()
+    let leftSeenByRightPromise = new Promise<DocHandleRemoteHeadsPayload>(
+      resolve => {
+        rightTabDoc.on("remote-heads", message => {
+          if (message.storageId === leftServiceWorkerStorageId) {
+            resolve(message)
+          }
+        })
+      }
+    )
+
+    // make a change on the right
+    rightTabDoc.change(d => (d.foo = "baz"))
+
+    // wait for the change to be acknolwedged by the left
+    const leftSeenByRight = await leftSeenByRightPromise
+
+    assert.deepStrictEqual(
+      leftSeenByRight.heads,
+      A.getHeads(leftServiceWorkerDoc.docSync())
+    )
+  })
+})
+
+function connectRepos(repo1: Repo, repo2: Repo) {
+  const { port1: leftToRight, port2: rightToLeft } = new MessageChannel()
+
+  repo1.networkSubsystem.addNetworkAdapter(
+    new MessageChannelNetworkAdapter(leftToRight)
+  )
+  repo2.networkSubsystem.addNetworkAdapter(
+    new MessageChannelNetworkAdapter(rightToLeft)
+  )
+}