@fireproof/core 0.0.6 → 0.0.8

package/src/clock.js

@@ -22,7 +22,7 @@ import { CIDCounter } from 'prolly-trees/utils'
  * Advance the clock by adding an event.
  *
  * @template T
- * @param {import('./block').BlockFetcher} blocks Block storage.
+ * @param {import('../test/block').BlockFetcher} blocks Block storage.
  * @param {EventLink<T>[]} head The head of the clock.
  * @param {EventLink<T>} event The event to add.
  * @returns {Promise<EventLink<T>[]>} The new head of the clock.
@@ -89,11 +89,12 @@ export class EventBlock extends Block {
 
 /** @template T */
 export class EventFetcher {
-  /** @param {import('./block').BlockFetcher} blocks */
+  /** @param {import('../test/block').BlockFetcher} blocks */
   constructor (blocks) {
     /** @private */
     this._blocks = blocks
     this._cids = new CIDCounter()
+    this._cache = new Map()
   }
 
   /**
@@ -101,10 +102,15 @@ export class EventFetcher {
    * @returns {Promise<EventBlockView<T>>}
    */
   async get (link) {
+    const slink = link.toString()
+    // console.log('get', link.toString())
+    if (this._cache.has(slink)) return this._cache.get(slink)
     const block = await this._blocks.get(link)
     this._cids.add({ address: link })
     if (!block) throw new Error(`missing block: ${link}`)
-    return decodeEventBlock(block.bytes)
+    const got = decodeEventBlock(block.bytes)
+    this._cache.set(slink, got)
+    return got
   }
 
   async all () {
@@ -162,7 +168,7 @@ async function contains (events, a, b) {
 
 /**
  * @template T
- * @param {import('./block').BlockFetcher} blocks Block storage.
+ * @param {import('../test/block').BlockFetcher} blocks Block storage.
  * @param {EventLink<T>[]} head
  * @param {object} [options]
  * @param {(b: EventBlockView<T>) => string} [options.renderNodeLabel]
@@ -200,22 +206,34 @@ export async function * vis (blocks, head, options = {}) {
 }
 
 export async function findEventsToSync (blocks, head) {
+  // const callTag = Math.random().toString(36).substring(7)
   const events = new EventFetcher(blocks)
+  // console.time(callTag + '.findCommonAncestorWithSortedEvents')
   const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head)
+  // console.timeEnd(callTag + '.findCommonAncestorWithSortedEvents')
+  // console.log('sorted', sorted.length)
+  // console.time(callTag + '.contains')
   const toSync = await asyncFilter(sorted, async (uks) => !(await contains(events, ancestor, uks.cid)))
+  // console.timeEnd(callTag + '.contains')
+
   return { cids: events.cids, events: toSync }
 }
 
 const asyncFilter = async (arr, predicate) =>
+
   Promise.all(arr.map(predicate)).then((results) => arr.filter((_v, index) => results[index]))
 
 export async function findCommonAncestorWithSortedEvents (events, children) {
+  // const callTag = Math.random().toString(36).substring(7)
+  // console.time(callTag + '.findCommonAncestor')
   const ancestor = await findCommonAncestor(events, children)
+  // console.timeEnd(callTag + '.findCommonAncestor')
   if (!ancestor) {
     throw new Error('failed to find common ancestor event')
   }
-  // Sort the events by their sequence number
+  // console.time(callTag + '.findSortedEvents')
   const sorted = await findSortedEvents(events, children, ancestor)
+  // console.timeEnd(callTag + '.findSortedEvents')
   return { ancestor, sorted }
 }
 
@@ -279,12 +297,14 @@ function findCommonString (arrays) {
  * @param {import('./clock').EventLink<EventData>} tail
  */
 async function findSortedEvents (events, head, tail) {
+  // const callTag = Math.random().toString(36).substring(7)
   // get weighted events - heavier events happened first
   /** @type {Map<string, { event: import('./clock').EventBlockView<EventData>, weight: number }>} */
   const weights = new Map()
   const all = await Promise.all(head.map((h) => findEvents(events, h, tail)))
   for (const arr of all) {
     for (const { event, depth } of arr) {
+      // console.log('event value', event.value.data.value)
       const info = weights.get(event.cid.toString())
       if (info) {
         info.weight += depth
@@ -311,6 +331,7 @@ async function findSortedEvents (events, head, tail) {
     .sort((a, b) => b[0] - a[0])
     .flatMap(([, es]) => es.sort((a, b) => (String(a.cid) < String(b.cid) ? -1 : 1)))
   // console.log('sorted', sorted.map(s => s.value.data.value))
+
   return sorted
 }
 
@@ -321,6 +342,7 @@ async function findSortedEvents (events, head, tail) {
  * @returns {Promise<Array<{ event: import('./clock').EventBlockView<EventData>, depth: number }>>}
  */
 async function findEvents (events, start, end, depth = 0) {
+  // console.log('findEvents', start)
   const event = await events.get(start)
   const acc = [{ event, depth }]
   const { parents } = event.value

package/src/db-index.js

@@ -1,32 +1,53 @@
-import { create, load } from 'prolly-trees/db-index'
+// import { create, load } from 'prolly-trees/db-index'
+import { create, load } from '../../../../prolly-trees/src/db-index.js'
+
 import { sha256 as hasher } from 'multiformats/hashes/sha2'
 import { nocache as cache } from 'prolly-trees/cache'
 import { bf, simpleCompare } from 'prolly-trees/utils'
 import { makeGetBlock } from './prolly.js'
 import { cidsToProof } from './fireproof.js'
+import { CID } from 'multiformats'
+
 import * as codec from '@ipld/dag-cbor'
 // import { create as createBlock } from 'multiformats/block'
 import { doTransaction } from './blockstore.js'
 import charwise from 'charwise'
 
-const ALWAYS_REBUILD = true // todo: remove this
+const ALWAYS_REBUILD = false // todo: make false
 
-const arrayCompare = (a, b) => {
-  if (Array.isArray(a) && Array.isArray(b)) {
-    const len = Math.min(a.length, b.length)
-    for (let i = 0; i < len; i++) {
-      const comp = simpleCompare(a[i], b[i])
-      if (comp !== 0) {
-        return comp
-      }
-    }
-    return simpleCompare(a.length, b.length)
-  } else {
-    return simpleCompare(a, b)
-  }
+// const arrayCompare = (a, b) => {
+//   if (Array.isArray(a) && Array.isArray(b)) {
+//     const len = Math.min(a.length, b.length)
+//     for (let i = 0; i < len; i++) {
+//       const comp = simpleCompare(a[i], b[i])
+//       if (comp !== 0) {
+//         return comp
+//       }
+//     }
+//     return simpleCompare(a.length, b.length)
+//   } else {
+//     return simpleCompare(a, b)
+//   }
+// }
+
+const compare = (a, b) => {
+  const [aKey, aRef] = a
+  const [bKey, bRef] = b
+  const comp = simpleCompare(aKey, bKey)
+  if (comp !== 0) return comp
+  return refCompare(aRef, bRef)
+}
+
+const refCompare = (aRef, bRef) => {
+  if (Number.isNaN(aRef)) return -1
+  if (Number.isNaN(bRef)) throw new Error('ref may not be Infinity or NaN')
+  if (aRef === Infinity) return 1 // need to test this on equal docids!
+  // if (!Number.isFinite(bRef)) throw new Error('ref may not be Infinity or NaN')
+  return simpleCompare(aRef, bRef)
 }
 
-const opts = { cache, chunker: bf(3), codec, hasher, compare: arrayCompare }
+const dbIndexOpts = { cache, chunker: bf(3), codec, hasher, compare }
+const idIndexOpts = { cache, chunker: bf(3), codec, hasher, compare: simpleCompare }
 
 const makeDoc = ({ key, value }) => ({ _id: key, ...value })
 
@@ -71,14 +92,6 @@ const indexEntriesForChanges = (changes, mapFun) => {
   return indexEntries
 }
 
-const indexEntriesForOldChanges = async (blocks, byIDindexRoot, ids, mapFun) => {
-  const { getBlock } = makeGetBlock(blocks)
-  const byIDindex = await load({ cid: byIDindexRoot.cid, get: getBlock, ...opts })
-
-  const result = await byIDindex.getMany(ids)
-  return result
-}
-
 /**
  * Represents an DbIndex for a Fireproof database.
  *
@@ -102,11 +115,31 @@ export default class DbIndex {
      */
     this.mapFun = mapFun
 
-    this.dbIndexRoot = null
-    this.dbIndex = null
+    this.database.indexes.set(mapFun.toString(), this)
+
+    this.indexById = { root: null, cid: null }
+    this.indexByKey = { root: null, cid: null }
 
-    this.byIDindexRoot = null
     this.dbHead = null
+
+    this.instanceId = this.database.instanceId + `.DbIndex.${Math.random().toString(36).substring(2, 7)}`
+
+    this.updateIndexPromise = null
+  }
+
+  toJSON () {
+    return { code: this.mapFun?.toString(), clock: { db: this.dbHead?.map(cid => cid.toString()), byId: this.indexById.cid?.toString(), byKey: this.indexByKey.cid?.toString() } }
+  }
+
+  static fromJSON (database, { code, clock: { byId, byKey, db } }) {
+    let mapFun
+    // eslint-disable-next-line
+    eval("mapFun = "+ code)
+    const index = new DbIndex(database, mapFun)
+    index.indexById.cid = CID.parse(byId)
+    index.indexByKey.cid = CID.parse(byKey)
+    index.dbHead = db.map(cid => CID.parse(cid))
+    return index
   }
 
   /**
@@ -124,17 +157,25 @@ export default class DbIndex {
    * @instance
    */
   async query (query) {
+    // const callId = Math.random().toString(36).substring(2, 7)
     // if (!root) {
     // pass a root to query a snapshot
-    await doTransaction('#updateIndex', this.database.blocks, async (blocks) => {
-      await this.#updateIndex(blocks)
-    })
+    // console.time(callId + '.#updateIndex')
+    await this.#updateIndex(this.database.blocks)
+    // console.timeEnd(callId + '.#updateIndex')
+
     // }
-    const response = await doIndexQuery(this.database.blocks, this.dbIndexRoot, this.dbIndex, query)
+    // console.time(callId + '.doIndexQuery')
+    const response = await doIndexQuery(this.database.blocks, this.indexByKey, query)
+    // console.timeEnd(callId + '.doIndexQuery')
+
     return {
       proof: { index: await cidsToProof(response.cids) },
       // TODO fix this naming upstream in prolly/db-DbIndex?
-      rows: response.result.map(({ id, key, row }) => ({ id: key, key: charwise.decode(id), value: row }))
+      rows: response.result.map(({ id, key, row }) => {
+        // console.log('query', id, key, row)
+        return ({ id, key: charwise.decode(key), value: row })
+      })
     }
   }
 
@@ -143,56 +184,55 @@ export default class DbIndex {
    * @private
    * @returns {Promise<void>}
    */
+
   async #updateIndex (blocks) {
+    // todo this could enqueue the request and give fresh ones to all second comers -- right now it gives out stale promises while working
+    // what would it do in a world where all indexes provide a database snapshot to query?
+    if (this.updateIndexPromise) return this.updateIndexPromise
+    this.updateIndexPromise = this.#innerUpdateIndex(blocks)
+    this.updateIndexPromise.finally(() => { this.updateIndexPromise = null })
+    return this.updateIndexPromise
+  }
+
+  async #innerUpdateIndex (inBlocks) {
+    // const callTag = Math.random().toString(36).substring(4)
+    // console.log(`#updateIndex ${callTag} >`, this.instanceId, this.dbHead?.toString(), this.dbIndexRoot?.cid.toString(), this.indexByIdRoot?.cid.toString())
     // todo remove this hack
     if (ALWAYS_REBUILD) {
       this.dbHead = null // hack
-      this.dbIndex = null // hack
+      this.indexByKey = null // hack
       this.dbIndexRoot = null
     }
+    // console.log('dbHead', this.dbHead)
+    // console.time(callTag + '.changesSince')
     const result = await this.database.changesSince(this.dbHead) // {key, value, del}
-    if (this.dbHead) {
-      const oldChangeEntries = await indexEntriesForOldChanges(
-        blocks,
-        this.byIDindexRoot,
-        result.rows.map(({ key }) => key),
-        this.mapFun
-      )
-      const oldIndexEntries = oldChangeEntries.result.map((key) => ({ key, del: true }))
-      const removalResult = await bulkIndex(blocks, this.dbIndexRoot, this.dbIndex, oldIndexEntries, opts)
-      this.dbIndexRoot = removalResult.root
-      this.dbIndex = removalResult.dbIndex
-
-      const removeByIdIndexEntries = oldIndexEntries.map(({ key }) => ({ key: key[1], del: true }))
-      const purgedRemovalResults = await bulkIndex(
-        blocks,
-        this.byIDindexRoot,
-        this.byIDIndex,
-        removeByIdIndexEntries,
-        opts
-      )
-      this.byIDindexRoot = purgedRemovalResults.root
-      this.byIDIndex = purgedRemovalResults.dbIndex
-    }
-    const indexEntries = indexEntriesForChanges(result.rows, this.mapFun)
-    const byIdIndexEntries = indexEntries.map(({ key }) => ({ key: key[1], value: key }))
-    const addFutureRemovalsResult = await bulkIndex(blocks, this.byIDindexRoot, this.byIDIndex, byIdIndexEntries, opts)
-    this.byIDindexRoot = addFutureRemovalsResult.root
-    this.byIDIndex = addFutureRemovalsResult.dbIndex
+    // console.timeEnd(callTag + '.changesSince')
+    // console.log('result.rows.length', result.rows.length)
 
-    // console.log('indexEntries', indexEntries)
+    // console.time(callTag + '.doTransaction#updateIndex')
 
-    const updateIndexResult = await bulkIndex(blocks, this.dbIndexRoot, this.dbIndex, indexEntries, opts)
-    this.dbIndexRoot = updateIndexResult.root
-    this.dbIndex = updateIndexResult.dbIndex
-
-    this.dbHead = result.clock
+    if (result.rows.length === 0) {
+      // console.log('#updateIndex < no changes')
+      this.dbHead = result.clock
+      return
+    }
+    await doTransaction('#updateIndex', inBlocks, async (blocks) => {
+      let oldIndexEntries = []
+      let removeByIdIndexEntries = []
+      if (this.dbHead) { // need a maybe load
+        const oldChangeEntries = await this.indexById.root.getMany(result.rows.map(({ key }) => key))
+        oldIndexEntries = oldChangeEntries.result.map((key) => ({ key, del: true }))
+        removeByIdIndexEntries = oldIndexEntries.map(({ key }) => ({ key: key[1], del: true }))
+      }
+      const indexEntries = indexEntriesForChanges(result.rows, this.mapFun)
+      const byIdIndexEntries = indexEntries.map(({ key }) => ({ key: key[1], value: key }))
+      this.indexById = await bulkIndex(blocks, this.indexById, removeByIdIndexEntries.concat(byIdIndexEntries), idIndexOpts)
+      this.indexByKey = await bulkIndex(blocks, this.indexByKey, oldIndexEntries.concat(indexEntries), dbIndexOpts)
+      this.dbHead = result.clock
+    })
+    // console.timeEnd(callTag + '.doTransaction#updateIndex')
+    // console.log(`#updateIndex ${callTag} <`, this.instanceId, this.dbHead?.toString(), this.dbIndexRoot?.cid.toString(), this.indexByIdRoot?.cid.toString())
   }
-
-  // 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 ()) {}
 }
 
 /**
@@ -202,44 +242,47 @@ export default class DbIndex {
  * @param {DbIndexEntry[]} indexEntries
  * @private
  */
-async function bulkIndex (blocks, inRoot, inDBindex, indexEntries) {
-  if (!indexEntries.length) return { dbIndex: inDBindex, root: inRoot }
+async function bulkIndex (blocks, inIndex, indexEntries, opts) {
+  if (!indexEntries.length) return inIndex
   const putBlock = blocks.put.bind(blocks)
   const { getBlock } = makeGetBlock(blocks)
   let returnRootBlock
   let returnNode
-  if (!inDBindex) {
-    for await (const node of await create({ get: getBlock, list: indexEntries, ...opts })) {
-      const block = await node.block
-      await putBlock(block.cid, block.bytes)
-      returnRootBlock = block
-      returnNode = node
-    }
-  } else {
-    // const dbIndex = await load({ cid: inRoot.cid, get: getBlock, ...opts }) // todo load from root on refresh
-    const { root, blocks } = await inDBindex.bulk(indexEntries)
-    returnRootBlock = await root.block
-    returnNode = root
-    for await (const block of blocks) {
-      await putBlock(block.cid, block.bytes)
+  if (!inIndex.root) {
+    const cid = inIndex.cid
+    if (!cid) {
+      for await (const node of await create({ get: getBlock, list: indexEntries, ...opts })) {
+        const block = await node.block
+        await putBlock(block.cid, block.bytes)
+        returnRootBlock = block
+        returnNode = node
+      }
+      return { root: returnNode, cid: returnRootBlock.cid }
     }
-    await putBlock(returnRootBlock.cid, returnRootBlock.bytes)
+    inIndex.root = await load({ cid, get: getBlock, ...dbIndexOpts })
+  }
+  const { root, blocks: newBlocks } = await inIndex.root.bulk(indexEntries)
+  returnRootBlock = await root.block
+  returnNode = root
+  for await (const block of newBlocks) {
+    await putBlock(block.cid, block.bytes)
   }
-  return { dbIndex: returnNode, root: returnRootBlock }
+  await putBlock(returnRootBlock.cid, returnRootBlock.bytes)
+  return { root: returnNode, cid: returnRootBlock.cid }
 }
 
-async function doIndexQuery (blocks, dbIndexRoot, dbIndex, query) {
-  if (!dbIndex) {
-    const cid = dbIndexRoot && dbIndexRoot.cid
+async function doIndexQuery (blocks, indexByKey, query) {
+  if (!indexByKey.root) {
+    const cid = indexByKey.cid
     if (!cid) return { result: [] }
     const { getBlock } = makeGetBlock(blocks)
-    dbIndex = await load({ cid, get: getBlock, ...opts })
+    indexByKey.root = await load({ cid, get: getBlock, ...dbIndexOpts })
   }
   if (query.range) {
     const encodedRange = query.range.map((key) => charwise.encode(key))
-    return dbIndex.range(...encodedRange)
+    return indexByKey.root.range(...encodedRange)
   } else if (query.key) {
     const encodedKey = charwise.encode(query.key)
-    return dbIndex.get(encodedKey)
+    return indexByKey.root.get(encodedKey)
   }
 }

package/src/fireproof.js

@@ -1,5 +1,6 @@
-import { put, get, getAll, eventsSince } from './prolly.js'
-import Blockstore, { doTransaction } from './blockstore.js'
+import { vis, put, get, getAll, eventsSince } from './prolly.js'
+import TransactionBlockstore, { doTransaction } from './blockstore.js'
+import charwise from 'charwise'
 
 // const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
 
@@ -26,16 +27,18 @@ export default class Fireproof {
    * @static
    * @returns {Fireproof} - a new Fireproof instance
    */
-  static storage = () => {
-    return new Fireproof(new Blockstore(), [])
+  static storage = (name) => {
+    return new Fireproof(new TransactionBlockstore(name), [], { name })
   }
 
-  constructor (blocks, clock, config = {}, authCtx = {}) {
+  constructor (blocks, clock, config, authCtx = {}) {
+    this.name = config?.name || 'global'
+    this.instanceId = `fp.${this.name}.${Math.random().toString(36).substring(2, 7)}`
     this.blocks = blocks
     this.clock = clock
     this.config = config
     this.authCtx = authCtx
-    this.instanceId = 'fp.' + Math.random().toString(36).substring(2, 7)
+    this.indexes = new Map()
   }
 
   /**
@@ -49,7 +52,7 @@ export default class Fireproof {
    */
   snapshot (clock) {
     // how to handle listeners, views, and config?
-    // todo needs a test for that
+    // todo needs a test for listeners, views, and config
     return new Fireproof(this.blocks, clock || this.clock)
   }
 
@@ -76,7 +79,11 @@ export default class Fireproof {
    */
   toJSON () {
     // todo this also needs to return the index roots...
-    return { clock: this.clock }
+    return {
+      clock: this.clock.map(cid => cid.toString()),
+      name: this.name,
+      indexes: [...this.indexes.values()].map((index) => index.toJSON())
+    }
   }
 
   /**
@@ -93,7 +100,7 @@ export default class Fireproof {
     if (event) {
       const resp = await eventsSince(this.blocks, this.clock, event)
       const docsMap = new Map()
-      for (const { key, type, value } of resp.result) {
+      for (const { key, type, value } of resp.result.map(decodeEvent)) {
         if (type === 'del') {
           docsMap.set(key, { key, del: true })
         } else {
@@ -105,11 +112,15 @@ export default class Fireproof {
       // console.log('change rows', this.instanceId, rows)
     } else {
       const allResp = await getAll(this.blocks, this.clock)
-      rows = allResp.result.map(({ key, value }) => ({ key, value }))
+      rows = allResp.result.map(({ key, value }) => (decodeEvent({ key, value })))
       dataCIDs = allResp.cids
       // console.log('dbdoc rows', this.instanceId, rows)
     }
-    return { rows, clock: this.clock, proof: { data: await cidsToProof(dataCIDs), clock: await cidsToProof(clockCIDs) } }
+    return {
+      rows,
+      clock: this.clock,
+      proof: { data: await cidsToProof(dataCIDs), clock: await cidsToProof(clockCIDs) }
+    }
   }
 
   /**
@@ -127,7 +138,7 @@ export default class Fireproof {
   }
 
   async #notifyListeners (changes) {
-    // await sleep(0)
+    // await sleep(10)
     for (const listener of this.#listeners) {
       await listener(changes)
     }
@@ -195,7 +206,8 @@ export default class Fireproof {
    * @param {Object<{key : string, value: any}>} event - the event to add
    * @returns {Object<{ id: string, clock: CID[] }>} - The result of adding the event to storage
    */
-  async #putToProllyTree (event, clock = null) {
+  async #putToProllyTree (decodedEvent, clock = null) {
+    const event = encodeEvent(decodedEvent)
     if (clock && JSON.stringify(clock) !== JSON.stringify(this.clock)) {
       // we need to check and see what version of the document exists at the clock specified
       // if it is the same as the one we are trying to put, then we can proceed
@@ -214,9 +226,14 @@ export default class Fireproof {
       console.error('failed', event)
       throw new Error('failed to put at storage layer')
     }
+    // console.log('new clock head', this.instanceId, result.head.toString())
     this.clock = result.head // do we want to do this as a finally block
-    await this.#notifyListeners([event])
-    return { id: event.key, clock: this.clock, proof: { data: await cidsToProof(result.cids), clock: await cidsToProof(result.clockCIDs) } }
+    await this.#notifyListeners([decodedEvent]) // this type is odd
+    return {
+      id: decodedEvent.key,
+      clock: this.clock,
+      proof: { data: await cidsToProof(result.cids), clock: await cidsToProof(result.clockCIDs) }
+    }
     // todo should include additions (or split clock)
   }
 
@@ -255,7 +272,7 @@ export default class Fireproof {
    */
   async get (key, opts = {}) {
     const clock = opts.clock || this.clock
-    const resp = await get(this.blocks, clock, key)
+    const resp = await get(this.blocks, clock, charwise.encode(key))
 
     // this tombstone is temporary until we can get the prolly tree to delete
     if (!resp || resp.result === null) {
@@ -273,6 +290,10 @@ export default class Fireproof {
     return doc
   }
 
+  async * vis () {
+    return yield * vis(this.blocks, this.clock)
+  }
+
   setCarUploader (carUploaderFn) {
     console.log('registering car uploader')
     // https://en.wikipedia.org/wiki/Law_of_Demeter - this is a violation of the law of demeter
@@ -290,3 +311,14 @@ export async function cidsToProof (cids) {
   const all = await cids.all()
   return [...all].map((cid) => cid.toString())
 }
+
+function decodeEvent (event) {
+  const decodedKey = charwise.decode(event.key)
+  return { ...event, key: decodedKey }
+}
+
+function encodeEvent (event) {
+  if (!(event && event.key)) return
+  const encodedKey = charwise.encode(event.key)
+  return { ...event, key: encodedKey }
+}

package/src/hydrator.js

@@ -0,0 +1,10 @@
+import Fireproof from './fireproof.js'
+import DbIndex from './db-index.js'
+
+export function fromJSON (json, blocks) {
+  const fp = new Fireproof(blocks, json.clock, { name: json.name })
+  for (const index of json.indexes) {
+    DbIndex.fromJSON(fp, index)
+  }
+  return fp
+}

package/src/listener.js

@@ -11,12 +11,6 @@
 
 export default class Listener {
   #subcribers = new Map()
-
-  // todo code review if there is a better way that doesn't create a circular reference
-  // because otherwise we need to document that the user must call stopListening
-  // or else the listener will never be garbage collected
-  // maybe we can use WeakRef on the db side
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef
   #doStopListening = null
 
   constructor (database, routingFn) {