@fireproof/core 0.5.9 → 0.5.10

package/dist/src/link.js

@@ -0,0 +1 @@
+export {};

package/dist/src/listener.js

@@ -0,0 +1,112 @@
+// @ts-nocheck
+/**
+ * A Fireproof database Listener allows you to react to events in the database.
+ *
+ * @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('./database').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'
+/**
+ * @deprecated since version 0.7.0
+ */
+export class Listener {
+    subcribers = new Map();
+    doStopListening = null;
+    /**
+     * @param {import('./database').Database} database
+     * @param {(_: any, emit: any) => void} 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;
+        this.dbHead = null;
+    }
+    /**
+     * Subscribe to a topic emitted by the event function.
+     * @param {string} topic - The topic to subscribe to.
+     * @param {Function} subscriber - The function to call when the topic is emitted.
+     * @returns {Function} A function to unsubscribe from the topic.
+     * @memberof Listener
+     * @instance
+     * @param {any} [since] - clock to flush from on launch, pass null for all
+     */
+    on(topic, subscriber, since = undefined) {
+        const listOfTopicSubscribers = getTopicList(this.subcribers, topic);
+        listOfTopicSubscribers.push(subscriber);
+        if (typeof since !== 'undefined') {
+            this.database.changesSince(since).then(({ rows: changes }) => {
+                const keys = topicsForChanges(changes, this.routingFn).get(topic);
+                if (keys)
+                    keys.forEach((/** @type {any} */ key) => subscriber(key));
+            });
+        }
+        return () => {
+            const index = listOfTopicSubscribers.indexOf(subscriber);
+            if (index > -1)
+                listOfTopicSubscribers.splice(index, 1);
+        };
+    }
+    /**
+     * @typedef {import('./db-index').ChangeEvent} ChangeEvent
+     */
+    /**
+     * @param {ChangeEvent[]} changes
+     */
+    onChanges(changes) {
+        if (Array.isArray(changes)) {
+            const seenTopics = topicsForChanges(changes, this.routingFn);
+            for (const [topic, keys] of seenTopics) {
+                const listOfTopicSubscribers = getTopicList(this.subcribers, topic);
+                listOfTopicSubscribers.forEach((/** @type {(arg0: any) => any} */ subscriber) => keys.forEach((/** @type {any} */ key) => subscriber(key)));
+            }
+        }
+        else {
+            // non-arrays go to all subscribers
+            for (const [, listOfTopicSubscribers] of this.subcribers) {
+                listOfTopicSubscribers.forEach((/** @type {(arg0: any) => any} */ subscriber) => subscriber(changes));
+            }
+        }
+    }
+}
+/**
+ * @param {Map<any, any>} subscribersMap
+ * @param {string} name
+ */
+function getTopicList(subscribersMap, name) {
+    let topicList = subscribersMap.get(name);
+    if (!topicList) {
+        topicList = [];
+        subscribersMap.set(name, topicList);
+    }
+    return topicList;
+}
+/**
+ * Transforms a set of changes to events using an emitter function.
+ *
+ * @param {ChangeEvent[]} changes
+ * @param {Function} routingFn
+ * @returns {Map<string,string[]>} The topics emmitted by the event function.
+ * @private
+ */
+const topicsForChanges = (changes, routingFn) => {
+    const seenTopics = new Map();
+    changes.forEach(({ key, value, del }) => {
+        if (del || !value)
+            value = { _deleted: true };
+        routingFn({ _id: key, ...value }, (/** @type {any} */ t) => {
+            const topicList = getTopicList(seenTopics, t);
+            topicList.push(key);
+        });
+    });
+    return seenTopics;
+};

package/dist/src/prolly.js

@@ -0,0 +1,360 @@
+// @ts-nocheck
+import { advance, EventFetcher, EventBlock, findCommonAncestorWithSortedEvents, findEventsToSync, vis as visClock } from './clock';
+// import { create, load } from '../../../../prolly-trees/src/map'
+// @ts-ignore
+import { create, load } from 'prolly-trees/map';
+// @ts-ignore
+import { nocache as cache } from 'prolly-trees/cache';
+// @ts-ignore
+import { CIDCounter, bf, simpleCompare as compare } from 'prolly-trees/utils';
+import * as codec from '@ipld/dag-cbor';
+import { sha256 as hasher } from 'multiformats/hashes/sha2';
+import { doTransaction } from './blockstore';
+import { create as createBlock } from 'multiformats/block';
+const blockOpts = { cache, chunker: bf(30), codec, hasher, compare };
+/**
+ * @typedef {import('./blockstore').TransactionBlockstore} TransactionBlockstore
+ */
+// const withLog = async (label, fn) => {
+//   const resp = await fn()
+//   // console.log('withLog', label, !!resp)
+//   return resp
+// }
+// should also return a CIDCounter
+export const makeGetBlock = blocks => {
+    // const cids = new CIDCounter() // this could be used for proofs of mutations
+    const getBlockFn = async (address) => {
+        // const { cid, bytes } = await withLog(address, () => blocks.get(address))
+        const { cid, bytes } = await blocks.get(address);
+        // cids.add({ address: cid })
+        return createBlock({ cid, bytes, hasher, codec });
+    };
+    return {
+        // cids,
+        getBlock: getBlockFn
+    };
+};
+/**
+ *
+ * @param {*} param0
+ * @returns
+ */
+async function createAndSaveNewEvent({ inBlocks, bigPut, root, event: inEvent, head, additions, removals = [] }) {
+    let cids;
+    const { key, value, del } = inEvent;
+    const data = {
+        root: root
+            ? {
+                cid: root.cid,
+                bytes: root.bytes,
+                value: root.value // can we remove this?
+            }
+            : null,
+        key
+    };
+    // import('./clock').EventLink<import('./clock').EventData>
+    if (del) {
+        data.value = null;
+        data.type = 'del';
+    }
+    else {
+        data.value = value;
+        data.type = 'put';
+    }
+    /** @type {import('./clock').EventData} */
+    // @ts-ignore
+    const event = await EventBlock.create(data, head);
+    bigPut(event);
+    ({ head, cids } = await advance(inBlocks, head, event.cid));
+    return {
+        root,
+        additions,
+        removals,
+        head,
+        clockCIDs: cids,
+        event
+    };
+}
+const makeGetAndPutBlock = inBlocks => {
+    // const mblocks = new MemoryBlockstore()
+    // const blocks = new MultiBlockFetcher(mblocks, inBlocks)
+    const { getBlock, cids } = makeGetBlock(inBlocks);
+    const put = inBlocks.put.bind(inBlocks);
+    const bigPut = async (block, additions) => {
+        // console.log('bigPut', block.cid.toString())
+        const { cid, bytes } = block;
+        put(cid, bytes);
+        // mblocks.putSync(cid, bytes)
+        if (additions) {
+            additions.set(cid.toString(), block);
+        }
+    };
+    return { getBlock, bigPut, blocks: inBlocks, cids };
+};
+const bulkFromEvents = (sorted, event) => {
+    if (event) {
+        const update = { value: { data: { key: event.key } } };
+        if (event.del) {
+            update.value.data.type = 'del';
+        }
+        else {
+            update.value.data.type = 'put';
+            update.value.data.value = event.value;
+        }
+        sorted.push(update);
+    }
+    const bulk = new Map();
+    for (const { value: event } of sorted) {
+        const { data: { type, value, key } } = event;
+        const bulkEvent = type === 'put' ? { key, value } : { key, del: true };
+        bulk.set(bulkEvent.key, bulkEvent); // last wins
+    }
+    return Array.from(bulk.values());
+};
+// Get the value of the root from the ancestor event
+/**
+ *
+ * @param {EventFetcher} events
+ * @param {import('./clock').EventLink<import('./clock').EventData>} ancestor
+ * @param {*} getBlock
+ * @returns
+ */
+const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
+    // console.log('prollyRootFromAncestor', ancestor)
+    const event = await events.get(ancestor);
+    const { root } = event.value.data;
+    // console.log('prollyRootFromAncestor', root.cid, JSON.stringify(root.value))
+    if (root) {
+        return load({ cid: root.cid, get: getBlock, ...blockOpts });
+    }
+    else {
+        return null;
+    }
+};
+const doProllyBulk = async (inBlocks, head, event, doFull = false) => {
+    const { getBlock, blocks } = makeGetAndPutBlock(inBlocks);
+    let bulkSorted = [];
+    let prollyRootNode = null;
+    const events = new EventFetcher(blocks);
+    if (head.length) {
+        if (!doFull && head.length === 1) {
+            prollyRootNode = await prollyRootFromAncestor(events, head[0], getBlock);
+        }
+        else {
+            // Otherwise, we find the common ancestor and update the root and other blocks
+            // todo this is returning more events than necessary, lets define the desired semantics from the top down
+            // good semantics mean we can cache the results of this call
+            const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head, doFull);
+            bulkSorted = sorted;
+            // console.log('sorted', JSON.stringify(sorted.map(({ value: { data: { key, value } } }) => ({ key, value }))))
+            prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock);
+            // console.log('event', event)
+        }
+    }
+    const bulkOperations = bulkFromEvents(bulkSorted, event);
+    // if prolly root node is null, we need to create a new one
+    if (!prollyRootNode) {
+        let root;
+        const newBlocks = [];
+        // if all operations are deletes, we can just return an empty root
+        if (bulkOperations.every(op => op.del)) {
+            return { root: null, blocks: [], clockCIDs: await events.all() };
+        }
+        for await (const node of create({ get: getBlock, list: bulkOperations, ...blockOpts })) {
+            root = await node.block;
+            newBlocks.push(root);
+        }
+        return { root, blocks: newBlocks, clockCIDs: await events.all() };
+    }
+    else {
+        const writeResp = await prollyRootNode.bulk(bulkOperations); // { root: newProllyRootNode, blocks: newBlocks }
+        writeResp.clockCIDs = await events.all();
+        return writeResp;
+    }
+};
+/**
+ * Put a value (a CID) for the given key. If the key exists it's value is overwritten.
+ *
+ * @param {import('./blockstore').Blockstore} inBlocks Bucket block storage.
+ * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
+ * @param {{key: string, value: import('./clock').EventLink<import('./clock').EventData>}} event The key of the value to put.
+ * @param {object} [options]
+ * @returns {Promise<any>}
+ */
+export async function put(inBlocks, head, event, options) {
+    const { bigPut } = makeGetAndPutBlock(inBlocks);
+    // If the head is empty, we create a new event and return the root and addition blocks
+    if (!head.length) {
+        const additions = new Map();
+        const { root, blocks } = await doProllyBulk(inBlocks, head, event);
+        for (const b of blocks) {
+            bigPut(b, additions);
+        }
+        return createAndSaveNewEvent({ inBlocks, bigPut, root, event, head, additions: Array.from(additions.values()) });
+    }
+    const { root: newProllyRootNode, blocks: newBlocks } = await doProllyBulk(inBlocks, head, event);
+    if (!newProllyRootNode) {
+        return createAndSaveNewEvent({
+            inBlocks,
+            bigPut,
+            root: null,
+            event,
+            head,
+            additions: []
+        });
+    }
+    else {
+        const prollyRootBlock = await newProllyRootNode.block;
+        const additions = new Map(); // ; const removals = new Map()
+        bigPut(prollyRootBlock, additions);
+        for (const nb of newBlocks) {
+            bigPut(nb, additions);
+        }
+        // additions are new blocks
+        return createAndSaveNewEvent({
+            inBlocks,
+            bigPut,
+            root: prollyRootBlock,
+            event,
+            head,
+            additions: Array.from(additions.values()) /*, todo? Array.from(removals.values()) */
+        });
+    }
+}
+/**
+ * Determine the effective prolly root given the current merkle clock head.
+ *
+ * @param {TransactionBlockstore} inBlocks Bucket block storage.
+ * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
+ */
+export async function root(inBlocks, head, doFull = false) {
+    if (!head.length) {
+        throw new Error('no head');
+    }
+    // console.log('root', head.map(h => h.toString()))
+    const { root: newProllyRootNode, blocks: newBlocks, clockCIDs } = await doProllyBulk(inBlocks, head, null, doFull);
+    // todo maybe these should go to a temp blockstore?
+    await doTransaction('root', inBlocks, async (transactionBlocks) => {
+        const { bigPut } = makeGetAndPutBlock(transactionBlocks);
+        for (const nb of newBlocks) {
+            bigPut(nb);
+        }
+    }, false);
+    return { clockCIDs, node: newProllyRootNode };
+}
+/**
+ * Get the list of events not known by the `since` event
+ * @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[]}>}
+ */
+export async function eventsSince(blocks, head, since) {
+    if (!head.length) {
+        // throw new Error('no head')
+        return { clockCIDs: [], result: [] };
+    }
+    // @ts-ignore
+    const sinceHead = [...since, ...head]; // ?
+    const { cids, events: unknownSorted3 } = await findEventsToSync(blocks, sinceHead);
+    return { clockCIDs: cids, result: unknownSorted3.map(({ value: { data } }) => data) };
+}
+/**
+ *
+ * @param {TransactionBlockstore} blocks Bucket block storage.
+ * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
+ *
+ * @returns {Promise<{root: any, cids: CIDCounter, clockCIDs: CIDCounter, result: import('./clock').EventData[]}>}
+ *
+ */
+export async function getAll(blocks, head, rootCache = null, doFull = false) {
+    // todo use the root node left around from put, etc
+    // move load to a central place
+    if (!head.length) {
+        return { root: null, clockCIDs: new CIDCounter(), cids: new CIDCounter(), result: [] };
+    }
+    const { node: prollyRootNode, clockCIDs } = await rootOrCache(blocks, head, rootCache, doFull);
+    if (!prollyRootNode) {
+        return { root: null, clockCIDs, cids: new CIDCounter(), result: [] };
+    }
+    const { result, cids } = await prollyRootNode.getAllEntries(); // todo params
+    return { root: prollyRootNode, clockCIDs, cids, result: result.map(({ key, value }) => ({ key, value })) };
+}
+async function rootOrCache(blocks, head, rootCache, doFull = false) {
+    let node;
+    let clockCIDs;
+    if (!doFull && rootCache && rootCache.root) {
+        // console.log('get root from cache', rootCache)
+        node = rootCache.root;
+        clockCIDs = rootCache.clockCIDs;
+    }
+    else {
+        // console.log('finding root')
+        // const callTag = Math.random().toString(36).substring(7)
+        // console.time(callTag + '.root')
+        ;
+        ({ node, clockCIDs } = await root(blocks, head, doFull));
+        // console.timeEnd(callTag + '.root')
+        // console.log('found root')
+    }
+    return { node, clockCIDs };
+}
+/**
+ * @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.
+ */
+export async function get(blocks, head, key, rootCache = null) {
+    // instead pass root from db? and always update on change
+    if (!head.length) {
+        return { cids: new CIDCounter(), result: null };
+    }
+    const { node: prollyRootNode, clockCIDs } = await rootOrCache(blocks, head, rootCache);
+    if (!prollyRootNode) {
+        return { clockCIDs, cids: new CIDCounter(), result: null };
+    }
+    const { result, cids } = await prollyRootNode.get(key);
+    return { result, cids, clockCIDs, root: prollyRootNode };
+}
+export async function* vis(blocks, head) {
+    if (!head.length) {
+        return { cids: new CIDCounter(), result: null };
+    }
+    const { node: prollyRootNode, cids } = await root(blocks, head);
+    const lines = [];
+    for await (const line of prollyRootNode.vis()) {
+        yield line;
+        lines.push(line);
+    }
+    return { vis: lines.join('\n'), cids };
+}
+export async function visMerkleTree(blocks, head) {
+    // if (!head) return
+    if (head && !Array.isArray(head)) {
+        const getBl = makeGetBlock(blocks);
+        const prollyRootNode = await load({
+            cid: head,
+            get: getBl.getBlock,
+            ...blockOpts
+        });
+        const lines = [];
+        for await (const line of prollyRootNode.vis()) {
+            lines.push(line);
+        }
+        return { vis: lines.join('\n'), cids: new CIDCounter() };
+    }
+    const { node: prollyRootNode, cids } = await root(blocks, head);
+    const lines = [];
+    for await (const line of prollyRootNode.vis()) {
+        lines.push(line);
+    }
+    return { vis: lines.join('\n'), cids };
+}
+export async function visMerkleClock(blocks, head) {
+    const lines = [];
+    for await (const line of visClock(blocks, head)) {
+        // yield line
+        lines.push(line);
+    }
+    return { vis: lines.join('\n') };
+}

package/dist/src/sha1.js

@@ -0,0 +1,73 @@
+// from https://github.com/duzun/sync-sha1/blob/master/rawSha1
+// MIT License Copyright (c) 2020 Dumitru Uzun
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+// import {
+//   isLittleEndian, switchEndianness32
+// } from 'string-encode'
+/**
+* SHA1 on binary array
+*
+* @param   {Uint8Array}  b  Data to hash
+*
+* @return  {Uint8Array}  sha1 hash
+*/
+export function rawSha1(b) {
+    let i = b.byteLength;
+    let bs = 0;
+    let A;
+    let B;
+    let C;
+    let D;
+    let G;
+    const H = Uint32Array.from([A = 0x67452301, B = 0xEFCDAB89, ~A, ~B, 0xC3D2E1F0]);
+    const W = new Uint32Array(80);
+    const nrWords = (i / 4 + 2) | 15;
+    const words = new Uint32Array(nrWords + 1);
+    let j;
+    words[nrWords] = i * 8;
+    words[i >> 2] |= 0x80 << (~i << 3);
+    for (; i--;) {
+        words[i >> 2] |= b[i] << (~i << 3);
+    }
+    for (A = H.slice(); bs < nrWords; bs += 16, A.set(H)) {
+        for (i = 0; i < 80; A[0] = (G = ((b = A[0]) << 5 | b >>> 27) +
+            A[4] +
+            (W[i] = (i < 16) ? words[bs + i] : G << 1 | G >>> 31) +
+            0x5A827999,
+            B = A[1],
+            C = A[2],
+            D = A[3],
+            G + ((j = i / 5 >> 2) // eslint-disable-line no-cond-assign
+                ? j !== 2
+                    ? (B ^ C ^ D) + (j & 2 ? 0x6FE0483D : 0x14577208)
+                    : (B & C | B & D | C & D) + 0x34994343
+                : B & C | ~B & D))
+            , A[1] = b
+            , A[2] = B << 30 | B >>> 2
+            , A[3] = C
+            , A[4] = D
+            , ++i) {
+            G = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+        }
+        for (i = 5; i;)
+            H[--i] = H[i] + A[i];
+    }
+    // if (isLittleEndian()) {
+    //   H = H.map(switchEndianness32)
+    // }
+    return new Uint8Array(H.buffer, H.byteOffset, H.byteLength);
+}