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

package/src/helpers/abortable.ts

@@ -0,0 +1,62 @@
+/**
+ * Wraps a Promise and causes it to reject when the signal is aborted.
+ *
+ * @remarks
+ * This utility wraps a Promise and rejects when the provided AbortSignal is aborted.
+ * It's designed to make Promise awaits abortable.
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController();
+ *
+ * try {
+ *   const result = await abortable(fetch('https://api.example.com/data'), controller.signal);
+ *   // Meanwhile, to abort in concurrent code before the above line returns: controller.abort();
+ * } catch (err) {
+ *   if (err.name === 'AbortError') {
+ *     console.log('The operation was aborted');
+ *   }
+ * }
+ *
+ * ```
+ *
+ * @param p - A Promise to wrap
+ * @param signal - An AbortSignal that can be used to abort the operation
+ * @returns A wrapper Promise that rejects with AbortError if the signal is aborted
+ * before the promise p settles, and settles as p settles otherwise
+ * @throws {DOMException} With name "AbortError" if aborted before p settles
+ */
+
+export function abortable<T>(
+  p: Promise<T>,
+  signal: AbortSignal | undefined
+): Promise<T> {
+  let settled = false
+  return new Promise((resolve, reject) => {
+    signal?.addEventListener(
+      "abort",
+      () => {
+        if (!settled) {
+          reject(new DOMException("Operation aborted", "AbortError"))
+        }
+      },
+      { once: true }
+    )
+    p.then(result => {
+      resolve(result)
+    })
+      .catch(error => {
+        reject(error)
+      })
+      .finally(() => {
+        settled = true
+      })
+  })
+}
+
+/**
+ * Include this type in an options object to pass an AbortSignal to a function.
+ */
+export interface AbortOptions {
+  signal?: AbortSignal
+}

package/src/helpers/bufferFromHex.ts

@@ -0,0 +1,14 @@
+export const uint8ArrayFromHexString = (hexString: string): Uint8Array => {
+  if (hexString.length % 2 !== 0) {
+    throw new Error("Hex string must have an even length")
+  }
+  const bytes = new Uint8Array(hexString.length / 2)
+  for (let i = 0; i < hexString.length; i += 2) {
+    bytes[i >> 1] = parseInt(hexString.slice(i, i + 2), 16)
+  }
+  return bytes
+}
+
+export const uint8ArrayToHexString = (data: Uint8Array): string => {
+  return Array.from(data, byte => byte.toString(16).padStart(2, "0")).join("")
+}

package/src/helpers/headsAreSame.ts

@@ -1,6 +1,6 @@
-import { Heads } from "@automerge/automerge/slim/next"
 import { arraysAreEqual } from "./arraysAreEqual.js"
+import type { UrlHeads } from "../types.js"
 
-export const headsAreSame = (a: Heads, b: Heads) => {
+export const headsAreSame = (a: UrlHeads, b: UrlHeads) => {
   return arraysAreEqual(a, b)
 }

package/src/helpers/tests/network-adapter-tests.ts

@@ -49,9 +49,10 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
         // Alice creates a document
         const aliceHandle = aliceRepo.create<TestDoc>()
 
-        // Bob receives the document
-        await eventPromise(bobRepo, "document")
-        const bobHandle = bobRepo.find<TestDoc>(aliceHandle.url)
+        // TODO: ... let connections complete. this shouldn't be necessary.
+        await pause(50)
+
+        const bobHandle = await bobRepo.find<TestDoc>(aliceHandle.url)
 
         // Alice changes the document
         aliceHandle.change(d => {
@@ -60,7 +61,7 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
 
         // Bob receives the change
         await eventPromise(bobHandle, "change")
-        assert.equal((await bobHandle.doc())?.foo, "bar")
+        assert.equal((await bobHandle).doc()?.foo, "bar")
 
         // Bob changes the document
         bobHandle.change(d => {
@@ -69,7 +70,7 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
 
         // Alice receives the change
         await eventPromise(aliceHandle, "change")
-        assert.equal((await aliceHandle.doc())?.foo, "baz")
+        assert.equal(aliceHandle.doc().foo, "baz")
       }
 
       // Run the test in both directions, in case they're different types of adapters
@@ -100,9 +101,9 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
       const docUrl = aliceHandle.url
 
       // Bob and Charlie receive the document
-      await eventPromises([bobRepo, charlieRepo], "document")
-      const bobHandle = bobRepo.find<TestDoc>(docUrl)
-      const charlieHandle = charlieRepo.find<TestDoc>(docUrl)
+      await pause(50)
+      const bobHandle = await bobRepo.find<TestDoc>(docUrl)
+      const charlieHandle = await charlieRepo.find<TestDoc>(docUrl)
 
       // Alice changes the document
       aliceHandle.change(d => {
@@ -111,8 +112,8 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
 
       // Bob and Charlie receive the change
       await eventPromises([bobHandle, charlieHandle], "change")
-      assert.equal((await bobHandle.doc())?.foo, "bar")
-      assert.equal((await charlieHandle.doc())?.foo, "bar")
+      assert.equal(bobHandle.doc().foo, "bar")
+      assert.equal(charlieHandle.doc().foo, "bar")
 
       // Charlie changes the document
       charlieHandle.change(d => {
@@ -121,8 +122,8 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
 
       // Alice and Bob receive the change
       await eventPromises([aliceHandle, bobHandle], "change")
-      assert.equal((await bobHandle.doc())?.foo, "baz")
-      assert.equal((await charlieHandle.doc())?.foo, "baz")
+      assert.equal(bobHandle.doc().foo, "baz")
+      assert.equal(charlieHandle.doc().foo, "baz")
 
       teardown()
     })
@@ -141,7 +142,7 @@ export function runNetworkAdapterTests(_setup: SetupFn, title?: string): void {
       )
 
       const aliceHandle = aliceRepo.create<TestDoc>()
-      const charlieHandle = charlieRepo.find(aliceHandle.url)
+      const charlieHandle = await charlieRepo.find(aliceHandle.url)
 
       // pause to give charlie a chance to let alice know it wants the doc
       await pause(100)

package/src/helpers/tests/storage-adapter-tests.ts

@@ -67,20 +67,16 @@ export function runStorageAdapterTests(setup: SetupFn, title?: string): void {
         await adapter.save(["AAAAA", "snapshot", "yyyyy"], PAYLOAD_B())
         await adapter.save(["AAAAA", "sync-state", "zzzzz"], PAYLOAD_C())
 
-        expect(await adapter.loadRange(["AAAAA"])).toStrictEqual(
-          expect.arrayContaining([
-            { key: ["AAAAA", "sync-state", "xxxxx"], data: PAYLOAD_A() },
-            { key: ["AAAAA", "snapshot", "yyyyy"], data: PAYLOAD_B() },
-            { key: ["AAAAA", "sync-state", "zzzzz"], data: PAYLOAD_C() },
-          ])
-        )
-
-        expect(await adapter.loadRange(["AAAAA", "sync-state"])).toStrictEqual(
-          expect.arrayContaining([
-            { key: ["AAAAA", "sync-state", "xxxxx"], data: PAYLOAD_A() },
-            { key: ["AAAAA", "sync-state", "zzzzz"], data: PAYLOAD_C() },
-          ])
-        )
+        expect(await adapter.loadRange(["AAAAA"])).toStrictEqual([
+          { key: ["AAAAA", "sync-state", "xxxxx"], data: PAYLOAD_A() },
+          { key: ["AAAAA", "snapshot", "yyyyy"], data: PAYLOAD_B() },
+          { key: ["AAAAA", "sync-state", "zzzzz"], data: PAYLOAD_C() },
+        ])
+
+        expect(await adapter.loadRange(["AAAAA", "sync-state"])).toStrictEqual([
+          { key: ["AAAAA", "sync-state", "xxxxx"], data: PAYLOAD_A() },
+          { key: ["AAAAA", "sync-state", "zzzzz"], data: PAYLOAD_C() },
+        ])
       })
 
       it("should only load values that match they key", async ({ adapter }) => {
@@ -88,16 +84,9 @@ export function runStorageAdapterTests(setup: SetupFn, title?: string): void {
         await adapter.save(["BBBBB", "sync-state", "zzzzz"], PAYLOAD_C())
 
         const actual = await adapter.loadRange(["AAAAA"])
-        expect(actual).toStrictEqual(
-          expect.arrayContaining([
-            { key: ["AAAAA", "sync-state", "xxxxx"], data: PAYLOAD_A() },
-          ])
-        )
-        expect(actual).toStrictEqual(
-          expect.not.arrayContaining([
-            { key: ["BBBBB", "sync-state", "zzzzz"], data: PAYLOAD_C() },
-          ])
-        )
+        expect(actual).toStrictEqual([
+          { key: ["AAAAA", "sync-state", "xxxxx"], data: PAYLOAD_A() },
+        ])
       })
     })
 

package/src/index.ts

@@ -34,6 +34,8 @@ export {
   stringifyAutomergeUrl,
   interpretAsDocumentId,
   generateAutomergeUrl,
+  encodeHeads,
+  decodeHeads,
 } from "./AutomergeUrl.js"
 export { Repo } from "./Repo.js"
 export { NetworkAdapter } from "./network/NetworkAdapter.js"
@@ -41,8 +43,7 @@ export type { NetworkAdapterInterface } from "./network/NetworkAdapterInterface.
 export { isRepoMessage } from "./network/messages.js"
 export { StorageAdapter } from "./storage/StorageAdapter.js"
 export type { StorageAdapterInterface } from "./storage/StorageAdapterInterface.js"
-export type { Index, Progress } from "./ferigan.js"
-export { CollectionHandle } from "./CollectionHandle.js"
+import { next as Automerge } from "@automerge/automerge/slim"
 
 /** @hidden **/
 export * as cbor from "./helpers/cbor.js"
@@ -77,6 +78,11 @@ export type {
   PeerMetadata,
 } from "./network/NetworkAdapterInterface.js"
 
+export type {
+  NetworkSubsystemEvents,
+  PeerPayload,
+} from "./network/NetworkSubsystem.js"
+
 export type {
   DocumentUnavailableMessage,
   EphemeralMessage,
@@ -96,46 +102,59 @@ export type {
 
 export * from "./types.js"
 
-// export commonly used data types
-export { Counter, RawString } from "@automerge/automerge/slim/next"
-
-// export some automerge API types
-export type {
-  Doc,
-  Heads,
-  Patch,
-  PatchCallback,
-  Prop,
-  ActorId,
-  Change,
-  ChangeFn,
-  Mark,
-  MarkSet,
-  MarkRange,
-  MarkValue,
-  Cursor,
-} from "@automerge/automerge/slim/next"
+// Automerge re-exports
+//
+// Note that we can't use export type { .. } from "@automerge/automerge" because we are
+// importing automerge like this:
+//
+// import { next as Automerge } from "@automerge/automerge"
+//
+// I.e. we are using the `next` export from Automerge. Not the module itself. This is
+// to maintain compatiblity with Automerge 3.0 and 2.0. In 2.0 we used to have a
+// subpath export at `/next` so the re-exports looked like this:
+//
+// export { type .. } from "@automerge/automerge/slim/next"
+//
+// However, we have now removed the subpath export (and deprecated next generally)
+// so we need to explicitly name each type we are re-exporting here.
+export const Counter = Automerge.Counter
+export const RawString = Automerge.RawString
+// In automerge 3.0 RawString is renamed to ImmutableString
+export const ImmutableString = Automerge.RawString
+export type Counter = Automerge.Counter
+export type Doc<T> = Automerge.Doc<T>
+export type Heads = Automerge.Heads
+export type Patch = Automerge.Patch
+export type PatchCallback<T> = Automerge.PatchCallback<T>
+export type Prop = Automerge.Prop
+export type ActorId = Automerge.ActorId
+export type Change = Automerge.Change
+export type ChangeFn<T> = Automerge.ChangeFn<T>
+export type Mark = Automerge.Mark
+export type MarkSet = Automerge.MarkSet
+export type MarkRange = Automerge.MarkRange
+export type MarkValue = Automerge.MarkValue
+export type Cursor = Automerge.Cursor
 
 // export a few utility functions that aren't in automerge-repo
 // NB that these should probably all just be available via the dochandle
-export {
-  getChanges,
-  getAllChanges,
-  applyChanges,
-  view,
-  getConflicts,
-} from "@automerge/automerge/slim/next"
+export const getChanges = Automerge.getChanges
+export const getAllChanges = Automerge.getAllChanges
+export const applyChanges = Automerge.applyChanges
+export const view = Automerge.view
+export const getConflicts = Automerge.getConflicts
 
 // export type-specific utility functions
 // these mostly can't be on the data-type in question because
 // JS strings can't have methods added to them
-export {
-  getCursor,
-  getCursorPosition,
-  splice,
-  updateText,
-  insertAt,
-  deleteAt,
-  mark,
-  unmark,
-} from "@automerge/automerge/slim/next"
+export const getCursor = Automerge.getCursor
+export const getCursorPosition = Automerge.getCursorPosition
+export const splice = Automerge.splice
+export const updateText = Automerge.updateText
+export const insertAt = Automerge.insertAt
+export const deleteAt = Automerge.deleteAt
+export const mark = Automerge.mark
+export const unmark = Automerge.unmark
+export const isRawString = Automerge.isRawString
+// In Automerge 3.0 raw string is renamed to immutable string
+export const isImmutableString = Automerge.isRawString

package/src/network/NetworkSubsystem.ts

@@ -38,10 +38,6 @@ export class NetworkSubsystem extends EventEmitter<NetworkSubsystemEvents> {
     adapters.forEach(a => this.addNetworkAdapter(a))
   }
 
-  get peers(): PeerId[] {
-    return Array.from(Object.keys(this.#adaptersByPeer)) as PeerId[]
-  }
-
   disconnect() {
     this.adapters.forEach(a => a.disconnect())
   }

package/src/network/messages.ts

@@ -130,14 +130,6 @@ export type RepoMessage =
   | DocumentUnavailableMessage
   | RemoteSubscriptionControlMessage
   | RemoteHeadsChanged
-  | BeelayMessage
-
-export type BeelayMessage = {
-  type: "beelay"
-  senderId: PeerId
-  targetId: PeerId
-  message: Uint8Array
-}
 
 /** These are message types that are handled by the {@link CollectionSynchronizer}.*/
 export type DocMessage =
@@ -175,11 +167,10 @@ export const isRepoMessage = (message: Message): message is RepoMessage =>
   isRequestMessage(message) ||
   isDocumentUnavailableMessage(message) ||
   isRemoteSubscriptionControlMessage(message) ||
-  isRemoteHeadsChanged(message) ||
-  true
+  isRemoteHeadsChanged(message)
 
 // prettier-ignore
-export const isDocumentUnavailableMessage = (msg: Message): msg is DocumentUnavailableMessage =>
+export const isDocumentUnavailableMessage = (msg: Message): msg is DocumentUnavailableMessage => 
   msg.type === "doc-unavailable"
 
 export const isRequestMessage = (msg: Message): msg is RequestMessage =>

package/src/storage/StorageAdapter.ts

@@ -34,45 +34,3 @@ export abstract class StorageAdapter implements StorageAdapterInterface {
   /** Remove all values with keys that start with `keyPrefix` */
   abstract removeRange(keyPrefix: StorageKey): Promise<void>
 }
-
-export class InMemoryStorageAdapter extends StorageAdapter {
-  #data: Record<string, Uint8Array> = {}
-
-  #keyToString(key: string[]): string {
-    return key.join(".")
-  }
-
-  #stringToKey(key: string): string[] {
-    return key.split(".")
-  }
-
-  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 }))
-    return Promise.resolve(range)
-  }
-
-  async removeRange(keyPrefix: string[]): Promise<void> {
-    Object.entries(this.#data)
-      .filter(([key, _]) => key.startsWith(this.#keyToString(keyPrefix)))
-      .forEach(([key, _]) => delete this.#data[key])
-  }
-
-  async load(key: string[]): Promise<Uint8Array | undefined> {
-    return new Promise(resolve => resolve(this.#data[this.#keyToString(key)]))
-  }
-
-  async save(key: string[], binary: Uint8Array) {
-    this.#data[this.#keyToString(key)] = binary
-    return Promise.resolve()
-  }
-
-  async remove(key: string[]) {
-    delete this.#data[this.#keyToString(key)]
-  }
-
-  keys() {
-    return Object.keys(this.#data)
-  }
-}