@fireproof/core 0.0.1 → 0.0.2-dev-test

package/src/db-index.js

@@ -1,196 +0,0 @@
-import { create, load } from 'prolly-trees/db-index'
-import { sha256 as hasher } from 'multiformats/hashes/sha2'
-import { nocache as cache } from 'prolly-trees/cache'
-import { bf, simpleCompare as compare } from 'prolly-trees/utils'
-import * as codec from '@ipld/dag-cbor'
-import { create as createBlock } from 'multiformats/block'
-import { doTransaction } from './blockstore.js'
-import charwise from 'charwise'
-const opts = { cache, chunker: bf(3), codec, hasher, compare }
-
-const ALWAYS_REBUILD = true // todo: remove this
-
-const makeGetBlock = (blocks) => async (address) => {
-  const { cid, bytes } = await blocks.get(address)
-  return createBlock({ cid, bytes, hasher, codec })
-}
-const makeDoc = ({ key, value }) => ({ _id: key, ...value })
-
-console.x = function () {}
-
-/**
- * Transforms a set of changes to index 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.
- */
-
-const indexEntriesForChanges = (changes, mapFun) => {
-  const indexEntries = []
-  changes.forEach(({ key, value, del }) => {
-    if (del || !value) return
-    mapFun(makeDoc({ key, value }), (k, v) => {
-      indexEntries.push({
-        key: [charwise.encode(k), key],
-        value: v
-      })
-    })
-  })
-  return indexEntries
-}
-
-const indexEntriesForOldChanges = async (blocks, byIDindexRoot, ids, mapFun) => {
-  const getBlock = makeGetBlock(blocks)
-  const byIDindex = await load({ cid: byIDindexRoot.cid, get: getBlock, ...opts })
-  // console.trace('ids', ids)
-  const result = await byIDindex.getMany(ids)
-  return result.result
-}
-
-/**
- * Represents an index for a Fireproof database.
- *
- * @class
- * @classdesc An index 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 {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.
-   */
-  constructor (database, mapFun) {
-    /**
-     * The database instance to index.
-     * @type {import('./fireproof').Fireproof}
-     */
-    this.database = database
-    /**
-     * The map function to apply to each entry in the database.
-     * @type {Function}
-     */
-    this.mapFun = mapFun
-    this.indexRoot = null
-    this.byIDindexRoot = null
-    this.dbHead = null
-  }
-
-  /**
-   * Query object can have {range}
-   *
-   */
-  async query (query, root = null) {
-    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 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
-   * @private
-   * @returns {Promise<void>}
-   */
-  async #updateIndex (blocks) {
-    // todo remove this hack
-    if (ALWAYS_REBUILD) {
-      this.dbHead = null // hack
-      this.indexRoot = null // hack
-    }
-    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))
-        // .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?
-
-      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...
-      // const removeByIdIndexEntries = oldIndexEntries.map(({ key }) => ({ key: key[1], del: true }))
-      // this.byIDindexRoot = await bulkIndex(blocks, this.byIDindexRoot, removeByIdIndexEntries, opts)
-    }
-    const indexEntries = indexEntriesForChanges(result.rows, this.mapFun)
-    const byIdIndexEntries = indexEntries.map(({ key }) => ({ key: key[1], value: key }))
-    // [{key:  'xxxx-3c3a-4b5e-9c1c-8c5c0c5c0c5c', value : [ 53, 'xxxx-3c3a-4b5e-9c1c-8c5c0c5c0c5c' ]}]
-    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)
-    this.dbHead = result.clock
-  }
-
-  // todo use the index 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
- * @param {Blockstore} blocks
- * @param {import('multiformats/block').Block} inRoot
- * @param {import('prolly-trees/db-index').IndexEntry[]} indexEntries
- */
-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
-
-    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)
-    return inRoot
-  } else {
-    // load existing index
-    // console.x('loading index', inRoot.cid)
-    const index = await load({ cid: inRoot.cid, get: getBlock, ...opts })
-    // console.log('new indexEntries', indexEntries)
-    const { root, blocks } = await index.bulk(indexEntries)
-    for await (const block of blocks) {
-      await putBlock(block.cid, block.bytes)
-    }
-    // console.x('updated index', 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
- * @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>}
- **/
-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 })
-  if (query.range) {
-    const encodedRange = query.range.map((key) => charwise.encode(key))
-    return index.range(...encodedRange)
-  } else if (query.key) {
-    const encodedKey = charwise.encode(query.key)
-    return index.get(encodedKey)
-  }
-}

package/src/fireproof.js

@@ -1,209 +0,0 @@
-// 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
- * @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 {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 {
-  /**
-   * @param {Blockstore} blocks
-   * @param {import('../clock').EventLink<import('../crdt').EventData>[]} clock
-   */
-  #listeners = new Set()
-
-  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)
-  }
-
-  /**
-   * Returns a snapshot of the current Fireproof instance.
-   *
-   * @param {import('../clock').EventLink<import('../crdt').EventData>[]} clock
-   *    Clock to use for the snapshot.
-   * @returns {Fireproof}
-   *    A new Fireproof instance representing the snapshot.
-   */
-  snapshot (clock) {
-    // how to handle listeners, views, and config?
-    // todo needs a test for that
-    return new Fireproof(this.blocks, clock || this.clock)
-  }
-
-  /**
-   * This triggers a notification to all listeners of the Fireproof instance.
-   */
-  async setClock (clock) {
-    // console.log('setClock', this.instanceId, clock)
-    this.clock = clock.map((item) => item['/'] ? item['/'] : item)
-    await this.#notifyListeners({ reset: true, clock })
-  }
-
-  toJSON () {
-    // todo this also needs to return the index roots...
-    return { clock: this.clock }
-  }
-
-  /**
-   * 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.
-   */
-  async changesSince (event) {
-    // console.log('changesSince', this.instanceId, event, this.clock)
-    let rows
-    if (event) {
-      const resp = await eventsSince(this.blocks, this.clock, event)
-      const docsMap = new Map()
-      for (const { key, type, value } of resp) {
-        if (type === 'del') {
-          docsMap.set(key, { key, del: true })
-        } else {
-          docsMap.set(key, { key, value })
-        }
-      }
-      rows = Array.from(docsMap.values())
-      // console.log('change rows', this.instanceId, rows)
-    } else {
-      rows = (await getAll(this.blocks, this.clock)).map(({ key, value }) => ({ key, value }))
-      // console.log('dbdoc rows', this.instanceId, rows)
-    }
-    return { rows, clock: 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.
-   */
-  registerListener (listener) {
-    this.#listeners.add(listener)
-    return () => {
-      this.#listeners.delete(listener)
-    }
-  }
-
-  async #notifyListeners (changes) {
-    // await sleep(0)
-    this.#listeners.forEach((listener) => listener(changes))
-  }
-
-  /**
-   * Runs validation on the specified document using the Fireproof instance's configuration.
-   *
-   * @param {Object} doc - The document to validate.
-   */
-  async runValidation (doc) {
-    if (this.config && this.config.validateChange) {
-      const oldDoc = await this.get(doc._id)
-        .then((doc) => doc)
-        .catch(() => ({}))
-      this.config.validateChange(doc, oldDoc, this.authCtx)
-    }
-  }
-
-  /**
-   * Adds a new document to the database, or updates an existing document.
-   *
-   * @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
-   */
-  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 })
-  }
-
-  /**
-   * Deletes a document from the database
-   * @param {string} id - the document ID
-   * @returns {Promise<import('./prolly').PutResult>} - the result of deleting the document
-   */
-  async del (id) {
-    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 })
-  }
-
-  async putToProllyTree (event) {
-    const result = await doTransaction('putToProllyTree', this.blocks, async (blocks) => await put(blocks, this.clock, event))
-    if (!result) {
-      console.log('failed', event)
-    }
-    this.clock = result.head // do we want to do this as a finally block
-    result.id = event.key
-    await this.#notifyListeners([event])
-    return { id: result.id, clock: this.clock }
-  }
-
-  //   /**
-  //    * Advances the clock to the specified event and updates the root CID
-  //    *   Will be used by replication
-  //    * @param {import('../clock').EventLink<import('../crdt').EventData>} event - the event to advance to
-  //    * @returns {import('../clock').EventLink<import('../crdt').EventData>[]} - the new clock after advancing
-  //    */
-  //     async advance (event) {
-  //       this.clock = await advance(this.blocks, this.clock, event)
-  //       this.rootCid = await root(this.blocks, this.clock)
-  //       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
-   * @returns {Promise<import('./prolly').GetResult>} - the document with the specified ID
-   */
-  async get (key) {
-    const got = await get(this.blocks, this.clock, key)
-    // this tombstone is temporary until we can get the prolly tree to delete
-    if (got === null) {
-      throw new Error('Not found')
-    }
-    got._id = key
-    return got
-  }
-}
-
-Fireproof.storage = (_email) => {
-  return new Fireproof(new Blockstore(), [])
-}

package/src/link.d.ts

@@ -1,3 +0,0 @@
-import type { Link } from 'multiformats'
-
-export type AnyLink = Link<unknown, number, number, 1|0>

package/src/listener.js

@@ -1,111 +0,0 @@
-/**
- * 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
- *
- * @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.
- *
- */
-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
-
-  /**
-   * 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
-     * The database instance to index.
-     * @type {import('./fireproof').Fireproof}
-     */
-    this.database = database
-    this.#doStopListening = database.registerListener((changes) => this.#onChanges(changes))
-    /**
-     * The map function to apply to each entry in the database.
-     * @type {Function}
-     */
-    this.eventFun = eventFun || function (_, emit) { emit('*') }
-    this.dbHead = null
-  }
-
-  /**
-   * Subscribe to a topic emitted by the event function.
-   * @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.
-   */
-  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)
-        if (keys) keys.forEach((key) => subscriber(key))
-      })
-    }
-    return () => {
-      const index = listOfTopicSubscribers.indexOf(subscriber)
-      if (index > -1) listOfTopicSubscribers.splice(index, 1)
-    }
-  }
-
-  #onChanges (changes) {
-    if (Array.isArray(changes)) {
-      const seenTopics = topicsForChanges(changes, this.eventFun)
-      for (const [topic, keys] of seenTopics) {
-        const listOfTopicSubscribers = getTopicList(this.#subcribers, topic)
-        listOfTopicSubscribers.forEach((subscriber) => keys.forEach((key) => subscriber(key)))
-      }
-    } else {
-      // reset event
-      if (changes.reset) {
-        for (const [, listOfTopicSubscribers] of this.#subcribers) {
-          listOfTopicSubscribers.forEach((subscriber) => subscriber(changes))
-        }
-      }
-    }
-    // if changes is special, notify all listeners?
-    // first make the example app use listeners
-  }
-}
-
-function getTopicList (subscribersMap, name) {
-  let topicList = subscribersMap.get(name)
-  if (!topicList) {
-    topicList = []
-    subscribersMap.set(name, topicList)
-  }
-  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.
- *
- * @param {Array<{ key: string, value: import('./link').AnyLink, del?: boolean }>} changes
- * @param {Function} eventFun
- * @returns {Array<string>} The topics emmitted by the event function.
- */
-const topicsForChanges = (changes, eventFun) => {
-  const seenTopics = new Map()
-  changes.forEach(({ key, value, del }) => {
-    if (del || !value) value = { _deleted: true }
-    eventFun(makeDoc({ key, value }), (t) => {
-      const topicList = getTopicList(seenTopics, t)
-      topicList.push(key)
-    })
-  })
-  return seenTopics
-}