@automerge/automerge-repo 1.1.0-alpha.1 → 1.1.0-alpha.13

package/test/RemoteHeadsSubscriptions.test.ts

@@ -1,15 +1,14 @@
 import * as A from "@automerge/automerge"
 import assert from "assert"
 import { describe, it } from "vitest"
+import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
 import { RemoteHeadsSubscriptions } from "../src/RemoteHeadsSubscriptions.js"
 import { PeerId, StorageId } from "../src/index.js"
-import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
-import { pause } from "../src/helpers/pause.js"
-import { EventEmitter } from "eventemitter3"
 import {
   RemoteHeadsChanged,
   RemoteSubscriptionControlMessage,
 } from "../src/network/messages.js"
+import { waitForMessages } from "./helpers/waitForMessages.js"
 
 describe("RepoHeadsSubscriptions", () => {
   const storageA = "remote-a" as StorageId
@@ -224,6 +223,8 @@ describe("RepoHeadsSubscriptions", () => {
       remoteHeadsSubscriptions,
       "notify-remote-heads"
     )
+    remoteHeadsSubscriptions.subscribePeerToDoc(peerC, docA)
+    remoteHeadsSubscriptions.subscribePeerToDoc(peerC, docC)
 
     // change message for docA in storageB
     remoteHeadsSubscriptions.handleRemoteHeads(docAHeadsChangedForStorageB)
@@ -260,7 +261,33 @@ describe("RepoHeadsSubscriptions", () => {
     assert.strictEqual(messages.length, 0)
   })
 
-  it("should ignore sync states with an older timestamp", async () => {
+  it("should not send remote heads for docs that the peer is not subscribed to", async () => {
+    const remoteHeadsSubscriptions = new RemoteHeadsSubscriptions()
+    remoteHeadsSubscriptions.subscribeToRemotes([storageB])
+
+    // subscribe peer c to storage b
+    remoteHeadsSubscriptions.handleControlMessage(subscribePeerCToStorageB)
+    const messagesAfterSubscribePromise = waitForMessages(
+      remoteHeadsSubscriptions,
+      "notify-remote-heads"
+    )
+
+    // change message for docA in storageB
+    remoteHeadsSubscriptions.handleRemoteHeads(docAHeadsChangedForStorageB)
+
+    // change heads directly
+    remoteHeadsSubscriptions.handleImmediateRemoteHeadsChanged(
+      docC,
+      storageB,
+      []
+    )
+
+    // expect peer c to be notified both changes
+    let messages = await messagesAfterSubscribePromise
+    assert.strictEqual(messages.length, 0)
+  })
+
+  it("should only notify of sync states with a more recent timestamp", async () => {
     const remoteHeadsSubscription = new RemoteHeadsSubscriptions()
 
     const messagesPromise = waitForMessages(
@@ -271,6 +298,9 @@ describe("RepoHeadsSubscriptions", () => {
     remoteHeadsSubscription.subscribeToRemotes([storageB])
     remoteHeadsSubscription.handleRemoteHeads(docBHeadsChangedForStorageB2)
 
+    // send same message
+    remoteHeadsSubscription.handleRemoteHeads(docBHeadsChangedForStorageB2)
+
     // send message with old heads
     remoteHeadsSubscription.handleRemoteHeads(docBHeadsChangedForStorageB)
 
@@ -321,23 +351,3 @@ describe("RepoHeadsSubscriptions", () => {
     assert.deepStrictEqual(messages[2].peers, [])
   })
 })
-
-async function waitForMessages(
-  emitter: EventEmitter,
-  event: string,
-  timeout: number = 100
-): Promise<any[]> {
-  const messages = []
-
-  const onEvent = message => {
-    messages.push(message)
-  }
-
-  emitter.on(event, onEvent)
-
-  await pause(timeout)
-
-  emitter.off(event)
-
-  return messages
-}

package/test/Repo.test.ts

@@ -1,8 +1,8 @@
 import { next as A } from "@automerge/automerge"
-import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel"
+import { MessageChannelNetworkAdapter } from "../../automerge-repo-network-messagechannel/src/index.js"
 import assert from "assert"
 import * as Uuid from "uuid"
-import { describe, it } from "vitest"
+import { describe, expect, it } from "vitest"
 import { READY } from "../src/DocHandle.js"
 import { parseAutomergeUrl } from "../src/AutomergeUrl.js"
 import {
@@ -13,6 +13,7 @@ import { Repo } from "../src/Repo.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
 import { pause } from "../src/helpers/pause.js"
 import {
+  AnyDocumentId,
   AutomergeUrl,
   DocHandle,
   DocumentId,
@@ -31,6 +32,15 @@ import { TestDoc } from "./types.js"
 import { StorageId } from "../src/storage/types.js"
 
 describe("Repo", () => {
+  describe("constructor", () => {
+    it("can be instantiated without network adapters", () => {
+      const repo = new Repo({
+        network: [],
+      })
+      expect(repo).toBeInstanceOf(Repo)
+    })
+  })
+
   describe("local only", () => {
     const setup = ({ startReady = true } = {}) => {
       const storageAdapter = new DummyStorageAdapter()
@@ -321,6 +331,27 @@ describe("Repo", () => {
         repo.delete(handle.documentId)
       }))
 
+    it("exports a document", async () => {
+      const { repo } = setup()
+      const handle = repo.create<TestDoc>()
+      handle.change(d => {
+        d.foo = "bar"
+      })
+      assert.equal(handle.isReady(), true)
+
+      const exported = await repo.export(handle.documentId)
+      const loaded = A.load(exported)
+      const doc = await handle.doc()
+      assert.deepEqual(doc, loaded)
+    })
+
+    it("rejects when exporting a document that does not exist", async () => {
+      const { repo } = setup()
+      assert.rejects(async () => {
+        await repo.export("foo" as AnyDocumentId)
+      })
+    })
+
     it("storage state doesn't change across reloads when the document hasn't changed", async () => {
       const storage = new DummyStorageAdapter()
 
@@ -396,6 +427,30 @@ describe("Repo", () => {
       const storageKeyTypes = storageAdapter.keys().map(k => k.split(".")[1])
       assert(storageKeyTypes.filter(k => k === "snapshot").length === 1)
     })
+
+    it("can import an existing document", async () => {
+      const { repo } = setup()
+      const doc = A.init<TestDoc>()
+      const updatedDoc = A.change(doc, d => {
+        d.foo = "bar"
+      })
+
+      const saved = A.save(updatedDoc)
+
+      const handle = repo.import<TestDoc>(saved)
+      assert.equal(handle.isReady(), true)
+      const v = await handle.doc()
+      assert.equal(v?.foo, "bar")
+
+      expect(A.getHistory(v)).toEqual(A.getHistory(updatedDoc))
+    })
+
+    it("throws an error if we try to import an invalid document", async () => {
+      const { repo } = setup()
+      expect(() => {
+        repo.import<TestDoc>(A.init<TestDoc> as unknown as Uint8Array)
+      }).toThrow()
+    })
   })
 
   describe("with peers (linear network)", async () => {

package/test/StorageSubsystem.test.ts

@@ -1,4 +1,4 @@
-import { NodeFSStorageAdapter } from "@automerge/automerge-repo-storage-nodefs"
+import { NodeFSStorageAdapter } from "../../automerge-repo-storage-nodefs/src/index.js"
 import * as A from "@automerge/automerge/next"
 import assert from "assert"
 import fs from "fs"

package/test/helpers/waitForMessages.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from "eventemitter3"
+import { pause } from "../../src/helpers/pause.js"
+
+export async function waitForMessages(
+  emitter: EventEmitter,
+  event: string,
+  timeout: number = 100
+): Promise<any[]> {
+  const messages = []
+
+  const onEvent = message => {
+    messages.push(message)
+  }
+
+  emitter.on(event, onEvent)
+
+  await pause(timeout)
+
+  emitter.off(event)
+
+  return messages
+}

package/test/remoteHeads.test.ts

@@ -1,20 +1,19 @@
+import { MessageChannelNetworkAdapter } from "../../automerge-repo-network-messagechannel/dist/index.js"
 import * as A from "@automerge/automerge/next"
 import assert from "assert"
-import { decode } from "cbor-x"
+import { setTimeout } from "timers/promises"
 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"
+import { waitForMessages } from "./helpers/waitForMessages.js"
+import { TestDoc } from "./types.js"
 
 describe("DocHandle.remoteHeads", () => {
   const TEST_ID = parseAutomergeUrl(generateAutomergeUrl()).documentId
@@ -25,6 +24,7 @@ describe("DocHandle.remoteHeads", () => {
       peerId: "bob" as PeerId,
       network: [],
       storage: new DummyStorageAdapter(),
+      enableRemoteHeadsGossiping: true,
     })
     const bobStorageId = await bobRepo.storageId()
 
@@ -40,86 +40,211 @@ describe("DocHandle.remoteHeads", () => {
     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(),
+  describe("multi hop sync", () => {
+    async function setup() {
+      // setup topology: tab -> service worker -> sync server <- service worker <- tab
+      const leftTab1 = new Repo({
+        peerId: "left-tab-1" as PeerId,
+        network: [],
+        sharePolicy: async () => true,
+        enableRemoteHeadsGossiping: true,
+      })
+      const leftTab2 = new Repo({
+        peerId: "left-tab-2" as PeerId,
+        network: [],
+        sharePolicy: async () => true,
+        enableRemoteHeadsGossiping: true,
+      })
+      const leftServiceWorker = new Repo({
+        peerId: "left-service-worker" as PeerId,
+        network: [],
+        sharePolicy: async peer => peer === "sync-server",
+        storage: new DummyStorageAdapter(),
+        isEphemeral: false,
+        enableRemoteHeadsGossiping: true,
+      })
+      const syncServer = new Repo({
+        peerId: "sync-server" as PeerId,
+        network: [],
+        isEphemeral: false,
+        sharePolicy: async () => false,
+        storage: new DummyStorageAdapter(),
+        enableRemoteHeadsGossiping: true,
+      })
+      const rightServiceWorker = new Repo({
+        peerId: "right-service-worker" as PeerId,
+        network: [],
+        sharePolicy: async peer => peer === "sync-server",
+        isEphemeral: false,
+        storage: new DummyStorageAdapter(),
+        enableRemoteHeadsGossiping: true,
+      })
+      const rightTab = new Repo({
+        peerId: "right-tab" as PeerId,
+        network: [],
+        sharePolicy: async () => true,
+        enableRemoteHeadsGossiping: true,
+      })
+
+      // connect them all up
+      connectRepos(leftTab1, leftServiceWorker)
+      connectRepos(leftTab2, leftServiceWorker)
+      connectRepos(leftServiceWorker, syncServer)
+      connectRepos(syncServer, rightServiceWorker)
+      connectRepos(rightServiceWorker, rightTab)
+
+      await setTimeout(100)
+
+      return {
+        leftTab1,
+        leftTab2,
+        leftServiceWorker,
+        syncServer,
+        rightServiceWorker,
+        rightTab,
+      }
+    }
+
+    it("should report remoteHeads for peers", async () => {
+      const { rightTab, rightServiceWorker, leftServiceWorker, leftTab1 } =
+        await setup()
+
+      // 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 = leftTab1.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())
+      )
     })
-    const rightTab = new Repo({
-      peerId: "right-tab" as PeerId,
-      network: [],
-      sharePolicy: async () => true,
+
+    it("should report remoteHeads only for documents the subscriber has open", async () => {
+      const { leftTab1, rightTab, rightServiceWorker } = await setup()
+
+      // subscribe leftTab to storageId of rightServiceWorker
+      leftTab1.subscribeToRemotes([await rightServiceWorker.storageId()!])
+
+      await setTimeout(100)
+
+      // create 2 docs in right tab
+      const rightTabDocA = rightTab.create<TestDoc>()
+      rightTabDocA.change(d => (d.foo = "A"))
+
+      const rightTabDocB = rightTab.create<TestDoc>()
+      rightTabDocB.change(d => (d.foo = "B"))
+
+      // open doc b in left tab 1
+      const leftTabDocA = leftTab1.find<TestDoc>(rightTabDocA.url)
+
+      const remoteHeadsChangedMessages = (
+        await waitForMessages(leftTab1.networkSubsystem, "message")
+      ).filter(({ type }) => type === "remote-heads-changed")
+
+      // we should only be notified of the head changes of doc A
+      const docIds = remoteHeadsChangedMessages.map(d => d.documentId)
+      const uniqueDocIds = [...new Set(docIds)]
+      assert.deepStrictEqual(uniqueDocIds, [leftTabDocA.documentId])
     })
 
-    // connect them all up
-    connectRepos(leftTab, leftServiceWorker)
-    connectRepos(leftServiceWorker, syncServer)
-    connectRepos(syncServer, rightServiceWorker)
-    connectRepos(rightServiceWorker, rightTab)
+    it("should report remote heads for doc on subscribe if peer already knows them", async () => {
+      const { leftTab1, leftTab2, rightTab, rightServiceWorker } = await setup()
 
-    await setTimeout(100)
+      // create 2 docs in right tab
+      const rightTabDocA = rightTab.create<TestDoc>()
+      rightTabDocA.change(d => (d.foo = "A"))
 
-    // subscribe to the left service worker storage ID on the right tab
-    rightTab.subscribeToRemotes([await leftServiceWorker.storageId()!])
+      const rightTabDocB = rightTab.create<TestDoc>()
+      rightTabDocB.change(d => (d.foo = "B"))
 
-    await setTimeout(100)
+      // open docs in left tab 1
+      const leftTab1DocA = leftTab1.find<TestDoc>(rightTabDocA.url)
+      const leftTab1DocB = leftTab1.find<TestDoc>(rightTabDocB.url)
 
-    // create a doc in the left tab
-    const leftTabDoc = leftTab.create<TestDoc>()
-    leftTabDoc.change(d => (d.foo = "bar"))
+      // subscribe leftTab 1 to storageId of rightServiceWorker
+      leftTab1.subscribeToRemotes([await rightServiceWorker.storageId()!])
 
-    // wait for the document to arrive on the right tab
-    const rightTabDoc = rightTab.find<TestDoc>(leftTabDoc.url)
-    await rightTabDoc.whenReady()
+      await setTimeout(200)
 
-    // wait for the document to arrive in the left service worker
-    const leftServiceWorkerDoc = leftServiceWorker.find(leftTabDoc.documentId)
-    await leftServiceWorkerDoc.whenReady()
+      // now the left service worker has the remote heads of the right service worker for both doc A and doc B
+      // if we subscribe from left tab 1 the left service workers should send it's stored remote heads immediately
 
-    const leftServiceWorkerStorageId = await leftServiceWorker.storageId()
-    let leftSeenByRightPromise = new Promise<DocHandleRemoteHeadsPayload>(
-      resolve => {
-        rightTabDoc.on("remote-heads", message => {
-          if (message.storageId === leftServiceWorkerStorageId) {
-            resolve(message)
-          }
-        })
-      }
-    )
+      // open doc and subscribe leftTab 2 to storageId of rightServiceWorker
+      const leftTab2DocA = leftTab2.find<TestDoc>(rightTabDocA.url)
+      leftTab2.subscribeToRemotes([await rightServiceWorker.storageId()!])
+
+      const remoteHeadsChangedMessages = (
+        await waitForMessages(leftTab2.networkSubsystem, "message")
+      ).filter(({ type }) => type === "remote-heads-changed")
+
+      // we should only be notified of the head changes of doc A
+      assert.strictEqual(remoteHeadsChangedMessages.length, 1)
+      assert.strictEqual(
+        remoteHeadsChangedMessages[0].documentId,
+        leftTab1DocA.documentId
+      )
+    })
+
+    it("should report remote heads for subscribed storage id once we open a new doc", async () => {
+      const { leftTab1, leftTab2, rightTab, rightServiceWorker } = await setup()
 
-    // make a change on the right
-    rightTabDoc.change(d => (d.foo = "baz"))
+      // create 2 docs in right tab
+      const rightTabDocA = rightTab.create<TestDoc>()
+      rightTabDocA.change(d => (d.foo = "A"))
 
-    // wait for the change to be acknolwedged by the left
-    const leftSeenByRight = await leftSeenByRightPromise
+      const rightTabDocB = rightTab.create<TestDoc>()
+      rightTabDocB.change(d => (d.foo = "B"))
 
-    assert.deepStrictEqual(
-      leftSeenByRight.heads,
-      A.getHeads(leftServiceWorkerDoc.docSync())
-    )
+      await setTimeout(200)
+
+      // subscribe leftTab 1 to storageId of rightServiceWorker
+      leftTab1.subscribeToRemotes([await rightServiceWorker.storageId()!])
+
+      // in leftTab 1 open doc A
+      const leftTab1DocA = leftTab1.find<TestDoc>(rightTabDocA.url)
+
+      const remoteHeadsChangedMessages = (
+        await waitForMessages(leftTab1.networkSubsystem, "message")
+      ).filter(({ type }) => type === "remote-heads-changed")
+
+      // console.log(JSON.stringify(remoteHeadsChangedMessages, null, 2))
+
+      assert.strictEqual(remoteHeadsChangedMessages.length, 1)
+      assert.strictEqual(
+        remoteHeadsChangedMessages[0].documentId,
+        leftTab1DocA.documentId
+      )
+    })
   })
 })
 

package/.eslintrc

@@ -1,28 +0,0 @@
-{
-  "env": {
-    "browser": true,
-    "es2021": true
-  },
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/eslint-recommended",
-    "plugin:@typescript-eslint/recommended"
-  ],
-  "ignorePatterns": ["dist/**", "test/**", "node_modules/**"],
-  "parser": "@typescript-eslint/parser",
-  "plugins": ["@typescript-eslint"],
-  "parserOptions": {
-    "project": "./tsconfig.json",
-    "ecmaVersion": "latest",
-    "sourceType": "module"
-  },
-  "rules": {
-    "semi": ["error", "never"],
-    "import/extensions": 0,
-    "lines-between-class-members": 0,
-    "@typescript-eslint/no-floating-promises": "error",
-    "@typescript-eslint/no-empty-function": ["warn", { "allow": ["methods"] }],
-    "no-param-reassign": 0,
-    "no-use-before-define": 0
-  }
-}