@automerge/automerge-repo 1.0.12 → 1.0.14

package/test/AutomergeUrl.test.ts

@@ -0,0 +1,100 @@
+import assert from "assert"
+import bs58check from "bs58check"
+import { describe, it } from "vitest"
+import {
+  generateAutomergeUrl,
+  isValidAutomergeUrl,
+  parseAutomergeUrl,
+  stringifyAutomergeUrl,
+} from "../src/AutomergeUrl.js"
+import type {
+  AutomergeUrl,
+  BinaryDocumentId,
+  DocumentId,
+} from "../src/types.js"
+
+const goodUrl = "automerge:4NMNnkMhL8jXrdJ9jamS58PAVdXu" as AutomergeUrl
+const badChecksumUrl = "automerge:badbadbad" as AutomergeUrl
+const badPrefixUrl = "yjs😉:4NMNnkMhL8jXrdJ9jamS58PAVdXu" as AutomergeUrl
+
+const goodDocumentId = "4NMNnkMhL8jXrdJ9jamS58PAVdXu" as DocumentId
+const badChecksumDocumentId = "badbadbad" as DocumentId
+const badUuidDocumentId = bs58check.encode(
+  new Uint8Array([1, 2, 3, 4, 42, -1, 69, 777])
+) as DocumentId
+
+const goodBinaryDocumentId = Uint8Array.from([
+  241, 194, 156, 132, 116, 200, 74, 222, 184, 0, 190, 71, 98, 125, 51, 191,
+]) as BinaryDocumentId
+
+describe("AutomergeUrl", () => {
+  describe("generateAutomergeUrl", () => {
+    it("should generate a valid Automerge URL", () => {
+      const url = generateAutomergeUrl()
+      assert(url.startsWith("automerge:"))
+      assert(parseAutomergeUrl(url).binaryDocumentId)
+    })
+  })
+
+  describe("stringifyAutomergeUrl", () => {
+    it("should stringify a binary document ID", () => {
+      const url = stringifyAutomergeUrl({ documentId: goodBinaryDocumentId })
+      assert.strictEqual(url, goodUrl)
+    })
+
+    it("should stringify a string document ID", () => {
+      const url = stringifyAutomergeUrl({ documentId: goodDocumentId })
+      assert.strictEqual(url, goodUrl)
+    })
+
+    it("supports passing a document ID without wrapping it in an object", () => {
+      const url1 = stringifyAutomergeUrl(goodDocumentId)
+      const url2 = stringifyAutomergeUrl({ documentId: goodDocumentId })
+      assert.equal(url1, url2)
+    })
+  })
+
+  describe("parseAutomergeUrl", () => {
+    it("should parse a valid url", () => {
+      const { binaryDocumentId, documentId } = parseAutomergeUrl(goodUrl)
+      assert.deepEqual(binaryDocumentId, goodBinaryDocumentId)
+      assert.equal(documentId, goodDocumentId)
+    })
+
+    it("should throw on url with invalid checksum", () => {
+      assert.throws(() => parseAutomergeUrl(badChecksumUrl))
+    })
+
+    it("should throw on url with invalid prefix", () => {
+      assert.throws(() => parseAutomergeUrl(badPrefixUrl))
+    })
+  })
+
+  describe("isValidAutomergeUrl", () => {
+    it("should return true for a valid url", () => {
+      assert(isValidAutomergeUrl(goodUrl) === true)
+    })
+
+    it("should return false for null url", () => {
+      assert(isValidAutomergeUrl(null) === false)
+    })
+
+    it("should return false for a url with invalid checksum", () => {
+      assert(isValidAutomergeUrl(badChecksumUrl) === false)
+    })
+
+    it("should return false for a url with invalid prefix", () => {
+      assert(isValidAutomergeUrl(badPrefixUrl) === false)
+    })
+
+    it("should return false for a documentId with an invalid checksum", () => {
+      const url = stringifyAutomergeUrl({ documentId: badChecksumDocumentId })
+      assert(isValidAutomergeUrl(url) === false)
+    })
+
+    it("should return false for a documentId that is not a valid UUID ", () => {
+      const url = stringifyAutomergeUrl({ documentId: badUuidDocumentId })
+      assert(isValidAutomergeUrl(url) === false)
+    })
+  })
+})

package/test/DocHandle.test.ts

@@ -2,7 +2,7 @@ import * as A from "@automerge/automerge/next"
 import assert from "assert"
 import { decode } from "cbor-x"
 import { describe, it } from "vitest"
-import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
+import { 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"

package/test/DocSynchronizer.test.ts

@@ -1,7 +1,7 @@
 import assert from "assert"
 import { describe, it } from "vitest"
 import { DocHandle } from "../src/DocHandle.js"
-import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
+import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
 import {
   DocumentUnavailableMessage,

package/test/Repo.test.ts

@@ -2,9 +2,12 @@ import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-
 import assert from "assert"
 import * as Uuid from "uuid"
 import { describe, it } from "vitest"
-import { parseAutomergeUrl } from "../dist/DocUrl.js"
+import { parseAutomergeUrl } from "../src/AutomergeUrl.js"
 import { READY } from "../src/DocHandle.js"
-import { generateAutomergeUrl, stringifyAutomergeUrl } from "../src/DocUrl.js"
+import {
+  generateAutomergeUrl,
+  stringifyAutomergeUrl,
+} from "../src/AutomergeUrl.js"
 import { Repo } from "../src/Repo.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
 import { pause } from "../src/helpers/pause.js"
@@ -12,6 +15,7 @@ import {
   AutomergeUrl,
   DocHandle,
   DocumentId,
+  LegacyDocumentId,
   PeerId,
   SharePolicy,
 } from "../src/index.js"
@@ -51,7 +55,7 @@ describe("Repo", () => {
       assert.equal(handle.isReady(), true)
     })
 
-    it("can find a document once it's created", () => {
+    it("can find a document by url", () => {
       const { repo } = setup()
       const handle = repo.create<TestDoc>()
       handle.change((d: TestDoc) => {
@@ -63,7 +67,19 @@ describe("Repo", () => {
       assert.deepEqual(handle2.docSync(), { foo: "bar" })
     })
 
-    it("can find a document using a legacy UUID (for now)", () => {
+    it("can find a document by its unprefixed document ID", () => {
+      const { repo } = setup()
+      const handle = repo.create<TestDoc>()
+      handle.change((d: TestDoc) => {
+        d.foo = "bar"
+      })
+
+      const handle2 = repo.find(handle.documentId)
+      assert.equal(handle, handle2)
+      assert.deepEqual(handle2.docSync(), { foo: "bar" })
+    })
+
+    it("can find a document by legacy UUID (for now)", () => {
       disableConsoleWarn()
 
       const { repo } = setup()
@@ -74,9 +90,9 @@ describe("Repo", () => {
 
       const url = handle.url
       const { binaryDocumentId } = parseAutomergeUrl(url)
-      const legacyDocumentId = Uuid.stringify(binaryDocumentId) as AutomergeUrl // a white lie
+      const legacyDocId = Uuid.stringify(binaryDocumentId) as LegacyDocumentId
 
-      const handle2 = repo.find(legacyDocumentId)
+      const handle2 = repo.find(legacyDocId)
       assert.equal(handle, handle2)
       assert.deepEqual(handle2.docSync(), { foo: "bar" })
 

package/test/StorageSubsystem.test.ts

@@ -5,9 +5,11 @@ import fs from "fs"
 import os from "os"
 import path from "path"
 import { describe, it } from "vitest"
-import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
+import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
 import { StorageSubsystem } from "../src/storage/StorageSubsystem.js"
 import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
+import { cbor } from "../src/index.js"
+import { pause } from "../src/helpers/pause.js"
 
 const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "automerge-repo-tests"))
 
@@ -19,55 +21,161 @@ describe("StorageSubsystem", () => {
 
   Object.entries(adaptersToTest).forEach(([adapterName, adapter]) => {
     describe(adapterName, () => {
-      it("can store and retrieve an Automerge document", async () => {
-        const storage = new StorageSubsystem(adapter)
+      describe("Automerge document storage", () => {
+        it("stores and retrieves an Automerge document", async () => {
+          const storage = new StorageSubsystem(adapter)
 
-        const doc = A.change(A.init<any>(), "test", d => {
-          d.foo = "bar"
+          const doc = A.change(A.init<any>(), "test", d => {
+            d.foo = "bar"
+          })
+
+          // save it to storage
+          const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
+          await storage.saveDoc(key, doc)
+
+          // reload it from storage
+          const reloadedDoc = await storage.loadDoc(key)
+
+          // check that it's the same doc
+          assert.deepStrictEqual(reloadedDoc, doc)
+        })
+
+        it("retrieves an Automerge document following lots of changes", async () => {
+          const storage = new StorageSubsystem(adapter)
+
+          type TestDoc = { foo: number }
+
+          const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
+
+          let doc = A.init<TestDoc>()
+
+          const N = 100
+          for (let i = 0; i < N; i++) {
+            doc = A.change(doc, "test", d => {
+              d.foo = i
+            })
+            // save it to storage
+            await storage.saveDoc(key, doc)
+          }
+
+          // reload it from storage, simulating a new process
+          const storage2 = new StorageSubsystem(adapter)
+          const reloadedDoc = await storage2.loadDoc<TestDoc>(key)
+
+          // check that the doc has the right value
+          assert.equal(reloadedDoc?.foo, N - 1)
         })
 
-        // save it to storage
-        const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
-        await storage.saveDoc(key, doc)
+        it("stores incremental changes following a load", async () => {
+          const storage = new StorageSubsystem(adapter)
+
+          const doc = A.change(A.init<any>(), "test", d => {
+            d.foo = "bar"
+          })
+
+          // save it to storage
+          const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
+          storage.saveDoc(key, doc)
+
+          // reload it from storage, simulating a new process
+          const storage2 = new StorageSubsystem(adapter)
+          const reloadedDoc = await storage2.loadDoc(key)
+
+          assert(reloadedDoc, "doc should be loaded")
+
+          // make a change
+          const changedDoc = A.change<any>(reloadedDoc, "test 2", d => {
+            d.foo = "baz"
+          })
+
+          // save it to storage
+          storage2.saveDoc(key, changedDoc)
+        })
+
+        it("removes an Automerge document", async () => {
+          const storage = new StorageSubsystem(adapter)
+
+          const doc = A.change(A.init<any>(), "test", d => {
+            d.foo = "bar"
+          })
+
+          // save it to storage
+          const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
+          await storage.saveDoc(key, doc)
 
-        // reload it from storage
-        const reloadedDoc = await storage.loadDoc(key)
+          // reload it from storage
+          const reloadedDoc = await storage.loadDoc(key)
 
-        // check that it's the same doc
-        assert.deepStrictEqual(reloadedDoc, doc)
+          // check that it's the same doc
+          assert.deepStrictEqual(reloadedDoc, doc)
+
+          // remove it
+          await storage.removeDoc(key)
+
+          // reload it from storage
+          const reloadedDoc2 = await storage.loadDoc(key)
+
+          // check that it's undefined
+          assert.equal(reloadedDoc2, undefined)
+        })
       })
-    })
-  })
 
-  it("correctly stores incremental changes following a load", async () => {
-    const adapter = new DummyStorageAdapter()
-    const storage = new StorageSubsystem(adapter)
+      describe("Arbitrary key/value storage", () => {
+        it("stores and retrieves a blob", async () => {
+          const storage = new StorageSubsystem(adapter)
 
-    const doc = A.change(A.init<any>(), "test", d => {
-      d.foo = "bar"
-    })
+          const value = cbor.encode({ foo: "bar" })
 
-    // save it to storage
-    const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
-    storage.saveDoc(key, doc)
+          const namespace = "MyCoolAdapter"
+          const key = "ABC123"
+          await storage.save(namespace, key, value)
 
-    // create new storage subsystem to simulate a new process
-    const storage2 = new StorageSubsystem(adapter)
+          const reloadedValue = await storage.load(namespace, key)
+          assert.notEqual(reloadedValue, undefined)
+          assert.deepEqual(cbor.decode(reloadedValue)["foo"], "bar")
+        })
 
-    // reload it from storage
-    const reloadedDoc = await storage2.loadDoc(key)
+        it("keeps namespaces separate", async () => {
+          const storage = new StorageSubsystem(adapter)
 
-    assert(reloadedDoc, "doc should be loaded")
+          const key = "ABC123"
 
-    // make a change
-    const changedDoc = A.change<any>(reloadedDoc, "test 2", d => {
-      d.foo = "baz"
-    })
+          const namespace1 = "MyCoolAdapter"
+          const value1 = cbor.encode({ foo: "bar" })
+          await storage.save(namespace1, key, value1)
+
+          const namespace2 = "SomeDumbAdapter"
+          const value2 = cbor.encode({ baz: "pizza" })
+          await storage.save(namespace2, key, value2)
 
-    // save it to storage
-    storage2.saveDoc(key, changedDoc)
+          const reloadedValue1 = await storage.load(namespace1, key)
+          assert.notEqual(reloadedValue1, undefined)
+          assert.deepEqual(cbor.decode(reloadedValue1)["foo"], "bar")
 
-    // check that the storage adapter contains the correct keys
-    assert(adapter.keys().some(k => k.startsWith(`${key}.incremental.`)))
+          const reloadedValue2 = await storage.load(namespace2, key)
+          assert.notEqual(reloadedValue2, undefined)
+          assert.deepEqual(cbor.decode(reloadedValue2)["baz"], "pizza")
+        })
+
+        it("removes a blob", async () => {
+          const storage = new StorageSubsystem(adapter)
+
+          const value = cbor.encode({ foo: "bar" })
+
+          const namespace = "MyCoolAdapter"
+          const key = "ABC123"
+          await storage.save(namespace, key, value)
+
+          const reloadedValue = await storage.load(namespace, key)
+          assert.notEqual(reloadedValue, undefined)
+          assert.deepEqual(cbor.decode(reloadedValue)["foo"], "bar")
+
+          await storage.remove(namespace, key)
+
+          const reloadedValue2 = await storage.load(namespace, key)
+          assert.equal(reloadedValue2, undefined)
+        })
+      })
+    })
   })
 })

package/test/helpers/DummyStorageAdapter.ts

@@ -1,4 +1,4 @@
-import { StorageAdapter, type StorageKey } from "../../src/index.js"
+import { Chunk, StorageAdapter, type StorageKey } from "../../src/index.js"
 
 export class DummyStorageAdapter implements StorageAdapter {
   #data: Record<string, Uint8Array> = {}
@@ -11,9 +11,7 @@ export class DummyStorageAdapter implements StorageAdapter {
     return key.split(".")
   }
 
-  async loadRange(
-    keyPrefix: StorageKey
-  ): Promise<{ data: Uint8Array; key: StorageKey }[]> {
+  async loadRange(keyPrefix: StorageKey): Promise<Chunk[]> {
     const range = Object.entries(this.#data)
       .filter(([key, _]) => key.startsWith(this.#keyToString(keyPrefix)))
       .map(([key, data]) => ({ key: this.#stringToKey(key), data }))

package/dist/DocUrl.d.ts

@@ -1,39 +0,0 @@
-import { type AutomergeUrl, type BinaryDocumentId, type DocumentId } from "./types.js";
-export declare const urlPrefix = "automerge:";
-/**
- * given an Automerge URL, return a decoded DocumentId (and the encoded DocumentId)
- *
- * @param url
- * @returns { binaryDocumentId: BinaryDocumentId, documentId: DocumentId }
- */
-export declare const parseAutomergeUrl: (url: AutomergeUrl) => {
-    binaryDocumentId: BinaryDocumentId;
-    documentId: DocumentId;
-};
-/**
- * Given a documentId in either canonical form, return an Automerge URL
- * Throws on invalid input.
- * Note: this is an object because we anticipate adding fields in the future.
- * @param { documentId: BinaryDocumentId | DocumentId }
- * @returns AutomergeUrl
- */
-export declare const stringifyAutomergeUrl: ({ documentId, }: {
-    documentId: DocumentId | BinaryDocumentId;
-}) => AutomergeUrl;
-/**
- * Given a string, return true if it is a valid Automerge URL
- * also acts as a type discriminator in Typescript.
- * @param str: URL candidate
- * @returns boolean
- */
-export declare const isValidAutomergeUrl: (str: string) => str is AutomergeUrl;
-/**
- * generateAutomergeUrl produces a new AutomergeUrl.
- * generally only called by create(), but used in tests as well.
- * @returns a new Automerge URL with a random UUID documentId
- */
-export declare const generateAutomergeUrl: () => AutomergeUrl;
-export declare const documentIdToBinary: (docId: DocumentId) => BinaryDocumentId | undefined;
-export declare const binaryToDocumentId: (docId: BinaryDocumentId) => DocumentId;
-export declare const parseLegacyUUID: (str: string) => AutomergeUrl | undefined;
-//# sourceMappingURL=DocUrl.d.ts.map

package/dist/DocUrl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DocUrl.d.ts","sourceRoot":"","sources":["../src/DocUrl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAChB,MAAM,YAAY,CAAA;AAInB,eAAO,MAAM,SAAS,eAAe,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,QAAS,YAAY;;;CAIlD,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;gBAGpB,UAAU,GAAG,gBAAgB;MACvC,YAQH,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,QAAS,MAAM,wBAK9C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAO,YAGpC,CAAA;AAEJ,eAAO,MAAM,kBAAkB,UACtB,UAAU,KAChB,gBAAgB,GAAG,SACyC,CAAA;AAE/D,eAAO,MAAM,kBAAkB,UAAW,gBAAgB,KAAG,UACtB,CAAA;AAEvC,eAAO,MAAM,eAAe,QAAS,MAAM,KAAG,YAAY,GAAG,SAM5D,CAAA"}

package/dist/DocUrl.js

@@ -1,74 +0,0 @@
-import * as Uuid from "uuid";
-import bs58check from "bs58check";
-export const urlPrefix = "automerge:";
-/**
- * given an Automerge URL, return a decoded DocumentId (and the encoded DocumentId)
- *
- * @param url
- * @returns { binaryDocumentId: BinaryDocumentId, documentId: DocumentId }
- */
-export const parseAutomergeUrl = (url) => {
-    const { binaryDocumentId, documentId } = parts(url);
-    if (!binaryDocumentId)
-        throw new Error("Invalid document URL: " + url);
-    return { binaryDocumentId, documentId };
-};
-/**
- * Given a documentId in either canonical form, return an Automerge URL
- * Throws on invalid input.
- * Note: this is an object because we anticipate adding fields in the future.
- * @param { documentId: BinaryDocumentId | DocumentId }
- * @returns AutomergeUrl
- */
-export const stringifyAutomergeUrl = ({ documentId, }) => {
-    if (documentId instanceof Uint8Array)
-        return (urlPrefix +
-            binaryToDocumentId(documentId));
-    else if (typeof documentId === "string") {
-        return (urlPrefix + documentId);
-    }
-    throw new Error("Invalid documentId: " + documentId);
-};
-/**
- * Given a string, return true if it is a valid Automerge URL
- * also acts as a type discriminator in Typescript.
- * @param str: URL candidate
- * @returns boolean
- */
-export const isValidAutomergeUrl = (str) => {
-    if (!str.startsWith(urlPrefix))
-        return false;
-    const { binaryDocumentId: documentId } = parts(str);
-    return documentId ? true : false;
-};
-/**
- * generateAutomergeUrl produces a new AutomergeUrl.
- * generally only called by create(), but used in tests as well.
- * @returns a new Automerge URL with a random UUID documentId
- */
-export const generateAutomergeUrl = () => stringifyAutomergeUrl({
-    documentId: Uuid.v4(null, new Uint8Array(16)),
-});
-export const documentIdToBinary = (docId) => bs58check.decodeUnsafe(docId);
-export const binaryToDocumentId = (docId) => bs58check.encode(docId);
-export const parseLegacyUUID = (str) => {
-    if (Uuid.validate(str)) {
-        const uuid = Uuid.parse(str);
-        return stringifyAutomergeUrl({ documentId: uuid });
-    }
-    return undefined;
-};
-/**
- * parts breaks up the URL into constituent pieces,
- * eventually this could include things like heads, so we use this structure
- * we return both a binary & string-encoded version of the document ID
- * @param str
- * @returns { binaryDocumentId, documentId }
- */
-const parts = (str) => {
-    const regex = new RegExp(`^${urlPrefix}(\\w+)$`);
-    const [_, docMatch] = str.match(regex) || [];
-    const documentId = docMatch;
-    const binaryDocumentId = documentIdToBinary(documentId);
-    return { binaryDocumentId, documentId };
-};

package/src/DocUrl.ts

@@ -1,96 +0,0 @@
-import {
-  type AutomergeUrl,
-  type BinaryDocumentId,
-  type DocumentId,
-} from "./types.js"
-import * as Uuid from "uuid"
-import bs58check from "bs58check"
-
-export const urlPrefix = "automerge:"
-
-/**
- * given an Automerge URL, return a decoded DocumentId (and the encoded DocumentId)
- *
- * @param url
- * @returns { binaryDocumentId: BinaryDocumentId, documentId: DocumentId }
- */
-export const parseAutomergeUrl = (url: AutomergeUrl) => {
-  const { binaryDocumentId, documentId } = parts(url)
-  if (!binaryDocumentId) throw new Error("Invalid document URL: " + url)
-  return { binaryDocumentId, documentId }
-}
-
-/**
- * Given a documentId in either canonical form, return an Automerge URL
- * Throws on invalid input.
- * Note: this is an object because we anticipate adding fields in the future.
- * @param { documentId: BinaryDocumentId | DocumentId }
- * @returns AutomergeUrl
- */
-export const stringifyAutomergeUrl = ({
-  documentId,
-}: {
-  documentId: DocumentId | BinaryDocumentId
-}): AutomergeUrl => {
-  if (documentId instanceof Uint8Array)
-    return (urlPrefix +
-      binaryToDocumentId(documentId as BinaryDocumentId)) as AutomergeUrl
-  else if (typeof documentId === "string") {
-    return (urlPrefix + documentId) as AutomergeUrl
-  }
-  throw new Error("Invalid documentId: " + documentId)
-}
-
-/**
- * Given a string, return true if it is a valid Automerge URL
- * also acts as a type discriminator in Typescript.
- * @param str: URL candidate
- * @returns boolean
- */
-export const isValidAutomergeUrl = (str: string): str is AutomergeUrl => {
-  if (!str.startsWith(urlPrefix)) return false
-
-  const { binaryDocumentId: documentId } = parts(str)
-  return documentId ? true : false
-}
-
-/**
- * generateAutomergeUrl produces a new AutomergeUrl.
- * generally only called by create(), but used in tests as well.
- * @returns a new Automerge URL with a random UUID documentId
- */
-export const generateAutomergeUrl = (): AutomergeUrl =>
-  stringifyAutomergeUrl({
-    documentId: Uuid.v4(null, new Uint8Array(16)) as BinaryDocumentId,
-  })
-
-export const documentIdToBinary = (
-  docId: DocumentId
-): BinaryDocumentId | undefined =>
-  bs58check.decodeUnsafe(docId) as BinaryDocumentId | undefined
-
-export const binaryToDocumentId = (docId: BinaryDocumentId): DocumentId =>
-  bs58check.encode(docId) as DocumentId
-
-export const parseLegacyUUID = (str: string): AutomergeUrl | undefined => {
-  if (Uuid.validate(str)) {
-    const uuid = Uuid.parse(str) as BinaryDocumentId
-    return stringifyAutomergeUrl({ documentId: uuid })
-  }
-  return undefined
-}
-
-/**
- * parts breaks up the URL into constituent pieces,
- * eventually this could include things like heads, so we use this structure
- * we return both a binary & string-encoded version of the document ID
- * @param str
- * @returns { binaryDocumentId, documentId }
- */
-const parts = (str: string) => {
-  const regex = new RegExp(`^${urlPrefix}(\\w+)$`)
-  const [_, docMatch] = str.match(regex) || []
-  const documentId = docMatch as DocumentId
-  const binaryDocumentId = documentIdToBinary(documentId)
-  return { binaryDocumentId, documentId }
-}