@neo-one/node-storage-cache-esnext-esm/cacheStorage.js

NEO•ONE node storage cache.

import { keys } from '@neo-one/node-storage-common-esnext-esm';
import { utils } from '@neo-one/utils-esnext-esm';
import LRUCache from 'lru-cache';
import { convertChange } from './convertChange';
import * as read from './read';
export const cacheStorage = ({ environment, storage, }) => {
    const cache = new LRUCache({
        max: environment.maxSizeBytes,
    });
    const serializeHeaderKey = ({ hashOrIndex }) => typeof hashOrIndex === 'number'
        ? `header:${hashOrIndex}`
        : keys.typeKeyToSerializeKey.header({ hash: hashOrIndex });
    const headerBase = read.createReadStorage({
        cache,
        storage: storage.header,
        serializeKeyString: serializeHeaderKey,
    });
    const header = {
        get: headerBase.get,
        tryGet: headerBase.tryGet,
        tryGetLatest: storage.header.tryGetLatest,
    };
    const serializeBlockKey = ({ hashOrIndex }) => typeof hashOrIndex === 'number' ? `block:${hashOrIndex}` : keys.typeKeyToSerializeKey.block({ hash: hashOrIndex });
    const blockBase = read.createReadStorage({
        cache,
        storage: storage.block,
        serializeKeyString: serializeBlockKey,
    });
    const block = {
        get: blockBase.get,
        tryGet: blockBase.tryGet,
        tryGetLatest: storage.block.tryGetLatest,
    };
    return {
        header,
        block,
        blockData: read.createReadStorage({
            cache,
            storage: storage.blockData,
            serializeKeyString: keys.typeKeyToSerializeKey.blockData,
        }),
        account: read.createReadAllStorage({
            cache,
            storage: storage.account,
            serializeKeyString: keys.typeKeyToSerializeKey.account,
        }),
        accountUnspent: storage.accountUnspent,
        accountUnclaimed: storage.accountUnclaimed,
        action: storage.action,
        asset: read.createReadStorage({
            cache,
            storage: storage.asset,
            serializeKeyString: keys.typeKeyToSerializeKey.asset,
        }),
        transaction: read.createReadStorage({
            cache,
            storage: storage.transaction,
            serializeKeyString: keys.typeKeyToSerializeKey.transaction,
        }),
        transactionData: read.createReadStorage({
            cache,
            storage: storage.transactionData,
            serializeKeyString: keys.typeKeyToSerializeKey.transactionData,
        }),
        output: read.createReadStorage({
            cache,
            storage: storage.output,
            serializeKeyString: keys.typeKeyToSerializeKey.output,
        }),
        contract: read.createReadStorage({
            cache,
            storage: storage.contract,
            serializeKeyString: keys.typeKeyToSerializeKey.contract,
        }),
        storageItem: read.createReadGetAllStorage({
            cache,
            storage: storage.storageItem,
            serializeKeyString: keys.typeKeyToSerializeKey.storageItem,
        }),
        validator: read.createReadAllStorage({
            cache,
            storage: storage.validator,
            serializeKeyString: keys.typeKeyToSerializeKey.validator,
        }),
        invocationData: storage.invocationData,
        validatorsCount: storage.validatorsCount,
        async close() {
            await storage.close();
        },
        async commit(changeSet) {
            const changesList = changeSet.map(convertChange);
            for (const changes of changesList) {
                for (const change of changes) {
                    switch (change.type) {
                        case 'add':
                            cache.set(change.key, change.value);
                            break;
                        case 'delete':
                            cache.del(change.key);
                            break;
                        default:
                            utils.assertNever(change);
                            throw new Error('For TS');
                    }
                }
            }
            await storage.commit(changeSet);
        },
        async reset() {
            cache.reset();
            await storage.reset();
        },
    };
};

//# sourceMappingURL=cacheStorage.js.map