@fireproof/core 0.0.2 → 0.0.3

package/src/blockstore.js

@@ -3,11 +3,23 @@ import * as raw from 'multiformats/codecs/raw'
 import { sha256 } from 'multiformats/hashes/sha2'
 import * as Block from 'multiformats/block'
 import * as CBW from '@ipld/car/buffer-writer'
+import { CID } from 'multiformats'
 
 import Valet from './valet.js'
 
 // const sleep = ms => new Promise(r => setTimeout(r, ms))
 
+const husherMap = new Map()
+const husher = (id, workFn) => {
+  if (!husherMap.has(id)) {
+    husherMap.set(
+      id,
+      workFn().finally(() => setTimeout(() => husherMap.delete(id), 100))
+    )
+  }
+  return husherMap.get(id)
+}
+
 /**
  * @typedef {Object} AnyBlock
  * @property {import('./link').AnyLink} cid - The CID of the block
@@ -24,7 +36,7 @@ export default class TransactionBlockstore {
   /** @type {Map<string, Uint8Array>} */
   #oldBlocks = new Map()
 
-  #valet = new Valet() // cars by cid
+  valet = new Valet() // cars by cid
 
   #instanceId = 'blkz.' + Math.random().toString(36).substring(2, 4)
   #inflightTransactions = new Set()
@@ -38,10 +50,10 @@ export default class TransactionBlockstore {
   async get (cid) {
     const key = cid.toString()
     // it is safe to read from the in-flight transactions becauase they are immutable
-    // const bytes = this.#oldBlocks.get(key) || await this.#valet.getBlock(key)
-    const bytes = await this.#transactionsGet(key) || await this.commitedGet(key)
-    // const bytes = this.#blocks.get(key) || await this.#valet.getBlock(key)
-    // console.log('bytes', typeof bytes)
+    const bytes = await Promise.any([this.#transactionsGet(key), this.commitedGet(key)]).catch((e) => {
+      console.log('networkGet', cid.toString(), e)
+      return this.networkGet(key)
+    })
     if (!bytes) throw new Error('Missing block: ' + key)
     return { cid, bytes }
   }
@@ -53,11 +65,30 @@ export default class TransactionBlockstore {
       const got = await transaction.get(key)
       if (got && got.bytes) return got.bytes
     }
+    throw new Error('Missing block: ' + key)
   }
 
   async commitedGet (key) {
-    return this.#oldBlocks.get(key) || await this.#valet.getBlock(key)
-    // return await this.#valet.getBlock(key) // todo this is just for testing
+    const old = this.#oldBlocks.get(key)
+    if (old) return old
+    return await this.valet.getBlock(key)
+  }
+
+  async networkGet (key) {
+    if (this.valet.remoteBlockFunction) {
+      const value = await husher(key, async () => await this.valet.remoteBlockFunction(key))
+      if (value) {
+        // console.log('networkGot: ' + key, value.length)
+        // dont turn this on until the Nan thing is fixed
+        // it keep the network blocks in indexedb but lets get the basics solid first
+        doTransaction('networkGot: ' + key, this, async (innerBlockstore) => {
+          await innerBlockstore.put(CID.parse(key), value)
+        })
+        return value
+      }
+    } else {
+      throw new Error('No remoteBlockFunction')
+    }
   }
 
   /**
@@ -91,11 +122,11 @@ export default class TransactionBlockstore {
   }
 
   /**
-     * Begin a transaction. Ensures the uncommited blocks are empty at the begining.
-     * Returns the blocks to read and write during the transaction.
-     * @returns {InnerBlockstore}
-     * @memberof TransactionBlockstore
-     */
+   * Begin a transaction. Ensures the uncommited blocks are empty at the begining.
+   * Returns the blocks to read and write during the transaction.
+   * @returns {InnerBlockstore}
+   * @memberof TransactionBlockstore
+   */
   begin (label = '') {
     const innerTransactionBlockstore = new InnerBlockstore(label, this)
     this.#inflightTransactions.add(innerTransactionBlockstore)
@@ -103,10 +134,10 @@ export default class TransactionBlockstore {
   }
 
   /**
-     * Commit the transaction. Writes the blocks to the store.
-     * @returns {Promise<void>}
-     * @memberof TransactionBlockstore
-     */
+   * Commit the transaction. Writes the blocks to the store.
+   * @returns {Promise<void>}
+   * @memberof TransactionBlockstore
+   */
   async commit (innerBlockstore) {
     await this.#doCommit(innerBlockstore)
   }
@@ -128,7 +159,7 @@ export default class TransactionBlockstore {
       }
     }
     if (cids.size > 0) {
-      console.log(innerBlockstore.label, 'committing', cids.size, 'blocks')
+      // console.log(innerBlockstore.label, 'committing', cids.size, 'blocks')
       await this.#valetWriteTransaction(innerBlockstore, cids)
     }
   }
@@ -144,15 +175,15 @@ export default class TransactionBlockstore {
   #valetWriteTransaction = async (innerBlockstore, cids) => {
     if (innerBlockstore.lastCid) {
       const newCar = await blocksToCarBlock(innerBlockstore.lastCid, innerBlockstore)
-      await this.#valet.parkCar(newCar.cid.toString(), newCar.bytes, cids)
+      await this.valet.parkCar(newCar.cid.toString(), newCar.bytes, cids)
     }
   }
 
   /**
-     * Retire the transaction. Clears the uncommited blocks.
-     * @returns {void}
-     * @memberof TransactionBlockstore
-     */
+   * Retire the transaction. Clears the uncommited blocks.
+   * @returns {void}
+   * @memberof TransactionBlockstore
+   */
   retire (innerBlockstore) {
     this.#inflightTransactions.delete(innerBlockstore)
   }

package/src/db-index.js

@@ -16,16 +16,14 @@ const makeGetBlock = (blocks) => async (address) => {
 }
 const makeDoc = ({ key, value }) => ({ _id: key, ...value })
 
-console.x = function () {}
-
 /**
- * Transforms a set of changes to index entries using a map function.
+ * Transforms a set of changes to DbIndex entries using a map function.
  *
  * @param {Array<{ key: string, value: import('./link').AnyLink, del?: boolean }>} changes
  * @param {Function} mapFun
- * @returns {Array<{ key: [string, string], value: any }>} The index entries generated by the map function.
+ * @returns {Array<{ key: [string, string], value: any }>} The DbIndex entries generated by the map function.
+ * @private
  */
-
 const indexEntriesForChanges = (changes, mapFun) => {
   const indexEntries = []
   changes.forEach(({ key, value, del }) => {
@@ -49,24 +47,19 @@ const indexEntriesForOldChanges = async (blocks, byIDindexRoot, ids, mapFun) =>
 }
 
 /**
- * Represents an index for a Fireproof database.
+ * Represents an DbIndex for a Fireproof database.
  *
- * @class
- * @classdesc An index can be used to order and filter the documents in a Fireproof database.
+ * @class DbIndex
+ * @classdesc An DbIndex can be used to order and filter the documents in a Fireproof database.
  *
- * @param {import('./fireproof').Fireproof} database - The Fireproof database instance to index.
+ * @param {import('./fireproof').Fireproof} database - The Fireproof database instance to DbIndex.
  * @param {Function} mapFun - The map function to apply to each entry in the database.
  *
  */
-export default class Index {
-  /**
-   * Creates a new index with the given map function and database.
-   * @param {import('./fireproof').Fireproof} database - The Fireproof database instance to index.
-   * @param {Function} mapFun - The map function to apply to each entry in the database.
-   */
+export default class DbIndex {
   constructor (database, mapFun) {
     /**
-     * The database instance to index.
+     * The database instance to DbIndex.
      * @type {import('./fireproof').Fireproof}
      */
     this.database = database
@@ -82,24 +75,29 @@ export default class Index {
 
   /**
    * Query object can have {range}
-   *
+   * @param {Object<{range:[startKey, endKey]}>} query - the query range to use
+   * @param {CID} [root] - an optional root to query a snapshot
+   * @returns {Promise<{rows: Array<{id: string, key: string, value: any}>}>}
+   * @memberof DbIndex
+   * @instance
    */
   async query (query, root = null) {
-    if (!root) { // pass a root to query a snapshot
+    if (!root) {
+      // pass a root to query a snapshot
       await doTransaction('#updateIndex', this.database.blocks, async (blocks) => {
         await this.#updateIndex(blocks)
       })
     }
     const response = await doIndexQuery(this.database.blocks, root || this.indexRoot, query)
     return {
-      // TODO fix this naming upstream in prolly/db-index
+      // TODO fix this naming upstream in prolly/db-DbIndex
       // todo maybe this is a hint about why deletes arent working?
       rows: response.result.map(({ id, key, row }) => ({ id: key, key: charwise.decode(id), value: row }))
     }
   }
 
   /**
-   * Update the index with the latest changes
+   * Update the DbIndex with the latest changes
    * @private
    * @returns {Promise<void>}
    */
@@ -111,16 +109,23 @@ export default class Index {
     }
     const result = await this.database.changesSince(this.dbHead) // {key, value, del}
     if (this.dbHead) {
-      const oldIndexEntries = (await indexEntriesForOldChanges(blocks, this.byIDindexRoot, result.rows.map(({ key }) => key), this.mapFun))
+      const oldIndexEntries = (
+        await indexEntriesForOldChanges(
+          blocks,
+          this.byIDindexRoot,
+          result.rows.map(({ key }) => key),
+          this.mapFun
+        )
+      )
         // .map((key) => ({ key, value: null })) // tombstone just adds more rows...
         .map((key) => ({ key, del: true })) // should be this
-        // .map((key) => ({ key: undefined, del: true })) // todo why does this work?
+      // .map((key) => ({ key: undefined, del: true })) // todo why does this work?
 
       this.indexRoot = await bulkIndex(blocks, this.indexRoot, oldIndexEntries, opts)
       // console.x('oldIndexEntries', oldIndexEntries)
       // [ { key: ['b', 1], del: true } ]
       // [ { key: [ 5, 'x' ], del: true } ]
-      // for now we just let the by id index grow and then don't use the results...
+      // for now we just let the by id DbIndex grow and then don't use the results...
       // const removeByIdIndexEntries = oldIndexEntries.map(({ key }) => ({ key: key[1], del: true }))
       // this.byIDindexRoot = await bulkIndex(blocks, this.byIDindexRoot, removeByIdIndexEntries, opts)
     }
@@ -130,67 +135,69 @@ export default class Index {
     this.byIDindexRoot = await bulkIndex(blocks, this.byIDindexRoot, byIdIndexEntries, opts)
     // console.log('indexEntries', indexEntries)
     this.indexRoot = await bulkIndex(blocks, this.indexRoot, indexEntries, opts)
-    // console.log('did index', this.indexRoot)
+    // console.log('did DbIndex', this.indexRoot)
     this.dbHead = result.clock
   }
 
-  // todo use the index from other peers?
+  // todo use the DbIndex from other peers?
   // we might need to add CRDT logic to it for that
   // it would only be a performance improvement, but might add a lot of complexity
   //   advanceIndex ()) {}
 }
 
 /**
- * Update the index with the given entries
+ * Update the DbIndex with the given entries
  * @param {Blockstore} blocks
  * @param {import('multiformats/block').Block} inRoot
- * @param {import('prolly-trees/db-index').IndexEntry[]} indexEntries
+ * @param {import('prolly-trees/db-DbIndex').IndexEntry[]} indexEntries
+ * @private
  */
 async function bulkIndex (blocks, inRoot, indexEntries) {
   if (!indexEntries.length) return inRoot
   const putBlock = blocks.put.bind(blocks)
   const getBlock = makeGetBlock(blocks)
   if (!inRoot) {
-    // make a new index
+    // make a new DbIndex
 
     for await (const node of await create({ get: getBlock, list: indexEntries, ...opts })) {
       const block = await node.block
       await putBlock(block.cid, block.bytes)
       inRoot = block
     }
-    // console.x('created index', inRoot.cid)
+    // console.x('created DbIndex', inRoot.cid)
     return inRoot
   } else {
-    // load existing index
-    // console.x('loading index', inRoot.cid)
-    const index = await load({ cid: inRoot.cid, get: getBlock, ...opts })
+    // load existing DbIndex
+    // console.x('loading DbIndex', inRoot.cid)
+    const DbIndex = await load({ cid: inRoot.cid, get: getBlock, ...opts })
     // console.log('new indexEntries', indexEntries)
-    const { root, blocks } = await index.bulk(indexEntries)
+    const { root, blocks } = await DbIndex.bulk(indexEntries)
     for await (const block of blocks) {
       await putBlock(block.cid, block.bytes)
     }
-    // console.x('updated index', root.block.cid)
+    // console.x('updated DbIndex', root.block.cid)
     return await root.block // if we hold the root we won't have to load every time
   }
 }
 
 /**
- * Query the index for the given range
+ * Query the DbIndex for the given range
  * @param {Blockstore} blocks
  * @param {import('multiformats/block').Block} inRoot
- * @param {import('prolly-trees/db-index').Query} query
- * @returns {Promise<import('prolly-trees/db-index').QueryResult>}
+ * @param {import('prolly-trees/db-DbIndex').Query} query
+ * @returns {Promise<import('prolly-trees/db-DbIndex').QueryResult>}
+ * @private
  **/
 async function doIndexQuery (blocks, root, query) {
   const cid = root && root.cid
   if (!cid) return { result: [] }
   const getBlock = makeGetBlock(blocks)
-  const index = await load({ cid, get: getBlock, ...opts })
+  const DbIndex = await load({ cid, get: getBlock, ...opts })
   if (query.range) {
     const encodedRange = query.range.map((key) => charwise.encode(key))
-    return index.range(...encodedRange)
+    return DbIndex.range(...encodedRange)
   } else if (query.key) {
     const encodedKey = charwise.encode(query.key)
-    return index.get(encodedKey)
+    return DbIndex.get(encodedKey)
   }
 }

package/src/fireproof.js

@@ -1,44 +1,51 @@
-// import { vis } from './clock.js'
 import { put, get, getAll, eventsSince } from './prolly.js'
 import Blockstore, { doTransaction } from './blockstore.js'
 
 // const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
 
 /**
- * Represents a Fireproof instance that wraps a ProllyDB instance and Merkle clock head.
+ * @class Fireproof
+ * @classdesc Fireproof stores data in IndexedDB and provides a Merkle clock.
+ *  This is the main class for saving and loading JSON and other documents with the database. You can find additional examples and
+ *  usage guides in the repository README.
  *
- * @class
- * @classdesc A Fireproof instance can be used to store and retrieve values from a ProllyDB instance.
- *
- * @param {Blockstore} blocks - The block storage instance to use for the underlying ProllyDB instance.
- * @param {import('../clock').EventLink<import('../crdt').EventData>[]} clock - The Merkle clock head to use for the Fireproof instance.
+ * @param {Blockstore} blocks - The block storage instance to use documents and indexes
+ * @param {CID[]} clock - The Merkle clock head to use for the Fireproof instance.
  * @param {object} [config] - Optional configuration options for the Fireproof instance.
  * @param {object} [authCtx] - Optional authorization context object to use for any authentication checks.
  *
  */
-
 export default class Fireproof {
+  #listeners = new Set()
+
   /**
-   * @param {Blockstore} blocks
-   * @param {import('../clock').EventLink<import('../crdt').EventData>[]} clock
+   * @function storage
+   * @memberof Fireproof
+   * Creates a new Fireproof instance with default storage settings
+   * Most apps should use this and not worry about the details.
+   * @static
+   * @returns {Fireproof} - a new Fireproof instance
    */
-  #listeners = new Set()
+  static storage = () => {
+    return new Fireproof(new Blockstore(), [])
+  }
 
   constructor (blocks, clock, config = {}, authCtx = {}) {
     this.blocks = blocks
     this.clock = clock
     this.config = config
     this.authCtx = authCtx
-    this.instanceId = 'db.' + Math.random().toString(36).substring(2, 7)
+    this.instanceId = 'fp.' + Math.random().toString(36).substring(2, 7)
   }
 
   /**
-   * Returns a snapshot of the current Fireproof instance.
-   *
-   * @param {import('../clock').EventLink<import('../crdt').EventData>[]} clock
-   *    Clock to use for the snapshot.
+   * Returns a snapshot of the current Fireproof instance as a new instance.
+   * @function snapshot
+   * @param {CID[]} clock - The Merkle clock head to use for the snapshot.
    * @returns {Fireproof}
    *    A new Fireproof instance representing the snapshot.
+   * @memberof Fireproof
+   * @instance
    */
   snapshot (clock) {
     // how to handle listeners, views, and config?
@@ -47,14 +54,26 @@ export default class Fireproof {
   }
 
   /**
-   * This triggers a notification to all listeners of the Fireproof instance.
+   * Move the current instance to a new point in time. This triggers a notification to all listeners
+   * of the Fireproof instance so they can repaint UI, etc.
+   * @param {CID[] } clock
+   *    Clock to use for the snapshot.
+   * @returns {Promise<void>}
+   * @memberof Fireproof
+   * @instance
    */
   async setClock (clock) {
     // console.log('setClock', this.instanceId, clock)
-    this.clock = clock.map((item) => item['/'] ? item['/'] : item)
+    this.clock = clock.map((item) => (item['/'] ? item['/'] : item))
     await this.#notifyListeners({ reset: true, clock })
   }
 
+  /**
+   * Renders the Fireproof instance as a JSON object.
+   * @returns {Object} - The JSON representation of the Fireproof instance. Includes clock heads for the database and its indexes.
+   * @memberof Fireproof
+   * @instance
+   */
   toJSON () {
     // todo this also needs to return the index roots...
     return { clock: this.clock }
@@ -62,13 +81,11 @@ export default class Fireproof {
 
   /**
    * Returns the changes made to the Fireproof instance since the specified event.
-   *
-   * @param {import('../clock').EventLink<import('../crdt').EventData>?} event -
-   * The event to retrieve changes since. If null or undefined, retrieves all changes.
-   * @returns {Promise<{
-   *   rows: { key: string, value?: any, del?: boolean }[],
-   *   head: import('../clock').EventLink<import('../crdt').EventData>[]
-   * }>} - An object `{rows : [...{key, value, del}], head}` containing the rows and the head of the instance's clock.
+   * @function changesSince
+   * @param {CID[]} [event] - The clock head to retrieve changes since. If null or undefined, retrieves all changes.
+   * @returns {Object<{rows : Object[], clock: CID[]}>} An object containing the rows and the head of the instance's clock.
+   * @memberof Fireproof
+   * @instance
    */
   async changesSince (event) {
     // console.log('changesSince', this.instanceId, event, this.clock)
@@ -97,6 +114,7 @@ export default class Fireproof {
    * Recieves live changes from the database after they are committed.
    * @param {Function} listener - The listener to be called when the clock is updated.
    * @returns {Function} - A function that can be called to unregister the listener.
+   * @memberof Fireproof
    */
   registerListener (listener) {
     this.#listeners.add(listener)
@@ -107,15 +125,21 @@ export default class Fireproof {
 
   async #notifyListeners (changes) {
     // await sleep(0)
-    this.#listeners.forEach((listener) => listener(changes))
+    for (const listener of this.#listeners) {
+      await listener(changes)
+    }
   }
 
   /**
-   * Runs validation on the specified document using the Fireproof instance's configuration.
+   * Runs validation on the specified document using the Fireproof instance's configuration. Throws an error if the document is invalid.
    *
    * @param {Object} doc - The document to validate.
+   * @returns {Promise<void>}
+   * @throws {Error} - Throws an error if the document is invalid.
+   * @memberof Fireproof
+   * @instance
    */
-  async runValidation (doc) {
+  async #runValidation (doc) {
     if (this.config && this.config.validateChange) {
       const oldDoc = await this.get(doc._id)
         .then((doc) => doc)
@@ -125,35 +149,50 @@ export default class Fireproof {
   }
 
   /**
-   * Adds a new document to the database, or updates an existing document.
+   * Adds a new document to the database, or updates an existing document. Returns the ID of the document and the new clock head.
    *
    * @param {Object} doc - the document to be added
    * @param {string} doc._id - the document ID. If not provided, a random ID will be generated.
    * @param {Object} doc.* - the document data to be added
-   * @returns {Promise<import('./prolly').PutResult>} - the result of adding the document
+   * @returns {Object<{ id: string, clock: CID[]  }>} - The result of adding the document to the database
+   * @memberof Fireproof
+   * @instance
    */
   async put ({ _id, ...doc }) {
     const id = _id || 'f' + Math.random().toString(36).slice(2)
-    await this.runValidation({ _id: id, ...doc })
-    return await this.putToProllyTree({ key: id, value: doc })
+    await this.#runValidation({ _id: id, ...doc })
+    return await this.#putToProllyTree({ key: id, value: doc })
   }
 
   /**
    * Deletes a document from the database
    * @param {string} id - the document ID
-   * @returns {Promise<import('./prolly').PutResult>} - the result of deleting the document
+   * @returns {Object<{ id: string, clock: CID[] }>} - The result of deleting the document from the database
+   * @memberof Fireproof
+   * @instance
    */
   async del (id) {
-    await this.runValidation({ _id: id, _deleted: true })
-    // return await this.putToProllyTree({ key: id, del: true }) // not working at prolly tree layer?
+    await this.#runValidation({ _id: id, _deleted: true })
+    // return await this.#putToProllyTree({ key: id, del: true }) // not working at prolly tree layer?
     // this tombstone is temporary until we can get the prolly tree to delete
-    return await this.putToProllyTree({ key: id, value: null })
+    return await this.#putToProllyTree({ key: id, value: null })
   }
 
-  async putToProllyTree (event) {
-    const result = await doTransaction('putToProllyTree', this.blocks, async (blocks) => await put(blocks, this.clock, event))
+  /**
+   * Updates the underlying storage with the specified event.
+   * @private
+   * @param {import('../clock').EventLink<import('../crdt').EventData>} event - the event to add
+   * @returns {Object<{ id: string, clock: import('../clock').EventLink<import('../crdt').EventData }>} - The result of adding the event to storage
+   */
+  async #putToProllyTree (event) {
+    const result = await doTransaction(
+      '#putToProllyTree',
+      this.blocks,
+      async (blocks) => await put(blocks, this.clock, event)
+    )
     if (!result) {
-      console.log('failed', event)
+      console.error('failed', event)
+      throw new Error('failed to put at storage layer')
     }
     this.clock = result.head // do we want to do this as a finally block
     result.id = event.key
@@ -191,7 +230,9 @@ export default class Fireproof {
    * Retrieves the document with the specified ID from the database
    *
    * @param {string} key - the ID of the document to retrieve
-   * @returns {Promise<import('./prolly').GetResult>} - the document with the specified ID
+   * @returns {Object<{_id: string, ...doc: Object}>} - the document with the specified ID
+   * @memberof Fireproof
+   * @instance
    */
   async get (key) {
     const got = await get(this.blocks, this.clock, key)
@@ -202,8 +243,21 @@ export default class Fireproof {
     got._id = key
     return got
   }
-}
 
-Fireproof.storage = (_email) => {
-  return new Fireproof(new Blockstore(), [])
+  setCarUploader (carUploaderFn) {
+    console.log('registering car uploader')
+    // https://en.wikipedia.org/wiki/Law_of_Demeter - this is a violation of the law of demeter
+    this.blocks.valet.uploadFunction = carUploaderFn
+  }
+
+  /**
+   * Sets the function that will be used to read blocks from a remote peer.
+   * @param {Function} remoteBlockReaderFn - the function that will be used to read blocks from a remote peer
+   * @memberof Fireproof
+   * @instance
+   */
+  setRemoteBlockReader (remoteBlockReaderFn) {
+    // console.log('registering remote block reader')
+    this.blocks.valet.remoteBlockFunction = remoteBlockReaderFn
+  }
 }

package/src/listener.js

@@ -1,12 +1,11 @@
 /**
  * A Fireproof database Listener allows you to react to events in the database.
  *
- * @class
- * @classdesc An listener can be notified of events as they happen or on reconection
+ * @class Listener
+ * @classdesc An listener attaches to a Fireproof database and runs a routing function on each change, sending the results to subscribers.
  *
  * @param {import('./fireproof').Fireproof} database - The Fireproof database instance to index.
- * @param {Function} eventFun - The map function to apply to each entry in the database.
- *
+ * @param {Function} routingFn - The routing function to apply to each entry in the database.
  */
 export default class Listener {
   #subcribers = new Map()
@@ -18,13 +17,8 @@ export default class Listener {
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef
   #doStopListening = null
 
-  /**
-   * Creates a new index with the given map function and database.
-   * @param {import('./fireproof').Fireproof} database - The Fireproof database instance to index.
-   * @param {Function} eventFun - The event function to apply to each current change to the database.
-   */
-  constructor (database, eventFun) {
-    /** eventFun
+  constructor (database, routingFn) {
+    /** routingFn
      * The database instance to index.
      * @type {import('./fireproof').Fireproof}
      */
@@ -34,7 +28,11 @@ export default class Listener {
      * The map function to apply to each entry in the database.
      * @type {Function}
      */
-    this.eventFun = eventFun || function (_, emit) { emit('*') }
+    this.routingFn =
+      routingFn ||
+      function (_, emit) {
+        emit('*')
+      }
     this.dbHead = null
   }
 
@@ -43,13 +41,15 @@ export default class Listener {
    * @param {string} topic - The topic to subscribe to.
    * @param {Function} subscriber - The function to call when the topic is emitted.
    * @returns {Function} A function to unsubscribe from the topic.
+   * @memberof Listener
+   * @instance
    */
   on (topic, subscriber, since) {
     const listOfTopicSubscribers = getTopicList(this.#subcribers, topic)
     listOfTopicSubscribers.push(subscriber)
     if (typeof since !== 'undefined') {
       this.database.changesSince(since).then(({ rows: changes }) => {
-        const keys = topicsForChanges(changes, this.eventFun).get(topic)
+        const keys = topicsForChanges(changes, this.routingFn).get(topic)
         if (keys) keys.forEach((key) => subscriber(key))
       })
     }
@@ -61,7 +61,7 @@ export default class Listener {
 
   #onChanges (changes) {
     if (Array.isArray(changes)) {
-      const seenTopics = topicsForChanges(changes, this.eventFun)
+      const seenTopics = topicsForChanges(changes, this.routingFn)
       for (const [topic, keys] of seenTopics) {
         const listOfTopicSubscribers = getTopicList(this.#subcribers, topic)
         listOfTopicSubscribers.forEach((subscriber) => keys.forEach((key) => subscriber(key)))
@@ -95,14 +95,15 @@ const makeDoc = ({ key, value }) => ({ _id: key, ...value })
  * Transforms a set of changes to events using an emitter function.
  *
  * @param {Array<{ key: string, value: import('./link').AnyLink, del?: boolean }>} changes
- * @param {Function} eventFun
+ * @param {Function} routingFn
  * @returns {Array<string>} The topics emmitted by the event function.
+ * @private
  */
-const topicsForChanges = (changes, eventFun) => {
+const topicsForChanges = (changes, routingFn) => {
   const seenTopics = new Map()
   changes.forEach(({ key, value, del }) => {
     if (del || !value) value = { _deleted: true }
-    eventFun(makeDoc({ key, value }), (t) => {
+    routingFn(makeDoc({ key, value }), (t) => {
       const topicList = getTopicList(seenTopics, t)
       topicList.push(key)
     })