@fireproof/core 0.3.22 → 0.4.0

package/src/fireproof.js

@@ -1,343 +1,86 @@
-// @ts-nocheck
 import randomBytes from 'randombytes'
-import { visMerkleClock, visMerkleTree, vis, put, get, getAll, eventsSince } from './prolly.js'
-import { TransactionBlockstore, doTransaction } from './blockstore.js'
-import charwise from 'charwise'
 
-// 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 {}
+import { Database } from './database.js'
+import { Listener } from './listener.js'
+import { DbIndex as Index } from './db-index.js'
+import { CID } from 'multiformats'
+import { TransactionBlockstore } from './blockstore.js'
+import { localGet } from './utils.js'
 
-/**
- * @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 {import('./blockstore.js').TransactionBlockstore} 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 class Fireproof {
-  listeners = new Set()
+export { Index, Listener }
+
+const parseCID = cid => typeof cid === 'string' ? CID.parse(cid) : cid
 
+export class Fireproof {
   /**
    * @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
-   */
-  static storage = (name = 'global') => {
-    const instanceKey = randomBytes(32).toString('hex') // pass null to disable encryption
-    // pick a random key from const validatedKeys
-    // const instanceKey = validatedKeys[Math.floor(Math.random() * validatedKeys.length)]
-    return new Fireproof(new TransactionBlockstore(name, instanceKey), [], { name })
-  }
-
-  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.indexes = new Map()
-  }
-
-  /**
-   * 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.clockToJSON(),
-      name: this.name,
-      key: this.blocks.valet.getKeyMaterial(),
-      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 () {
-    return this.clock.map(cid => cid.toString())
-  }
-
-  hydrate ({ clock, name, key }) {
-    this.name = name
-    this.clock = clock
-    this.blocks.valet.setKeyMaterial(key)
-    this.indexBlocks = null
-  }
-
-  /**
-   * Triggers a notification to all listeners
-   * of the Fireproof instance so they can repaint UI, etc.
-   * @returns {Promise<void>}
-   * @memberof Fireproof
-   * @instance
+   * @returns {Database} - a new Fireproof instance
    */
-  async notifyReset () {
-    await this.notifyListeners({ _reset: true, _clock: this.clockToJSON() })
-  }
-
-  // used be indexes etc to notify database listeners of new availability
-  async notifyExternal (source = 'unknown') {
-    await this.notifyListeners({ _external: source, _clock: this.clockToJSON() })
-  }
-
-  /**
-   * 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 (event) {
-    // console.log('changesSince', this.instanceId, event, this.clock)
-    let rows, dataCIDs, clockCIDs
-    // if (!event) event = []
-    if (event) {
-      const resp = await eventsSince(this.blocks, this.clock, event)
-      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 })
-        }
+  static storage = (name = null, opts = {}) => {
+    if (name) {
+      opts.name = name
+      const existing = localGet('fp.' + name)
+      if (existing) {
+        const existingConfig = JSON.parse(existing)
+        const fp = new Database(new TransactionBlockstore(name, existingConfig.key), [], opts)
+        return this.fromJSON(existingConfig, fp)
+      } else {
+        const instanceKey = randomBytes(32).toString('hex') // pass null to disable encryption
+        return new Database(new TransactionBlockstore(name, instanceKey), [], opts)
       }
-      rows = Array.from(docsMap.values())
-      clockCIDs = resp.clockCIDs
-      // console.log('change rows', this.instanceId, rows)
-    } else {
-      const allResp = await getAll(this.blocks, this.clock)
-      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 () {
-    const allResp = await getAll(this.blocks, this.clock)
-    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)
-    }
-  }
-
-  /**
-   * 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)
-    }
-  }
-
-  /**
-   * 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 = {}) {
-    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.
-   *
-   * @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 {CID[]} doc._clock - the document ID. If not provided, a random ID will be generated.
-   * @param {Proof} doc._proof - CIDs referenced by the update
-   * @returns {Promise<{ id: string, clock: CID[]  }>} - The result of adding the document to the database
-   * @memberof Fireproof
-   * @instance
-   */
-  async put ({ _id, _proof, ...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 }, 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) {
-    let id
-    let clock = null
-    if (docOrId._id) {
-      id = docOrId._id
-      clock = docOrId._clock
     } else {
-      id = docOrId
+      return new Database(new TransactionBlockstore(), [], opts)
     }
-    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)
   }
 
-  /**
-   * 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) {
-    const event = encodeEvent(decodedEvent)
-    if (clock && JSON.stringify(clock) !== JSON.stringify(this.clockToJSON())) {
-      // 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.')
+  static fromJSON (json, database) {
+    database.hydrate({ clock: json.clock.map(c => parseCID(c)), name: json.name, key: json.key })
+    if (json.indexes) {
+      for (const { name, code, clock: { byId, byKey, db } } of json.indexes) {
+        Index.fromJSON(database, {
+          clock: {
+            byId: byId ? parseCID(byId) : null,
+            byKey: byKey ? parseCID(byKey) : null,
+            db: db ? db.map(c => parseCID(c)) : null
+          },
+          code,
+          name
+        })
       }
     }
-    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')
+    return database
+  }
+
+  static snapshot (database, clock) {
+    const definition = database.toJSON()
+    const withBlocks = new Database(database.blocks)
+    if (clock) {
+      definition.clock = clock.map(c => parseCID(c))
+      definition.indexes.forEach(index => {
+        index.clock.byId = null
+        index.clock.byKey = null
+        index.clock.db = null
+      })
     }
-    // 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([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)
+    const snappedDb = this.fromJSON(definition, withBlocks)
+    ;([...database.indexes.values()]).forEach(index => {
+      snappedDb.indexes.get(index.mapFnString).mapFn = index.mapFn
+    })
+    return snappedDb
+  }
+
+  static async zoom (database, clock) {
+    ;([...database.indexes.values()]).forEach(index => {
+      index.indexById = { root: null, cid: null }
+      index.indexByKey = { root: null, cid: null }
+      index.dbHead = null
+    })
+    database.clock = clock.map(c => parseCID(c))
+    await database.notifyReset() // hmm... indexes should listen to this? might be more complex than worth it. so far this is the only caller
+    return database
   }
-
-  //   /**
-  //    * 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
-   */
-  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
-    this.blocks.valet.uploadFunction = carUploaderFn
-  }
-
-  setRemoteBlockReader (remoteBlockReaderFn) {
-    // console.log('registering remote block reader')
-    this.blocks.valet.remoteBlockFunction = remoteBlockReaderFn
-  }
-}
-
-export async function cidsToProof (cids) {
-  if (!cids || !cids.all) return []
-  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/listener.js

@@ -4,7 +4,7 @@
  * @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.js').Fireproof} database - The Fireproof database instance to index.
+ * @param {import('./database.js').Database} database - The Database database instance to index.
  * @param {Function} routingFn - The routing function to apply to each entry in the database.
  */
 // import { ChangeEvent } from './db-index'
@@ -14,21 +14,23 @@ export class Listener {
   doStopListening = null
 
   /**
-   * @param {import('./fireproof.js').Fireproof} database
+   * @param {import('./database.js').Database} database
    * @param {(_: any, emit: any) => void} routingFn
    */
-  constructor (database, routingFn) {
+  constructor (
+    database,
+    routingFn = function (/** @type {any} */ _, /** @type {(arg0: string) => void} */ emit) {
+      emit('*')
+    }
+  ) {
     this.database = database
     this.doStopListening = database.registerListener((/** @type {any} */ changes) => this.onChanges(changes))
     /**
      * The map function to apply to each entry in the database.
      * @type {Function}
      */
-    this.routingFn =
-      routingFn ||
-      function (/** @type {any} */ _, /** @type {(arg0: string) => void} */ emit) {
-        emit('*')
-      }
+    this.routingFn = routingFn
+
     this.dbHead = null
   }
 

package/src/prolly.js

@@ -19,6 +19,10 @@ import { doTransaction } from './blockstore.js'
 import { create as createBlock } from 'multiformats/block'
 const blockOpts = { cache, chunker: bf(3), codec, hasher, compare }
 
+/**
+ * @typedef {import('./blockstore.js').TransactionBlockstore} TransactionBlockstore
+ */
+
 const withLog = async (label, fn) => {
   const resp = await fn()
   // console.log('withLog', label, !!resp)
@@ -239,7 +243,7 @@ export async function put (inBlocks, head, event, options) {
 /**
  * Determine the effective prolly root given the current merkle clock head.
  *
- * @param {import('./blockstore.js').TransactionBlockstore} inBlocks Bucket block storage.
+ * @param {TransactionBlockstore} inBlocks Bucket block storage.
  * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
  */
 export async function root (inBlocks, head) {
@@ -248,8 +252,8 @@ export async function root (inBlocks, head) {
   }
   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)
+  await doTransaction('root', inBlocks, async (transactionBlocks) => {
+    const { bigPut } = makeGetAndPutBlock(transactionBlocks)
     for (const nb of newBlocks) {
       bigPut(nb)
     }
@@ -259,7 +263,7 @@ export async function root (inBlocks, head) {
 
 /**
  * Get the list of events not known by the `since` event
- * @param {import('./blockstore.js').TransactionBlockstore} blocks Bucket block storage.
+ * @param {TransactionBlockstore} blocks Bucket block storage.
  * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
  * @param {import('./clock').EventLink<import('./clock').EventData>} since Event to compare against.
  * @returns {Promise<{clockCIDs: CIDCounter, result: import('./clock').EventData[]}>}
@@ -276,7 +280,7 @@ export async function eventsSince (blocks, head, since) {
 
 /**
  *
- * @param {import('./blockstore.js').TransactionBlockstore} blocks Bucket block storage.
+ * @param {TransactionBlockstore} blocks Bucket block storage.
  * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
  *
  * @returns {Promise<{cids: CIDCounter, clockCIDs: CIDCounter, result: import('./clock').EventData[]}>}
@@ -297,7 +301,7 @@ export async function getAll (blocks, head) {
 }
 
 /**
- * @param {import('./blockstore.js').TransactionBlockstore} blocks Bucket block storage.
+ * @param {TransactionBlockstore} blocks Bucket block storage.
  * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
  * @param {string} key The key of the value to retrieve.
  */

package/src/utils.js

@@ -0,0 +1,16 @@
+
+/* global localStorage */
+let storageSupported = false
+try {
+  storageSupported = window.localStorage && true
+} catch (e) {}
+export function localGet (key) {
+  if (storageSupported) {
+    return localStorage && localStorage.getItem(key)
+  }
+}
+export function localSet (key, value) {
+  if (storageSupported) {
+    return localStorage && localStorage.setItem(key, value)
+  }
+}

package/src/hydrator.js

@@ -1,54 +0,0 @@
-import { DbIndex } from './db-index.js'
-import { Fireproof } from './fireproof.js'
-import { CID } from 'multiformats'
-
-const parseCID = cid => typeof cid === 'string' ? CID.parse(cid) : cid
-
-export 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 { 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,
-          name
-        })
-      }
-    }
-    return database
-  }
-
-  static snapshot (database, clock) {
-    const definition = database.toJSON()
-    const withBlocks = new Fireproof(database.blocks)
-    if (clock) {
-      definition.clock = clock.map(c => parseCID(c))
-      definition.indexes.forEach(index => {
-        index.clock.byId = null
-        index.clock.byKey = null
-        index.clock.db = null
-      })
-    }
-    const snappedDb = this.fromJSON(definition, withBlocks)
-    ;([...database.indexes.values()]).forEach(index => {
-      snappedDb.indexes.get(index.mapFnString).mapFn = index.mapFn
-    })
-    return snappedDb
-  }
-
-  static async zoom (database, clock) {
-    ;([...database.indexes.values()]).forEach(index => {
-      index.indexById = { root: null, cid: null }
-      index.indexByKey = { root: null, cid: null }
-      index.dbHead = null
-    })
-    database.clock = clock.map(c => parseCID(c))
-    await database.notifyReset() // hmm... indexes should listen to this? might be more complex than worth it. so far this is the only caller
-    return database
-  }
-}

package/src/index.js

@@ -1,6 +0,0 @@
-import { Fireproof } from './fireproof.js'
-import { DbIndex as Index } from './db-index.js'
-import { Listener } from './listener.js'
-import { Hydrator } from './hydrator.js'
-
-export { Fireproof, Index, Listener, Hydrator }