@fireproof/core 0.6.5 → 0.7.0-alpha.0

package/dist/{src/storage → storage}/filesystem.js

@@ -1,5 +1,5 @@
-import { readFileSync } from 'fs';
-import { mkdir, writeFile } from 'fs/promises';
+import { readFileSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { Base } from './base.js';

package/dist/{src/sync.js → sync.js}

@@ -193,7 +193,7 @@ export class Sync {
             return null;
         }
         if (typeof key === 'undefined') {
-            key = blocks.valet?.getKeyMaterial();
+            key = blocks.valet?.primary.keyMaterial;
         }
         if (key) {
             return blocksToEncryptedCarBlock(rootCIDs, {

package/dist/valet.js

@@ -0,0 +1,200 @@
+import { sha256 } from 'multiformats/hashes/sha2';
+import * as CBW from '@ipld/car/buffer-writer';
+import * as raw from 'multiformats/codecs/raw';
+import * as Block from 'multiformats/block';
+import { Loader } from './loader.js';
+// @ts-ignore
+import { bf } from 'prolly-trees/utils';
+// @ts-ignore
+import { nocache as cache } from 'prolly-trees/cache';
+import { encrypt, decrypt } from './crypto.js';
+import { Buffer } from 'buffer';
+const chunker = bf(30);
+export class Valet {
+    idb = null;
+    name = null;
+    uploadQueue = null;
+    alreadyEnqueued = new Set();
+    instanceId = Math.random().toString(36).slice(2);
+    constructor(name = 'default', config = {}) {
+        this.name = name;
+        // console.log('new Valet', name, config.primary)
+        this.primary = Loader.appropriate(name, config.primary);
+        this.secondary = config.secondary ? Loader.appropriate(name, config.secondary) : null;
+        // set up a promise listener that applies all the headers to the clock
+        // when they resolve
+        const readyP = [this.primary.ready];
+        if (this.secondary)
+            readyP.push(this.secondary.ready);
+        this.ready = Promise.all(readyP).then((blocksReady) => {
+            // console.log('blocksReady valet', this.name, blocksReady)
+            return blocksReady;
+        });
+    }
+    async saveHeader(header) {
+        // each storage needs to add its own carCidMapCarCid to the header
+        if (this.secondary) {
+            this.secondary.saveHeader(header);
+        } // todo: await?
+        return await this.primary.saveHeader(header);
+    }
+    /**
+     * Group the blocks into a car and write it to the valet.
+     * @param {import('./blockstore.js').InnerBlockstore} innerBlockstore
+     * @param {Set<string>} cids
+     * @returns {Promise<void>}
+     * @memberof Valet
+     */
+    async writeTransaction(innerBlockstore, cids) {
+        if (innerBlockstore.lastCid) {
+            await parkCar(this.primary, innerBlockstore, cids);
+            if (this.secondary)
+                await parkCar(this.secondary, innerBlockstore, cids);
+        }
+        else {
+            throw new Error('missing lastCid for car header');
+        }
+    }
+    /**
+     * Iterate over all blocks in the store.
+     *
+     * @yields {{cid: string, value: Uint8Array}}
+     * @returns {AsyncGenerator<any, any, any>}
+     */
+    async *cids() {
+        // console.log('valet cids')
+        // todo use cidMap
+        // while (cursor) {
+        // yield { cid: cursor.key, car: cursor.value.car }
+        // cursor = await cursor.continue()
+        // }
+    }
+    remoteBlockFunction = null;
+    async getValetBlock(dataCID) {
+        // console.log('getValetBlock primary', dataCID)
+        try {
+            const { block } = await this.primary.getLoaderBlock(dataCID);
+            return block;
+        }
+        catch (e) {
+            // console.log('getValetBlock error', e)
+            if (this.secondary) {
+                // console.log('getValetBlock secondary', dataCID)
+                try {
+                    const { block, reader } = await this.secondary.getLoaderBlock(dataCID);
+                    const cids = new Set();
+                    for await (const { cid } of reader.entries()) {
+                        // console.log(cid, bytes)
+                        cids.add(cid.toString());
+                    }
+                    reader.get = reader.gat; // some consumers prefer get
+                    // console.log('replicating', reader.root)
+                    reader.lastCid = reader.root.cid;
+                    await parkCar(this.primary, reader, [...cids]);
+                    return block;
+                }
+                catch (e) {
+                    // console.log('getValetBlock secondary error', e)
+                }
+            }
+        }
+    }
+}
+async function parkCar(storage, innerBlockstore, cids) {
+    // console.log('parkCar', this.instanceId, this.name, carCid, cids)
+    let newCar;
+    if (storage.keyMaterial) {
+        // console.log('encrypting car', innerBlockstore.label)
+        newCar = await blocksToEncryptedCarBlock(innerBlockstore.lastCid, innerBlockstore, storage.keyMaterial);
+    }
+    else {
+        // todo should we pass cids in instead of iterating innerBlockstore?
+        newCar = await blocksToCarBlock(innerBlockstore.lastCid, innerBlockstore);
+    }
+    // console.log('new car', newCar.cid.toString())
+    return await storage.saveCar(newCar.cid.toString(), newCar.bytes, cids);
+}
+export const blocksToCarBlock = async (rootCids, blocks) => {
+    // console.log('blocksToCarBlock', rootCids, blocks.constructor.name)
+    let size = 0;
+    if (!Array.isArray(rootCids)) {
+        rootCids = [rootCids];
+    }
+    const headerSize = CBW.headerLength({ roots: rootCids });
+    size += headerSize;
+    if (!Array.isArray(blocks)) {
+        blocks = Array.from(blocks.entries());
+    }
+    for (const { cid, bytes } of blocks) {
+        // console.log(cid, bytes)
+        size += CBW.blockLength({ cid, bytes });
+    }
+    const buffer = new Uint8Array(size);
+    const writer = await CBW.createWriter(buffer, { headerSize });
+    for (const cid of rootCids) {
+        writer.addRoot(cid);
+    }
+    for (const { cid, bytes } of blocks) {
+        writer.write({ cid, bytes });
+    }
+    await writer.close();
+    return await Block.encode({ value: writer.bytes, hasher: sha256, codec: raw });
+};
+export const blocksToEncryptedCarBlock = async (innerBlockStoreClockRootCid, blocks, keyMaterial) => {
+    const encryptionKey = Buffer.from(keyMaterial, 'hex');
+    const encryptedBlocks = [];
+    const theCids = [];
+    // console.trace('blocksToEncryptedCarBlock', blocks)
+    for (const { cid } of blocks.entries()) {
+        theCids.push(cid.toString());
+    }
+    // console.log('encrypting', theCids.length, 'blocks', theCids.includes(innerBlockStoreClockRootCid.toString()), keyMaterial)
+    // console.log('cids', theCids, innerBlockStoreClockRootCid.toString())
+    let last;
+    for await (const block of encrypt({
+        cids: theCids,
+        get: async (cid) => blocks.get(cid),
+        key: encryptionKey,
+        hasher: sha256,
+        chunker,
+        cache,
+        // codec: dagcbor, // should be crypto?
+        root: innerBlockStoreClockRootCid
+    })) {
+        encryptedBlocks.push(block);
+        last = block;
+    }
+    // console.log('last', last.cid.toString(), 'for clock', innerBlockStoreClockRootCid.toString())
+    const encryptedCar = await blocksToCarBlock(last.cid, encryptedBlocks);
+    return encryptedCar;
+};
+// { root, get, key, cache, chunker, hasher }
+const memoizeDecryptedCarBlocks = new Map();
+export const blocksFromEncryptedCarBlock = async (cid, get, keyMaterial) => {
+    if (memoizeDecryptedCarBlocks.has(cid.toString())) {
+        return memoizeDecryptedCarBlocks.get(cid.toString());
+    }
+    else {
+        const blocksPromise = (async () => {
+            const decryptionKey = Buffer.from(keyMaterial, 'hex');
+            // console.log('decrypting', keyMaterial, cid.toString())
+            const cids = new Set();
+            const decryptedBlocks = [];
+            for await (const block of decrypt({
+                root: cid,
+                get,
+                key: decryptionKey,
+                chunker,
+                hasher: sha256,
+                cache
+                // codec: dagcbor
+            })) {
+                decryptedBlocks.push(block);
+                cids.add(block.cid.toString());
+            }
+            return { blocks: decryptedBlocks, cids };
+        })();
+        memoizeDecryptedCarBlocks.set(cid.toString(), blocksPromise);
+        return blocksPromise;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireproof/core",
-  "version": "0.6.5",
+  "version": "0.7.0-alpha.0",
   "description": "Live data for React, accelerated by proofs, powered by IPFS",
   "main": "dist/src/fireproof.js",
   "module": "dist/src/fireproof.mjs",
@@ -9,7 +9,7 @@
   "type": "module",
   "scripts": {
     "keygen": "node scripts/keygen.js",
-    "test": "standard && npm run test:unencrypted && npm run test:mocha",
+    "test": "standard && tsc && npm run test:unencrypted && npm run test:mocha",
     "test:unencrypted": "set NO_ENCRYPT=true && npm run test:mocha",
     "test:mocha": "mocha test/*.test.js",
     "test:watch": "npm run test:mocha -- -w --parallel",
@@ -40,6 +40,7 @@
   "dependencies": {
     "@ipld/car": "^5.1.0",
     "@ipld/dag-cbor": "^9.0.0",
+    "@jsonlines/core": "^1.0.2",
     "@rollup/plugin-commonjs": "^24.0.1",
     "archy": "^1.0.0",
     "async": "^3.2.4",
@@ -51,6 +52,7 @@
     "idb": "^7.1.1",
     "ipld-hashmap": "^2.1.18",
     "multiformats": "^11.0.1",
+    "node-fetch": "^3.3.1",
     "node-polyfill-webpack-plugin": "^2.0.1",
     "prolly-trees": "1.0.4",
     "randombytes": "^2.1.0",
@@ -110,9 +112,6 @@
       "default": "./dist/src/fireproof.js",
       "require": "./dist/src/fireproof.js"
     },
-    "./hooks/use-fireproof": {
-      "import": "./hooks/use-fireproof.js"
-    },
     "./package.json": "./package.json"
   },
   "files": [

package/src/blockstore.js

@@ -41,9 +41,12 @@ export class TransactionBlockstore {
   inflightTransactions = new Set()
   syncs = new Set()
 
-  constructor (name, encryptionKey) {
+  constructor (name, config) {
     if (name) {
-      this.valet = new Valet(name, encryptionKey)
+      this.valet = new Valet(name, config)
+      this.ready = this.valet.ready
+    } else {
+      this.ready = Promise.resolve()
     }
     this.remoteBlockFunction = null
   }
@@ -58,7 +61,7 @@ export class TransactionBlockstore {
     const key = cid.toString()
     // it is safe to read from the in-flight transactions becauase they are immutable
     const bytes = await Promise.any([this.transactionsGet(key), this.committedGet(key)]).catch(e => {
-      // console.log('networkGet', cid.toString(), e)
+      console.log('get error', cid.toString(), e)
       return this.networkGet(key)
     })
     if (!bytes) throw new Error('Missing block: ' + key)

package/src/database.js

@@ -2,8 +2,8 @@
 import { visMerkleClock, visMerkleTree, vis, put, get, getAll, eventsSince } from './prolly.js'
 import { doTransaction, TransactionBlockstore } from './blockstore.js'
 import charwise from 'charwise'
-import { localSet } from './utils.js'
 import { CID } from 'multiformats'
+import { DbIndex as Index } from './db-index.js'
 
 // TypeScript Types
 // eslint-disable-next-line no-unused-vars
@@ -30,13 +30,53 @@ export class Database {
   rootCache = null
   eventsCache = new Map()
 
-  constructor (name, clock, config = {}) {
+  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.key)
-    this.indexBlocks = new TransactionBlockstore(name + '.indexes', config.key)
-    this.clock = clock
+    this.blocks = new TransactionBlockstore(name, config)
+    this.indexBlocks = new TransactionBlockstore(name ? name + '.indexes' : null, { primary: config.index })
+
     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.setCarCidMapCarCid(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]
+    })
   }
 
   /**
@@ -46,12 +86,17 @@ export class Database {
    * @instance
    */
   toJSON () {
+    return this.blocks.valet ? this.blocks.valet.primary.prepareHeader(this.toHeader(), false) : this.toHeader() // omg
+  }
+
+  toHeader () {
     return {
       clock: this.clockToJSON(),
       name: this.name,
-      key: this.blocks.valet?.getKeyMaterial(),
-      car: this.blocks.valet?.valetRootCarCid.toString(),
-      indexCar: this.indexBlocks.valet?.valetRootCarCid?.toString(),
+      index: {
+        key: this.indexBlocks.valet?.primary.keyMaterial,
+        car: this.indexBlocks.valet?.primary.valetRootCarCid?.toString()
+      },
       indexes: [...this.indexes.values()].map(index => index.toJSON())
     }
   }
@@ -66,27 +111,13 @@ export class Database {
     return (clock || this.clock).map(cid => cid.toString())
   }
 
-  hydrate ({ clock, name, key, car, indexCar }) {
-    this.name = name
-    this.clock = clock
-    this.blocks.valet?.setKeyMaterial(key)
-    this.blocks.valet?.setRootCarCid(car) // maybe
-    this.indexBlocks.valet?.setKeyMaterial(key)
-    this.indexBlocks.valet?.setRootCarCid(indexCar) // maybe
-    // this.indexBlocks = null
-  }
-
   maybeSaveClock () {
     if (this.name && this.blocks.valet) {
-      localSet('fp.' + this.name, JSON.stringify(this))
+      this.blocks.valet.saveHeader(this.toHeader())
     }
   }
 
   index (name) {
-    // iterate over the indexes and gather any with the same name
-    // if there are more than one, throw an error
-    // if there is one, return it
-    // if there are none, return null
     const indexes = [...this.indexes.values()].filter(index => index.name === name)
     if (indexes.length > 1) {
       throw new Error(`Multiple indexes found with name ${name}`)
@@ -102,14 +133,10 @@ export class Database {
    * @instance
    */
   async notifyReset () {
+    await this.ready
     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
@@ -119,6 +146,7 @@ export class Database {
    * @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
@@ -162,6 +190,7 @@ export class Database {
   }
 
   async allDocuments () {
+    await this.ready
     const allResp = await getAll(this.blocks, this.clock, this.rootCache)
     this.rootCache = { root: allResp.root, clockCIDs: allResp.clockCIDs }
 
@@ -176,6 +205,7 @@ export class Database {
   }
 
   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)
@@ -186,6 +216,7 @@ export class Database {
   }
 
   async allStoredCIDs () {
+    await this.ready
     const allCIDs = []
     for await (const { cid } of this.blocks.entries()) {
       allCIDs.push(cid)
@@ -193,24 +224,6 @@ export class Database {
     return allCIDs
   }
 
-  /**
-   * 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
    *
@@ -221,6 +234,7 @@ export class Database {
    * @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 }
@@ -256,6 +270,7 @@ export class Database {
    * @instance
    */
   async put ({ _id, _proof, ...doc }) {
+    await this.ready
     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)
@@ -269,6 +284,7 @@ export class Database {
    * @instance
    */
   async del (docOrId) {
+    await this.ready
     let id
     let clock = null
     if (docOrId._id) {
@@ -283,6 +299,24 @@ export class Database {
     // 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
@@ -395,12 +429,6 @@ export class Database {
     }
   }
 
-  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) {
     this.blocks.remoteBlockFunction = remoteBlockReaderFn
   }

package/src/db-index.js

@@ -247,6 +247,7 @@ export class DbIndex {
    * @returns
    */
   async applyQuery (resp, query) {
+    // console.log('applyQuery', resp, query)
     if (query.descending) {
       resp.result = resp.result.reverse()
     }
@@ -280,7 +281,7 @@ export class DbIndex {
       return await this.applyQuery(await this.indexByKey.root.range(...encodedRange), query)
     } else if (query.key) {
       const encodedKey = charwise.encode(query.key)
-      return await this.applyQuery(this.indexByKey.root.get(encodedKey), query)
+      return await this.applyQuery(await this.indexByKey.root.get(encodedKey), query)
     } else {
       const { result, ...all } = await this.indexByKey.root.getAllEntries()
       return await this.applyQuery(

package/src/fireproof.js

@@ -1,13 +1,8 @@
-import randomBytes from 'randombytes'
 import { Database, parseCID } from './database.js'
-import { Listener } from './listener.js'
 import { DbIndex as Index } from './db-index.js'
-// import { TransactionBlockstore } from './blockstore.js'
-import { localGet } from './utils.js'
 import { Sync } from './sync.js'
 
-// todo remove Listener in 0.7.0
-export { Index, Listener, Database, Sync }
+export { Index, Database, Sync }
 
 export class Fireproof {
   /**
@@ -16,34 +11,47 @@ export class Fireproof {
    * Creates a new Fireproof instance with default storage settings
    * Most apps should use this and not worry about the details.
    * @static
-   * @returns {Database} - a new Fireproof instance
+   * @returns {Database|Promise<Database>} - a new Fireproof instance or a promise for remote loaders
    */
   static storage = (name = null, opts = {}) => {
-    if (name) {
-      opts.name = name
-      // todo this can come from a registry also eg remote database / config, etc
-      const existing = localGet('fp.' + name)
-      if (existing) {
-        const existingConfig = JSON.parse(existing)
-        return Fireproof.fromConfig(name, existingConfig, opts)
-      } else {
-        const instanceKey = randomBytes(32).toString('hex') // pass null to disable encryption
-        opts.key = instanceKey
-        return new Database(name, [], opts)
-      }
+    if (!name) {
+      return new Database(null, opts)
     } else {
-      return new Database(null, [], opts)
+      // const primaryLoader = Loader.appropriate(name, opts.primary, { key: null })
+      // const secondaryLoader = opts.secondary ? Loader.appropriate(name, opts.secondary, { key: null }) : null
+      const db = new Database(name, opts)
+      return db
+      // const loaders = [pr]
+
+      // todo we need branch names here
+
+      // console.log('storage', name, opts, primaryLoader, secondaryLoader)
     }
   }
 
-  static fromConfig (name, existingConfig, opts = {}) {
-    opts.key = existingConfig.key
-    const fp = new Database(name, [], opts)
-    return Fireproof.fromJSON(existingConfig, fp)
-  }
+  // static fromConfig (name, primary, secondary, opts = {}) {
+  //   console.log('fromConfig', name, primary, secondary, opts)
+  //   let clock = []
+  //   if (primary && primary.clock) {
+  //     clock = clock.concat(primary.clock)
+  //   }
+  //   if (secondary && secondary.clock) {
+  //     clock = clock.concat(secondary.clock)
+  //   }
+
+  //   const mergedClock = [...new Set(clock)].map(c => parseCID(c))
+
+  //   opts.primaryHeader = primary
+  //   opts.secondaryHeader = secondary
+
+  //   opts.index = primary ? primary.index : {}
 
-  static fromJSON (json, database) {
-    database.hydrate({ car: json.car, indexCar: json.indexCar, clock: json.clock.map(c => parseCID(c)), name: json.name, key: json.key })
+  //   const fp = new Database(name, mergedClock, opts)
+  //   return Fireproof.fromJSON(primary, secondary, fp)
+  // }
+
+  static fromJSON (primary, secondary, database) {
+    const json = primary && primary.indexes ? primary : secondary
     if (json.indexes) {
       for (const {
         name,
@@ -66,8 +74,6 @@ export class Fireproof {
 
   static snapshot (database, clock) {
     const definition = database.toJSON()
-    const withBlocks = new Database(database.name)
-    withBlocks.blocks = database.blocks
     if (clock) {
       definition.clock = clock.map(c => parseCID(c))
       definition.indexes.forEach(index => {
@@ -76,7 +82,12 @@ export class Fireproof {
         index.clock.db = null
       })
     }
-    const snappedDb = Fireproof.fromJSON(definition, withBlocks)
+
+    const withBlocks = new Database(database.name)
+    withBlocks.blocks = database.blocks
+    withBlocks.clock = definition.clock
+
+    const snappedDb = Fireproof.fromJSON(definition, null, withBlocks)
     ;[...database.indexes.values()].forEach(index => {
       snappedDb.indexes.get(index.mapFnString).mapFn = index.mapFn
     })