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

package/src/synchronizer/DocSynchronizer.ts

@@ -137,11 +137,13 @@ export class DocSynchronizer extends Synchronizer {
 
     let pendingCallbacks = this.#pendingSyncStateCallbacks[peerId]
     if (!pendingCallbacks) {
-      this.#onLoadSyncState(peerId).then(syncState => {
-        this.#initSyncState(peerId, syncState ?? A.initSyncState())
-      }).catch(err => {
-        this.#log(`Error loading sync state for ${peerId}: ${err}`)
-      })
+      this.#onLoadSyncState(peerId)
+        .then(syncState => {
+          this.#initSyncState(peerId, syncState ?? A.initSyncState())
+        })
+        .catch(err => {
+          this.#log(`Error loading sync state for ${peerId}: ${err}`)
+        })
       pendingCallbacks = this.#pendingSyncStateCallbacks[peerId] = []
     }
 
@@ -262,13 +264,15 @@ export class DocSynchronizer extends Synchronizer {
         )
         this.#setSyncState(peerId, reparsedSyncState)
 
-        docPromise.then(doc => {
-          if (doc) {
-            this.#sendSyncMessage(peerId, doc)
-          }
-        }).catch(err => {
-          this.#log(`Error loading doc for ${peerId}: ${err}`)
-        })
+        docPromise
+          .then(doc => {
+            if (doc) {
+              this.#sendSyncMessage(peerId, doc)
+            }
+          })
+          .catch(err => {
+            this.#log(`Error loading doc for ${peerId}: ${err}`)
+          })
       })
     })
   }
@@ -330,10 +334,10 @@ export class DocSynchronizer extends Synchronizer {
     }
 
     this.#processAllPendingSyncMessages()
-    this.#processSyncMessage(message, new Date())
+    this.#processSyncMessage(message)
   }
 
-  #processSyncMessage(message: SyncMessage | RequestMessage, received: Date) {
+  #processSyncMessage(message: SyncMessage | RequestMessage) {
     if (isRequestMessage(message)) {
       this.#peerDocumentStatuses[message.senderId] = "wants"
     }
@@ -392,7 +396,7 @@ export class DocSynchronizer extends Synchronizer {
 
   #processAllPendingSyncMessages() {
     for (const message of this.#pendingSyncMessages) {
-      this.#processSyncMessage(message.message, message.received)
+      this.#processSyncMessage(message.message)
     }
 
     this.#pendingSyncMessages = []

package/src/synchronizer/Synchronizer.ts

@@ -3,15 +3,23 @@ import {
   MessageContents,
   OpenDocMessage,
   RepoMessage,
-  SyncStateMessage,
 } from "../network/messages.js"
+import { SyncState } from "@automerge/automerge"
+import { PeerId, DocumentId } from "../types.js"
 
 export abstract class Synchronizer extends EventEmitter<SynchronizerEvents> {
   abstract receiveMessage(message: RepoMessage): void
 }
 
 export interface SynchronizerEvents {
-  message: (arg: MessageContents) => void
-  "sync-state": (arg: SyncStateMessage) => void
+  message: (payload: MessageContents) => void
+  "sync-state": (payload: SyncStatePayload) => void
   "open-doc": (arg: OpenDocMessage) => void
 }
+
+/** Notify the repo that the sync state has changed  */
+export interface SyncStatePayload {
+  peerId: PeerId
+  documentId: DocumentId
+  syncState: SyncState
+}

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

@@ -5,7 +5,7 @@ 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, 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)

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,5 +1,5 @@
 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"
@@ -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()
 

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