@fireproof/core 0.2.0 → 0.3.1

package/hooks/{use-fireproof.ts → use-fireproof.js}

@@ -1,16 +1,15 @@
 /* global localStorage */
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import { useEffect, useState, createContext } from 'react'
 import { Fireproof, Listener, Hydrator } from '../index'
 
-export interface FireproofCtxValue {
-  addSubscriber: (label: String, fn: Function) => void
-  database: Fireproof
-  ready: boolean
-  persist: () => void
-}
-export const FireproofCtx = createContext<FireproofCtxValue>({
+// export interface FireproofCtxValue {
+//   addSubscriber: (label: String, fn: Function) => void
+//   database: Fireproof
+//   ready: boolean
+//   persist: () => void
+// }
+export const FireproofCtx = createContext({
   addSubscriber: () => {},
   database: null,
   ready: false
@@ -35,21 +34,21 @@ const initializeDatabase = name => {
  * @param [setupDatabaseFn] Asynchronous function that sets up the database, run this to load fixture data etc
  * @returns {FireproofCtxValue} { addSubscriber, database, ready }
  */
-export function useFireproof(
-  defineDatabaseFn = (database: Fireproof) => {},
-  setupDatabaseFn = async (database: Fireproof) => {},
-  name: string
-): FireproofCtxValue {
+export function useFireproof (
+  defineDatabaseFn = () => {},
+  setupDatabaseFn = async () => {},
+  name
+) {
   const [ready, setReady] = useState(false)
   initializeDatabase(name || 'useFireproof')
   const localStorageKey = 'fp.' + database.name
 
-  const addSubscriber = (label: String, fn: Function) => {
+  const addSubscriber = (label, fn) => {
     inboundSubscriberQueue.set(label, fn)
   }
 
   const listenerCallback = async event => {
-      localSet(localStorageKey, JSON.stringify(database))
+    localSet(localStorageKey, JSON.stringify(database))
     if (event._external) return
     for (const [, fn] of inboundSubscriberQueue) fn()
   }
@@ -84,7 +83,7 @@ export function useFireproof(
         localSet(localStorageKey, JSON.stringify(database))
       }
       setReady(true)
-      listener.on('*', listenerCallback)//hushed('*', listenerCallback, 250))
+      listener.on('*', listenerCallback)// hushed('*', listenerCallback, 250))
     }
     doSetup()
   }, [ready])
@@ -99,32 +98,32 @@ export function useFireproof(
   }
 }
 
-const husherMap = new Map()
-const husher = (id: string, workFn: { (): Promise<any> }, ms: number) => {
-  if (!husherMap.has(id)) {
-    const start: number = Date.now()
-    husherMap.set(
-      id,
-      workFn().finally(() => setTimeout(() => husherMap.delete(id), ms - (Date.now() - start)))
-    )
-  }
-  return husherMap.get(id)
-}
-const hushed =
-  (id: string, workFn: { (...args): Promise<any> }, ms: number) =>
-  (...args) =>
-    husher(id, () => workFn(...args), ms)
+// const husherMap = new Map()
+// const husher = (id, workFn, ms) => {
+//   if (!husherMap.has(id)) {
+//     const start = Date.now()
+//     husherMap.set(
+//       id,
+//       workFn().finally(() => setTimeout(() => husherMap.delete(id), ms - (Date.now() - start)))
+//     )
+//   }
+//   return husherMap.get(id)
+// }
+// const hushed =
+//   (id, workFn, ms) =>
+//     (...args) =>
+//       husher(id, () => workFn(...args), ms)
 
 let storageSupported = false
 try {
   storageSupported = window.localStorage && true
 } catch (e) {}
-export function localGet(key: string) {
+export function localGet (key) {
   if (storageSupported) {
     return localStorage && localStorage.getItem(key)
   }
 }
-function localSet(key: string, value: string) {
+function localSet (key, value) {
   if (storageSupported) {
     return localStorage && localStorage.setItem(key, value)
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireproof/core",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Realtime database for IPFS",
   "main": "index.js",
   "type": "module",
@@ -32,6 +32,7 @@
   ],
   "license": "Apache-2.0 OR MIT",
   "dependencies": {
+    "prolly-trees": "1.0.4",
     "@ipld/car": "^5.1.0",
     "@ipld/dag-cbor": "^9.0.0",
     "archy": "^1.0.0",
@@ -42,7 +43,6 @@
     "encrypted-block": "^0.0.3",
     "idb": "^7.1.1",
     "multiformats": "^11.0.1",
-    "prolly-trees": "1.0.3",
     "sade": "^1.8.1"
   },
   "devDependencies": {

package/src/db-index.js

@@ -14,21 +14,6 @@ import charwise from 'charwise'
 
 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 compare = (a, b) => {
   const [aKey, aRef] = a
   const [bKey, bRef] = b
@@ -124,6 +109,7 @@ export default class DbIndex {
       this.mapFn = mapFn
       this.mapFnString = mapFn.toString()
     }
+    this.name = opts.name || this.makeName()
     this.indexById = { root: null, cid: null }
     this.indexByKey = { root: null, cid: null }
     this.dbHead = null
@@ -137,42 +123,43 @@ export default class DbIndex {
     if (!opts.temporary) { DbIndex.registerWithDatabase(this, this.database) }
   }
 
+  makeName () {
+    const regex = /\(([^,()]+,\s*[^,()]+|\[[^\]]+\],\s*[^,()]+)\)/g
+    const matches = Array.from(this.mapFnString.matchAll(regex), match => match[1].trim())
+    return matches[1]
+  }
+
   static registerWithDatabase (inIndex, database) {
-    // console.log('.reg > in Index', inIndex.instanceId, { live: !!inIndex.mapFn }, inIndex.indexByKey, inIndex.mapFnString)
-    if (database.indexes.has(inIndex.mapFnString)) {
+    if (!database.indexes.has(inIndex.mapFnString)) {
+      database.indexes.set(inIndex.mapFnString, inIndex)
+    } else {
       // merge our inIndex code with the inIndex clock or vice versa
-      // keep the code instance, discard the clock instance
       const existingIndex = database.indexes.get(inIndex.mapFnString)
-      // console.log('.reg - existingIndex', existingIndex.instanceId, { live: !!inIndex.mapFn }, existingIndex.indexByKey)
+      // keep the code instance, discard the clock instance
       if (existingIndex.mapFn) { // this one also has other config
         existingIndex.dbHead = inIndex.dbHead
         existingIndex.indexById.cid = inIndex.indexById.cid
         existingIndex.indexByKey.cid = inIndex.indexByKey.cid
       } else {
-        // console.log('.reg use inIndex with existingIndex clock')
         inIndex.dbHead = existingIndex.dbHead
         inIndex.indexById.cid = existingIndex.indexById.cid
         inIndex.indexByKey.cid = existingIndex.indexByKey.cid
         database.indexes.set(inIndex.mapFnString, inIndex)
       }
-    } else {
-      // console.log('.reg - fresh')
-      database.indexes.set(inIndex.mapFnString, inIndex)
     }
-    // console.log('.reg after', JSON.stringify([...database.indexes.values()].map(i => [i.instanceId, typeof i.mapFn, i.indexByKey, i.indexById])))
   }
 
   toJSON () {
-    const indexJson = { code: this.mapFnString, clock: { db: null, byId: null, byKey: null } }
+    const indexJson = { name: this.name, code: this.mapFnString, clock: { db: null, byId: null, byKey: null } }
     indexJson.clock.db = this.dbHead?.map(cid => cid.toString())
     indexJson.clock.byId = this.indexById.cid?.toString()
     indexJson.clock.byKey = this.indexByKey.cid?.toString()
     return indexJson
   }
 
-  static fromJSON (database, { code, clock }) {
+  static fromJSON (database, { code, clock, name }) {
     // console.log('DbIndex.fromJSON', database.constructor.name, code, clock)
-    return new DbIndex(database, code, clock)
+    return new DbIndex(database, code, clock, { name })
   }
 
   /**
@@ -191,23 +178,17 @@ export default class DbIndex {
    */
   async query (query, update = true) {
     // const callId = Math.random().toString(36).substring(2, 7)
-    // if (!root) {
-    // pass a root to query a snapshot
+    // todo pass a root to query a snapshot
     // console.time(callId + '.#updateIndex')
     update && await this.#updateIndex(this.database.indexBlocks)
     // console.timeEnd(callId + '.#updateIndex')
-
-    // }
     // console.time(callId + '.doIndexQuery')
     // console.log('query', query)
     const response = await doIndexQuery(this.database.indexBlocks, 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 }) => {
-        // console.log('query', id, key, row)
         return ({ id, key: charwise.decode(key), value: row })
       })
     }
@@ -322,20 +303,22 @@ async function loadIndex (blocks, index, indexOpts) {
   return index.root
 }
 
+async function applyLimit (results, limit) {
+  results.result = results.result.slice(0, limit)
+  return results
+}
+
 async function doIndexQuery (blocks, indexByKey, query = {}) {
   await loadIndex(blocks, indexByKey, dbIndexOpts)
+  if (!indexByKey.root) return { result: [] }
   if (query.range) {
     const encodedRange = query.range.map((key) => charwise.encode(key))
-    return indexByKey.root.range(...encodedRange)
+    return applyLimit(await indexByKey.root.range(...encodedRange), query.limit)
   } else if (query.key) {
     const encodedKey = charwise.encode(query.key)
     return indexByKey.root.get(encodedKey)
   } else {
-    if (indexByKey.root) {
-      const { result, ...all } = await indexByKey.root.getAllEntries()
-      return { result: result.map(({ key: [k, id], value }) => ({ key: k, id, row: value })), ...all }
-    } else {
-      return { result: [] }
-    }
+    const { result, ...all } = await indexByKey.root.getAllEntries()
+    return applyLimit({ result: result.map(({ key: [k, id], value }) => ({ key: k, id, row: value })), ...all }, query.limit)
   }
 }

package/src/fireproof.js

@@ -138,27 +138,6 @@ export default class Fireproof {
     }
   }
 
-  /**
-   * Registers a Listener to be called when the Fireproof instance's clock is updated.
-   * 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)
-    return () => {
-      this.#listeners.delete(listener)
-    }
-  }
-
-  async #notifyListeners (changes) {
-    // await sleep(10)
-    for (const listener of this.#listeners) {
-      await listener(changes)
-    }
-  }
-
   /**
    * Runs validation on the specified document using the Fireproof instance's configuration. Throws an error if the document is invalid.
    *
@@ -177,6 +156,35 @@ export default class Fireproof {
     }
   }
 
+  /**
+   * Retrieves the document with the specified ID from the database
+   *
+   * @param {string} key - the ID of the document to retrieve
+   * @param {Object} [opts] - options
+   * @returns {Object<{_id: string, ...doc: Object}>} - the document with the specified ID
+   * @memberof Fireproof
+   * @instance
+   */
+  async get (key, opts = {}) {
+    const clock = opts.clock || this.clock
+    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) {
+      throw new Error('Not found')
+    }
+    const doc = resp.result
+    if (opts.mvcc === true) {
+      doc._clock = this.clockToJSON()
+    }
+    doc._proof = {
+      data: await cidsToProof(resp.cids),
+      clock: this.clockToJSON()
+    }
+    doc._id = key
+    return doc
+  }
+
   /**
    * Adds a new document to the database, or updates an existing document. Returns the ID of the document and the new clock head.
    *
@@ -210,9 +218,9 @@ export default class Fireproof {
       id = docOrId
     }
     await this.#runValidation({ _id: id, _deleted: true })
-    // return await this.#putToProllyTree({ key: id, del: true }) // not working at prolly tree layer?
+    return await this.#putToProllyTree({ key: id, del: true }, clock) // 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 }, clock)
+    // return await this.#putToProllyTree({ key: id, value: null }, clock)
   }
 
   /**
@@ -262,49 +270,6 @@ export default class Fireproof {
   //       return this.clock
   //     }
 
-  /**
-   * Displays a visualization of the current clock in the console
-   */
-  //   async visClock () {
-  //     const shortLink = (l) => `${String(l).slice(0, 4)}..${String(l).slice(-4)}`
-  //     const renderNodeLabel = (event) => {
-  //       return event.value.data.type === 'put'
-  //         ? `${shortLink(event.cid)}\\nput(${shortLink(event.value.data.key)},
-  //         {${Object.values(event.value.data.value)}})`
-  //         : `${shortLink(event.cid)}\\ndel(${event.value.data.key})`
-  //     }
-  //     for await (const line of vis(this.blocks, this.clock, { renderNodeLabel })) console.log(line)
-  //   }
-
-  /**
-   * Retrieves the document with the specified ID from the database
-   *
-   * @param {string} key - the ID of the document to retrieve
-   * @param {Object} [opts] - options
-   * @returns {Object<{_id: string, ...doc: Object}>} - the document with the specified ID
-   * @memberof Fireproof
-   * @instance
-   */
-  async get (key, opts = {}) {
-    const clock = opts.clock || this.clock
-    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) {
-      throw new Error('Not found')
-    }
-    const doc = resp.result
-    if (opts.mvcc === true) {
-      doc._clock = this.clockToJSON()
-    }
-    doc._proof = {
-      data: await cidsToProof(resp.cids),
-      clock: this.clockToJSON()
-    }
-    doc._id = key
-    return doc
-  }
-
   async * vis () {
     return yield * vis(this.blocks, this.clock)
   }
@@ -317,6 +282,27 @@ export default class Fireproof {
     return await visMerkleClock(this.blocks, this.clock)
   }
 
+  /**
+   * Registers a Listener to be called when the Fireproof instance's clock is updated.
+   * 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)
+    return () => {
+      this.#listeners.delete(listener)
+    }
+  }
+
+  async #notifyListeners (changes) {
+    // await sleep(10)
+    for (const listener of this.#listeners) {
+      await listener(changes)
+    }
+  }
+
   setCarUploader (carUploaderFn) {
     // console.log('registering car uploader')
     // https://en.wikipedia.org/wiki/Law_of_Demeter - this is a violation of the law of demeter

package/src/hydrator.js

@@ -8,14 +8,15 @@ export default class Hydrator {
   static fromJSON (json, database) {
     database.hydrate({ clock: json.clock.map(c => parseCID(c)), name: json.name, key: json.key })
     if (json.indexes) {
-      for (const { code, clock: { byId, byKey, db } } of json.indexes) {
+      for (const { name, code, clock: { byId, byKey, db } } of json.indexes) {
         DbIndex.fromJSON(database, {
           clock: {
             byId: byId ? parseCID(byId) : null,
             byKey: byKey ? parseCID(byKey) : null,
             db: db ? db.map(c => parseCID(c)) : null
           },
-          code
+          code,
+          name
         })
       }
     }

package/src/listener.js

@@ -80,9 +80,6 @@ function getTopicList (subscribersMap, name) {
   return topicList
 }
 
-// copied from src/db-index.js
-const makeDoc = ({ key, value }) => ({ _id: key, ...value })
-
 /**
  * Transforms a set of changes to events using an emitter function.
  *
@@ -95,7 +92,7 @@ const topicsForChanges = (changes, routingFn) => {
   const seenTopics = new Map()
   changes.forEach(({ key, value, del }) => {
     if (del || !value) value = { _deleted: true }
-    routingFn(makeDoc({ key, value }), t => {
+    routingFn(({ _id: key, ...value }), t => {
       const topicList = getTopicList(seenTopics, t)
       topicList.push(key)
     })

package/src/prolly.js

@@ -67,12 +67,13 @@ async function createAndSaveNewEvent ({
   let cids
   const { key, value, del } = inEvent
   const data = {
-    type: 'put',
-    root: {
-      cid: root.cid,
-      bytes: root.bytes,
-      value: root.value
-    },
+    root: (root
+      ? {
+          cid: root.cid,
+          bytes: root.bytes, // can we remove this?
+          value: root.value // can we remove this?
+        }
+      : null),
     key
   }
 
@@ -81,6 +82,7 @@ async function createAndSaveNewEvent ({
     data.type = 'del'
   } else {
     data.value = value
+    data.type = 'put'
   }
   /** @type {EventData} */
 
@@ -115,13 +117,27 @@ const makeGetAndPutBlock = (inBlocks) => {
   return { getBlock, bigPut, blocks: inBlocks, cids }
 }
 
-const bulkFromEvents = (sorted) =>
-  sorted.map(({ value: event }) => {
+const bulkFromEvents = (sorted, event) => {
+  if (event) {
+    const update = { value: { data: { key: event.key } } }
+    if (event.del) {
+      update.value.data.type = 'del'
+    } else {
+      update.value.data.type = 'put'
+      update.value.data.value = event.value
+    }
+    sorted.push(update)
+  }
+  const bulk = new Map()
+  for (const { value: event } of sorted) {
     const {
       data: { type, value, key }
     } = event
-    return type === 'put' ? { key, value } : { key, del: true }
-  })
+    const bulkEvent = type === 'put' ? { key, value } : { key, del: true }
+    bulk.set(bulkEvent.key, bulkEvent) // last wins
+  }
+  return Array.from(bulk.values())
+}
 
 // Get the value of the root from the ancestor event
 /**
@@ -136,7 +152,47 @@ const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
   const event = await events.get(ancestor)
   const { root } = event.value.data
   // console.log('prollyRootFromAncestor', root.cid, JSON.stringify(root.value))
-  return load({ cid: root.cid, get: getBlock, ...blockOpts })
+  if (root) {
+    return load({ cid: root.cid, get: getBlock, ...blockOpts })
+  } else {
+    return null
+  }
+}
+
+const doProllyBulk = async (inBlocks, head, event) => {
+  const { getBlock, blocks } = makeGetAndPutBlock(inBlocks)
+  let bulkSorted = []
+  let prollyRootNode = null
+  if (head.length) {
+  // Otherwise, we find the common ancestor and update the root and other blocks
+    const events = new EventFetcher(blocks)
+    // todo this is returning more events than necessary, lets define the desired semantics from the top down
+    // good semantics mean we can cache the results of this call
+    const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head)
+    bulkSorted = sorted
+    // console.log('sorted', JSON.stringify(sorted.map(({ value: { data: { key, value } } }) => ({ key, value }))))
+    prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock)
+    // console.log('event', event)
+  }
+
+  const bulkOperations = bulkFromEvents(bulkSorted, event)
+
+  // if prolly root node is null, we need to create a new one
+  if (!prollyRootNode) {
+    let root
+    const newBlocks = []
+    // if all operations are deletes, we can just return an empty root
+    if (bulkOperations.every((op) => op.del)) {
+      return { root: null, blocks: [] }
+    }
+    for await (const node of create({ get: getBlock, list: bulkOperations, ...blockOpts })) {
+      root = await node.block
+      newBlocks.push(root)
+    }
+    return { root, blocks: newBlocks }
+  } else {
+    return await prollyRootNode.bulk(bulkOperations) // { root: newProllyRootNode, blocks: newBlocks }
+  }
 }
 
 /**
@@ -150,44 +206,45 @@ const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
  * @returns {Promise<Result>}
  */
 export async function put (inBlocks, head, event, options) {
-  const { getBlock, bigPut, blocks } = makeGetAndPutBlock(inBlocks)
+  const { bigPut } = makeGetAndPutBlock(inBlocks)
 
   // If the head is empty, we create a new event and return the root and addition blocks
   if (!head.length) {
     const additions = new Map()
-    let root
-    for await (const node of create({ get: getBlock, list: [event], ...blockOpts })) {
-      root = await node.block
-      bigPut(root, additions)
+    const { root, blocks } = await doProllyBulk(inBlocks, head, event)
+    for (const b of blocks) {
+      bigPut(b, additions)
     }
     return createAndSaveNewEvent({ inBlocks, bigPut, root, event, head, additions: Array.from(additions.values()) })
   }
+  const { root: newProllyRootNode, blocks: newBlocks } = await doProllyBulk(inBlocks, head, event)
 
-  // Otherwise, we find the common ancestor and update the root and other blocks
-  const events = new EventFetcher(blocks)
-  // todo this is returning more events than necessary, lets define the desired semantics from the top down
-  // good semantics mean we can cache the results of this call
-  const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head)
-  // console.log('sorted', JSON.stringify(sorted.map(({ value: { data: { key, value } } }) => ({ key, value }))))
-  const prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock)
-
-  const bulkOperations = bulkFromEvents(sorted)
-  const { root: newProllyRootNode, blocks: newBlocks } = await prollyRootNode.bulk([...bulkOperations, event]) // ading delete support here
-  const prollyRootBlock = await newProllyRootNode.block
-  const additions = new Map() // ; const removals = new Map()
-  bigPut(prollyRootBlock, additions)
-  for (const nb of newBlocks) {
-    bigPut(nb, additions)
+  if (!newProllyRootNode) {
+    return createAndSaveNewEvent({
+      inBlocks,
+      bigPut,
+      root: null,
+      event,
+      head,
+      additions: []
+    })
+  } else {
+    const prollyRootBlock = await newProllyRootNode.block
+    const additions = new Map() // ; const removals = new Map()
+    bigPut(prollyRootBlock, additions)
+    for (const nb of newBlocks) {
+      bigPut(nb, additions)
+    }
+    // additions are new blocks
+    return createAndSaveNewEvent({
+      inBlocks,
+      bigPut,
+      root: prollyRootBlock,
+      event,
+      head,
+      additions: Array.from(additions.values()) /*, todo? Array.from(removals.values()) */
+    })
   }
-  // additions are new blocks
-  return createAndSaveNewEvent({
-    inBlocks,
-    bigPut,
-    root: prollyRootBlock,
-    event,
-    head,
-    additions: Array.from(additions.values()) /*, todo? Array.from(removals.values()) */
-  })
 }
 
 /**
@@ -200,25 +257,15 @@ export async function root (inBlocks, head) {
   if (!head.length) {
     throw new Error('no head')
   }
-  const { getBlock, blocks } = makeGetAndPutBlock(inBlocks)
-  const events = new EventFetcher(blocks)
-  const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head)
-  const prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock)
-
-  // Perform bulk operations (put or delete) for each event in the sorted array
-  const bulkOperations = bulkFromEvents(sorted)
-  const { root: newProllyRootNode, blocks: newBlocks } = await prollyRootNode.bulk(bulkOperations)
-  // const prollyRootBlock = await newProllyRootNode.block
-  // console.log('newBlocks', newBlocks.map((nb) => nb.cid.toString()))
+  const { root: newProllyRootNode, blocks: newBlocks, cids } = await doProllyBulk(inBlocks, head)
   // todo maybe these should go to a temp blockstore?
   await doTransaction('root', inBlocks, async (transactionBlockstore) => {
     const { bigPut } = makeGetAndPutBlock(transactionBlockstore)
     for (const nb of newBlocks) {
       bigPut(nb)
     }
-    // bigPut(prollyRootBlock)
   })
-  return { cids: events.cids, node: newProllyRootNode }
+  return { cids, node: newProllyRootNode }
 }
 
 /**
@@ -252,6 +299,9 @@ export async function getAll (blocks, head) {
     return { clockCIDs: new CIDCounter(), cids: new CIDCounter(), result: [] }
   }
   const { node: prollyRootNode, cids: clockCIDs } = await root(blocks, head)
+  if (!prollyRootNode) {
+    return { clockCIDs, cids: new CIDCounter(), result: [] }
+  }
   const { result, cids } = await prollyRootNode.getAllEntries() // todo params
   return { clockCIDs, cids, result: result.map(({ key, value }) => ({ key, value })) }
 }
@@ -267,6 +317,9 @@ export async function get (blocks, head, key) {
     return { cids: new CIDCounter(), result: null }
   }
   const { node: prollyRootNode, cids: clockCIDs } = await root(blocks, head)
+  if (!prollyRootNode) {
+    return { clockCIDs, cids: new CIDCounter(), result: null }
+  }
   const { result, cids } = await prollyRootNode.get(key)
   return { result, cids, clockCIDs }
 }

package/test/db-index.test.js

@@ -27,7 +27,10 @@ describe('DbIndex query', () => {
     }
     index = new DbIndex(database, function (doc, map) {
       map(doc.age, doc.name)
-    })
+    }, null, { name: 'namesByAge' })
+  })
+  it('has a name', () => {
+    assert.equal(index.name, 'namesByAge')
   })
   it('query index range', async () => {
     const result = await index.query({ range: [41, 49] })
@@ -56,6 +59,14 @@ describe('DbIndex query', () => {
     assert.equal(result.rows[0].value, 'emily')
     assert.equal(result.rows[result.rows.length - 1].value, 'dave')
   })
+  it('query index limit', async () => {
+    const result = await index.query({ limit: 3 })
+    assert(result, 'did return result')
+    assert(result.rows)
+    assert.equal(result.rows.length, 3, 'six row matched')
+    assert.equal(result.rows[0].key, 4)
+    assert.equal(result.rows[0].value, 'emily')
+  })
   it('query index NaN', async () => {
     const result = await index.query({ range: [NaN, 44] })
     assert(result, 'did return result')
@@ -236,6 +247,9 @@ describe('DbIndex query with bad index definition', () => {
       map(doc.oops.missingField, doc.name)
     })
   })
+  it('has a default name', () => {
+    assert.equal(index.name, 'doc.oops.missingField, doc.name')
+  })
   it('query index range', async () => {
     const oldErrFn = console.error
     console.error = () => {}

package/test/fireproof.test.js

@@ -124,6 +124,14 @@ describe('Fireproof', () => {
     const changes = await db.changesSince()
     assert.equal(changes.rows.length, 0)
   })
+  it('delete on an empty database', async () => {
+    const db = Fireproof.storage()
+    assert(db instanceof Fireproof)
+    const e = await db.del('8c5c0c5c0c5c').catch((err) => err)
+    assert.equal(e.id, '8c5c0c5c0c5c')
+    const changes = await db.changesSince()
+    assert.equal(changes.rows.length, 0)
+  })
   it('update existing document', async () => {
     // const alice = await database.get('1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
     // assert.equal(alice.name, 'alice')
@@ -194,7 +202,7 @@ describe('Fireproof', () => {
     const e = await database.get('missing').catch((e) => e)
     assert.equal(e.message, 'Not found')
   })
-  it('delete a document', async () => {
+  it('delete the only document', async () => {
     const id = '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c'
     const found = await database.get(id)
     assert.equal(found._id, id)
@@ -212,6 +220,31 @@ describe('Fireproof', () => {
     assert.equal(e.message, 'Not found')
   })
 
+  it('delete not last document', async () => {
+    const resp1 = await database.put({
+      _id: 'second',
+      name: 'bob',
+      age: 39
+    })
+
+    // const id = '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c'
+    const id = resp1.id
+    const found = await database.get(id)
+    assert.equal(found._id, id)
+    const deleted = await database.del(id)
+    assert.equal(deleted.id, id)
+    const e = await database
+      .get(id)
+      .then((doc) => assert.equal('should be deleted', JSON.stringify(doc)))
+      .catch((e) => {
+        if (e.message !== 'Not found') {
+          throw e
+        }
+        return e
+      })
+    assert.equal(e.message, 'Not found')
+  })
+
   it("delete a document with validation function that doesn't allow it", async () => {
     const validationDatabase = new Fireproof(new Blockstore(), [], {
       validateChange: (newDoc, oldDoc, authCtx) => {

package/test/hydrator.test.js

@@ -25,7 +25,7 @@ describe('DbIndex query', () => {
     }
     index = new DbIndex(database, function (doc, map) {
       map(doc.age, doc.name)
-    })
+    }, null, { name: 'names_by_age' })
   })
   it('serialize database with index', async () => {
     await database.put({ _id: 'rehy', name: 'drate', age: 1 })
@@ -44,6 +44,8 @@ describe('DbIndex query', () => {
     assert.equal(serialized.indexes[0].code, `function (doc, map) {
       map(doc.age, doc.name)
     }`)
+    assert.equal(serialized.indexes[0].name, 'names_by_age')
+
     assert.equal(serialized.indexes[0].clock.byId.constructor.name, 'String')
     assert.equal(serialized.indexes[0].clock.byKey.constructor.name, 'String')
     assert.equal(serialized.indexes[0].clock.db[0].constructor.name, 'String')
@@ -71,6 +73,8 @@ describe('DbIndex query', () => {
     assert.equal(newIndex.indexByKey.cid, 'bafyreicr5rpvsxnqchcwk5rxlmdvd3fah2vexmbsp2dvr4cfdxd2q2ycgu')
     // assert.equal(newIndex.indexByKey.root, null)
 
+    assert.equal(newIndex.name, 'names_by_age')
+
     const newResult = await newIndex.query({ range: [0, 54] })
     assert.equal(newResult.rows[0].value, 'drate')
   })