@automerge/automerge-repo 2.5.0 → 2.5.2-alpha.0

package/src/index.ts

@@ -39,6 +39,14 @@ export {
   decodeHeads,
 } from "./AutomergeUrl.js"
 export { Repo } from "./Repo.js"
+export {
+  Presence,
+  PeerPresenceView,
+  PeerState,
+  PresenceConfig,
+  UserId,
+  DeviceId,
+} from "./Presence.js"
 export { NetworkAdapter } from "./network/NetworkAdapter.js"
 export type { NetworkAdapterInterface } from "./network/NetworkAdapterInterface.js"
 export { isRepoMessage } from "./network/messages.js"

package/src/synchronizer/CollectionSynchronizer.ts

@@ -22,6 +22,7 @@ export class CollectionSynchronizer extends Synchronizer {
   #docSetUp: Record<DocumentId, boolean> = {}
 
   #denylist: DocumentId[]
+  #hasRequested: Map<DocumentId, Set<PeerId>> = new Map()
 
   constructor(private repo: Repo, denylist: AutomergeUrl[] = []) {
     super()
@@ -108,6 +109,16 @@ export class CollectionSynchronizer extends Synchronizer {
       return
     }
 
+    // Record the request so that even if access is denied now, we know that the
+    // peer requested the document so that if the share policy changes we know
+    // to begin syncing with this peer
+    if (message.type === "request") {
+      if (!this.#hasRequested.has(documentId)) {
+        this.#hasRequested.set(documentId, new Set())
+      }
+      this.#hasRequested.get(documentId)?.add(message.senderId)
+    }
+
     const hasAccess = await this.repo.shareConfig.access(
       message.senderId,
       documentId
@@ -146,6 +157,7 @@ export class CollectionSynchronizer extends Synchronizer {
     if (this.#docSetUp[handle.documentId]) {
       return
     }
+    this.#docSetUp[handle.documentId] = true
     const docSynchronizer = this.#fetchDocSynchronizer(handle)
     void this.#documentGenerousPeers(handle.documentId).then(peers => {
       void docSynchronizer.beginSync(peers)
@@ -184,6 +196,9 @@ export class CollectionSynchronizer extends Synchronizer {
   removePeer(peerId: PeerId) {
     log(`removing peer ${peerId}`)
     this.#peers.delete(peerId)
+    for (const requested of this.#hasRequested.values()) {
+      requested.delete(peerId)
+    }
 
     for (const docSynchronizer of Object.values(this.docSynchronizers)) {
       docSynchronizer.endSync(peerId)
@@ -195,6 +210,49 @@ export class CollectionSynchronizer extends Synchronizer {
     return Array.from(this.#peers)
   }
 
+  /**
+   * Re-evaluates share policy for a document and updates sync accordingly
+   *
+   * @remarks
+   * This is called when the share policy for a document has changed. It re-evaluates
+   * which peers should have access and starts/stops synchronization as needed.
+   */
+  async reevaluateDocumentShare() {
+    const peers = Array.from(this.#peers)
+    const docPromises = []
+    for (const docSynchronizer of Object.values(this.docSynchronizers)) {
+      const documentId = docSynchronizer.documentId
+      docPromises.push(
+        (async () => {
+          for (const peerId of peers) {
+            const shouldShare = await this.#shouldShare(peerId, documentId)
+            const isAlreadySyncing = docSynchronizer.hasPeer(peerId)
+
+            log(
+              `reevaluateDocumentShare: ${peerId} for ${documentId}, shouldShare: ${shouldShare}, isAlreadySyncing: ${isAlreadySyncing}`
+            )
+            if (shouldShare && !isAlreadySyncing) {
+              log(
+                `reevaluateDocumentShare: starting sync with ${peerId} for ${documentId}`
+              )
+              void docSynchronizer.beginSync([peerId])
+            } else if (!shouldShare && isAlreadySyncing) {
+              log(
+                `reevaluateDocumentShare: stopping sync with ${peerId} for ${documentId}`
+              )
+              docSynchronizer.endSync(peerId)
+            }
+          }
+        })().catch(e => {
+          console.log(
+            `error reevaluating document share for ${documentId}: ${e}`
+          )
+        })
+      )
+    }
+    await Promise.allSettled(docPromises)
+  }
+
   metrics(): {
     [key: string]: {
       peers: PeerId[]
@@ -215,6 +273,8 @@ export class CollectionSynchronizer extends Synchronizer {
       this.repo.shareConfig.announce(peerId, documentId),
       this.repo.shareConfig.access(peerId, documentId),
     ])
-    return announce && access
+    const hasRequested =
+      this.#hasRequested.get(documentId)?.has(peerId) ?? false
+    return announce || (access && hasRequested)
   }
 }

package/src/synchronizer/DocSynchronizer.ts

@@ -201,8 +201,8 @@ export class DocSynchronizer extends Synchronizer {
         forPeer: peerId,
       })
 
+      this.#setSyncState(peerId, newSyncState)
       if (message) {
-        this.#setSyncState(peerId, newSyncState)
         const isNew = A.getHeads(doc).length === 0
 
         if (

package/test/Presence.test.ts

@@ -0,0 +1,264 @@
+import { describe, expect, it } from "vitest"
+
+import { Presence, PresenceEventHeartbeat } from "../src/Presence.js"
+import { Repo } from "../src/Repo.js"
+import { PeerId } from "../src/types.js"
+import { DummyNetworkAdapter } from "../src/helpers/DummyNetworkAdapter.js"
+import { waitFor } from "./helpers/waitFor.js"
+import { wait } from "./helpers/wait.js"
+
+type PresenceState = { position: number }
+
+describe("Presence", () => {
+  async function setup(opts?: { skipAnnounce?: boolean }) {
+    const alice = new Repo({ peerId: "alice" as PeerId })
+    const bob = new Repo({ peerId: "bob" as PeerId })
+    const [aliceToBob, bobToAlice] = DummyNetworkAdapter.createConnectedPair()
+    alice.networkSubsystem.addNetworkAdapter(aliceToBob)
+    bob.networkSubsystem.addNetworkAdapter(bobToAlice)
+    if (!opts?.skipAnnounce) {
+      aliceToBob.peerCandidate("bob" as PeerId)
+      bobToAlice.peerCandidate("alice" as PeerId)
+    }
+    await Promise.all([
+      alice.networkSubsystem.whenReady(),
+      bob.networkSubsystem.whenReady(),
+    ])
+
+    const aliceHandle = alice.create({
+      test: "doc",
+    })
+    const alicePresence = new Presence<PresenceState>({
+      handle: aliceHandle,
+      userId: "alice",
+      deviceId: "phone",
+    })
+
+    const bobHandle = await bob.find(aliceHandle.url)
+    const bobPresence = new Presence<PresenceState>({
+      handle: bobHandle,
+      userId: "bob",
+      deviceId: "phone",
+    })
+
+    return {
+      alice: {
+        repo: alice,
+        handle: aliceHandle,
+        presence: alicePresence,
+        network: aliceToBob,
+      },
+      bob: {
+        repo: bob,
+        handle: bobHandle,
+        presence: bobPresence,
+        network: bobToAlice,
+      },
+    }
+  }
+
+  describe("start", () => {
+    it("activates presence and shares initial state", async () => {
+      const { alice, bob } = await setup()
+
+      alice.presence.start({
+        initialState: {
+          position: 123,
+        },
+      })
+      expect(alice.presence.running).toBe(true)
+
+      bob.presence.start({
+        initialState: {
+          position: 456,
+        },
+      })
+      expect(bob.presence.running).toBe(true)
+
+      await waitFor(() => {
+        const bobPeerStates = bob.presence.getPeerStates()
+        const bobPeers = bobPeerStates.getPeers()
+
+        expect(bobPeers.length).toBe(1)
+        expect(bobPeers[0]).toBe(alice.repo.peerId)
+        expect(bobPeerStates.getPeerState(bobPeers[0], "position")).toBe(123)
+
+        const alicePeerStates = alice.presence.getPeerStates()
+        const alicePeers = alicePeerStates.getPeers()
+
+        expect(alicePeers.length).toBe(1)
+        expect(alicePeers[0]).toBe(bob.repo.peerId)
+        expect(alicePeerStates.getPeerState(alicePeers[0], "position")).toBe(
+          456
+        )
+      })
+    })
+
+    it("does nothing if invoked on an already-running Presence", async () => {
+      const { alice } = await setup()
+
+      alice.presence.start({
+        initialState: {
+          position: 123,
+        },
+      })
+      expect(alice.presence.running).toBe(true)
+
+      alice.presence.start({
+        initialState: {
+          position: 789,
+        },
+      })
+      expect(alice.presence.running).toBe(true)
+      expect(alice.presence.getLocalState().position).toBe(123)
+    })
+  })
+
+  describe("stop", () => {
+    it("stops running presence and ignores further broadcasts", async () => {
+      const { alice, bob } = await setup()
+
+      alice.presence.start({
+        initialState: {
+          position: 123,
+        },
+      })
+      expect(alice.presence.running).toBe(true)
+
+      bob.presence.start({
+        initialState: {
+          position: 456,
+        },
+      })
+
+      await waitFor(() => {
+        const bobPeerStates = bob.presence.getPeerStates()
+        const bobPeers = bobPeerStates.getPeers()
+
+        expect(bobPeers.length).toBe(1)
+        expect(bobPeers[0]).toBe(alice.repo.peerId)
+        expect(bobPeerStates.getPeerState(bobPeers[0], "position")).toBe(123)
+      })
+
+      alice.presence.stop()
+      expect(alice.presence.running).toBe(false)
+
+      await waitFor(() => {
+        const bobPeerStates = bob.presence.getPeerStates()
+        const bobPeers = bobPeerStates.getPeers()
+
+        expect(bobPeers.length).toBe(0)
+      })
+    })
+
+    it("does nothing if invoked on a non-running Presence", async () => {
+      const { alice } = await setup()
+
+      expect(alice.presence.running).toBe(false)
+
+      alice.presence.stop()
+
+      expect(alice.presence.running).toBe(false)
+    })
+  })
+
+  describe("heartbeats", () => {
+    it("sends heartbeats on the configured interval", async () => {
+      const { alice, bob } = await setup()
+      alice.presence.start({
+        initialState: {
+          position: 123,
+        },
+        heartbeatMs: 10,
+      })
+
+      bob.presence.start({
+        initialState: {
+          position: 456,
+        },
+      })
+
+      let hbPeerMsg: PresenceEventHeartbeat
+      bob.presence.on("heartbeat", msg => {
+        hbPeerMsg = msg
+      })
+
+      await waitFor(() => {
+        expect(hbPeerMsg.peerId).toEqual(alice.repo.peerId)
+        expect(hbPeerMsg.type).toEqual("heartbeat")
+        expect(hbPeerMsg.userId).toEqual("alice")
+      })
+    })
+
+    it("delays heartbeats when there is a state update", async () => {
+      const { alice, bob } = await setup()
+      alice.presence.start({
+        initialState: {
+          position: 123,
+        },
+        heartbeatMs: 10,
+      })
+
+      bob.presence.start({
+        initialState: {
+          position: 456,
+        },
+      })
+
+      let hbPeerMsg: PresenceEventHeartbeat
+      bob.presence.on("heartbeat", msg => {
+        hbPeerMsg = msg
+      })
+
+      await wait(7)
+      alice.presence.broadcast("position", 789)
+      await wait(7)
+
+      expect(hbPeerMsg).toBeUndefined()
+
+      await wait(20)
+      expect(hbPeerMsg.peerId).toEqual(alice.repo.peerId)
+      expect(hbPeerMsg.type).toEqual("heartbeat")
+      expect(hbPeerMsg.userId).toEqual("alice")
+    })
+  })
+
+  describe("broadcast", () => {
+    it("sends updates to peers", async () => {
+      const { alice, bob } = await setup()
+      alice.presence.start({
+        initialState: {
+          position: 123,
+        },
+      })
+
+      bob.presence.start({
+        initialState: {
+          position: 456,
+        },
+      })
+
+      await waitFor(() => {
+        const bobPeerStates = bob.presence.getPeerStates()
+        const bobPeers = bobPeerStates.getPeers()
+
+        expect(bobPeers.length).toBe(1)
+        expect(bobPeerStates.getPeerState(alice.repo.peerId, "position")).toBe(
+          123
+        )
+      })
+
+      alice.presence.broadcast("position", 213)
+
+      await waitFor(() => {
+        const bobPeerStates = bob.presence.getPeerStates()
+        const bobPeers = bobPeerStates.getPeers()
+
+        expect(bobPeers.length).toBe(1)
+        expect(bobPeerStates.getPeerState(alice.repo.peerId, "position")).toBe(
+          213
+        )
+      })
+    })
+  })
+})

package/test/Repo.test.ts

@@ -35,6 +35,10 @@ import {
   LargeObject,
   generateLargeObject,
 } from "./helpers/generate-large-object.js"
+import twoPeers from "./helpers/twoPeers.js"
+import connectRepos from "./helpers/connectRepos.js"
+import awaitState from "./helpers/awaitState.js"
+import withTimeout from "./helpers/withTimeout.js"
 import { getRandomItem } from "./helpers/getRandomItem.js"
 import { TestDoc } from "./types.js"
 import { StorageId, StorageKey } from "../src/storage/types.js"
@@ -1182,6 +1186,49 @@ describe("Repo", () => {
       teardown()
     })
 
+    it("a previously unavailable document syncs if a connected peer obtains it (but doesn't announce it)", async () => {
+      const alice = new Repo({
+        peerId: "alice" as PeerId,
+        shareConfig: {
+          announce: async peerId => peerId === "charlie",
+          access: async () => true,
+        },
+      })
+      const bob = new Repo({
+        peerId: "bob" as PeerId,
+        shareConfig: {
+          announce: async () => true,
+          access: async () => true,
+        },
+      })
+      const charlie = new Repo({
+        peerId: "charlie" as PeerId,
+        shareConfig: {
+          announce: async () => false,
+          access: async () => true,
+        },
+      })
+      await connectRepos(alice, bob)
+
+      const charlieHandle = charlie.create({ foo: "bar" })
+
+      // Charlie isn't connected to any peer, so we don't have the document
+      await assert.rejects(bob.find(charlieHandle.url))
+
+      // Now, connect charlie to alice
+      await connectRepos(alice, charlie)
+
+      // Alice should now find the document
+      const aliceHandle = await withTimeout(alice.find(charlieHandle.url), 500)
+      assert.deepStrictEqual(aliceHandle.doc(), { foo: "bar" })
+
+      await pause(150) // wait for the sync debounce rate to elapse
+
+      // Bob should now find the document via alice
+      const bobHandle = await withTimeout(bob.find(charlieHandle.url), 500)
+      assert.deepStrictEqual(bobHandle.doc(), { foo: "bar" })
+    })
+
     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
@@ -1716,174 +1763,6 @@ describe("Repo", () => {
       assert.deepEqual(openDocs, 0)
     })
   })
-
-  describe("the sharePolicy", () => {
-    async function connect(left: Repo, right: Repo) {
-      const [leftToRight, rightToLeft] =
-        DummyNetworkAdapter.createConnectedPair({ latency: 0 })
-      left.networkSubsystem.addNetworkAdapter(leftToRight)
-      right.networkSubsystem.addNetworkAdapter(rightToLeft)
-      leftToRight.peerCandidate(right.peerId)
-      rightToLeft.peerCandidate(left.peerId)
-      await Promise.all([
-        left.networkSubsystem.whenReady(),
-        right.networkSubsystem.whenReady(),
-      ])
-      await pause(10)
-    }
-
-    async function withTimeout<T>(
-      promise: Promise<T>,
-      timeout: number
-    ): Promise<T | undefined> {
-      const timeoutPromise = new Promise<T | undefined>(resolve => {
-        setTimeout(() => resolve(undefined), timeout)
-      })
-      return Promise.race([promise, timeoutPromise])
-    }
-
-    async function awaitState(
-      progress: FindProgress<unknown> | FindProgressWithMethods<unknown>,
-      state: string
-    ): Promise<void> {
-      if (progress.state == state) {
-        return
-      }
-      if (!("subscribe" in progress)) {
-        throw new Error(
-          `expected progress in state ${state} but was in final state ${progress.state}`
-        )
-      }
-      await new Promise(resolve => {
-        const unsubscribe = progress.subscribe(progress => {
-          if (progress.state === state) {
-            unsubscribe()
-            resolve(null)
-          }
-        })
-      })
-    }
-
-    // The parts of `RepoConfig` which are either the old sharePolicy API or the new shareConfig API
-    type EitherConfig = { sharePolicy?: SharePolicy; shareConfig?: ShareConfig }
-
-    /// Create two connected peers with the given share configurations
-    async function twoPeers({
-      alice: aliceConfig,
-      bob: bobConfig,
-    }: {
-      alice: EitherConfig
-      bob: EitherConfig
-    }): Promise<{ alice: Repo; bob: Repo }> {
-      const alice = new Repo({
-        peerId: "alice" as PeerId,
-        ...aliceConfig,
-      })
-      const bob = new Repo({
-        peerId: "bob" as PeerId,
-        ...bobConfig,
-      })
-      await connect(alice, bob)
-      return { alice, bob }
-    }
-
-    describe("the legacy API", () => {
-      it("should announce documents to peers for whom the sharePolicy returns true", async () => {
-        const { alice, bob } = await twoPeers({
-          alice: { sharePolicy: async () => true },
-          bob: { sharePolicy: async () => true },
-        })
-        const handle = alice.create({ foo: "bar" })
-
-        // Wait for the announcement to be synced
-        await pause(100)
-
-        // Disconnect and stop alice
-        await alice.shutdown()
-
-        // Bob should have the handle already because it was announced to him
-        const bobHandle = await bob.find(handle.url)
-      })
-
-      it("should not annouce documents to peers for whom the sharePolicy returns false", async () => {
-        const { alice, bob } = await twoPeers({
-          alice: { sharePolicy: async () => false },
-          bob: { sharePolicy: async () => true },
-        })
-        const handle = alice.create({ foo: "bar" })
-
-        // Disconnect and stop alice
-        await alice.shutdown()
-
-        // Bob should have the handle already because it was announced to him
-        const bobHandle = await withTimeout(bob.find(handle.url), 100)
-        assert.equal(bobHandle, null)
-      })
-
-      it("should respond to direct requests for document where the sharePolicy returns false", async () => {
-        const { alice, bob } = await twoPeers({
-          alice: { sharePolicy: async () => false },
-          bob: { sharePolicy: async () => true },
-        })
-        await connect(alice, bob)
-
-        const aliceHandle = alice.create({ foo: "bar" })
-        const bobHandle = await bob.find(aliceHandle.url)
-      })
-    })
-
-    it("should respond to direct requests for document where the announce policy returns false but the access policy returns true", async () => {
-      const { alice, bob } = await twoPeers({
-        alice: {
-          shareConfig: {
-            announce: async () => false,
-            access: async () => true,
-          },
-        },
-        bob: { sharePolicy: async () => true },
-      })
-
-      const aliceHandle = alice.create({ foo: "bar" })
-      const bobHandle = await bob.find(aliceHandle.url)
-    })
-
-    it("should not respond to direct requests for a document where the access policy returns false and the announce policy return trrrue", async () => {
-      const { alice, bob } = await twoPeers({
-        alice: {
-          shareConfig: {
-            announce: async () => true,
-            access: async () => false,
-          },
-        },
-        bob: { sharePolicy: async () => true },
-      })
-      await connect(alice, bob)
-
-      const aliceHandle = alice.create({ foo: "bar" })
-      withTimeout(
-        awaitState(bob.findWithProgress(aliceHandle.url), "unavailable"),
-        500
-      )
-    })
-
-    it("should not respond to direct requests for a document where the access policy and the announce policy return false", async () => {
-      const { alice, bob } = await twoPeers({
-        alice: {
-          shareConfig: {
-            announce: async () => false,
-            access: async () => false,
-          },
-        },
-        bob: { sharePolicy: async () => false },
-      })
-
-      const aliceHandle = alice.create({ foo: "bar" })
-      withTimeout(
-        awaitState(bob.findWithProgress(aliceHandle.url), "unavailable"),
-        500
-      )
-    })
-  })
 })
 
 describe("Repo heads-in-URLs functionality", () => {