@fireproof/core 0.8.0 → 0.10.1-dev

package/src/database.js

@@ -1,469 +0,0 @@
-// @ts-nocheck
-import { visMerkleClock, visMerkleTree, vis, put, get, getAll, eventsSince } from './prolly.js'
-import { doTransaction, TransactionBlockstore } from './blockstore.js'
-import charwise from 'charwise'
-import { CID } from 'multiformats'
-import { DbIndex as Index } from './db-index.js'
-
-import { Remote } from './remote.js'
-
-// TypeScript Types
-// eslint-disable-next-line no-unused-vars
-// import { CID } from 'multiformats/dist/types/src/cid.js'
-
-// eslint-disable-next-line no-unused-vars
-class Proof {}
-export const parseCID = cid => (typeof cid === 'string' ? CID.parse(cid) : cid)
-
-/**
- * @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.
- *
- * @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 class Database {
-  listeners = new Set()
-  indexes = new Map()
-  rootCache = null
-  eventsCache = new Map()
-  remote = null
-  name = ''
-  constructor (name, config = {}) {
-    this.name = name
-    this.clock = []
-    this.instanceId = `fp.${this.name}.${Math.random().toString(36).substring(2, 7)}`
-    this.blocks = new TransactionBlockstore(name, config)
-    this.indexBlocks = new TransactionBlockstore(name ? name + '.indexes' : null, { primary: config.index })
-    this.remote = new Remote(this, name, config)
-    this.config = config
-    // todo we can wait for index blocks elsewhere
-    this.ready = Promise.all([this.blocks.ready, this.indexBlocks.ready]).then(([blocksReady, indexReady]) => {
-      const clock = new Set()
-      // console.log('blocksReady', blocksReady)
-      if (!blocksReady) {
-        return
-      }
-      for (const headers of blocksReady) {
-        for (const [, header] of Object.entries(headers)) {
-          if (!header) continue
-          for (const cid of header.clock) {
-            clock.add(cid)
-          }
-          if (header.index) {
-            this.indexBlocks.valet.primary.setLastCar(header.index.car)
-            this.indexBlocks.valet.primary.setKeyMaterial(header.index.key)
-          }
-          if (header.indexes) {
-            for (const {
-              name,
-              code,
-              clock: { byId, byKey, db }
-            } of header.indexes) {
-              // console.log('index', name, code, { byId, byKey }, db, header.indexes)
-              Index.fromJSON(this, {
-                clock: {
-                  byId: byId ? parseCID(byId) : null,
-                  byKey: byKey ? parseCID(byKey) : null,
-                  db: db && db.length > 0 ? db.map(c => parseCID(c)) : null
-                },
-                code,
-                name
-              })
-            }
-          }
-        }
-      }
-      this.clock = [...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 prepareHeader ignores secondary storage, need both
-    return this.blocks.valet ? this.blocks.valet.primary.prepareHeader(this.toHeader(), false) : this.toHeader() // omg
-  }
-
-  toHeader () {
-    return {
-      // clock: this.clockToJSON(),
-      name: this.name,
-      index: {
-        key: this.indexBlocks.valet?.primary.keyMaterial,
-        car: this.indexBlocks.valet?.primary.lastCar?.toString()
-      },
-      indexes: [...this.indexes.values()].map(index => index.toJSON())
-    }
-  }
-
-  /**
-   * Returns the Merkle clock heads for the Fireproof instance.
-   * @returns {string[]} - The Merkle clock heads for the Fireproof instance.
-   * @memberof Fireproof
-   * @instance
-   */
-  clockToJSON (clock = null) {
-    return (clock || this.clock).map(cid => cid.toString())
-  }
-
-  async maybeSaveClock () {
-    if (this.name && this.blocks.valet) {
-      await this.blocks.valet.saveHeader(this.toHeader())
-    }
-  }
-
-  index (name) {
-    const indexes = [...this.indexes.values()].filter(index => index.name === name)
-    if (indexes.length > 1) {
-      throw new Error(`Multiple indexes found with name ${name}`)
-    }
-    return indexes[0] || null
-  }
-
-  /**
-   * Triggers a notification to all listeners
-   * of the Fireproof instance so they can repaint UI, etc.
-   * @returns {Promise<void>}
-   * @memberof Fireproof
-   * @instance
-   */
-  async notifyReset () {
-    await this.ready
-    await this.notifyListeners({ _reset: true, _clock: this.clockToJSON() })
-  }
-
-  async compact () {
-    if (this.name && this.blocks.valet) {
-      await this.blocks.valet.compact(this.clock)
-      await this.blocks.valet.saveHeader(this.toHeader())
-    }
-  }
-
-  /**
-   * Returns the changes made to the Fireproof instance since the specified event.
-   * @function changesSince
-   * @param {CID[]} [event] - The clock head to retrieve changes since. If null or undefined, retrieves all changes.
-   * @returns {Promise<{rows : Object[], clock: CID[], proof: {}}>} An object containing the rows and the head of the instance's clock.
-   * @memberof Fireproof
-   * @instance
-   */
-  async changesSince (aClock) {
-    await this.ready
-    // console.log('events for', this.instanceId, aClock?.constructor.name)
-    // console.log('changesSince', this.instanceId, this.clockToJSON(aClock), this.clockToJSON())
-    let rows, dataCIDs, clockCIDs
-    // if (!aClock) aClock = []
-    if (aClock && aClock.length > 0) {
-      aClock = aClock.map(cid => cid.toString())
-      const eventKey = JSON.stringify([...this.clockToJSON(aClock), ...this.clockToJSON()])
-
-      let resp
-      if (this.eventsCache.has(eventKey)) {
-        // console.log('events from cache')
-        resp = this.eventsCache.get(eventKey)
-      } else {
-        resp = await eventsSince(this.blocks, this.clock, aClock)
-        this.eventsCache.set(eventKey, resp)
-      }
-      const docsMap = new Map()
-      for (const { key, type, value } of resp.result.map(decodeEvent)) {
-        if (type === 'del') {
-          docsMap.set(key, { key, del: true })
-        } else {
-          docsMap.set(key, { key, value })
-        }
-      }
-      rows = Array.from(docsMap.values())
-      clockCIDs = resp.clockCIDs
-      // console.log('change rows', this.instanceId, rows)
-    } else {
-      const allResp = await getAll(this.blocks, this.clock, this.rootCache)
-      this.rootCache = { root: allResp.root, clockCIDs: allResp.clockCIDs }
-
-      rows = allResp.result.map(({ key, value }) => decodeEvent({ key, value }))
-      dataCIDs = allResp.cids
-      // console.log('dbdoc rows', this.instanceId, rows)
-    }
-    return {
-      rows,
-      clock: this.clockToJSON(),
-      proof: { data: await cidsToProof(dataCIDs), clock: await cidsToProof(clockCIDs) }
-    }
-  }
-
-  async allDocuments () {
-    await this.ready
-    const allResp = await getAll(this.blocks, this.clock, this.rootCache)
-    this.rootCache = { root: allResp.root, clockCIDs: allResp.clockCIDs }
-
-    const rows = allResp.result
-      .map(({ key, value }) => decodeEvent({ key, value }))
-      .map(({ key, value }) => ({ key, value: { _id: key, ...value } }))
-    return {
-      rows,
-      clock: this.clockToJSON(),
-      proof: await cidsToProof(allResp.cids)
-    }
-  }
-
-  async allCIDs () {
-    await this.ready
-    const allResp = await getAll(this.blocks, this.clock, this.rootCache, true)
-    this.rootCache = { root: allResp.root, clockCIDs: allResp.clockCIDs }
-    // console.log('allcids', allResp.cids, allResp.clockCIDs)
-    const cids = await cidsToProof(allResp.cids)
-    const clockCids = await cidsToProof(allResp.clockCIDs)
-    // console.log('allcids', cids, clockCids)
-    return [...cids, ...clockCids] // clock CID last -- need to handle multiple entry clocks
-  }
-
-  async allStoredCIDs () {
-    await this.ready
-    const allCIDs = []
-    for await (const { cid } of this.blocks.entries()) {
-      allCIDs.push(cid)
-    }
-    return allCIDs
-  }
-
-  /**
-   * 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 {Promise<{_id: string}>} - the document with the specified ID
-   * @memberof Fireproof
-   * @instance
-   */
-  async get (key, opts = {}) {
-    await this.ready
-    const clock = opts.clock || this.clock
-    const resp = await get(this.blocks, clock, charwise.encode(key), this.rootCache)
-    this.rootCache = { root: resp.root, clockCIDs: resp.clockCIDs }
-    // ? 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
-  }
-  /**
-   * @typedef {any} Document
-   * @property {string} _id - The ID of the document (required)
-   * @property {string} [_proof] - The proof of the document (optional)
-   * @property {string} [_clock] - The clock of the document (optional)
-   * @property {Object.<string, any>} [unknown: string] - Any other unknown properties (optional)
-   */
-
-  /**
-   * Adds a new document to the database, or updates an existing document. Returns the ID of the document and the new clock head.
-   *
-   * @param {Document} doc - the document to be added
-   * @returns {Promise<{ id: string, clock: CID[]  }>} - The result of adding the document to the database
-   * @memberof Fireproof
-   * @instance
-   */
-  async put ({ _id, _proof, _clock, ...doc }) {
-    await this.ready
-    const id = _id || 'f' + Math.random().toString(36).slice(2)
-    doc = JSON.parse(JSON.stringify(doc))
-    if (_clock) doc._clock = _clock
-    await this.runValidation({ _id: id, ...doc })
-    return await this.putToProllyTree({ key: id, value: doc }, _clock)
-  }
-
-  /**
-   * Deletes a document from the database
-   * @param {string | any} docOrId - the document ID
-   * @returns {Promise<{ id: string, clock: CID[] }>} - The result of deleting the document from the database
-   * @memberof Fireproof
-   * @instance
-   */
-  async del (docOrId) {
-    await this.ready
-    let id
-    let clock = null
-    if (docOrId._id) {
-      id = docOrId._id
-      clock = docOrId._clock
-    } else {
-      id = docOrId
-    }
-    await this.runValidation({ _id: id, _deleted: true })
-    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)
-  }
-
-  /**
-   * 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) {
-    if (this.config && this.config.validateChange) {
-      const oldDoc = await this.get(doc._id)
-        .then(doc => doc)
-        .catch(() => ({}))
-      this.config.validateChange(doc, oldDoc, this.authCtx)
-    }
-  }
-
-  /**
-   * Updates the underlying storage with the specified event.
-   * @private
-   * @param {{del?: true, key : string, value?: any}} decodedEvent - the event to add
-   * @returns {Promise<{ proof:{}, id: string, clock: CID[] }>} - The result of adding the event to storage
-   */
-  async putToProllyTree (decodedEvent, clock = null) {
-    // console.log('putToProllyTree', decodedEvent)
-    const event = encodeEvent(decodedEvent)
-    if (clock && JSON.stringify(this.clockToJSON(clock)) !== JSON.stringify(this.clockToJSON())) {
-      // console.log('this.clock', this.clockToJSON())
-      // console.log('that.clock', this.clockToJSON(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
-      const resp = await eventsSince(this.blocks, this.clock, event.value._clock)
-      const missedChange = resp.result.find(({ key }) => key === event.key)
-      if (missedChange) {
-        throw new Error('MVCC conflict, document is changed, please reload the document and try again.')
-      }
-    }
-    const prevClock = [...this.clock]
-    // console.log('putToProllyTree', this.clockToJSON(), decodedEvent)
-    const result = await doTransaction(
-      'putToProllyTree',
-      this.blocks,
-      async blocks => await put(blocks, this.clock, event)
-    )
-    if (!result) {
-      console.error('failed', event)
-      throw new Error('failed to put at storage layer')
-    }
-    this.applyClock(prevClock, result.head)
-    await this.notifyListeners([decodedEvent]) // this type is odd
-    return {
-      id: decodedEvent.key,
-      clock: this.clockToJSON(),
-      proof: { data: await cidsToProof(result.cids), clock: await cidsToProof(result.clockCIDs) }
-    }
-    // todo should include additions (or split clock)
-  }
-
-  applyClock (prevClock, newClock) {
-    // console.log('prevClock', prevClock.length, prevClock.map((cid) => cid.toString()))
-    // console.log('newClock', newClock.length, newClock.map((cid) => cid.toString()))
-    // console.log('this.clock', this.clock.length, this.clockToJSON())
-    const stPrev = prevClock.map(cid => cid.toString())
-    const keptPrevClock = this.clock.filter(cid => stPrev.indexOf(cid.toString()) === -1)
-    const merged = keptPrevClock.concat(newClock)
-    const uniquebyCid = new Map()
-    for (const cid of merged) {
-      uniquebyCid.set(cid.toString(), cid)
-    }
-    this.clock = Array.from(uniquebyCid.values()).sort((a, b) => a.toString().localeCompare(b.toString()))
-    this.rootCache = null
-    this.eventsCache.clear()
-    // console.log('afterClock', this.clock.length, this.clockToJSON())
-  }
-
-  //   /**
-  //    * Advances the clock to the specified event and updates the root CID
-  //    *   Will be used by replication
-  //    */
-  //     async advance (event) {
-  //       this.clock = await advance(this.blocks, this.clock, event)
-  //       this.rootCid = await root(this.blocks, this.clock)
-  //       return this.clock
-  //     }
-
-  async * vis () {
-    return yield * vis(this.blocks, this.clock)
-  }
-
-  async visTree () {
-    return await visMerkleTree(this.blocks, this.clock)
-  }
-
-  async visClock () {
-    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
-   */
-  subscribe (listener) {
-    this.listeners.add(listener)
-    return () => {
-      this.listeners.delete(listener)
-    }
-  }
-
-  /**
-   * @deprecated 0.7.0 - renamed subscribe(listener)
-   * @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) {
-    return this.subscribe(listener)
-  }
-
-  async notifyListeners (changes) {
-    // await sleep(10)
-    await this.maybeSaveClock()
-    for (const listener of this.listeners) {
-      await listener(changes)
-    }
-  }
-
-  setRemoteBlockReader (remoteBlockReaderFn) {
-    this.blocks.remoteBlockFunction = remoteBlockReaderFn
-  }
-}
-
-export async function cidsToProof (cids) {
-  if (!cids) return []
-  if (!cids.all) {
-    return [...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 }
-}