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

package/dist/test/helpers/DummyStorageAdapter.js

@@ -0,0 +1,33 @@
+export class DummyStorageAdapter {
+  #data = {}
+  #keyToString(key) {
+    return key.join(".")
+  }
+  #stringToKey(key) {
+    return key.split(".")
+  }
+  async loadRange(keyPrefix) {
+    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) {
+    Object.entries(this.#data)
+      .filter(([key, _]) => key.startsWith(this.#keyToString(keyPrefix)))
+      .forEach(([key, _]) => delete this.#data[key])
+  }
+  async load(key) {
+    return new Promise(resolve => resolve(this.#data[this.#keyToString(key)]))
+  }
+  async save(key, binary) {
+    this.#data[this.#keyToString(key)] = binary
+    return Promise.resolve()
+  }
+  async remove(key) {
+    delete this.#data[this.#keyToString(key)]
+  }
+  keys() {
+    return Object.keys(this.#data)
+  }
+}

package/dist/test/helpers/generate-large-object.d.ts

@@ -0,0 +1,5 @@
+export type LargeObject = {
+  [key: string]: number
+}
+export declare function generateLargeObject(size: number): LargeObject
+//# sourceMappingURL=generate-large-object.d.ts.map

package/dist/test/helpers/generate-large-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-large-object.d.ts","sourceRoot":"","sources":["../../../test/helpers/generate-large-object.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAA;AAEnD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAU7D"}

package/dist/test/helpers/generate-large-object.js

@@ -0,0 +1,9 @@
+export function generateLargeObject(size) {
+  const largeObject = {}
+  for (let i = 0; i < size; i++) {
+    const key = `key${i}`
+    const value = Math.random()
+    largeObject[key] = value
+  }
+  return largeObject
+}

package/dist/test/helpers/getRandomItem.d.ts

@@ -0,0 +1,2 @@
+export declare const getRandomItem: <T>(obj: T[]) => T
+//# sourceMappingURL=getRandomItem.d.ts.map

package/dist/test/helpers/getRandomItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRandomItem.d.ts","sourceRoot":"","sources":["../../../test/helpers/getRandomItem.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,oBAGzB,CAAA"}

package/dist/test/helpers/getRandomItem.js

@@ -0,0 +1,4 @@
+export const getRandomItem = obj => {
+  const index = Math.floor(Math.random() * obj.length)
+  return obj[index]
+}

package/dist/test/types.d.ts

@@ -0,0 +1,4 @@
+export interface TestDoc {
+  foo: string
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../test/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAA;CACZ"}

package/dist/test/types.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automerge/automerge-repo",
-  "version": "2.0.0-alpha.6",
+  "version": "2.0.0-collectionsync-alpha.1",
   "description": "A repository object to manage a collection of automerge documents",
   "repository": "https://github.com/automerge/automerge-repo/tree/master/packages/automerge-repo",
   "author": "Peter van Hardenberg <pvh@pvh.ca>",
@@ -23,7 +23,7 @@
     "vite": "^5.0.8"
   },
   "dependencies": {
-    "@automerge/automerge": "^2.2.8",
+    "@automerge/automerge": "3.0.0-collectionsync-alpha.1",
     "bs58check": "^3.0.1",
     "cbor-x": "^1.3.0",
     "debug": "^4.3.4",
@@ -60,5 +60,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "87353a94d2e5d8facc1db359d9e6fa74e2ab8888"
+  "gitHead": "0a639a7d57bcee4e0a87890e6592b9582c2a5d6f"
 }

package/src/CollectionHandle.ts

@@ -0,0 +1,54 @@
+import { EventEmitter } from "eventemitter3"
+import { Ferigan, Index } from "./ferigan.js"
+import { AutomergeUrl, DocumentId } from "./types.js"
+import { next as A } from "@automerge/automerge"
+import { parseAutomergeUrl } from "./AutomergeUrl.js"
+
+export type CollectionHandleEvents = {
+  doc_added: (url: AutomergeUrl) => void
+}
+
+export class CollectionHandle extends EventEmitter<CollectionHandleEvents> {
+  //#index: Index
+  #beelay: A.beelay.Beelay
+  //#ferigan: Ferigan
+  #rootId: DocumentId
+  #rootUrl: AutomergeUrl
+  #entries: AutomergeUrl[] = []
+
+  get index(): Index {
+    return {
+      rootUrl: this.#rootUrl,
+      entries: this.#entries,
+    }
+  }
+
+  constructor(
+    belay: A.beelay.Beelay,
+    rootUrl: AutomergeUrl,
+    entries: AutomergeUrl[]
+  ) {
+    super()
+    this.#rootUrl = rootUrl
+    this.#rootId = parseAutomergeUrl(rootUrl).documentId
+    this.#beelay = belay
+    this.#entries = entries
+
+    //this.#ferigan.on("indexChanged", ({indexUrl, change}) => {
+    //if (indexUrl != this.#index.rootUrl) {
+    //return
+    //}
+
+    //if (change.type === "add") {
+    //this.#index.entries.push(change.url)
+    //this.emit("doc_added", change.url as AutomergeUrl)
+    //}
+    //})
+  }
+
+  add(url: AutomergeUrl): void {
+    this.#entries.push(url)
+    let docId = parseAutomergeUrl(url).documentId
+    this.#beelay.addLink({ from: this.#rootId, to: docId })
+  }
+}

package/src/DocHandle.ts

@@ -72,6 +72,9 @@ export class DocHandle<T> extends EventEmitter<DocHandleEvents<T>> {
           this.emit("delete", { handle: this })
           return { doc: A.init() }
         }),
+        onUnload: assign(() => {
+          return { doc: A.init() }
+        }),
         onUnavailable: () => {
           this.emit("unavailable", { handle: this })
         },
@@ -86,6 +89,7 @@ export class DocHandle<T> extends EventEmitter<DocHandleEvents<T>> {
       context: { documentId, doc },
       on: {
         UPDATE: { actions: "onUpdate" },
+        UNLOAD: ".unloaded",
         DELETE: ".deleted",
       },
       states: {
@@ -113,6 +117,12 @@ export class DocHandle<T> extends EventEmitter<DocHandleEvents<T>> {
           on: { DOC_READY: "ready" },
         },
         ready: {},
+        unloaded: {
+          entry: "onUnload",
+          on: {
+            RELOAD: "loading",
+          },
+        },
         deleted: { entry: "onDelete", type: "final" },
       },
     })
@@ -131,7 +141,7 @@ export class DocHandle<T> extends EventEmitter<DocHandleEvents<T>> {
 
     // Start the machine, and send a create or find event to get things going
     this.#machine.start()
-    this.#machine.send({ type: BEGIN })
+    this.begin()
   }
 
   // PRIVATE
@@ -203,6 +213,14 @@ export class DocHandle<T> extends EventEmitter<DocHandleEvents<T>> {
    */
   isReady = () => this.inState(["ready"])
 
+  /**
+   * @returns true if the document has been unloaded.
+   *
+   * Unloaded documents are freed from memory but not removed from local storage. It's not currently
+   * possible at runtime to reload an unloaded document.
+   */
+  isUnloaded = () => this.inState(["unloaded"])
+
   /**
    * @returns true if the document has been marked as deleted.
    *
@@ -291,6 +309,94 @@ export class DocHandle<T> extends EventEmitter<DocHandleEvents<T>> {
     return A.getHeads(this.#doc)
   }
 
+  begin() {
+    this.#machine.send({ type: BEGIN })
+  }
+
+  /**
+   * Creates a fixed "view" of an automerge document at the given point in time represented
+   * by the `heads` passed in. The return value is the same type as docSync() and will return
+   * undefined if the object hasn't finished loading.
+   *
+   * @remarks
+   * A point-in-time in an automerge document is an *array* of heads since there may be
+   * concurrent edits. This API just returns a topologically sorted history of all edits
+   * so every previous entry will be (in some sense) before later ones, but the set of all possible
+   * history views would be quite large under concurrency (every thing in each branch against each other).
+   * There might be a clever way to think about this, but we haven't found it yet, so for now at least
+   * we present a single traversable view which excludes concurrency.
+   * @returns The individual heads for every change in the document.
+   */
+  history(): A.Heads[] | undefined {
+    if (!this.isReady()) {
+      return undefined
+    }
+    // This just returns all the heads as individual strings.
+
+    return A.topoHistoryTraversal(this.#doc).map(h => [h]) as A.Heads[]
+  }
+
+  /**
+   * Creates a fixed "view" of an automerge document at the given point in time represented
+   * by the `heads` passed in. The return value is the same type as docSync() and will return
+   * undefined if the object hasn't finished loading.
+   *
+   * @remarks
+   * Note that our Typescript types do not consider change over time and the current version
+   * of Automerge doesn't check types at runtime, so if you go back to an old set of heads
+   * that doesn't match the heads here, Typescript will not save you.
+   *
+   * @returns An Automerge.Doc<T> at the point in time.
+   */
+  view(heads: A.Heads): A.Doc<T> | undefined {
+    if (!this.isReady()) {
+      return undefined
+    }
+    return A.view(this.#doc, heads)
+  }
+
+  /**
+   * Returns a set of Patch operations that will move a materialized document from one state to another
+   * if applied.
+   *
+   * @remarks
+   * We allow specifying both a from/to heads or just a single comparison point, in which case
+   * the base will be the current document heads.
+   *
+   * @returns Automerge patches that go from one document state to the other. Use view() to get the full state.
+   */
+  diff(first: A.Heads, second?: A.Heads): A.Patch[] | undefined {
+    if (!this.isReady()) {
+      return undefined
+    }
+    // We allow only one set of heads to be specified, in which case we use the doc's heads
+    const from = second ? first : this.heads() || [] // because we guard above this should always have useful data
+    const to = second ? second : first
+    return A.diff(this.#doc, from, to)
+  }
+
+  /**
+   * `metadata(head?)` allows you to look at the metadata for a change
+   * this can be used to build history graphs to find commit messages and edit times.
+   * this interface.
+   *
+   * @remarks
+   * I'm really not convinced this is the right way to surface this information so
+   * I'm leaving this API "hidden".
+   *
+   * @hidden
+   */
+  metadata(change?: string): A.DecodedChange | undefined {
+    if (!this.isReady()) {
+      return undefined
+    }
+    if (!change) {
+      change = this.heads()![0]
+    }
+    // we return undefined instead of null by convention in this API
+    return A.inspectChange(this.#doc, change) || undefined
+  }
+
   /**
    * `update` is called any time we have a new document state; could be
    * from a local change, a remote change, or a new document from storage.
@@ -421,6 +527,16 @@ export class DocHandle<T> extends EventEmitter<DocHandleEvents<T>> {
     if (this.#state === "loading") this.#machine.send({ type: REQUEST })
   }
 
+  /** Called by the repo to free memory used by the document. */
+  unload() {
+    this.#machine.send({ type: UNLOAD })
+  }
+
+  /** Called by the repo to reuse an unloaded handle. */
+  reload() {
+    this.#machine.send({ type: RELOAD })
+  }
+
   /** Called by the repo when the document is deleted. */
   delete() {
     this.#machine.send({ type: DELETE })
@@ -543,6 +659,8 @@ export const HandleState = {
   REQUESTING: "requesting",
   /** The document is available */
   READY: "ready",
+  /** The document has been unloaded from the handle, to free memory usage */
+  UNLOADED: "unloaded",
   /** The document has been deleted from the repo */
   DELETED: "deleted",
   /** The document was not available in storage or from any connected peers */
@@ -550,8 +668,15 @@ export const HandleState = {
 } as const
 export type HandleState = (typeof HandleState)[keyof typeof HandleState]
 
-export const { IDLE, LOADING, REQUESTING, READY, DELETED, UNAVAILABLE } =
-  HandleState
+export const {
+  IDLE,
+  LOADING,
+  REQUESTING,
+  READY,
+  UNLOADED,
+  DELETED,
+  UNAVAILABLE,
+} = HandleState
 
 // context
 
@@ -571,14 +696,18 @@ type DocHandleEvent<T> =
       type: typeof UPDATE
       payload: { callback: (doc: A.Doc<T>) => A.Doc<T> }
     }
-  | { type: typeof TIMEOUT }
+  | { type: typeof UNLOAD }
+  | { type: typeof RELOAD }
   | { type: typeof DELETE }
+  | { type: typeof TIMEOUT }
   | { type: typeof DOC_UNAVAILABLE }
 
 const BEGIN = "BEGIN"
 const REQUEST = "REQUEST"
 const DOC_READY = "DOC_READY"
 const UPDATE = "UPDATE"
+const UNLOAD = "UNLOAD"
+const RELOAD = "RELOAD"
 const DELETE = "DELETE"
 const TIMEOUT = "TIMEOUT"
 const DOC_UNAVAILABLE = "DOC_UNAVAILABLE"