@fireproof/core 0.8.0 → 0.10.1-dev

package/dist/database.js

@@ -1,434 +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 };
-}