@automerge/automerge-repo 2.0.0-collectionsync-alpha.1 → 2.0.1

package/dist/test/DocHandle.test.d.ts

@@ -1,2 +0,0 @@
-export {}
-//# sourceMappingURL=DocHandle.test.d.ts.map

package/dist/test/DocHandle.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DocHandle.test.d.ts","sourceRoot":"","sources":["../../test/DocHandle.test.ts"],"names":[],"mappings":""}

package/dist/test/DocHandle.test.js

@@ -1,238 +0,0 @@
-import * as A from "@automerge/automerge/next"
-import assert from "assert"
-import { it } from "mocha"
-import { DocHandle } from "../src/index.js"
-import { pause } from "../src/helpers/pause.js"
-import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
-import { eventPromise } from "../src/helpers/eventPromise.js"
-import { decode } from "cbor-x"
-describe("DocHandle", () => {
-  const TEST_ID = parseAutomergeUrl(generateAutomergeUrl()).documentId
-  const BOGUS_ID = parseAutomergeUrl(generateAutomergeUrl()).documentId
-  const docFromMockStorage = doc => {
-    return A.change(doc, d => (d.foo = "bar"))
-  }
-  it("should take the UUID passed into it", () => {
-    const handle = new DocHandle(TEST_ID)
-    assert.equal(handle.documentId, TEST_ID)
-  })
-  it("should become ready when a document is loaded", async () => {
-    const handle = new DocHandle(TEST_ID)
-    assert.equal(handle.isReady(), false)
-    // simulate loading from storage
-    handle.update(doc => docFromMockStorage(doc))
-    assert.equal(handle.isReady(), true)
-    const doc = await handle.doc()
-    assert.equal(doc?.foo, "bar")
-  })
-  it("should allow sync access to the doc", async () => {
-    const handle = new DocHandle(TEST_ID)
-    assert.equal(handle.isReady(), false)
-    // simulate loading from storage
-    handle.update(doc => docFromMockStorage(doc))
-    assert.equal(handle.isReady(), true)
-    const doc = await handle.doc()
-    assert.deepEqual(doc, handle.docSync())
-  })
-  it("should return undefined if we accessing the doc before ready", async () => {
-    const handle = new DocHandle(TEST_ID)
-    assert.equal(handle.docSync(), undefined)
-  })
-  it("should not return a doc until ready", async () => {
-    const handle = new DocHandle(TEST_ID)
-    assert.equal(handle.isReady(), false)
-    // simulate loading from storage
-    handle.update(doc => docFromMockStorage(doc))
-    const doc = await handle.doc()
-    assert.equal(handle.isReady(), true)
-    assert.equal(doc?.foo, "bar")
-  })
-  it("should block changes until ready()", async () => {
-    const handle = new DocHandle(TEST_ID)
-    // can't make changes in LOADING state
-    assert.equal(handle.isReady(), false)
-    assert.throws(() => handle.change(d => (d.foo = "baz")))
-    // simulate loading from storage
-    handle.update(doc => docFromMockStorage(doc))
-    // now we're in READY state so we can make changes
-    assert.equal(handle.isReady(), true)
-    handle.change(d => (d.foo = "pizza"))
-    const doc = await handle.doc()
-    assert.equal(doc?.foo, "pizza")
-  })
-  it("should not be ready while requesting from the network", async () => {
-    const handle = new DocHandle(TEST_ID)
-    // we don't have it in storage, so we request it from the network
-    handle.request()
-    assert.equal(handle.docSync(), undefined)
-    assert.equal(handle.isReady(), false)
-    assert.throws(() => handle.change(_ => {}))
-  })
-  it("should become ready if the document is updated by the network", async () => {
-    const handle = new DocHandle(TEST_ID)
-    // we don't have it in storage, so we request it from the network
-    handle.request()
-    // simulate updating from the network
-    handle.update(doc => {
-      return A.change(doc, d => (d.foo = "bar"))
-    })
-    const doc = await handle.doc()
-    assert.equal(handle.isReady(), true)
-    assert.equal(doc?.foo, "bar")
-  })
-  it("should emit a change message when changes happen", async () => {
-    const handle = new DocHandle(TEST_ID, { isNew: true })
-    const p = new Promise(resolve => handle.once("change", d => resolve(d)))
-    handle.change(doc => {
-      doc.foo = "bar"
-    })
-    const doc = await handle.doc()
-    assert.equal(doc?.foo, "bar")
-    const changePayload = await p
-    assert.deepStrictEqual(changePayload.doc, doc)
-    assert.deepStrictEqual(changePayload.handle, handle)
-  })
-  it("should not emit a change message if no change happens via update", done => {
-    const handle = new DocHandle(TEST_ID, { isNew: true })
-    handle.once("change", () => {
-      done(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(TEST_ID, { isNew: true })
-    const p = new Promise(resolve =>
-      handle.once("change", ({ handle, doc }) => {
-        assert.equal(handle.docSync()?.foo, doc.foo)
-        resolve()
-      })
-    )
-    handle.change(doc => {
-      doc.foo = "baz"
-    })
-    return p
-  })
-  it("should emit distinct change messages when consecutive changes happen", async () => {
-    const handle = new DocHandle(TEST_ID, { isNew: true })
-    let calls = 0
-    const p = new Promise(resolve =>
-      handle.on("change", async ({ doc: d }) => {
-        if (calls === 0) {
-          assert.equal(d.foo, "bar")
-          calls++
-          return
-        }
-        assert.equal(d.foo, "baz")
-        resolve(d)
-      })
-    )
-    handle.change(doc => {
-      doc.foo = "bar"
-    })
-    handle.change(doc => {
-      doc.foo = "baz"
-    })
-    const doc = await handle.doc()
-    assert.equal(doc?.foo, "baz")
-    return p
-  })
-  it("should emit a change message when changes happen", async () => {
-    const handle = new DocHandle(TEST_ID, { isNew: true })
-    const p = new Promise(resolve => handle.once("change", d => resolve(d)))
-    handle.change(doc => {
-      doc.foo = "bar"
-    })
-    await p
-    const doc = await handle.doc()
-    assert.equal(doc?.foo, "bar")
-  })
-  it("should not emit a patch message if no change happens", done => {
-    const handle = new DocHandle(TEST_ID, { isNew: true })
-    handle.on("change", () => {
-      done(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 () => {
-    // set docHandle time out after 5 ms
-    const handle = new DocHandle(TEST_ID, { timeoutDelay: 5 })
-    // we're not going to load
-    await pause(10)
-    assert.equal(handle.state, "failed")
-    // so it should time out
-    return assert.rejects(handle.doc, "DocHandle timed out")
-  })
-  it("should not time out if the document is loaded in time", async () => {
-    // set docHandle time out after 5 ms
-    const handle = new DocHandle(TEST_ID, { timeoutDelay: 5 })
-    // simulate loading from storage before the timeout expires
-    handle.update(doc => docFromMockStorage(doc))
-    // now it should not time out
-    const doc = await handle.doc()
-    assert.equal(doc?.foo, "bar")
-  })
-  it("should time out if the document is not updated from the network", async () => {
-    // set docHandle time out after 5 ms
-    const handle = new DocHandle(TEST_ID, { timeoutDelay: 5 })
-    // simulate requesting from the network
-    handle.request()
-    // there's no update
-    await pause(10)
-    // so it should time out
-    return assert.rejects(handle.doc, "DocHandle timed out")
-  })
-  it("should not time out if the document is updated in time", async () => {
-    // set docHandle time out after 5 ms
-    const handle = new DocHandle(TEST_ID, { timeoutDelay: 1 })
-    // simulate requesting from the network
-    handle.request()
-    // simulate updating from the network before the timeout expires
-    handle.update(doc => {
-      return A.change(doc, d => (d.foo = "bar"))
-    })
-    // now it should not time out
-    await pause(5)
-    const doc = await handle.doc()
-    assert.equal(doc?.foo, "bar")
-  })
-  it("should emit a delete event when deleted", async () => {
-    const handle = new DocHandle(TEST_ID, { isNew: true })
-    const p = new Promise(resolve => handle.once("delete", () => resolve()))
-    handle.delete()
-    await p
-    assert.equal(handle.isDeleted(), true)
-  })
-  it("should allow changing at old heads", async () => {
-    const handle = new DocHandle(TEST_ID, { isNew: true })
-    handle.change(doc => {
-      doc.foo = "bar"
-    })
-    const headsBefore = A.getHeads(handle.docSync())
-    handle.change(doc => {
-      doc.foo = "rab"
-    })
-    let wasBar = false
-    let newHeads = handle.changeAt(headsBefore, doc => {
-      wasBar = doc.foo === "bar"
-      doc.foo = "baz"
-    })
-    assert(newHeads && newHeads.length > 0, "should have new heads")
-    assert(wasBar, "foo should have been bar as we changed at the old heads")
-  })
-  describe("ephemeral messaging", () => {
-    it("can broadcast a message for the network to send out", async () => {
-      const handle = new DocHandle(TEST_ID, { isNew: true })
-      const message = { foo: "bar" }
-      const promise = eventPromise(handle, "ephemeral-message-outbound")
-      handle.broadcast(message)
-      const { data } = await promise
-      assert.deepStrictEqual(decode(data), message)
-    })
-  })
-})

package/dist/test/DocSynchronizer.test.d.ts

@@ -1,2 +0,0 @@
-export {}
-//# sourceMappingURL=DocSynchronizer.test.d.ts.map

package/dist/test/DocSynchronizer.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DocSynchronizer.test.d.ts","sourceRoot":"","sources":["../../test/DocSynchronizer.test.ts"],"names":[],"mappings":""}

package/dist/test/DocSynchronizer.test.js

@@ -1,111 +0,0 @@
-import assert from "assert"
-import { DocHandle } from "../src/DocHandle.js"
-import { DocSynchronizer } from "../src/synchronizer/DocSynchronizer.js"
-import { eventPromise } from "../src/helpers/eventPromise.js"
-import { parseAutomergeUrl, generateAutomergeUrl } from "../src/DocUrl.js"
-const alice = "alice"
-const bob = "bob"
-const charlie = "charlie"
-describe("DocSynchronizer", () => {
-  let handle
-  let docSynchronizer
-  const setup = () => {
-    const docId = parseAutomergeUrl(generateAutomergeUrl()).documentId
-    handle = new DocHandle(docId, { isNew: true })
-    docSynchronizer = new DocSynchronizer(handle)
-    return { handle, docSynchronizer }
-  }
-  it("takes the handle passed into it", () => {
-    const { handle, docSynchronizer } = setup()
-    assert(docSynchronizer.documentId === handle.documentId)
-  })
-  it("emits a syncMessage when beginSync is called", async () => {
-    const { docSynchronizer } = setup()
-    docSynchronizer.beginSync([alice])
-    const { targetId, type } = await eventPromise(docSynchronizer, "message")
-    assert.equal(type, "sync")
-    assert.equal(targetId, "alice")
-  })
-  it("emits a syncMessage to peers when the handle is updated", async () => {
-    const { handle, docSynchronizer } = setup()
-    docSynchronizer.beginSync([alice])
-    handle.change(doc => {
-      doc.foo = "bar"
-    })
-    const { targetId, type } = await eventPromise(docSynchronizer, "message")
-    assert.equal(targetId, "alice")
-    assert.equal(type, "sync")
-  })
-  it("still syncs with a peer after it disconnects and reconnects", async () => {
-    const { handle, docSynchronizer } = setup()
-    // first connection
-    {
-      docSynchronizer.beginSync([bob])
-      handle.change(doc => {
-        doc.foo = "a change"
-      })
-      const { targetId, type } = await eventPromise(docSynchronizer, "message")
-      assert.equal(targetId, "bob")
-      assert.equal(type, "sync")
-      docSynchronizer.endSync(bob)
-    }
-    // second connection
-    {
-      docSynchronizer.beginSync([bob])
-      handle.change(doc => {
-        doc.foo = "another change"
-      })
-      const { targetId, type } = await eventPromise(docSynchronizer, "message")
-      assert.equal(targetId, "bob")
-      assert.equal(type, "sync")
-    }
-  })
-  it("emits a requestMessage if the local handle is being requested", async () => {
-    const docId = parseAutomergeUrl(generateAutomergeUrl()).documentId
-    const handle = new DocHandle(docId, { isNew: false })
-    docSynchronizer = new DocSynchronizer(handle)
-    docSynchronizer.beginSync([alice])
-    handle.request()
-    const message = await eventPromise(docSynchronizer, "message")
-    assert.equal(message.targetId, "alice")
-    assert.equal(message.type, "request")
-  })
-  it("emits the correct sequence of messages when a document is not found then not available", async () => {
-    const docId = parseAutomergeUrl(generateAutomergeUrl()).documentId
-    const bobHandle = new DocHandle(docId, { isNew: false })
-    const bobDocSynchronizer = new DocSynchronizer(bobHandle)
-    bobDocSynchronizer.beginSync([alice])
-    bobHandle.request()
-    const message = await eventPromise(bobDocSynchronizer, "message")
-    const aliceHandle = new DocHandle(docId, { isNew: false })
-    const aliceDocSynchronizer = new DocSynchronizer(aliceHandle)
-    aliceHandle.request()
-    aliceDocSynchronizer.receiveSyncMessage({ ...message, senderId: bob })
-    aliceDocSynchronizer.beginSync([charlie, bob])
-    const [charlieMessage, bobMessage] = await new Promise(resolve => {
-      const messages = []
-      aliceDocSynchronizer.on("message", message => {
-        messages.push(message)
-        if (messages.length === 2) {
-          resolve(messages)
-        }
-      })
-    })
-    // the response should be a sync message, not a request message
-    assert.equal(charlieMessage.targetId, "charlie")
-    assert.equal(charlieMessage.type, "request")
-    assert.equal(bobMessage.targetId, "bob")
-    assert.equal(bobMessage.type, "sync")
-    const docUnavailableMessage = {
-      type: "doc-unavailable",
-      targetId: alice,
-      senderId: charlie,
-      documentId: docId,
-    }
-    const p = eventPromise(aliceDocSynchronizer, "message")
-    aliceDocSynchronizer.receiveMessage(docUnavailableMessage)
-    const message2 = await p
-    assert.equal(message2.targetId, "bob")
-    assert.equal(message2.type, "doc-unavailable")
-  })
-})

package/dist/test/Network.test.d.ts

@@ -1,2 +0,0 @@
-export {}
-//# sourceMappingURL=Network.test.d.ts.map

package/dist/test/Network.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Network.test.d.ts","sourceRoot":"","sources":["../../test/Network.test.ts"],"names":[],"mappings":""}

package/dist/test/Network.test.js

@@ -1,11 +0,0 @@
-import assert from "assert"
-import { NetworkSubsystem } from "../src/network/NetworkSubsystem.js"
-// Note: The sync tests in `Repo.test.ts` exercise the network subsystem, and the suite in
-// `automerge-repo` provides test utilities that individual adapters can
-// use to ensure that they work correctly.
-describe("Network subsystem", () => {
-  it("Can be instantiated", () => {
-    const network = new NetworkSubsystem([])
-    assert(network !== null)
-  })
-})

package/dist/test/Repo.test.d.ts

@@ -1,2 +0,0 @@
-export {}
-//# sourceMappingURL=Repo.test.d.ts.map

package/dist/test/Repo.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Repo.test.d.ts","sourceRoot":"","sources":["../../test/Repo.test.ts"],"names":[],"mappings":""}