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

package/test/DocHandle.test.ts

@@ -1,13 +1,16 @@
-import * as A from "@automerge/automerge/next"
+import { next as A } from "@automerge/automerge"
 import assert from "assert"
 import { decode } from "cbor-x"
-import { describe, it, vi } from "vitest"
-import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
+import { describe, expect, it, vi } from "vitest"
+import {
+  encodeHeads,
+  generateAutomergeUrl,
+  parseAutomergeUrl,
+} from "../src/AutomergeUrl.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
 import { pause } from "../src/helpers/pause.js"
 import { DocHandle, DocHandleChangePayload } from "../src/index.js"
 import { TestDoc } from "./types.js"
-import { UNLOADED } from "../src/DocHandle.js"
 
 describe("DocHandle", () => {
   const TEST_ID = parseAutomergeUrl(generateAutomergeUrl()).documentId
@@ -35,7 +38,7 @@ describe("DocHandle", () => {
     handle.update(doc => docFromMockStorage(doc))
 
     assert.equal(handle.isReady(), true)
-    const doc = await handle.doc()
+    const doc = handle.doc()
     assert.equal(doc?.foo, "bar")
   })
 
@@ -47,13 +50,13 @@ describe("DocHandle", () => {
     handle.update(doc => docFromMockStorage(doc))
 
     assert.equal(handle.isReady(), true)
-    const doc = await handle.doc()
-    assert.deepEqual(doc, handle.docSync())
+    const doc = handle.doc()
+    assert.deepEqual(doc, handle.doc())
   })
 
-  it("should return undefined if we access the doc before ready", async () => {
+  it("should throw an exception if we access the doc before ready", async () => {
     const handle = new DocHandle<TestDoc>(TEST_ID)
-    assert.equal(handle.docSync(), undefined)
+    assert.throws(() => handle.doc())
   })
 
   it("should not return a doc until ready", async () => {
@@ -63,7 +66,7 @@ describe("DocHandle", () => {
     // simulate loading from storage
     handle.update(doc => docFromMockStorage(doc))
 
-    const doc = await handle.doc()
+    const doc = handle.doc()
 
     assert.equal(handle.isReady(), true)
     assert.equal(doc?.foo, "bar")
@@ -83,15 +86,15 @@ describe("DocHandle", () => {
     handle.change(d => (d.foo = "bar"))
     assert.equal(handle.isReady(), true)
 
-    const heads = A.getHeads(handle.docSync())
+    const heads = encodeHeads(A.getHeads(handle.doc()))
     assert.notDeepEqual(handle.heads(), [])
     assert.deepEqual(heads, handle.heads())
   })
 
-  it("should return undefined if the heads aren't loaded", async () => {
+  it("should throw an if the heads aren't loaded", async () => {
     const handle = new DocHandle<TestDoc>(TEST_ID)
     assert.equal(handle.isReady(), false)
-    assert.deepEqual(handle.heads(), undefined)
+    expect(() => handle.heads()).toThrow("DocHandle is not ready")
   })
 
   it("should return the history when requested", async () => {
@@ -113,8 +116,45 @@ describe("DocHandle", () => {
     assert.equal(handle.isReady(), true)
 
     const history = handle.history()
-    const view = handle.view(history[1])
-    assert.deepEqual(view, { foo: "one" })
+    const viewHandle = handle.view(history[1])
+    assert.deepEqual(await viewHandle.doc(), { foo: "one" })
+  })
+
+  it("should support fixed heads from construction", async () => {
+    const handle = setup()
+    handle.change(d => (d.foo = "zero"))
+    handle.change(d => (d.foo = "one"))
+
+    const history = handle.history()
+    const viewHandle = new DocHandle<TestDoc>(TEST_ID, { heads: history[0] })
+    viewHandle.update(() => A.clone(handle.doc()!))
+    viewHandle.doneLoading()
+
+    assert.deepEqual(await viewHandle.doc(), { foo: "zero" })
+  })
+
+  it("should prevent changes on fixed-heads handles", async () => {
+    const handle = setup()
+    handle.change(d => (d.foo = "zero"))
+    const viewHandle = handle.view(handle.heads()!)
+
+    assert.throws(() => viewHandle.change(d => (d.foo = "one")))
+    assert.throws(() =>
+      viewHandle.changeAt(handle.heads()!, d => (d.foo = "one"))
+    )
+    assert.throws(() => viewHandle.merge(handle))
+  })
+
+  it("should return fixed heads from heads()", async () => {
+    const handle = setup()
+    handle.change(d => (d.foo = "zero"))
+    const originalHeads = handle.heads()!
+
+    handle.change(d => (d.foo = "one"))
+    const viewHandle = handle.view(originalHeads)
+
+    assert.deepEqual(viewHandle.heads(), originalHeads)
+    assert.notDeepEqual(viewHandle.heads(), handle.heads())
   })
 
   it("should return diffs", async () => {
@@ -154,6 +194,31 @@ describe("DocHandle", () => {
     ])
   })
 
+  it("should support diffing against another handle", async () => {
+    const handle = setup()
+    handle.change(d => (d.foo = "zero"))
+    const viewHandle = handle.view(handle.heads()!)
+
+    handle.change(d => (d.foo = "one"))
+
+    const patches = viewHandle.diff(handle)
+    assert.deepEqual(patches, [
+      { action: "put", path: ["foo"], value: "" },
+      { action: "splice", path: ["foo", 0], value: "one" },
+    ])
+  })
+
+  // TODO: alexg -- should i remove this test? should this fail or no?
+  it.skip("should fail diffing against unrelated handles", async () => {
+    const handle1 = setup()
+    const handle2 = setup()
+
+    handle1.change(d => (d.foo = "zero"))
+    handle2.change(d => (d.foo = "one"))
+
+    assert.throws(() => handle1.diff(handle2))
+  })
+
   it("should allow direct access to decoded changes", async () => {
     const handle = setup()
     const time = Date.now()
@@ -194,8 +259,6 @@ describe("DocHandle", () => {
     const handle = new DocHandle<TestDoc>(TEST_ID)
     assert.equal(handle.isReady(), false)
 
-    handle.doc()
-
     assert(vi.getTimerCount() > timerCount)
 
     // simulate loading from storage
@@ -220,7 +283,7 @@ describe("DocHandle", () => {
     assert.equal(handle.isReady(), true)
     handle.change(d => (d.foo = "pizza"))
 
-    const doc = await handle.doc()
+    const doc = handle.doc()
     assert.equal(doc?.foo, "pizza")
   })
 
@@ -230,7 +293,9 @@ describe("DocHandle", () => {
     // we don't have it in storage, so we request it from the network
     handle.request()
 
-    assert.equal(handle.docSync(), undefined)
+    await expect(() => {
+      handle.doc()
+    }).toThrowError("DocHandle is not ready")
     assert.equal(handle.isReady(), false)
     assert.throws(() => handle.change(_ => {}))
   })
@@ -246,7 +311,7 @@ describe("DocHandle", () => {
       return A.change(doc, d => (d.foo = "bar"))
     })
 
-    const doc = await handle.doc()
+    const doc = handle.doc()
     assert.equal(handle.isReady(), true)
     assert.equal(doc?.foo, "bar")
   })
@@ -262,7 +327,7 @@ describe("DocHandle", () => {
       doc.foo = "bar"
     })
 
-    const doc = await handle.doc()
+    const doc = handle.doc()
     assert.equal(doc?.foo, "bar")
 
     const changePayload = await p
@@ -287,7 +352,7 @@ describe("DocHandle", () => {
 
     const p = new Promise<void>(resolve =>
       handle.once("change", ({ handle, doc }) => {
-        assert.equal(handle.docSync()?.foo, doc.foo)
+        assert.equal(handle.doc()?.foo, doc.foo)
 
         resolve()
       })
@@ -324,7 +389,7 @@ describe("DocHandle", () => {
       doc.foo = "baz"
     })
 
-    const doc = await handle.doc()
+    const doc = handle.doc()
     assert.equal(doc?.foo, "baz")
 
     return p
@@ -339,7 +404,7 @@ describe("DocHandle", () => {
     })
 
     await p
-    const doc = await handle.doc()
+    const doc = handle.doc()
     assert.equal(doc?.foo, "bar")
   })
 
@@ -359,11 +424,7 @@ describe("DocHandle", () => {
     // set docHandle time out after 5 ms
     const handle = new DocHandle<TestDoc>(TEST_ID, { timeoutDelay: 5 })
 
-    const doc = await handle.doc()
-
-    assert.equal(doc, undefined)
-
-    assert.equal(handle.state, "unavailable")
+    expect(() => handle.doc()).toThrowError("DocHandle is not ready")
   })
 
   it("should not time out if the document is loaded in time", async () => {
@@ -374,11 +435,11 @@ describe("DocHandle", () => {
     handle.update(doc => docFromMockStorage(doc))
 
     // now it should not time out
-    const doc = await handle.doc()
+    const doc = handle.doc()
     assert.equal(doc?.foo, "bar")
   })
 
-  it("should be undefined if loading from the network times out", async () => {
+  it("should throw an exception if loading from the network times out", async () => {
     // set docHandle time out after 5 ms
     const handle = new DocHandle<TestDoc>(TEST_ID, { timeoutDelay: 5 })
 
@@ -388,8 +449,7 @@ describe("DocHandle", () => {
     // there's no update
     await pause(10)
 
-    const doc = await handle.doc()
-    assert.equal(doc, undefined)
+    expect(() => handle.doc()).toThrowError("DocHandle is not ready")
   })
 
   it("should not time out if the document is updated in time", async () => {
@@ -407,7 +467,7 @@ describe("DocHandle", () => {
     // now it should not time out
     await pause(5)
 
-    const doc = await handle.doc()
+    const doc = handle.doc()
     assert.equal(doc?.foo, "bar")
   })
 
@@ -423,49 +483,6 @@ describe("DocHandle", () => {
     assert.equal(handle.isDeleted(), true)
   })
 
-  it("should clear document reference when unloaded", async () => {
-    const handle = setup()
-
-    handle.change(doc => {
-      doc.foo = "bar"
-    })
-    const doc = await handle.doc()
-    assert.equal(doc?.foo, "bar")
-
-    handle.unload()
-    assert.equal(handle.isUnloaded(), true)
-
-    const clearedDoc = await handle.doc([UNLOADED])
-    assert.notEqual(clearedDoc?.foo, "bar")
-  })
-
-  it("should allow reloading after unloading", async () => {
-    const handle = setup()
-
-    handle.change(doc => {
-      doc.foo = "bar"
-    })
-    const doc = await handle.doc()
-    assert.equal(doc?.foo, "bar")
-
-    handle.unload()
-
-    // reload to transition from unloaded to loading
-    handle.reload()
-
-    // simulate requesting from the network
-    handle.request()
-
-    // simulate updating from the network
-    handle.update(doc => {
-      return A.change(doc, d => (d.foo = "bar"))
-    })
-
-    const reloadedDoc = await handle.doc()
-    assert.equal(handle.isReady(), true)
-    assert.equal(reloadedDoc?.foo, "bar")
-  })
-
   it("should allow changing at old heads", async () => {
     const handle = setup()
 
@@ -503,4 +520,71 @@ describe("DocHandle", () => {
       assert.deepStrictEqual(decode(data), message)
     })
   })
+
+  it("should cache view handles based on heads", async () => {
+    // Create and setup a document with some data
+    const handle = setup()
+    handle.change(doc => {
+      doc.foo = "Hello"
+    })
+    const heads1 = handle.heads()
+
+    // Make another change to get a different set of heads
+    handle.change(doc => {
+      doc.foo = "Hello, World!"
+    })
+
+    // Create a view at the first set of heads
+    const view1 = handle.view(heads1)
+
+    // Request the same view again
+    const view2 = handle.view(heads1)
+
+    // Verify we got the same handle instance back (cached version)
+    expect(view1).toBe(view2)
+
+    // Verify the contents are correct
+    expect(view1.doc().foo).toBe("Hello")
+
+    // Test with a different set of heads
+    const view3 = handle.view(handle.heads())
+    expect(view3).not.toBe(view1)
+    expect(view3.doc().foo).toBe("Hello, World!")
+  })
+
+  it("should improve performance when requesting the same view multiple times", () => {
+    // Create and setup a document with some data
+    const handle = setup()
+    handle.change(doc => {
+      doc.foo = "Hello"
+    })
+    const heads = handle.heads()
+
+    // First, measure time without cache (first access)
+    const startTimeNoCached = performance.now()
+    const firstView = handle.view(heads)
+    const endTimeNoCached = performance.now()
+
+    // Now measure with cache (subsequent accesses)
+    const startTimeCached = performance.now()
+    for (let i = 0; i < 100; i++) {
+      handle.view(heads)
+    }
+    const endTimeCached = performance.now()
+
+    // Assert that all views are the same instance
+    for (let i = 0; i < 10; i++) {
+      expect(handle.view(heads)).toBe(firstView)
+    }
+
+    // Calculate average times
+    const timeForFirstAccess = endTimeNoCached - startTimeNoCached
+    const timeForCachedAccesses = (endTimeCached - startTimeCached) / 100
+
+    console.log(`Time for first view (no cache): ${timeForFirstAccess}ms`)
+    console.log(`Average time per cached view: ${timeForCachedAccesses}ms`)
+
+    // Cached access should be significantly faster
+    expect(timeForCachedAccesses).toBeLessThan(timeForFirstAccess / 10)
+  })
 })

package/test/DocSynchronizer.test.ts

@@ -1,7 +1,11 @@
 import assert from "assert"
 import { describe, it } from "vitest"
 import { next as Automerge } from "@automerge/automerge"
-import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
+import {
+  encodeHeads,
+  generateAutomergeUrl,
+  parseAutomergeUrl,
+} from "../src/AutomergeUrl.js"
 import { DocHandle } from "../src/DocHandle.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
 import {
@@ -16,10 +20,9 @@ const alice = "alice" as PeerId
 const bob = "bob" as PeerId
 const charlie = "charlie" as PeerId
 
-describe.skip("DocSynchronizer", () => {
+describe("DocSynchronizer", () => {
   let handle: DocHandle<TestDoc>
   let docSynchronizer: DocSynchronizer
-  let beelay: Automerge.beelay.Beelay
 
   const setup = () => {
     const docId = parseAutomergeUrl(generateAutomergeUrl()).documentId
@@ -27,7 +30,6 @@ describe.skip("DocSynchronizer", () => {
     handle.doneLoading()
 
     docSynchronizer = new DocSynchronizer({
-      beelay,
       handle: handle as DocHandle<unknown>,
     })
 
@@ -69,11 +71,14 @@ describe.skip("DocSynchronizer", () => {
 
     assert.equal(message1.peerId, "alice")
     assert.equal(message1.documentId, handle.documentId)
-    assert.deepEqual(message1.syncState.lastSentHeads, [])
+    assert.deepStrictEqual(message1.syncState.lastSentHeads, [])
 
     assert.equal(message2.peerId, "alice")
     assert.equal(message2.documentId, handle.documentId)
-    assert.deepEqual(message2.syncState.lastSentHeads, handle.heads())
+    assert.deepStrictEqual(
+      encodeHeads(message2.syncState.lastSentHeads),
+      handle.heads()
+    )
   })
 
   it("still syncs with a peer after it disconnects and reconnects", async () => {
@@ -108,7 +113,6 @@ describe.skip("DocSynchronizer", () => {
 
     const handle = new DocHandle<TestDoc>(docId, { isNew: false })
     docSynchronizer = new DocSynchronizer({
-      beelay,
       handle: handle as DocHandle<unknown>,
     })
     docSynchronizer.beginSync([alice])
@@ -123,7 +127,6 @@ describe.skip("DocSynchronizer", () => {
 
     const bobHandle = new DocHandle<TestDoc>(docId, { isNew: false })
     const bobDocSynchronizer = new DocSynchronizer({
-      beelay,
       handle: bobHandle as DocHandle<unknown>,
     })
     bobDocSynchronizer.beginSync([alice])
@@ -133,7 +136,6 @@ describe.skip("DocSynchronizer", () => {
     const aliceHandle = new DocHandle<TestDoc>(docId, { isNew: false })
     const aliceDocSynchronizer = new DocSynchronizer({
       handle: aliceHandle as DocHandle<unknown>,
-      beelay,
     })
     aliceHandle.request()
 

package/test/RemoteHeadsSubscriptions.test.ts

@@ -10,7 +10,7 @@ import {
 } from "../src/network/messages.js"
 import { collectMessages } from "./helpers/collectMessages.js"
 
-describe.skip("RepoHeadsSubscriptions", () => {
+describe("RepoHeadsSubscriptions", () => {
   const storageA = "remote-a" as StorageId
   const storageB = "remote-b" as StorageId
   const storageC = "remote-c" as StorageId