@fireproof/core 0.3.22 → 0.4.0

package/dist/database.js

@@ -0,0 +1,308 @@
+// @ts-nocheck
+import { visMerkleClock, visMerkleTree, vis, put, get, getAll, eventsSince } from './prolly.js';
+import { doTransaction } from './blockstore.js';
+import charwise from 'charwise';
+import { localSet } from './utils.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 {
+}
+/**
+ * @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 Database {
+    listeners = new Set();
+    // todo refactor this for the next version
+    constructor(blocks, clock, config = {}) {
+        this.name = config.name;
+        this.instanceId = `fp.${this.name}.${Math.random().toString(36).substring(2, 7)}`;
+        this.blocks = blocks;
+        this.clock = clock;
+        this.config = config;
+        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;
+    }
+    maybeSaveClock() {
+        if (this.name && this.blocks.valet) {
+            localSet('fp.' + this.name, JSON.stringify(this));
+        }
+    }
+    /**
+     * 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.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 });
+                }
+            }
+            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;
+        }
+        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.');
+            }
+        }
+        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');
+        }
+        // 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)
+    }
+    //   /**
+    //    * 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)
+        await this.maybeSaveClock();
+        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) {
+        this.blocks.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/dist/db-index.js

@@ -0,0 +1,314 @@
+// @ts-ignore
+import { create, load } from 'prolly-trees/db-index';
+// import { create, load } from '../../../../prolly-trees/src/db-index.js'
+import { sha256 as hasher } from 'multiformats/hashes/sha2';
+// @ts-ignore
+import { nocache as cache } from 'prolly-trees/cache';
+// @ts-ignore
+import { bf, simpleCompare } from 'prolly-trees/utils';
+import { makeGetBlock } from './prolly.js';
+// eslint-disable-next-line no-unused-vars
+import { Database, cidsToProof } from './database.js';
+import * as codec from '@ipld/dag-cbor';
+// import { create as createBlock } from 'multiformats/block'
+import { TransactionBlockstore, doTransaction } from './blockstore.js';
+// @ts-ignore
+import charwise from 'charwise';
+const ALWAYS_REBUILD = false; // todo: make false
+const compare = (a, b) => {
+    const [aKey, aRef] = a;
+    const [bKey, bRef] = b;
+    const comp = simpleCompare(aKey, bKey);
+    if (comp !== 0)
+        return comp;
+    return refCompare(aRef, bRef);
+};
+const refCompare = (aRef, bRef) => {
+    if (Number.isNaN(aRef))
+        return -1;
+    if (Number.isNaN(bRef))
+        throw new Error('ref may not be Infinity or NaN');
+    if (aRef === Infinity)
+        return 1; // need to test this on equal docids!
+    // if (!Number.isFinite(bRef)) throw new Error('ref may not be Infinity or NaN')
+    return simpleCompare(aRef, bRef);
+};
+const dbIndexOpts = { cache, chunker: bf(3), codec, hasher, compare };
+const idIndexOpts = { cache, chunker: bf(3), codec, hasher, compare: simpleCompare };
+const makeDoc = ({ key, value }) => ({ _id: key, ...value });
+/**
+ * JDoc for the result row type.
+ * @typedef {Object} ChangeEvent
+ * @property {string} key - The key of the document.
+ * @property {Object} value - The new value of the document.
+ * @property {boolean} [del] - Is the row deleted?
+ * @memberof DbIndex
+ */
+/**
+ * JDoc for the result row type.
+ * @typedef {Object} DbIndexEntry
+ * @property {string[]} key - The key for the DbIndex entry.
+ * @property {Object} value - The value of the document.
+ * @property {boolean} [del] - Is the row deleted?
+ * @memberof DbIndex
+ */
+/**
+ * Transforms a set of changes to DbIndex entries using a map function.
+ *
+ * @param {ChangeEvent[]} changes
+ * @param {Function} mapFn
+ * @returns {DbIndexEntry[]} The DbIndex entries generated by the map function.
+ * @private
+ * @memberof DbIndex
+ */
+const indexEntriesForChanges = (changes, mapFn) => {
+    const indexEntries = [];
+    changes.forEach(({ key, value, del }) => {
+        if (del || !value)
+            return;
+        mapFn(makeDoc({ key, value }), (k, v) => {
+            if (typeof v === 'undefined' || typeof k === 'undefined')
+                return;
+            indexEntries.push({
+                key: [charwise.encode(k), key],
+                value: v
+            });
+        });
+    });
+    return indexEntries;
+};
+/**
+ * Represents an DbIndex for a Fireproof database.
+ *
+ * @class DbIndex
+ * @classdesc An DbIndex can be used to order and filter the documents in a Fireproof database.
+ *
+ * @param {Database} database - The Fireproof database instance to DbIndex.
+ * @param {Function} mapFn - The map function to apply to each entry in the database.
+ *
+ */
+export class DbIndex {
+    constructor(database, mapFn, clock, opts = {}) {
+        this.database = database;
+        if (!database.indexBlocks) {
+            database.indexBlocks = new TransactionBlockstore(database?.name + '.indexes', database.blocks.valet?.getKeyMaterial());
+        }
+        /**
+         * The map function to apply to each entry in the database.
+         * @type {Function}
+         */
+        if (typeof mapFn === 'string') {
+            this.mapFnString = mapFn;
+        }
+        else {
+            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;
+        if (clock) {
+            this.indexById.cid = clock.byId;
+            this.indexByKey.cid = clock.byKey;
+            this.dbHead = clock.db;
+        }
+        this.instanceId = this.database.instanceId + `.DbIndex.${Math.random().toString(36).substring(2, 7)}`;
+        this.updateIndexPromise = null;
+        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) {
+        if (!database.indexes.has(inIndex.mapFnString)) {
+            database.indexes.set(inIndex.mapFnString, inIndex);
+        }
+        else {
+            // merge our inIndex code with the inIndex clock or vice versa
+            const existingIndex = database.indexes.get(inIndex.mapFnString);
+            // 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 {
+                inIndex.dbHead = existingIndex.dbHead;
+                inIndex.indexById.cid = existingIndex.indexById.cid;
+                inIndex.indexByKey.cid = existingIndex.indexByKey.cid;
+                database.indexes.set(inIndex.mapFnString, inIndex);
+            }
+        }
+    }
+    toJSON() {
+        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, name }) {
+        // console.log('DbIndex.fromJSON', database.constructor.name, code, clock)
+        return new DbIndex(database, code, clock, { name });
+    }
+    /**
+     * JSDoc for Query type.
+     * @typedef {Object} DbQuery
+     * @property {string[]} [range] - The range to query.
+     * @memberof DbIndex
+     */
+    /**
+     * Query object can have {range}
+     * @param {DbQuery} query - the query range to use
+     * @returns {Promise<{proof: {}, rows: Array<{id: string, key: string, value: any}>}>}
+     * @memberof DbIndex
+     * @instance
+     */
+    async query(query, update = true) {
+        // const callId = Math.random().toString(36).substring(2, 7)
+        // 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) },
+            rows: response.result.map(({ id, key, row }) => {
+                return ({ id, key: charwise.decode(key), value: row });
+            })
+        };
+    }
+    /**
+     * Update the DbIndex with the latest changes
+     * @private
+     * @returns {Promise<void>}
+     */
+    async updateIndex(blocks) {
+        // todo this could enqueue the request and give fresh ones to all second comers -- right now it gives out stale promises while working
+        // what would it do in a world where all indexes provide a database snapshot to query?
+        if (this.updateIndexPromise)
+            return this.updateIndexPromise;
+        this.updateIndexPromise = this.innerUpdateIndex(blocks);
+        this.updateIndexPromise.finally(() => { this.updateIndexPromise = null; });
+        return this.updateIndexPromise;
+    }
+    async innerUpdateIndex(inBlocks) {
+        // const callTag = Math.random().toString(36).substring(4)
+        // console.log(`updateIndex ${callTag} >`, this.instanceId, this.dbHead?.toString(), this.indexByKey.cid?.toString(), this.indexById.cid?.toString())
+        // todo remove this hack
+        if (ALWAYS_REBUILD) {
+            this.indexById = { root: null, cid: null };
+            this.indexByKey = { root: null, cid: null };
+            this.dbHead = null;
+        }
+        // console.log('dbHead', this.dbHead)
+        // console.time(callTag + '.changesSince')
+        const result = await this.database.changesSince(this.dbHead); // {key, value, del}
+        // console.timeEnd(callTag + '.changesSince')
+        // console.log('result.rows.length', result.rows.length)
+        // console.time(callTag + '.doTransactionupdateIndex')
+        // console.log('updateIndex changes length', result.rows.length)
+        if (result.rows.length === 0) {
+            // console.log('updateIndex < no changes', result.clock)
+            this.dbHead = result.clock;
+            return;
+        }
+        await doTransaction('updateIndex', inBlocks, async (blocks) => {
+            let oldIndexEntries = [];
+            let removeByIdIndexEntries = [];
+            await loadIndex(blocks, this.indexById, idIndexOpts);
+            await loadIndex(blocks, this.indexByKey, dbIndexOpts);
+            if (this.dbHead) {
+                const oldChangeEntries = await this.indexById.root.getMany(result.rows.map(({ key }) => key));
+                oldIndexEntries = oldChangeEntries.result.map((key) => ({ key, del: true }));
+                removeByIdIndexEntries = oldIndexEntries.map(({ key }) => ({ key: key[1], del: true }));
+            }
+            if (!this.mapFn) {
+                throw new Error('No live map function installed for index, cannot update. Make sure your index definition runs before any queries.' + (this.mapFnString ? ' Your code should match the stored map function source:\n' + this.mapFnString : ''));
+            }
+            const indexEntries = indexEntriesForChanges(result.rows, this.mapFn);
+            const byIdIndexEntries = indexEntries.map(({ key }) => ({ key: key[1], value: key }));
+            this.indexById = await bulkIndex(blocks, this.indexById, removeByIdIndexEntries.concat(byIdIndexEntries), idIndexOpts);
+            this.indexByKey = await bulkIndex(blocks, this.indexByKey, oldIndexEntries.concat(indexEntries), dbIndexOpts);
+            this.dbHead = result.clock;
+        });
+        this.database.notifyExternal('dbIndex');
+        // console.timeEnd(callTag + '.doTransactionupdateIndex')
+        // console.log(`updateIndex ${callTag} <`, this.instanceId, this.dbHead?.toString(), this.indexByKey.cid?.toString(), this.indexById.cid?.toString())
+    }
+}
+/**
+ * Update the DbIndex with the given entries
+ * @param {import('./blockstore.js').Blockstore} blocks
+ * @param {{root, cid}} inIndex
+ * @param {DbIndexEntry[]} indexEntries
+ * @private
+ */
+async function bulkIndex(blocks, inIndex, indexEntries, opts) {
+    if (!indexEntries.length)
+        return inIndex;
+    const putBlock = blocks.put.bind(blocks);
+    const { getBlock } = makeGetBlock(blocks);
+    let returnRootBlock;
+    let returnNode;
+    if (!inIndex.root) {
+        const cid = inIndex.cid;
+        if (!cid) {
+            for await (const node of await create({ get: getBlock, list: indexEntries, ...opts })) {
+                const block = await node.block;
+                await putBlock(block.cid, block.bytes);
+                returnRootBlock = block;
+                returnNode = node;
+            }
+            return { root: returnNode, cid: returnRootBlock.cid };
+        }
+        inIndex.root = await load({ cid, get: getBlock, ...dbIndexOpts });
+    }
+    const { root, blocks: newBlocks } = await inIndex.root.bulk(indexEntries);
+    returnRootBlock = await root.block;
+    returnNode = root;
+    for await (const block of newBlocks) {
+        await putBlock(block.cid, block.bytes);
+    }
+    await putBlock(returnRootBlock.cid, returnRootBlock.bytes);
+    return { root: returnNode, cid: returnRootBlock.cid };
+}
+async function loadIndex(blocks, index, indexOpts) {
+    if (!index.root) {
+        const cid = index.cid;
+        if (!cid)
+            return;
+        const { getBlock } = makeGetBlock(blocks);
+        index.root = await load({ cid, get: getBlock, ...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 applyLimit(await indexByKey.root.range(...encodedRange), query.limit);
+    }
+    else if (query.key) {
+        const encodedKey = charwise.encode(query.key);
+        return indexByKey.root.get(encodedKey);
+    }
+    else {
+        const { result, ...all } = await indexByKey.root.getAllEntries();
+        return applyLimit({ result: result.map(({ key: [k, id], value }) => ({ key: k, id, row: value })), ...all }, query.limit);
+    }
+}