@automerge/automerge-repo 0.2.1 → 1.0.0-alpha.2

package/test/CollectionSynchronizer.test.ts

@@ -1,5 +1,5 @@
 import { CollectionSynchronizer } from "../src/synchronizer/CollectionSynchronizer.js"
-import { ChannelId, DocCollection, DocumentId, PeerId } from "../src"
+import { ChannelId, DocCollection, BinaryDocumentId, PeerId } from "../src"
 import assert from "assert"
 import { beforeEach } from "mocha"
 import { MessagePayload } from "../src/network/NetworkAdapter.js"

package/test/DocCollection.test.ts

@@ -1,8 +1,9 @@
 import assert from "assert"
-import { DocCollection, DocumentId } from "../src"
+import { DocCollection, BinaryDocumentId } from "../src"
 import { TestDoc } from "./types.js"
+import { generateAutomergeUrl, stringifyAutomergeUrl } from "../src/DocUrl"
 
-const MISSING_DOCID = "non-existent-docID" as DocumentId
+const MISSING_DOCID = generateAutomergeUrl()
 
 describe("DocCollection", () => {
   it("can create documents which are ready to go", async () => {

package/test/DocHandle.test.ts

@@ -1,17 +1,17 @@
 import * as A from "@automerge/automerge"
 import assert from "assert"
 import { it } from "mocha"
-import { DocHandle, DocHandleChangePayload, DocumentId } from "../src"
+import { DocHandle, DocHandleChangePayload } from "../src"
 import { pause } from "../src/helpers/pause"
 import { TestDoc } from "./types.js"
+import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl"
 
 describe("DocHandle", () => {
-  const TEST_ID = "test-document-id" as DocumentId
+  const TEST_ID = parseAutomergeUrl(generateAutomergeUrl()).encodedDocumentId
+  const BOGUS_ID = parseAutomergeUrl(generateAutomergeUrl()).encodedDocumentId
 
-  const binaryFromMockStorage = () => {
-    const doc = A.change<{ foo: string }>(A.init(), d => (d.foo = "bar"))
-    const binary = A.save(doc)
-    return binary
+  const docFromMockStorage = (doc: A.Doc<{ foo: string }>) => {
+    return A.change<{ foo: string }>(doc, d => (d.foo = "bar"))
   }
 
   it("should take the UUID passed into it", () => {
@@ -24,10 +24,11 @@ describe("DocHandle", () => {
     assert.equal(handle.isReady(), false)
 
     // simulate loading from storage
-    handle.load(binaryFromMockStorage())
+    handle.update(doc => docFromMockStorage(doc))
 
     assert.equal(handle.isReady(), true)
-    const doc = await handle.value()
+    const doc = await handle.doc()
+    console.log("DOC", JSON.stringify(doc))
     assert.equal(doc.foo, "bar")
   })
 
@@ -36,27 +37,27 @@ describe("DocHandle", () => {
     assert.equal(handle.isReady(), false)
 
     // simulate loading from storage
-    handle.load(binaryFromMockStorage())
+    handle.update(doc => docFromMockStorage(doc))
 
     assert.equal(handle.isReady(), true)
-    const doc = await handle.value()
-    assert.deepEqual(doc, handle.doc)
+    const doc = await handle.doc()
+    assert.deepEqual(doc, handle.docSync())
   })
 
-  it("should throws an error if we accessing the doc before ready", async () => {
+  it("should return undefined if we accessing the doc before ready", async () => {
     const handle = new DocHandle<TestDoc>(TEST_ID)
 
-    assert.throws(() => handle.doc)
+    assert.equal(handle.docSync(), undefined)
   })
 
-  it("should not return a value until ready", async () => {
+  it("should not return a doc until ready", async () => {
     const handle = new DocHandle<TestDoc>(TEST_ID)
     assert.equal(handle.isReady(), false)
 
     // simulate loading from storage
-    handle.load(binaryFromMockStorage())
+    handle.update(doc => docFromMockStorage(doc))
 
-    const doc = await handle.value()
+    const doc = await handle.doc()
 
     assert.equal(handle.isReady(), true)
     assert.equal(doc.foo, "bar")
@@ -70,13 +71,13 @@ describe("DocHandle", () => {
     assert.throws(() => handle.change(d => (d.foo = "baz")))
 
     // simulate loading from storage
-    handle.load(binaryFromMockStorage())
+    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.value()
+    const doc = await handle.doc()
     assert.equal(doc.foo, "pizza")
   })
 
@@ -86,7 +87,7 @@ describe("DocHandle", () => {
     // we don't have it in storage, so we request it from the network
     handle.request()
 
-    assert.throws(() => handle.doc)
+    assert.equal(handle.docSync(), undefined)
     assert.equal(handle.isReady(), false)
     assert.throws(() => handle.change(h => {}))
   })
@@ -102,7 +103,7 @@ describe("DocHandle", () => {
       return A.change(doc, d => (d.foo = "bar"))
     })
 
-    const doc = await handle.value()
+    const doc = await handle.doc()
     assert.equal(handle.isReady(), true)
     assert.equal(doc.foo, "bar")
   })
@@ -118,7 +119,7 @@ describe("DocHandle", () => {
       doc.foo = "bar"
     })
 
-    const doc = await handle.value()
+    const doc = await handle.doc()
     assert.equal(doc.foo, "bar")
 
     const changePayload = await p
@@ -142,7 +143,7 @@ describe("DocHandle", () => {
 
     const p = new Promise<void>(resolve =>
       handle.once("change", ({ handle, doc }) => {
-        assert.equal(handle.doc.foo, doc.foo)
+        assert.equal(handle.docSync()?.foo, doc.foo)
 
         resolve()
       })
@@ -179,29 +180,29 @@ describe("DocHandle", () => {
       doc.foo = "baz"
     })
 
-    const doc = await handle.value()
+    const doc = await handle.doc()
     assert.equal(doc.foo, "baz")
 
     return p
   })
 
-  it("should emit a patch message when changes happen", async () => {
+  it("should emit a change message when changes happen", async () => {
     const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
-    const p = new Promise(resolve => handle.once("patch", d => resolve(d)))
+    const p = new Promise(resolve => handle.once("change", d => resolve(d)))
 
     handle.change(doc => {
       doc.foo = "bar"
     })
 
     await p
-    const doc = await handle.value()
+    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<TestDoc>(TEST_ID, { isNew: true })
-    handle.on("patch", () => {
-      done(new Error("shouldn't have patched"))
+    handle.on("change", () => {
+      done(new Error("shouldn't have changed"))
     })
     handle.change(_doc => {
       // do nothing
@@ -216,8 +217,10 @@ describe("DocHandle", () => {
     // we're not going to load
     await pause(10)
 
+    assert.equal(handle.state, "failed")
+
     // so it should time out
-    return assert.rejects(handle.value, "DocHandle timed out")
+    return assert.rejects(handle.doc, "DocHandle timed out")
   })
 
   it("should not time out if the document is loaded in time", async () => {
@@ -225,10 +228,10 @@ describe("DocHandle", () => {
     const handle = new DocHandle<TestDoc>(TEST_ID, { timeoutDelay: 5 })
 
     // simulate loading from storage before the timeout expires
-    handle.load(binaryFromMockStorage())
+    handle.update(doc => docFromMockStorage(doc))
 
     // now it should not time out
-    const doc = await handle.value()
+    const doc = await handle.doc()
     assert.equal(doc.foo, "bar")
   })
 
@@ -243,12 +246,12 @@ describe("DocHandle", () => {
     await pause(10)
 
     // so it should time out
-    return assert.rejects(handle.value, "DocHandle timed 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<TestDoc>(TEST_ID, { timeoutDelay: 5 })
+    const handle = new DocHandle<TestDoc>(TEST_ID, { timeoutDelay: 1 })
 
     // simulate requesting from the network
     handle.request()
@@ -259,7 +262,9 @@ describe("DocHandle", () => {
     })
 
     // now it should not time out
-    const doc = await handle.value()
+    await pause(5)
+
+    const doc = await handle.doc()
     assert.equal(doc.foo, "bar")
   })
 
@@ -282,7 +287,7 @@ describe("DocHandle", () => {
       doc.foo = "bar"
     })
 
-    const headsBefore = A.getHeads(handle.doc)
+    const headsBefore = A.getHeads(handle.docSync()!)
 
     handle.change(doc => {
       doc.foo = "rab"

package/test/DocSynchronizer.test.ts

@@ -1,9 +1,10 @@
 import assert from "assert"
-import { DocumentId, PeerId } from "../src/types.js"
+import { BinaryDocumentId, PeerId } from "../src/types.js"
 import { DocHandle } from "../src/DocHandle.js"
 import { DocSynchronizer } from "../src/synchronizer/DocSynchronizer.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
 import { TestDoc } from "./types.js"
+import { parseAutomergeUrl, generateAutomergeUrl } from "../src/DocUrl.js"
 
 const alice = "alice" as PeerId
 const bob = "bob" as PeerId
@@ -13,7 +14,7 @@ describe("DocSynchronizer", () => {
   let docSynchronizer: DocSynchronizer
 
   const setup = () => {
-    const docId = "synced-doc" as DocumentId
+    const docId = parseAutomergeUrl(generateAutomergeUrl()).encodedDocumentId
     handle = new DocHandle<TestDoc>(docId, { isNew: true })
     docSynchronizer = new DocSynchronizer(handle)
     return { handle, docSynchronizer }

package/test/Repo.test.ts

@@ -1,7 +1,15 @@
 import assert from "assert"
 import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel"
-
-import { ChannelId, DocHandle, DocumentId, PeerId, SharePolicy } from "../src"
+import * as A from "@automerge/automerge"
+
+import {
+  AutomergeUrl,
+  ChannelId,
+  DocHandle,
+  DocumentId,
+  PeerId,
+  SharePolicy,
+} from "../src"
 import { eventPromise } from "../src/helpers/eventPromise.js"
 import { pause, rejectOnTimeout } from "../src/helpers/pause.js"
 import { Repo } from "../src/Repo.js"
@@ -9,6 +17,11 @@ import { DummyNetworkAdapter } from "./helpers/DummyNetworkAdapter.js"
 import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
 import { getRandomItem } from "./helpers/getRandomItem.js"
 import { TestDoc } from "./types.js"
+import {
+  binaryToDocumentId,
+  generateAutomergeUrl,
+  stringifyAutomergeUrl,
+} from "../src/DocUrl"
 
 describe("Repo", () => {
   describe("single repo", () => {
@@ -41,19 +54,29 @@ describe("Repo", () => {
       handle.change(d => {
         d.foo = "bar"
       })
-      const v = await handle.value()
+      const v = await handle.doc()
+      console.log("V is ", v)
       assert.equal(handle.isReady(), true)
 
       assert.equal(v.foo, "bar")
     })
 
+    it("throws an error if we try to find a handle with an invalid AutomergeUrl", async () => {
+      const { repo } = setup()
+      try {
+        repo.find<TestDoc>("invalid-url" as unknown as AutomergeUrl)
+      } catch (e: any) {
+        assert.equal(e.message, "Invalid AutomergeUrl: 'invalid-url'")
+      }
+    })
+
     it("doesn't find a document that doesn't exist", async () => {
       const { repo } = setup()
-      const handle = repo.find<TestDoc>("does-not-exist" as DocumentId)
+      const handle = repo.find<TestDoc>(generateAutomergeUrl())
       assert.equal(handle.isReady(), false)
 
       return assert.rejects(
-        rejectOnTimeout(handle.value(), 100),
+        rejectOnTimeout(handle.doc(), 10),
         "This document should not exist"
       )
     })
@@ -66,12 +89,12 @@ describe("Repo", () => {
       })
       assert.equal(handle.isReady(), true)
 
-      const bobHandle = repo.find<TestDoc>(handle.documentId)
+      const bobHandle = repo.find<TestDoc>(handle.url)
 
       assert.equal(handle, bobHandle)
       assert.equal(handle.isReady(), true)
 
-      const v = await bobHandle.value()
+      const v = await bobHandle.doc()
       assert.equal(v.foo, "bar")
     })
 
@@ -92,9 +115,9 @@ describe("Repo", () => {
         network: [],
       })
 
-      const bobHandle = repo2.find<TestDoc>(handle.documentId)
+      const bobHandle = repo2.find<TestDoc>(handle.url)
 
-      const v = await bobHandle.value()
+      const v = await bobHandle.doc()
       assert.equal(v.foo, "bar")
     })
 
@@ -105,15 +128,37 @@ describe("Repo", () => {
         d.foo = "bar"
       })
       assert.equal(handle.isReady(), true)
-      await handle.value()
+      await handle.doc()
       repo.delete(handle.documentId)
 
       assert(handle.isDeleted())
       assert.equal(repo.handles[handle.documentId], undefined)
 
-      const bobHandle = repo.find<TestDoc>(handle.documentId)
+      const bobHandle = repo.find<TestDoc>(handle.url)
       await assert.rejects(
-        rejectOnTimeout(bobHandle.value(), 10),
+        rejectOnTimeout(bobHandle.doc(), 10),
+        "document should have been deleted"
+      )
+
+      assert(!bobHandle.isReady())
+    })
+
+    it("can delete an existing document by url", async () => {
+      const { repo } = setup()
+      const handle = repo.create<TestDoc>()
+      handle.change(d => {
+        d.foo = "bar"
+      })
+      assert.equal(handle.isReady(), true)
+      await handle.doc()
+      repo.delete(handle.url)
+
+      assert(handle.isDeleted())
+      assert.equal(repo.handles[handle.documentId], undefined)
+
+      const bobHandle = repo.find<TestDoc>(handle.url)
+      await assert.rejects(
+        rejectOnTimeout(bobHandle.doc(), 10),
         "document should have been deleted"
       )
 
@@ -128,14 +173,72 @@ describe("Repo", () => {
       })
       assert.equal(handle.isReady(), true)
 
-      repo.on("delete-document", ({ documentId }) => {
-        assert.equal(documentId, handle.documentId)
+      repo.on("delete-document", ({ encodedDocumentId }) => {
+        assert.equal(encodedDocumentId, handle.documentId)
 
         done()
       })
 
       repo.delete(handle.documentId)
     })
+
+    it("storage state doesn't change across reloads when the document hasn't changed", async () => {
+      const storage = new DummyStorageAdapter()
+
+      const repo = new Repo({
+        storage,
+        network: [],
+      })
+
+      const handle = repo.create<{ count: number }>()
+
+      handle.change(d => {
+        d.count = 0
+      })
+      handle.change(d => {
+        d.count = 1
+      })
+
+      const initialKeys = storage.keys()
+
+      const repo2 = new Repo({
+        storage,
+        network: [],
+      })
+      const handle2 = repo2.find(handle.url)
+      await handle2.doc()
+
+      assert.deepEqual(storage.keys(), initialKeys)
+    })
+
+    it("doesn't delete a document from storage when we refresh", async () => {
+      const storage = new DummyStorageAdapter()
+
+      const repo = new Repo({
+        storage,
+        network: [],
+      })
+
+      const handle = repo.create<{ count: number }>()
+
+      handle.change(d => {
+        d.count = 0
+      })
+      handle.change(d => {
+        d.count = 1
+      })
+
+      for (let i = 0; i < 3; i++) {
+        const repo2 = new Repo({
+          storage,
+          network: [],
+        })
+        const handle2 = repo2.find(handle.url)
+        await handle2.doc()
+
+        assert(storage.keys().length !== 0)
+      }
+    })
   })
 
   describe("sync", async () => {
@@ -232,9 +335,9 @@ describe("Repo", () => {
     it("changes are replicated from aliceRepo to bobRepo", async () => {
       const { bobRepo, aliceHandle, teardown } = await setup()
 
-      const bobHandle = bobRepo.find<TestDoc>(aliceHandle.documentId)
+      const bobHandle = bobRepo.find<TestDoc>(aliceHandle.url)
       await eventPromise(bobHandle, "change")
-      const bobDoc = await bobHandle.value()
+      const bobDoc = await bobHandle.doc()
       assert.deepStrictEqual(bobDoc, { foo: "bar" })
       teardown()
     })
@@ -242,9 +345,9 @@ describe("Repo", () => {
     it("can load a document from aliceRepo on charlieRepo", async () => {
       const { charlieRepo, aliceHandle, teardown } = await setup()
 
-      const handle3 = charlieRepo.find<TestDoc>(aliceHandle.documentId)
+      const handle3 = charlieRepo.find<TestDoc>(aliceHandle.url)
       await eventPromise(handle3, "change")
-      const doc3 = await handle3.value()
+      const doc3 = await handle3.doc()
       assert.deepStrictEqual(doc3, { foo: "bar" })
       teardown()
     })
@@ -268,8 +371,10 @@ describe("Repo", () => {
     it("charlieRepo can request a document not initially shared with it", async () => {
       const { charlieRepo, notForCharlie, teardown } = await setup()
 
-      const handle = charlieRepo.find<TestDoc>(notForCharlie)
-      const doc = await handle.value()
+      const handle = charlieRepo.find<TestDoc>(
+        stringifyAutomergeUrl({ documentId: notForCharlie })
+      )
+      const doc = await handle.doc()
 
       assert.deepStrictEqual(doc, { foo: "baz" })
 
@@ -279,8 +384,10 @@ describe("Repo", () => {
     it("charlieRepo can request a document across a network of multiple peers", async () => {
       const { charlieRepo, notForBob, teardown } = await setup()
 
-      const handle = charlieRepo.find<TestDoc>(notForBob)
-      const doc = await handle.value()
+      const handle = charlieRepo.find<TestDoc>(
+        stringifyAutomergeUrl({ documentId: notForBob })
+      )
+      const doc = await handle.doc()
       assert.deepStrictEqual(doc, { foo: "bap" })
 
       teardown()
@@ -288,11 +395,11 @@ describe("Repo", () => {
 
     it("doesn't find a document which doesn't exist anywhere on the network", async () => {
       const { charlieRepo } = await setup()
-      const handle = charlieRepo.find<TestDoc>("does-not-exist" as DocumentId)
+      const handle = charlieRepo.find<TestDoc>(generateAutomergeUrl())
       assert.equal(handle.isReady(), false)
 
       return assert.rejects(
-        rejectOnTimeout(handle.value(), 100),
+        rejectOnTimeout(handle.doc(), 10),
         "This document should not exist"
       )
     })
@@ -310,9 +417,9 @@ describe("Repo", () => {
       })
       await changePromise
 
-      const handle3 = charlieRepo.find<TestDoc>(aliceHandle.documentId)
+      const handle3 = charlieRepo.find<TestDoc>(aliceHandle.url)
       await eventPromise(handle3, "change")
-      const doc3 = await handle3.value()
+      const doc3 = await handle3.doc()
 
       assert.deepStrictEqual(doc3, { foo: "baz" })
 
@@ -351,7 +458,7 @@ describe("Repo", () => {
 
         // make sure the doc is ready
         if (!doc.isReady()) {
-          await doc.value()
+          await doc.doc()
         }
 
         // make a random change to it

package/test/StorageSubsystem.test.ts

@@ -9,8 +9,9 @@ import A from "@automerge/automerge"
 import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
 import { NodeFSStorageAdapter } from "@automerge/automerge-repo-storage-nodefs"
 
-import { DocumentId, StorageSubsystem } from "../src"
+import { StorageSubsystem } from "../src"
 import { TestDoc } from "./types.js"
+import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
 
 const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "automerge-repo-tests"))
 
@@ -30,11 +31,11 @@ describe("StorageSubsystem", () => {
         })
 
         // save it to storage
-        const key = "test-key" as DocumentId
-        await storage.save(key, doc)
+        const key = parseAutomergeUrl(generateAutomergeUrl()).encodedDocumentId
+        await storage.saveDoc(key, doc)
 
         // reload it from storage
-        const reloadedDoc = await storage.load<TestDoc>(key)
+        const reloadedDoc = await storage.loadDoc(key)
 
         // check that it's the same doc
         assert.deepStrictEqual(reloadedDoc, doc)
@@ -51,24 +52,26 @@ describe("StorageSubsystem", () => {
     })
 
     // save it to storage
-    const key = "test-key" as DocumentId
-    storage.save(key, doc)
+    const key = parseAutomergeUrl(generateAutomergeUrl()).encodedDocumentId
+    storage.saveDoc(key, doc)
 
     // create new storage subsystem to simulate a new process
     const storage2 = new StorageSubsystem(adapter)
 
     // reload it from storage
-    const reloadedDoc = await storage2.load<TestDoc>(key)
+    const reloadedDoc = await storage2.loadDoc(key)
+
+    assert(reloadedDoc, "doc should be loaded")
 
     // make a change
-    const changedDoc = A.change(reloadedDoc, "test 2", d => {
+    const changedDoc = A.change<any>(reloadedDoc, "test 2", d => {
       d.foo = "baz"
     })
 
     // save it to storage
-    storage2.save(key, changedDoc)
+    storage2.saveDoc(key, changedDoc)
 
     // check that the storage adapter contains the correct keys
-    assert(adapter.keys().some(k => k.startsWith("test-key.incremental.")))
+    assert(adapter.keys().some(k => k.startsWith(`${key}.incremental.`)))
   })
 })

package/test/helpers/DummyNetworkAdapter.ts

@@ -3,6 +3,6 @@ import { NetworkAdapter } from "../../src"
 export class DummyNetworkAdapter extends NetworkAdapter {
   sendMessage() {}
   connect(_: string) {}
-  join(_: string) {}
-  leave(_: string) {}
+  join() {}
+  leave() {}
 }

package/test/helpers/DummyStorageAdapter.ts

@@ -1,16 +1,20 @@
-import { StorageAdapter } from "../../src"
+import { StorageAdapter, type StorageKey } from "../../src"
 
 export class DummyStorageAdapter implements StorageAdapter {
   #data: Record<string, Uint8Array> = {}
 
-  #keyToString(key: string[]) {
+  #keyToString(key: string[]): string {
     return key.join(".")
   }
 
-  async loadRange(keyPrefix: string[]): Promise<Uint8Array[]> {
+  #stringToKey(key: string): string[] {
+    return key.split(".")
+  }
+
+  async loadRange(keyPrefix: StorageKey): Promise<{data: Uint8Array, key: StorageKey}[]> {
     const range = Object.entries(this.#data)
       .filter(([key, _]) => key.startsWith(this.#keyToString(keyPrefix)))
-      .map(([_, value]) => value)
+      .map(([key, data]) => ({key: this.#stringToKey(key), data}))
     return Promise.resolve(range)
   }