@automerge/automerge-repo 1.0.6 → 1.0.7

package/src/synchronizer/DocSynchronizer.ts

@@ -1,28 +1,26 @@
 import * as A from "@automerge/automerge/next"
+import { decode } from "cbor-x"
+import debug from "debug"
 import {
-  AWAITING_NETWORK,
   DocHandle,
   DocHandleOutboundEphemeralMessagePayload,
   READY,
   REQUESTING,
   UNAVAILABLE,
 } from "../DocHandle.js"
-import { PeerId } from "../types.js"
-import { Synchronizer } from "./Synchronizer.js"
-
-import debug from "debug"
 import {
+  DocumentUnavailableMessage,
   EphemeralMessage,
-  isDocumentUnavailableMessage,
-  isRequestMessage,
-  Message,
+  RepoMessage,
+  MessageContents,
   RequestMessage,
-  SynchronizerMessage,
   SyncMessage,
+  isRequestMessage,
 } from "../network/messages.js"
+import { PeerId } from "../types.js"
+import { Synchronizer } from "./Synchronizer.js"
 
 type PeerDocumentStatus = "unknown" | "has" | "unavailable" | "wants"
-import { decode } from "cbor-x"
 
 /**
  * DocSynchronizer takes a handle to an Automerge document, and receives & dispatches sync messages
@@ -45,7 +43,7 @@ export class DocSynchronizer extends Synchronizer {
 
   #syncStarted = false
 
-  constructor(private handle: DocHandle<any>) {
+  constructor(private handle: DocHandle<unknown>) {
     super()
     const docId = handle.documentId.slice(0, 5)
     this.#conciseLog = debug(`automerge-repo:concise:docsync:${docId}`) // Only logs one line per receive/send
@@ -82,7 +80,9 @@ export class DocSynchronizer extends Synchronizer {
     this.#peers.forEach(peerId => this.#sendSyncMessage(peerId, doc))
   }
 
-  async #broadcastToPeers({ data }: DocHandleOutboundEphemeralMessagePayload) {
+  async #broadcastToPeers({
+    data,
+  }: DocHandleOutboundEphemeralMessagePayload<unknown>) {
     this.#log(`broadcastToPeers`, this.#peers)
     this.#peers.forEach(peerId => this.#sendEphemeralMessage(peerId, data))
   }
@@ -90,12 +90,13 @@ export class DocSynchronizer extends Synchronizer {
   #sendEphemeralMessage(peerId: PeerId, data: Uint8Array) {
     this.#log(`sendEphemeralMessage ->${peerId}`)
 
-    this.emit("message", {
+    const message: MessageContents<EphemeralMessage> = {
       type: "ephemeral",
       targetId: peerId,
       documentId: this.handle.documentId,
       data,
-    })
+    }
+    this.emit("message", message)
   }
 
   #getSyncState(peerId: PeerId) {
@@ -128,13 +129,11 @@ export class DocSynchronizer extends Synchronizer {
     const [newSyncState, message] = A.generateSyncMessage(doc, syncState)
     this.#setSyncState(peerId, newSyncState)
     if (message) {
-      this.#logMessage(`sendSyncMessage 🡒 ${peerId}`, message)
-
-      const decoded = A.decodeSyncMessage(message)
+      const isNew = A.getHeads(doc).length === 0
 
       if (
         !this.handle.isReady() &&
-        decoded.heads.length === 0 &&
+        isNew &&
         newSyncState.sharedHeads.length === 0 &&
         !Object.values(this.#peerDocumentStatuses).includes("has") &&
         this.#peerDocumentStatuses[peerId] === "unknown"
@@ -145,43 +144,23 @@ export class DocSynchronizer extends Synchronizer {
           targetId: peerId,
           documentId: this.handle.documentId,
           data: message,
-        })
+        } as RequestMessage)
       } else {
         this.emit("message", {
           type: "sync",
           targetId: peerId,
           data: message,
           documentId: this.handle.documentId,
-        })
+        } as SyncMessage)
       }
 
       // if we have sent heads, then the peer now has or will have the document
-      if (decoded.heads.length > 0) {
+      if (!isNew) {
         this.#peerDocumentStatuses[peerId] = "has"
       }
     }
   }
 
-  #logMessage = (label: string, message: Uint8Array) => {
-    // This is real expensive...
-    return
-
-    const size = message.byteLength
-    const logText = `${label} ${size}b`
-    const decoded = A.decodeSyncMessage(message)
-
-    this.#conciseLog(logText)
-    this.#log(logText, decoded)
-
-    // expanding is expensive, so only do it if we're logging at this level
-    const expanded = this.#opsLog.enabled
-      ? decoded.changes.flatMap((change: A.Change) =>
-        A.decodeChange(change).ops.map((op: any) => JSON.stringify(op))
-      )
-      : null
-    this.#opsLog(logText, expanded)
-  }
-
   /// PUBLIC
 
   hasPeer(peerId: PeerId) {
@@ -189,6 +168,7 @@ export class DocSynchronizer extends Synchronizer {
   }
 
   beginSync(peerIds: PeerId[]) {
+    const newPeers = new Set(peerIds.filter(peerId => !this.#peers.includes(peerId)))
     this.#log(`beginSync: ${peerIds.join(", ")}`)
 
     // HACK: if we have a sync state already, we round-trip it through the encoding system to make
@@ -204,15 +184,20 @@ export class DocSynchronizer extends Synchronizer {
     // At this point if we don't have anything in our storage, we need to use an empty doc to sync
     // with; but we don't want to surface that state to the front end
     void this.handle.doc([READY, REQUESTING, UNAVAILABLE]).then(doc => {
-
       // we register out peers first, then say that sync has started
       this.#syncStarted = true
       this.#checkDocUnavailable()
 
-      if (doc === undefined) return
+      const wasUnavailable = doc === undefined
+      if (wasUnavailable && newPeers.size == 0) {
+        return
+      }
+      // If the doc is unavailable we still need a blank document to generate
+      // the sync message from
+      const theDoc = doc ?? A.init<unknown>()
 
       peerIds.forEach(peerId => {
-        this.#sendSyncMessage(peerId, doc)
+        this.#sendSyncMessage(peerId, theDoc)
       })
     })
   }
@@ -222,7 +207,7 @@ export class DocSynchronizer extends Synchronizer {
     this.#peers = this.#peers.filter(p => p !== peerId)
   }
 
-  receiveMessage(message: SynchronizerMessage) {
+  receiveMessage(message: RepoMessage) {
     switch (message.type) {
       case "sync":
       case "request":
@@ -246,7 +231,7 @@ export class DocSynchronizer extends Synchronizer {
 
     const { senderId, data } = message
 
-    const contents = decode(data)
+    const contents = decode(new Uint8Array(data))
 
     this.handle.emit("ephemeral-message", {
       handle: this.handle,
@@ -320,11 +305,12 @@ export class DocSynchronizer extends Synchronizer {
       this.#peers
         .filter(peerId => this.#peerDocumentStatuses[peerId] === "wants")
         .forEach(peerId => {
-          this.emit("message", {
+          const message: MessageContents<DocumentUnavailableMessage> = {
             type: "doc-unavailable",
             documentId: this.handle.documentId,
             targetId: peerId,
-          })
+          }
+          this.emit("message", message)
         })
 
       this.handle.unavailable()

package/src/synchronizer/Synchronizer.ts

@@ -1,8 +1,8 @@
 import { EventEmitter } from "eventemitter3"
-import { Message, MessageContents } from "../network/messages.js"
+import { RepoMessage, MessageContents } from "../network/messages.js"
 
 export abstract class Synchronizer extends EventEmitter<SynchronizerEvents> {
-  abstract receiveMessage(message: Message): void
+  abstract receiveMessage(message: RepoMessage): void
 }
 
 export interface SynchronizerEvents {

package/src/types.ts

@@ -1,17 +1,22 @@
 /** The ID of a document. Typically you should use a {@link AutomergeUrl} instead.
  */
 export type DocumentId = string & { __documentId: true } // for logging
-/** A branded string representing a URL for a document 
+
+/** A branded string representing a URL for a document
  *
  * @remarks
- * An automerge URL has the form `automerge:<base58 encoded string>`. This 
+ * An automerge URL has the form `automerge:<base58 encoded string>`. This
  * type is returned from various routines which validate a url.
  *
  */
 export type AutomergeUrl = string & { __documentUrl: true } // for opening / linking
+
 /** A document ID as a Uint8Array instead of a bas58 encoded string. Typically you should use a {@link AutomergeUrl} instead.
  */
 export type BinaryDocumentId = Uint8Array & { __binaryDocumentId: true } // for storing / syncing
 
 /** A branded type for peer IDs */
-export type PeerId = string & { __peerId: false }
+export type PeerId = string & { __peerId: true }
+
+/** A randomly generated string created when the {@link Repo} starts up */
+export type SessionId = string & { __SessionId: true }

package/test/CollectionSynchronizer.test.ts

@@ -1,5 +1,5 @@
 import assert from "assert"
-import { beforeEach } from "mocha"
+import { describe, it, beforeEach } from "vitest"
 import { PeerId, Repo } from "../src/index.js"
 import { CollectionSynchronizer } from "../src/synchronizer/CollectionSynchronizer.js"
 
@@ -18,56 +18,61 @@ describe("CollectionSynchronizer", () => {
     assert(synchronizer !== null)
   })
 
-  it("starts synchronizing a document to peers when added", done => {
-    const handle = repo.create()
-    synchronizer.addPeer("peer1" as PeerId)
-
-    synchronizer.once("message", event => {
-      assert(event.targetId === "peer1")
-      assert(event.documentId === handle.documentId)
-      done()
-    })
-
-    synchronizer.addDocument(handle.documentId)
-  })
-
-  it("starts synchronizing existing documents when a peer is added", done => {
-    const handle = repo.create()
-    synchronizer.addDocument(handle.documentId)
-    synchronizer.once("message", event => {
-      assert(event.targetId === "peer1")
-      assert(event.documentId === handle.documentId)
-      done()
-    })
-    synchronizer.addPeer("peer1" as PeerId)
-  })
-
-  it("should not synchronize to a peer which is excluded from the share policy", done => {
-    const handle = repo.create()
-
-    repo.sharePolicy = async (peerId: PeerId) => peerId !== "peer1"
-
-    synchronizer.addDocument(handle.documentId)
-    synchronizer.once("message", () => {
-      done(new Error("Should not have sent a message"))
-    })
-    synchronizer.addPeer("peer1" as PeerId)
-
-    setTimeout(done)
-  })
-
-  it("should not synchronize a document which is excluded from the share policy", done => {
-    const handle = repo.create()
-    repo.sharePolicy = async (_, documentId) => documentId !== handle.documentId
-
-    synchronizer.addPeer("peer2" as PeerId)
-
-    synchronizer.once("message", () => {
-      done(new Error("Should not have sent a message"))
-    })
-
-    synchronizer.addDocument(handle.documentId)
-
-    setTimeout(done)
-  })
+  it("starts synchronizing a document to peers when added", () =>
+    new Promise<void>(done => {
+      const handle = repo.create()
+      synchronizer.addPeer("peer1" as PeerId)
+
+      synchronizer.once("message", event => {
+        assert(event.targetId === "peer1")
+        assert(event.documentId === handle.documentId)
+        done()
+      })
+
+      synchronizer.addDocument(handle.documentId)
+    }))
+
+  it("starts synchronizing existing documents when a peer is added", () =>
+    new Promise<void>(done => {
+      const handle = repo.create()
+      synchronizer.addDocument(handle.documentId)
+      synchronizer.once("message", event => {
+        assert(event.targetId === "peer1")
+        assert(event.documentId === handle.documentId)
+        done()
+      })
+      synchronizer.addPeer("peer1" as PeerId)
+    }))
+
+  it("should not synchronize to a peer which is excluded from the share policy", () =>
+    new Promise<void>((done, reject) => {
+      const handle = repo.create()
+
+      repo.sharePolicy = async (peerId: PeerId) => peerId !== "peer1"
+
+      synchronizer.addDocument(handle.documentId)
+      synchronizer.once("message", () => {
+        reject(new Error("Should not have sent a message"))
+      })
+      synchronizer.addPeer("peer1" as PeerId)
+
+      setTimeout(done)
+    }))
+
+  it("should not synchronize a document which is excluded from the share policy", () =>
+    new Promise<void>((done, reject) => {
+      const handle = repo.create()
+      repo.sharePolicy = async (_, documentId) =>
+        documentId !== handle.documentId
+
+      synchronizer.addPeer("peer2" as PeerId)
+
+      synchronizer.once("message", () => {
+        reject(new Error("Should not have sent a message"))
+      })
+
+      synchronizer.addDocument(handle.documentId)
+
+      setTimeout(done)
+    }))
 })

package/test/DocHandle.test.ts

@@ -1,16 +1,15 @@
 import * as A from "@automerge/automerge/next"
+import { decode } from "cbor-x"
 import assert from "assert"
-import { it } from "mocha"
-import { DocHandle, DocHandleChangePayload } from "../src/index.js"
-import { pause } from "../src/helpers/pause.js"
-import { TestDoc } from "./types.js"
+import { describe, it } from "vitest"
 import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
-import { decode } from "cbor-x"
+import { pause } from "../src/helpers/pause.js"
+import { DocHandle, DocHandleChangePayload } from "../src/index.js"
+import { TestDoc } from "./types.js"
 
 describe("DocHandle", () => {
   const TEST_ID = parseAutomergeUrl(generateAutomergeUrl()).documentId
-  const BOGUS_ID = parseAutomergeUrl(generateAutomergeUrl()).documentId
 
   const docFromMockStorage = (doc: A.Doc<{ foo: string }>) => {
     return A.change<{ foo: string }>(doc, d => (d.foo = "bar"))
@@ -90,7 +89,7 @@ describe("DocHandle", () => {
 
     assert.equal(handle.docSync(), undefined)
     assert.equal(handle.isReady(), false)
-    assert.throws(() => handle.change(_ => { }))
+    assert.throws(() => handle.change(_ => {}))
   })
 
   it("should become ready if the document is updated by the network", async () => {
@@ -128,16 +127,17 @@ describe("DocHandle", () => {
     assert.deepStrictEqual(changePayload.handle, handle)
   })
 
-  it("should not emit a change message if no change happens via update", done => {
-    const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
-    handle.once("change", () => {
-      done(new Error("shouldn't have changed"))
-    })
-    handle.update(d => {
-      setTimeout(done, 0)
-      return d
-    })
-  })
+  it("should not emit a change message if no change happens via update", () =>
+    new Promise<void>((done, reject) => {
+      const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
+      handle.once("change", () => {
+        reject(new Error("shouldn't have changed"))
+      })
+      handle.update(d => {
+        setTimeout(done, 0)
+        return d
+      })
+    }))
 
   it("should update the internal doc prior to emitting the change message", async () => {
     const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
@@ -200,28 +200,27 @@ describe("DocHandle", () => {
     assert.equal(doc?.foo, "bar")
   })
 
-  it("should not emit a patch message if no change happens", done => {
-    const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
-    handle.on("change", () => {
-      done(new Error("shouldn't have changed"))
-    })
-    handle.change(_doc => {
-      // do nothing
-      setTimeout(done, 0)
-    })
-  })
+  it("should not emit a patch message if no change happens", () =>
+    new Promise<void>((done, reject) => {
+      const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
+      handle.on("change", () => {
+        reject(new Error("shouldn't have changed"))
+      })
+      handle.change(_doc => {
+        // do nothing
+        setTimeout(done, 0)
+      })
+    }))
 
-  it("should time out if the document is not loaded", async () => {
+  it("should be undefined if loading the document times out", async () => {
     // set docHandle time out after 5 ms
     const handle = new DocHandle<TestDoc>(TEST_ID, { timeoutDelay: 5 })
 
-    // we're not going to load
-    await pause(10)
+    const doc = await handle.doc()
 
-    assert.equal(handle.state, "failed")
+    assert.equal(doc, undefined)
 
-    // so it should time out
-    return assert.rejects(handle.doc, "DocHandle timed out")
+    assert.equal(handle.state, "failed")
   })
 
   it("should not time out if the document is loaded in time", async () => {
@@ -236,7 +235,7 @@ describe("DocHandle", () => {
     assert.equal(doc?.foo, "bar")
   })
 
-  it("should time out if the document is not updated from the network", async () => {
+  it("should be undefined if loading from the network times out", async () => {
     // set docHandle time out after 5 ms
     const handle = new DocHandle<TestDoc>(TEST_ID, { timeoutDelay: 5 })
 
@@ -246,8 +245,8 @@ describe("DocHandle", () => {
     // there's no update
     await pause(10)
 
-    // so it should time out
-    return assert.rejects(handle.doc, "DocHandle timed out")
+    const doc = await handle.doc()
+    assert.equal(doc, undefined)
   })
 
   it("should not time out if the document is updated in time", async () => {

package/test/DocSynchronizer.test.ts

@@ -1,18 +1,19 @@
 import assert from "assert"
-import { BinaryDocumentId, PeerId } from "../src/types.js"
+import { describe, it } from "vitest"
 import { DocHandle } from "../src/DocHandle.js"
-import { DocSynchronizer } from "../src/synchronizer/DocSynchronizer.js"
+import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
+import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
-import { TestDoc } from "./types.js"
-import { parseAutomergeUrl, generateAutomergeUrl } from "../src/DocUrl.js"
-import { SyncMessage } from "../src/index.js"
 import {
   DocumentUnavailableMessage,
-  DocumentUnavailableMessageContents,
   MessageContents,
-  RequestMessageContents,
-  SyncMessageContents,
 } from "../src/network/messages.js"
+import { DocSynchronizer } from "../src/synchronizer/DocSynchronizer.js"
+import { PeerId } from "../src/types.js"
+import { TestDoc } from "./types.js"
+import { DocSynchronizer } from "../src/synchronizer/DocSynchronizer.js"
+import { PeerId } from "../src/types.js"
+import { TestDoc } from "./types.js"
 
 const alice = "alice" as PeerId
 const bob = "bob" as PeerId

package/test/Network.test.ts

@@ -1,4 +1,5 @@
 import assert from "assert"
+import { describe, it } from "vitest"
 import { NetworkSubsystem } from "../src/network/NetworkSubsystem.js"
 
 // Note: The sync tests in `Repo.test.ts` exercise the network subsystem, and the suite in