@automerge/automerge-repo 1.1.0-alpha.7 → 1.1.1

package/test/CollectionSynchronizer.test.ts

@@ -1,6 +1,6 @@
 import assert from "assert"
 import { beforeEach, describe, it } from "vitest"
-import { PeerId, Repo } from "../src/index.js"
+import { PeerId, Repo, SyncMessage } from "../src/index.js"
 import { CollectionSynchronizer } from "../src/synchronizer/CollectionSynchronizer.js"
 
 describe("CollectionSynchronizer", () => {
@@ -24,8 +24,9 @@ describe("CollectionSynchronizer", () => {
       synchronizer.addPeer("peer1" as PeerId)
 
       synchronizer.once("message", event => {
-        assert(event.targetId === "peer1")
-        assert(event.documentId === handle.documentId)
+        const { targetId, documentId } = event as SyncMessage
+        assert(targetId === "peer1")
+        assert(documentId === handle.documentId)
         done()
       })
 
@@ -37,8 +38,9 @@ describe("CollectionSynchronizer", () => {
       const handle = repo.create()
       synchronizer.addDocument(handle.documentId)
       synchronizer.once("message", event => {
-        assert(event.targetId === "peer1")
-        assert(event.documentId === handle.documentId)
+        const { targetId, documentId } = event as SyncMessage
+        assert(targetId === "peer1")
+        assert(documentId === handle.documentId)
         done()
       })
       synchronizer.addPeer("peer1" as PeerId)

package/test/DocHandle.test.ts

@@ -1,11 +1,11 @@
 import * as A from "@automerge/automerge/next"
 import assert from "assert"
 import { decode } from "cbor-x"
-import { describe, it } from "vitest"
+import { describe, it, vi } 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, DocHandleChangePayload, PeerId } from "../src/index.js"
+import { DocHandle, DocHandleChangePayload } from "../src/index.js"
 import { TestDoc } from "./types.js"
 
 describe("DocHandle", () => {
@@ -20,6 +20,15 @@ describe("DocHandle", () => {
     assert.equal(handle.documentId, TEST_ID)
   })
 
+  it("should take an initial value", async () => {
+    const handle = new DocHandle(TEST_ID, {
+      isNew: true,
+      initialValue: { foo: "bar" },
+    })
+    const doc = await handle.doc()
+    assert.equal(doc.foo, "bar")
+  })
+
   it("should become ready when a document is loaded", async () => {
     const handle = new DocHandle<TestDoc>(TEST_ID)
     assert.equal(handle.isReady(), false)
@@ -44,7 +53,7 @@ describe("DocHandle", () => {
     assert.deepEqual(doc, handle.docSync())
   })
 
-  it("should return undefined if we accessing the doc before ready", async () => {
+  it("should return undefined if we access the doc before ready", async () => {
     const handle = new DocHandle<TestDoc>(TEST_ID)
 
     assert.equal(handle.docSync(), undefined)
@@ -63,6 +72,29 @@ describe("DocHandle", () => {
     assert.equal(doc?.foo, "bar")
   })
 
+  /**
+   * Once there's a Repo#stop API this case should be covered in accompanying
+   * tests and the following test removed.
+   */
+  it("no pending timers after a document is loaded", async () => {
+    vi.useFakeTimers()
+    const timerCount = vi.getTimerCount()
+
+    const handle = new DocHandle<TestDoc>(TEST_ID)
+    assert.equal(handle.isReady(), false)
+
+    handle.doc()
+
+    assert(vi.getTimerCount() > timerCount)
+
+    // simulate loading from storage
+    handle.update(doc => docFromMockStorage(doc))
+
+    assert.equal(handle.isReady(), true)
+    assert.equal(vi.getTimerCount(), timerCount)
+    vi.useRealTimers()
+  })
+
   it("should block changes until ready()", async () => {
     const handle = new DocHandle<TestDoc>(TEST_ID)
 

package/test/RemoteHeadsSubscriptions.test.ts

@@ -8,7 +8,7 @@ import {
   RemoteHeadsChanged,
   RemoteSubscriptionControlMessage,
 } from "../src/network/messages.js"
-import { waitForMessages } from "./helpers/waitForMessages.js"
+import { collectMessages } from "./helpers/collectMessages.js"
 
 describe("RepoHeadsSubscriptions", () => {
   const storageA = "remote-a" as StorageId
@@ -86,15 +86,15 @@ describe("RepoHeadsSubscriptions", () => {
   it("should allow to subscribe and unsubscribe to storage ids", async () => {
     const remoteHeadsSubscriptions = new RemoteHeadsSubscriptions()
 
-    const remoteHeadsMessages = waitForMessages(
-      remoteHeadsSubscriptions,
-      "remote-heads-changed"
-    )
+    const remoteHeadsMessages = collectMessages({
+      emitter: remoteHeadsSubscriptions,
+      event: "remote-heads-changed",
+    })
 
-    const changeRemoteSubsAfterSubscribe = waitForMessages(
-      remoteHeadsSubscriptions,
-      "change-remote-subs"
-    )
+    const changeRemoteSubsAfterSubscribe = collectMessages({
+      emitter: remoteHeadsSubscriptions,
+      event: "change-remote-subs",
+    })
 
     // subscribe to storageB and change storageB heads
     remoteHeadsSubscriptions.subscribeToRemotes([storageB])
@@ -114,10 +114,10 @@ describe("RepoHeadsSubscriptions", () => {
     assert.deepStrictEqual(messages[0].remove, undefined)
     assert.deepStrictEqual(messages[0].peers, [])
 
-    const remoteHeadsMessagesAfterUnsub = waitForMessages(
-      remoteHeadsSubscriptions,
-      "change-remote-subs"
-    )
+    const remoteHeadsMessagesAfterUnsub = collectMessages({
+      emitter: remoteHeadsSubscriptions,
+      event: "change-remote-subs",
+    })
 
     // unsubscribe from storageB
     remoteHeadsSubscriptions.unsubscribeFromRemotes([storageB])
@@ -133,15 +133,15 @@ describe("RepoHeadsSubscriptions", () => {
   it("should forward all changes to generous peers", async () => {
     const remoteHeadsSubscriptions = new RemoteHeadsSubscriptions()
 
-    const notifyRemoteHeadsMessagesPromise = waitForMessages(
-      remoteHeadsSubscriptions,
-      "notify-remote-heads"
-    )
+    const notifyRemoteHeadsMessagesPromise = collectMessages({
+      emitter: remoteHeadsSubscriptions,
+      event: "notify-remote-heads",
+    })
 
-    const changeRemoteSubsMessagesPromise = waitForMessages(
-      remoteHeadsSubscriptions,
-      "change-remote-subs"
-    )
+    const changeRemoteSubsMessagesPromise = collectMessages({
+      emitter: remoteHeadsSubscriptions,
+      event: "change-remote-subs",
+    })
 
     remoteHeadsSubscriptions.addGenerousPeer(peerC)
     remoteHeadsSubscriptions.subscribeToRemotes([storageB])
@@ -170,10 +170,10 @@ describe("RepoHeadsSubscriptions", () => {
     assert.deepStrictEqual(messages[0].remove, undefined)
     assert.deepStrictEqual(messages[0].peers, [peerC])
 
-    const changeRemoteSubsMessagesAfterUnsubPromise = waitForMessages(
-      remoteHeadsSubscriptions,
-      "change-remote-subs"
-    )
+    const changeRemoteSubsMessagesAfterUnsubPromise = collectMessages({
+      emitter: remoteHeadsSubscriptions,
+      event: "change-remote-subs",
+    })
 
     // unsubsscribe from storage B
     remoteHeadsSubscriptions.unsubscribeFromRemotes([storageB])
@@ -189,10 +189,10 @@ describe("RepoHeadsSubscriptions", () => {
   it("should not notify generous peers of changed remote heads, if they send the heads originally", async () => {
     const remoteHeadsSubscriptions = new RemoteHeadsSubscriptions()
 
-    const messagesPromise = waitForMessages(
-      remoteHeadsSubscriptions,
-      "notify-remote-heads"
-    )
+    const messagesPromise = collectMessages({
+      emitter: remoteHeadsSubscriptions,
+      event: "notify-remote-heads",
+    })
 
     remoteHeadsSubscriptions.addGenerousPeer(peerC)
     remoteHeadsSubscriptions.subscribeToRemotes([storageB])
@@ -219,10 +219,10 @@ describe("RepoHeadsSubscriptions", () => {
 
     // subscribe peer c to storage b
     remoteHeadsSubscriptions.handleControlMessage(subscribePeerCToStorageB)
-    const messagesAfterSubscribePromise = waitForMessages(
-      remoteHeadsSubscriptions,
-      "notify-remote-heads"
-    )
+    const messagesAfterSubscribePromise = collectMessages({
+      emitter: remoteHeadsSubscriptions,
+      event: "notify-remote-heads",
+    })
     remoteHeadsSubscriptions.subscribePeerToDoc(peerC, docA)
     remoteHeadsSubscriptions.subscribePeerToDoc(peerC, docC)
 
@@ -248,10 +248,10 @@ describe("RepoHeadsSubscriptions", () => {
 
     // unsubscribe peer C
     remoteHeadsSubscriptions.handleControlMessage(unsubscribePeerCFromStorageB)
-    const messagesAfteUnsubscribePromise = waitForMessages(
-      remoteHeadsSubscriptions,
-      "notify-remote-heads"
-    )
+    const messagesAfteUnsubscribePromise = collectMessages({
+      emitter: remoteHeadsSubscriptions,
+      event: "notify-remote-heads",
+    })
 
     // heads of docB for storageB change
     remoteHeadsSubscriptions.handleRemoteHeads(docBHeadsChangedForStorageB)
@@ -267,10 +267,10 @@ describe("RepoHeadsSubscriptions", () => {
 
     // subscribe peer c to storage b
     remoteHeadsSubscriptions.handleControlMessage(subscribePeerCToStorageB)
-    const messagesAfterSubscribePromise = waitForMessages(
-      remoteHeadsSubscriptions,
-      "notify-remote-heads"
-    )
+    const messagesAfterSubscribePromise = collectMessages({
+      emitter: remoteHeadsSubscriptions,
+      event: "notify-remote-heads",
+    })
 
     // change message for docA in storageB
     remoteHeadsSubscriptions.handleRemoteHeads(docAHeadsChangedForStorageB)
@@ -290,10 +290,10 @@ describe("RepoHeadsSubscriptions", () => {
   it("should only notify of sync states with a more recent timestamp", async () => {
     const remoteHeadsSubscription = new RemoteHeadsSubscriptions()
 
-    const messagesPromise = waitForMessages(
-      remoteHeadsSubscription,
-      "remote-heads-changed"
-    )
+    const messagesPromise = collectMessages({
+      emitter: remoteHeadsSubscription,
+      event: "remote-heads-changed",
+    })
 
     remoteHeadsSubscription.subscribeToRemotes([storageB])
     remoteHeadsSubscription.handleRemoteHeads(docBHeadsChangedForStorageB2)
@@ -314,10 +314,10 @@ describe("RepoHeadsSubscriptions", () => {
   it("should remove subs of disconnected peers", async () => {
     const remoteHeadsSubscriptions = new RemoteHeadsSubscriptions()
 
-    const messagesPromise = waitForMessages(
-      remoteHeadsSubscriptions,
-      "change-remote-subs"
-    )
+    const messagesPromise = collectMessages({
+      emitter: remoteHeadsSubscriptions,
+      event: "change-remote-subs",
+    })
 
     remoteHeadsSubscriptions.handleControlMessage({
       type: "remote-subscription-change",

package/test/Repo.test.ts

@@ -1,9 +1,9 @@
 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, expect, it } from "vitest"
-import { READY } from "../src/DocHandle.js"
+import { HandleState, READY } from "../src/DocHandle.js"
 import { parseAutomergeUrl } from "../src/AutomergeUrl.js"
 import {
   generateAutomergeUrl,
@@ -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()
 
@@ -985,6 +1023,37 @@ describe("Repo", () => {
     })
   })
 
+
+  it('peer receives a document when connection is recovered', async () => {
+    const alice = "alice" as PeerId;
+    const bob = "bob" as PeerId;
+    const [aliceAdapter, bobAdapter] = DummyNetworkAdapter.createConnectedPair();
+    const aliceRepo = new Repo({
+      network: [aliceAdapter],
+      peerId: alice
+    })
+    const bobRepo = new Repo({
+      network: [bobAdapter],
+      peerId: bob
+    })
+
+    const aliceDoc = aliceRepo.create();
+    aliceDoc.change((doc: any) => doc.text = 'Hello world');
+
+    const bobDoc = bobRepo.find(aliceDoc.url);
+    bobDoc.unavailable()
+    await bobDoc.whenReady([HandleState.UNAVAILABLE]);
+
+    aliceAdapter.peerCandidate(bob);
+    // Bob isn't yet connected to Alice and can't respond to her sync message
+    await pause(100);
+    bobAdapter.peerCandidate(alice);
+
+    await bobDoc.whenReady([HandleState.READY]);
+
+    assert.equal(bobDoc.isReady(), true);
+  });
+
   describe("with peers (mesh network)", () => {
     const setup = async () => {
       // Set up three repos; connect Alice to Bob, Bob to Charlie, and Alice to Charlie

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/DummyNetworkAdapter.ts

@@ -1,21 +1,53 @@
-import { NetworkAdapter } from "../../src/index.js"
+import { pause } from "../../src/helpers/pause.js";
+import { Message, NetworkAdapter, PeerId } from "../../src/index.js"
 
 export class DummyNetworkAdapter extends NetworkAdapter {
   #startReady: boolean
+  #sendMessage?: SendMessageFn;
 
-  constructor({ startReady = true }: Options = {}) {
+  constructor(opts: Options = {startReady: true}) {
     super()
-    this.#startReady = startReady
+    this.#startReady = opts.startReady;
+    this.#sendMessage = opts.sendMessage;
   }
-  send() {}
+
   connect(_: string) {
     if (this.#startReady) {
       this.emit("ready", { network: this })
     }
   }
+
   disconnect() {}
+
+  peerCandidate(peerId: PeerId) {
+    this.emit('peer-candidate', { peerId, peerMetadata: {} });
+  }
+
+  override send(message: Message) {
+    this.#sendMessage?.(message);
+  }
+
+  receive(message: Message) {
+    this.emit('message', message);
+  }
+
+  static createConnectedPair() {
+    const adapter1: DummyNetworkAdapter = new DummyNetworkAdapter({
+      startReady: true,
+      sendMessage: (message: Message) => pause(10).then(() => adapter2.receive(message)),
+    });
+    const adapter2: DummyNetworkAdapter = new DummyNetworkAdapter({
+      startReady: true,
+      sendMessage: (message: Message) => pause(10).then(() => adapter1.receive(message)),
+    });
+
+    return [adapter1, adapter2];
+  }
 }
 
+type SendMessageFn = (message: Message) => void;
+
 type Options = {
-  startReady?: boolean
+  startReady?: boolean;
+  sendMessage?: SendMessageFn;
 }

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