@automerge/automerge-repo 1.1.0-alpha.6 → 1.1.0

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()
@@ -57,6 +67,13 @@ describe("Repo", () => {
       assert.equal(handle.isReady(), true)
     })
 
+    it("can create a document with an initial value", async () => {
+      const { repo } = setup()
+      const handle = repo.create({ foo: "bar" })
+      await handle.doc()
+      assert.equal(handle.docSync().foo, "bar")
+    })
+
     it("can find a document by url", () => {
       const { repo } = setup()
       const handle = repo.create<TestDoc>()
@@ -321,6 +338,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 +434,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/collectMessages.ts

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

package/test/remoteHeads.test.ts

@@ -1,8 +1,7 @@
-import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel"
 import * as A from "@automerge/automerge/next"
 import assert from "assert"
-import { setTimeout } from "timers/promises"
 import { describe, it } from "vitest"
+import { MessageChannelNetworkAdapter } from "../../automerge-repo-network-messagechannel/dist/index.js"
 import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
 import {
@@ -12,7 +11,7 @@ import {
   Repo,
 } from "../src/index.js"
 import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
-import { waitForMessages } from "./helpers/waitForMessages.js"
+import { collectMessages } from "./helpers/collectMessages.js"
 import { TestDoc } from "./types.js"
 
 describe("DocHandle.remoteHeads", () => {
@@ -24,6 +23,7 @@ describe("DocHandle.remoteHeads", () => {
       peerId: "bob" as PeerId,
       network: [],
       storage: new DummyStorageAdapter(),
+      enableRemoteHeadsGossiping: true,
     })
     const bobStorageId = await bobRepo.storageId()
 
@@ -41,23 +41,26 @@ describe("DocHandle.remoteHeads", () => {
 
   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,
+      // setup topology: alice -> service worker -> sync server <- service worker <- bob
+      const alice = new Repo({
+        peerId: "alice-tab-1" as PeerId,
         network: [],
         sharePolicy: async () => true,
+        enableRemoteHeadsGossiping: true,
       })
-      const leftTab2 = new Repo({
-        peerId: "left-tab-2" as PeerId,
+      const alice2 = new Repo({
+        peerId: "alice-tab-2" as PeerId,
         network: [],
         sharePolicy: async () => true,
+        enableRemoteHeadsGossiping: true,
       })
-      const leftServiceWorker = new Repo({
-        peerId: "left-service-worker" as PeerId,
+      const aliceServiceWorker = new Repo({
+        peerId: "alice-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,
@@ -65,191 +68,209 @@ describe("DocHandle.remoteHeads", () => {
         isEphemeral: false,
         sharePolicy: async () => false,
         storage: new DummyStorageAdapter(),
+        enableRemoteHeadsGossiping: true,
       })
-      const rightServiceWorker = new Repo({
-        peerId: "right-service-worker" as PeerId,
+      const bobServiceWorker = new Repo({
+        peerId: "bob-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,
+      const bob = new Repo({
+        peerId: "bob-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)
+      await Promise.all([
+        connectRepos(alice, aliceServiceWorker),
+        connectRepos(alice2, aliceServiceWorker),
+        connectRepos(aliceServiceWorker, syncServer),
+        connectRepos(syncServer, bobServiceWorker),
+        connectRepos(bobServiceWorker, bob),
+      ])
+
+      const alice1StorageId = await aliceServiceWorker.storageId()
+      const alice2StorageId = await aliceServiceWorker.storageId()
+      const aliceServiceWorkerStorageId = await aliceServiceWorker.storageId()
+      const syncServerStorageId = await syncServer.storageId()
+      const bobServiceWorkerStorageId = await bobServiceWorker.storageId()
+      const bobStorageId = await bobServiceWorker.storageId()
 
       return {
-        leftTab1,
-        leftTab2,
-        leftServiceWorker,
+        alice,
+        alice2,
+        aliceServiceWorker,
         syncServer,
-        rightServiceWorker,
-        rightTab,
+        bobServiceWorker,
+        bob,
+        alice1StorageId,
+        alice2StorageId,
+        aliceServiceWorkerStorageId,
+        syncServerStorageId,
+        bobServiceWorkerStorageId,
+        bobStorageId,
       }
     }
 
     it("should report remoteHeads for peers", async () => {
-      const { rightTab, rightServiceWorker, leftServiceWorker, leftTab1 } =
+      const { bob, aliceServiceWorkerStorageId, aliceServiceWorker, alice } =
         await setup()
 
-      // subscribe to the left service worker storage ID on the right tab
-      rightTab.subscribeToRemotes([await leftServiceWorker.storageId()!])
-
-      await setTimeout(100)
+      // bob subscribes to alice's service worker's storageId
+      bob.subscribeToRemotes([aliceServiceWorkerStorageId])
 
-      // create a doc in the left tab
-      const leftTabDoc = leftTab1.create<TestDoc>()
-      leftTabDoc.change(d => (d.foo = "bar"))
+      // alice creates a doc
+      const aliceDoc = alice.create<TestDoc>()
+      aliceDoc.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()
+      // bob waits for the document to arrive
+      const bobDoc = bob.find<TestDoc>(aliceDoc.url)
+      await bobDoc.whenReady()
 
-      // wait for the document to arrive in the left service worker
-      const leftServiceWorkerDoc = leftServiceWorker.find(leftTabDoc.documentId)
-      await leftServiceWorkerDoc.whenReady()
+      // alice's service worker waits for the document to arrive
+      const aliceServiceWorkerDoc = aliceServiceWorker.find(aliceDoc.documentId)
+      await aliceServiceWorkerDoc.whenReady()
 
-      const leftServiceWorkerStorageId = await leftServiceWorker.storageId()
-      let leftSeenByRightPromise = new Promise<DocHandleRemoteHeadsPayload>(
+      let aliceSeenByBobPromise = new Promise<DocHandleRemoteHeadsPayload>(
         resolve => {
-          rightTabDoc.on("remote-heads", message => {
-            if (message.storageId === leftServiceWorkerStorageId) {
+          bobDoc.on("remote-heads", message => {
+            if (message.storageId === aliceServiceWorkerStorageId) {
               resolve(message)
             }
           })
         }
       )
 
-      // make a change on the right
-      rightTabDoc.change(d => (d.foo = "baz"))
+      // bob makes a change
+      bobDoc.change(d => (d.foo = "baz"))
 
-      // wait for the change to be acknolwedged by the left
-      const leftSeenByRight = await leftSeenByRightPromise
+      // wait for alice's service worker to acknowledge the change
+      const { heads } = await aliceSeenByBobPromise
 
-      assert.deepStrictEqual(
-        leftSeenByRight.heads,
-        A.getHeads(leftServiceWorkerDoc.docSync())
-      )
+      assert.deepStrictEqual(heads, A.getHeads(aliceServiceWorkerDoc.docSync()))
     })
 
     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()!])
+      const { alice, bob, bobServiceWorkerStorageId } = await setup()
 
-      await setTimeout(100)
+      // alice subscribes to bob's service worker
+      alice.subscribeToRemotes([bobServiceWorkerStorageId])
 
-      // create 2 docs in right tab
-      const rightTabDocA = rightTab.create<TestDoc>()
-      rightTabDocA.change(d => (d.foo = "A"))
+      // bob creates two docs
+      const bobDocA = bob.create<TestDoc>()
+      bobDocA.change(d => (d.foo = "A"))
 
-      const rightTabDocB = rightTab.create<TestDoc>()
-      rightTabDocB.change(d => (d.foo = "B"))
+      const bobDocB = bob.create<TestDoc>()
+      bobDocB.change(d => (d.foo = "B"))
 
-      // open doc b in left tab 1
-      const leftTabDocA = leftTab1.find<TestDoc>(rightTabDocA.url)
+      // alice opens doc A
+      const aliceDocA = alice.find<TestDoc>(bobDocA.url)
 
       const remoteHeadsChangedMessages = (
-        await waitForMessages(leftTab1.networkSubsystem, "message")
+        await collectMessages({
+          emitter: alice.networkSubsystem,
+          event: "message",
+          until: aliceDocA.whenReady(),
+        })
       ).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,
-        leftTabDocA.documentId
+      assert(
+        remoteHeadsChangedMessages.every(
+          d => d.documentId === aliceDocA.documentId
+        )
       )
     })
 
     it("should report remote heads for doc on subscribe if peer already knows them", async () => {
-      const { leftTab1, leftTab2, rightTab, rightServiceWorker } = await setup()
+      const { alice, alice2, bob, bobServiceWorkerStorageId } = await setup()
 
-      // create 2 docs in right tab
-      const rightTabDocA = rightTab.create<TestDoc>()
-      rightTabDocA.change(d => (d.foo = "A"))
+      // bob creates 2 docs
+      const bobDocA = bob.create<TestDoc>()
+      bobDocA.change(d => (d.foo = "A"))
 
-      const rightTabDocB = rightTab.create<TestDoc>()
-      rightTabDocB.change(d => (d.foo = "B"))
+      const bobDocB = bob.create<TestDoc>()
+      bobDocB.change(d => (d.foo = "B"))
 
-      // open docs in left tab 1
-      const leftTab1DocA = leftTab1.find<TestDoc>(rightTabDocA.url)
-      const leftTab1DocB = leftTab1.find<TestDoc>(rightTabDocB.url)
+      // alice opens the docs
+      const _aliceDocA = alice.find<TestDoc>(bobDocA.url)
+      const _aliceDocB = alice.find<TestDoc>(bobDocB.url)
 
-      // subscribe leftTab 1 to storageId of rightServiceWorker
-      leftTab1.subscribeToRemotes([await rightServiceWorker.storageId()!])
+      // alice subscribes to bob's service worker
+      alice.subscribeToRemotes([bobServiceWorkerStorageId])
 
-      await setTimeout(200)
+      // Now alice's service worker has the remote heads of bob's service worker for both doc A and
+      // doc B. If alice subscribes to bob's service worker, bob's service worker should send its
+      // stored remote heads immediately.
 
-      // 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
-
-      // open doc and subscribe leftTab 2 to storageId of rightServiceWorker
-      const leftTab2DocA = leftTab2.find<TestDoc>(rightTabDocA.url)
-      leftTab2.subscribeToRemotes([await rightServiceWorker.storageId()!])
+      // open doc and subscribe alice's second tab to bob's service worker
+      const alice2DocA = alice2.find<TestDoc>(bobDocA.url)
+      alice2.subscribeToRemotes([bobServiceWorkerStorageId])
 
       const remoteHeadsChangedMessages = (
-        await waitForMessages(leftTab2.networkSubsystem, "message")
+        await collectMessages({
+          emitter: alice2.networkSubsystem,
+          event: "message",
+          until: alice2DocA.whenReady(),
+        })
       ).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
+      assert.strictEqual(remoteHeadsChangedMessages.length, 2)
+      assert(
+        remoteHeadsChangedMessages.every(
+          d => d.documentId === alice2DocA.documentId
+        )
       )
     })
 
     it("should report remote heads for subscribed storage id once we open a new doc", async () => {
-      const { leftTab1, leftTab2, rightTab, rightServiceWorker } = await setup()
-
-      // create 2 docs in right tab
-      const rightTabDocA = rightTab.create<TestDoc>()
-      rightTabDocA.change(d => (d.foo = "A"))
+      const { alice, bob, bobServiceWorkerStorageId } = await setup()
 
-      const rightTabDocB = rightTab.create<TestDoc>()
-      rightTabDocB.change(d => (d.foo = "B"))
+      // bob creates 2 docs
+      const bobDocA = bob.create<TestDoc>()
+      bobDocA.change(d => (d.foo = "A"))
 
-      await setTimeout(200)
+      const bobDocB = bob.create<TestDoc>()
+      bobDocB.change(d => (d.foo = "B"))
 
-      // subscribe leftTab 1 to storageId of rightServiceWorker
-      leftTab1.subscribeToRemotes([await rightServiceWorker.storageId()!])
+      // alice subscribes to bob's service worker
+      alice.subscribeToRemotes([bobServiceWorkerStorageId])
 
-      // in leftTab 1 open doc A
-      const leftTab1DocA = leftTab1.find<TestDoc>(rightTabDocA.url)
+      // alice opens doc A
+      const alice1DocA = alice.find<TestDoc>(bobDocA.url)
 
       const remoteHeadsChangedMessages = (
-        await waitForMessages(leftTab1.networkSubsystem, "message")
+        await collectMessages({
+          emitter: alice.networkSubsystem,
+          event: "message",
+          until: alice1DocA.whenReady(),
+        })
       ).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
+      assert.strictEqual(remoteHeadsChangedMessages.length, 2)
+      assert(
+        remoteHeadsChangedMessages.every(
+          d => d.documentId === alice1DocA.documentId
+        )
       )
     })
   })
 })
 
-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)
-  )
+async function connectRepos(a: Repo, b: Repo) {
+  const { port1: a2b, port2: b2a } = new MessageChannel()
+  const aAdapter = new MessageChannelNetworkAdapter(a2b)
+  const bAdapter = new MessageChannelNetworkAdapter(b2a)
+  a.networkSubsystem.addNetworkAdapter(aAdapter)
+  b.networkSubsystem.addNetworkAdapter(bAdapter)
+  await Promise.all([
+    eventPromise(a.networkSubsystem, "ready"),
+    eventPromise(b.networkSubsystem, "ready"),
+  ])
 }

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
-  }
-}

package/test/helpers/waitForMessages.ts

@@ -1,22 +0,0 @@
-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
-}