@fireproof/core 0.4.0 → 0.5.0

package/dist/src/listener.js

@@ -1,108 +0,0 @@
-/**
- * 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.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'
-export class Listener {
-    subcribers = new Map();
-    doStopListening = null;
-    /**
-     * @param {import('./database.js').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
-     */
-    on(topic, subscriber, since) {
-        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

@@ -1,319 +0,0 @@
-import { advance, EventFetcher, EventBlock, findCommonAncestorWithSortedEvents, findEventsToSync, vis as visClock } from './clock.js';
-// import { create, load } from '../../../../prolly-trees/src/map.js'
-// @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.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)
-    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));
-        // 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) => {
-    const { getBlock, blocks } = makeGetAndPutBlock(inBlocks);
-    let bulkSorted = [];
-    let prollyRootNode = null;
-    if (head.length) {
-        // Otherwise, we find the common ancestor and update the root and other blocks
-        const events = new EventFetcher(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);
-        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: [] };
-        }
-        for await (const node of create({ get: getBlock, list: bulkOperations, ...blockOpts })) {
-            root = await node.block;
-            newBlocks.push(root);
-        }
-        return { root, blocks: newBlocks };
-    }
-    else {
-        return await prollyRootNode.bulk(bulkOperations); // { root: newProllyRootNode, blocks: newBlocks }
-    }
-};
-/**
- * Put a value (a CID) for the given key. If the key exists it's value is overwritten.
- *
- * @param {import('./blockstore.js').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) {
-    if (!head.length) {
-        throw new Error('no 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 (transactionBlocks) => {
-        const { bigPut } = makeGetAndPutBlock(transactionBlocks);
-        for (const nb of newBlocks) {
-            bigPut(nb);
-        }
-    });
-    return { cids, 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');
-    }
-    // @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<{cids: CIDCounter, clockCIDs: CIDCounter, result: import('./clock').EventData[]}>}
- *
- */
-export async function getAll(blocks, head) {
-    // todo use the root node left around from put, etc
-    // move load to a central place
-    if (!head.length) {
-        return { clockCIDs: new CIDCounter(), cids: new CIDCounter(), result: [] };
-    }
-    const { node: prollyRootNode, cids: clockCIDs } = await root(blocks, head);
-    if (!prollyRootNode) {
-        return { clockCIDs, cids: new CIDCounter(), result: [] };
-    }
-    const { result, cids } = await prollyRootNode.getAllEntries(); // todo params
-    return { clockCIDs, cids, result: result.map(({ key, value }) => ({ key, value })) };
-}
-/**
- * @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) {
-    // instead pass root from db? and always update on change
-    if (!head.length) {
-        return { cids: new CIDCounter(), result: null };
-    }
-    const { node: prollyRootNode, cids: clockCIDs } = await root(blocks, head);
-    if (!prollyRootNode) {
-        return { clockCIDs, cids: new CIDCounter(), result: null };
-    }
-    const { result, cids } = await prollyRootNode.get(key);
-    return { result, cids, clockCIDs };
-}
-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.length) {
-        return { cids: new CIDCounter(), result: null };
-    }
-    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

@@ -1,74 +0,0 @@
-// @ts-nocheck
-// from https://github.com/duzun/sync-sha1/blob/master/rawSha1.js
-// 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);
-}

package/dist/src/utils.js

@@ -1,16 +0,0 @@
-/* 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);
-    }
-}