@automerge/automerge-repo 1.0.5 → 1.0.7

package/test/Repo.test.ts

@@ -1,7 +1,13 @@
-import assert from "assert"
 import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel"
-import { BroadcastChannelNetworkAdapter } from "@automerge/automerge-repo-network-broadcastchannel"
-
+import assert from "assert"
+import * as Uuid from "uuid"
+import { describe, it } from "vitest"
+import { parseAutomergeUrl } from "../dist/DocUrl.js"
+import { READY } from "../src/DocHandle.js"
+import { generateAutomergeUrl, stringifyAutomergeUrl } from "../src/DocUrl.js"
+import { Repo } from "../src/Repo.js"
+import { eventPromise } from "../src/helpers/eventPromise.js"
+import { pause } from "../src/helpers/pause.js"
 import {
   AutomergeUrl,
   DocHandle,
@@ -9,22 +15,14 @@ import {
   PeerId,
   SharePolicy,
 } from "../src/index.js"
-import { eventPromise } from "../src/helpers/eventPromise.js"
-import { pause, rejectOnTimeout } from "../src/helpers/pause.js"
-import { Repo } from "../src/Repo.js"
 import { DummyNetworkAdapter } from "./helpers/DummyNetworkAdapter.js"
 import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
-import { getRandomItem } from "./helpers/getRandomItem.js"
-import { TestDoc } from "./types.js"
-import { generateAutomergeUrl, stringifyAutomergeUrl } from "../src/DocUrl.js"
-import { READY, AWAITING_NETWORK } from "../src/DocHandle.js"
 import {
-  generateLargeObject,
   LargeObject,
+  generateLargeObject,
 } from "./helpers/generate-large-object.js"
-import { parseAutomergeUrl } from "../dist/DocUrl.js"
-
-import * as Uuid from "uuid"
+import { getRandomItem } from "./helpers/getRandomItem.js"
+import { TestDoc } from "./types.js"
 
 describe("Repo", () => {
   describe("single repo", () => {
@@ -66,6 +64,8 @@ describe("Repo", () => {
     })
 
     it("can find a document using a legacy UUID (for now)", () => {
+      disableConsoleWarn()
+
       const { repo } = setup()
       const handle = repo.create<TestDoc>()
       handle.change((d: TestDoc) => {
@@ -79,6 +79,8 @@ describe("Repo", () => {
       const handle2 = repo.find(legacyDocumentId)
       assert.equal(handle, handle2)
       assert.deepEqual(handle2.docSync(), { foo: "bar" })
+
+      reenableConsoleWarn()
     })
 
     it("can change a document", async () => {
@@ -93,6 +95,65 @@ describe("Repo", () => {
       assert.equal(v?.foo, "bar")
     })
 
+    it("can clone a document", () => {
+      const { repo } = setup()
+      const handle = repo.create<TestDoc>()
+      handle.change(d => {
+        d.foo = "bar"
+      })
+      const handle2 = repo.clone(handle)
+      assert.equal(handle2.isReady(), true)
+      assert.notEqual(handle.documentId, handle2.documentId)
+      assert.deepStrictEqual(handle.docSync(), handle2.docSync())
+      assert.deepStrictEqual(handle2.docSync(), { foo: "bar" })
+    })
+
+    it("the cloned documents are distinct", () => {
+      const { repo } = setup()
+      const handle = repo.create<TestDoc>()
+      handle.change(d => {
+        d.foo = "bar"
+      })
+      const handle2 = repo.clone(handle)
+
+      handle.change(d => {
+        d.bar = "bif"
+      })
+      handle2.change(d => {
+        d.baz = "baz"
+      })
+
+      assert.notDeepStrictEqual(handle.docSync(), handle2.docSync())
+      assert.deepStrictEqual(handle.docSync(), { foo: "bar", bar: "bif" })
+      assert.deepStrictEqual(handle2.docSync(), { foo: "bar", baz: "baz" })
+    })
+
+    it("the cloned documents can merge", () => {
+      const { repo } = setup()
+      const handle = repo.create<TestDoc>()
+      handle.change(d => {
+        d.foo = "bar"
+      })
+      const handle2 = repo.clone(handle)
+
+      handle.change(d => {
+        d.bar = "bif"
+      })
+      handle2.change(d => {
+        d.baz = "baz"
+      })
+
+      handle.merge(handle2)
+
+      assert.deepStrictEqual(handle.docSync(), {
+        foo: "bar",
+        bar: "bif",
+        baz: "baz",
+      })
+      // only the one handle should be changed
+      assert.deepStrictEqual(handle2.docSync(), { foo: "bar", baz: "baz" })
+    })
+
     it("throws an error if we try to find a handle with an invalid AutomergeUrl", async () => {
       const { repo } = setup()
       try {
@@ -198,19 +259,14 @@ describe("Repo", () => {
       })
       // we now have a snapshot and an incremental change in storage
       assert.equal(handle.isReady(), true)
-      await handle.doc()
+      const foo = await handle.doc()
+      assert.equal(foo?.foo, "bar")
+
+      await pause()
       repo.delete(handle.documentId)
 
       assert(handle.isDeleted())
       assert.equal(repo.handles[handle.documentId], undefined)
-
-      const bobHandle = repo.find<TestDoc>(handle.url)
-      await assert.rejects(
-        rejectOnTimeout(bobHandle.doc(), 10),
-        "document should have been deleted"
-      )
-
-      assert(!bobHandle.isReady())
     })
 
     it("can delete an existing document by url", async () => {
@@ -221,36 +277,31 @@ describe("Repo", () => {
       })
       assert.equal(handle.isReady(), true)
       await handle.doc()
+
+      await pause()
       repo.delete(handle.url)
 
       assert(handle.isDeleted())
       assert.equal(repo.handles[handle.documentId], undefined)
-
-      const bobHandle = repo.find<TestDoc>(handle.url)
-      await assert.rejects(
-        rejectOnTimeout(bobHandle.doc(), 10),
-        "document should have been deleted"
-      )
-
-      assert(!bobHandle.isReady())
     })
 
-    it("deleting a document emits an event", async done => {
-      const { repo } = setup()
-      const handle = repo.create<TestDoc>()
-      handle.change(d => {
-        d.foo = "bar"
-      })
-      assert.equal(handle.isReady(), true)
+    it("deleting a document emits an event", async () =>
+      new Promise<void>(done => {
+        const { repo } = setup()
+        const handle = repo.create<TestDoc>()
+        handle.change(d => {
+          d.foo = "bar"
+        })
+        assert.equal(handle.isReady(), true)
 
-      repo.on("delete-document", ({ documentId }) => {
-        assert.equal(documentId, handle.documentId)
+        repo.on("delete-document", ({ documentId }) => {
+          assert.equal(documentId, handle.documentId)
 
-        done()
-      })
+          done()
+        })
 
-      repo.delete(handle.documentId)
-    })
+        repo.delete(handle.documentId)
+      }))
 
     it("storage state doesn't change across reloads when the document hasn't changed", async () => {
       const storage = new DummyStorageAdapter()
@@ -344,16 +395,16 @@ describe("Repo", () => {
       return true
     }
 
-    const setupRepos = (connectAlice = true) => {
+    const setupLinearNetwork = (connectAlice = true) => {
       // Set up three repos; connect Alice to Bob, and Bob to Charlie
 
-      const aliceBobChannel = new MessageChannel()
-      const bobCharlieChannel = new MessageChannel()
+      const abChannel = new MessageChannel()
+      const bcChannel = new MessageChannel()
 
-      const { port1: aliceToBob, port2: bobToAlice } = aliceBobChannel
-      const { port1: bobToCharlie, port2: charlieToBob } = bobCharlieChannel
+      const { port1: ab, port2: ba } = abChannel
+      const { port1: bc, port2: cb } = bcChannel
 
-      const aliceNetworkAdapter = new MessageChannelNetworkAdapter(aliceToBob)
+      const aliceNetworkAdapter = new MessageChannelNetworkAdapter(ab)
 
       const aliceRepo = new Repo({
         network: connectAlice ? [aliceNetworkAdapter] : [],
@@ -363,26 +414,26 @@ describe("Repo", () => {
 
       const bobRepo = new Repo({
         network: [
-          new MessageChannelNetworkAdapter(bobToAlice),
-          new MessageChannelNetworkAdapter(bobToCharlie),
+          new MessageChannelNetworkAdapter(ba),
+          new MessageChannelNetworkAdapter(bc),
         ],
         peerId: "bob" as PeerId,
         sharePolicy,
       })
 
       const charlieRepo = new Repo({
-        network: [new MessageChannelNetworkAdapter(charlieToBob)],
+        network: [new MessageChannelNetworkAdapter(cb)],
         peerId: "charlie" as PeerId,
       })
 
       const teardown = () => {
-        aliceBobChannel.port1.close()
-        bobCharlieChannel.port1.close()
+        abChannel.port1.close()
+        bcChannel.port1.close()
       }
 
       function doConnectAlice() {
         aliceRepo.networkSubsystem.addNetworkAdapter(
-          new MessageChannelNetworkAdapter(aliceToBob)
+          new MessageChannelNetworkAdapter(ab)
         )
         //bobRepo.networkSubsystem.addNetworkAdapter(new MessageChannelNetworkAdapter(bobToAlice))
       }
@@ -400,9 +451,60 @@ describe("Repo", () => {
       }
     }
 
+    const setupMeshNetwork = () => {
+      // Set up three repos; connect Alice to Bob, Bob to Charlie, and Alice to Charlie
+
+      const abChannel = new MessageChannel()
+      const bcChannel = new MessageChannel()
+      const acChannel = new MessageChannel()
+
+      const { port1: ab, port2: ba } = abChannel
+      const { port1: bc, port2: cb } = bcChannel
+      const { port1: ac, port2: ca } = acChannel
+
+      const aliceRepo = new Repo({
+        network: [
+          new MessageChannelNetworkAdapter(ab),
+          new MessageChannelNetworkAdapter(ac),
+        ],
+        peerId: "alice" as PeerId,
+        sharePolicy,
+      })
+
+      const bobRepo = new Repo({
+        network: [
+          new MessageChannelNetworkAdapter(ba),
+          new MessageChannelNetworkAdapter(bc),
+        ],
+        peerId: "bob" as PeerId,
+        sharePolicy,
+      })
+
+      const charlieRepo = new Repo({
+        network: [
+          new MessageChannelNetworkAdapter(ca),
+          new MessageChannelNetworkAdapter(cb),
+        ],
+        peerId: "charlie" as PeerId,
+      })
+
+      const teardown = () => {
+        abChannel.port1.close()
+        bcChannel.port1.close()
+        acChannel.port1.close()
+      }
+
+      return {
+        teardown,
+        aliceRepo,
+        bobRepo,
+        charlieRepo,
+      }
+    }
+
     const setup = async (connectAlice = true) => {
       const { teardown, aliceRepo, bobRepo, charlieRepo, connectAliceToBob } =
-        setupRepos(connectAlice)
+        setupLinearNetwork(connectAlice)
 
       const aliceHandle = aliceRepo.create<TestDoc>()
       aliceHandle.change(d => {
@@ -561,6 +663,56 @@ describe("Repo", () => {
       teardown()
     })
 
+    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
+      // case attempting to `Repo.find` a document which is not in the storage
+      // will result in an unavailable document. If a peer is later announced
+      // on the NetworkAdapter we should attempt to sync with the new peer and
+      // if the new peer has the document, the DocHandle should eventually
+      // transition to "ready"
+
+      // first create a repo with no network adapter and add a document so that
+      // we have a storage containing the document to pass to a new repo later
+      const storage = new DummyStorageAdapter()
+      const isolatedRepo = new Repo({
+        network: [],
+        storage,
+      })
+      const unsyncedHandle = isolatedRepo.create<TestDoc>()
+      const url = unsyncedHandle.url
+
+      // Now create a message channel to connect two repos
+      const abChannel = new MessageChannel()
+      const { port1: ab, port2: ba } = abChannel
+
+      // Create an empty repo to request the document from
+      const a = new Repo({
+        network: [new MessageChannelNetworkAdapter(ab)],
+        peerId: "a" as PeerId,
+        sharePolicy: async () => true
+      })
+
+      const handle = a.find(url)
+
+      // We expect this to be unavailable as there is no connected peer and
+      // the repo has no storage.
+      await eventPromise(handle, "unavailable")
+
+      // Now create a repo pointing at the storage containing the document and
+      // connect it to the other end of the MessageChannel
+      const b = new Repo({
+        storage,
+        peerId: "b" as PeerId,
+        network: [new MessageChannelNetworkAdapter(ba)],
+      })
+
+      // The empty repo should be notified of the new peer, send it a request
+      // and eventually resolve the handle to "READY"
+      await handle.whenReady()
+
+    })
+
     it("a deleted document from charlieRepo can be refetched", async () => {
       const { charlieRepo, aliceHandle, teardown } = await setup()
 
@@ -583,34 +735,8 @@ describe("Repo", () => {
       teardown()
     })
 
-    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)
-
-      return {
-        aliceRepo,
-        bobRepo,
-        charlieRepo,
-      }
-    }
-
     it("can emit an 'unavailable' event when it's not found on the network", async () => {
-      const { charlieRepo } = await setupMeshNetwork()
+      const { charlieRepo } = setupMeshNetwork()
 
       const url = generateAutomergeUrl()
       const handle = charlieRepo.find<TestDoc>(url)
@@ -689,10 +815,8 @@ describe("Repo", () => {
     })
 
     it("can broadcast a message without entering into an infinite loop", async () => {
-      const { aliceRepo, bobRepo, charlieRepo } = await setupMeshNetwork()
+      const { aliceRepo, bobRepo, charlieRepo } = setupMeshNetwork()
 
-      // pause to let the network set up
-      await pause(50)
       const message = { presence: "alex" }
 
       const aliceHandle = aliceRepo.create<TestDoc>()
@@ -706,7 +830,7 @@ describe("Repo", () => {
         }, 100)
 
         aliceHandle.on("ephemeral-message", () => {
-          reject("alice got the message")
+          reject(new Error("alice got the message"))
         })
       })
 
@@ -726,5 +850,66 @@ describe("Repo", () => {
       assert.deepStrictEqual(bob.message, message)
       assert.deepStrictEqual(charlie.message, message)
     })
+
+    it("notifies peers when a document is cloned", async () => {
+      const { bobRepo, charlieRepo } = setupMeshNetwork()
+
+      // pause to let the network set up
+      await pause(50)
+
+      const handle = bobRepo.create<TestDoc>()
+      handle.change(d => {
+        d.foo = "bar"
+      })
+      const handle2 = bobRepo.clone(handle)
+
+      // pause to let the sync happen
+      await pause(50)
+
+      const charlieHandle = charlieRepo.find(handle2.url)
+      await charlieHandle.doc()
+      assert.deepStrictEqual(charlieHandle.docSync(), { foo: "bar" })
+    })
+
+    it("notifies peers when a document is merged", async () => {
+      const { bobRepo, charlieRepo } = setupMeshNetwork()
+
+      // pause to let the network set up
+      await pause(50)
+
+      const handle = bobRepo.create<TestDoc>()
+      handle.change(d => {
+        d.foo = "bar"
+      })
+      const handle2 = bobRepo.clone(handle)
+
+      // pause to let the sync happen
+      await pause(50)
+
+      const charlieHandle = charlieRepo.find(handle2.url)
+      await charlieHandle.doc()
+      assert.deepStrictEqual(charlieHandle.docSync(), { foo: "bar" })
+
+      // now make a change to doc2 on bobs side and merge it into doc1
+      handle2.change(d => {
+        d.foo = "baz"
+      })
+      handle.merge(handle2)
+
+      // wait for the network to do it's thang
+      await pause(50)
+
+      await charlieHandle.doc()
+      assert.deepStrictEqual(charlieHandle.docSync(), { foo: "baz" })
+    })
   })
 })
+
+const disableConsoleWarn = () => {
+  console["_warn"] = console.warn
+  console.warn = () => {}
+}
+
+const reenableConsoleWarn = () => {
+  console.warn = console["_warn"]
+}

package/test/StorageSubsystem.test.ts

@@ -1,16 +1,13 @@
+import { NodeFSStorageAdapter } from "@automerge/automerge-repo-storage-nodefs"
+import * as A from "@automerge/automerge/next"
+import assert from "assert"
 import fs from "fs"
 import os from "os"
 import path from "path"
-
-import assert from "assert"
-
-import * as A from "@automerge/automerge/next"
-
-import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
-import { NodeFSStorageAdapter } from "@automerge/automerge-repo-storage-nodefs"
-
-import { StorageSubsystem } from "../src/storage/StorageSubsystem.js"
+import { describe, it } from "vitest"
 import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
+import { StorageSubsystem } from "../src/storage/StorageSubsystem.js"
+import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
 
 const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "automerge-repo-tests"))
 

package/test/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "Node16",
+    "noEmit": true
+  },
+  "include": ["**/*.ts"]
+}

package/test/types.ts

@@ -1,3 +1,5 @@
 export interface TestDoc {
   foo: string
+  bar?: string
+  baz?: string
 }

package/typedoc.json

@@ -1,5 +1,5 @@
 {
-    "extends": "../../typedoc.base.json",
-    "entryPoints": ["src/index.ts"],
-    "readme": "none"
+  "extends": ["../../typedoc.base.json"],
+  "entryPoints": ["src/index.ts"],
+  "readme": "none"
 }

package/.mocharc.json

@@ -1,5 +0,0 @@
-{
-  "extension": ["ts"],
-  "spec": "test/*.test.ts",
-  "loader": "ts-node/esm"
-}