cache-memory/dist/index.js

Node module for in memory caching

"use strict";
const Cacher = require('./lib/cacher');
const logger_1 = require("./lib/logger");
let cachers = [];
let defaultTtl = 0;
let defaultClone = true;
let defaultStoreUndefinedObjects = false;
let intervalId;
const getCachers = () => {
    cachers = cachers.filter(cacher => { return cacher !== undefined && cacher !== null; });
    return cachers;
};
const clearCachers = () => {
    getCachers().forEach(cacher => {
        cacher.clear();
        (0, logger_1.log)(`cleared cacher - id: ${cacher.id}`);
    });
};
const cacherWrapper = {
    create: (options) => {
        const cacherOptions = options || {};
        if (cacherOptions.ttl === undefined || typeof cacherOptions.ttl !== 'number') {
            cacherOptions.ttl = defaultTtl;
        }
        if (cacherOptions.clone === undefined || typeof cacherOptions.clone !== 'boolean') {
            cacherOptions.clone = defaultClone;
        }
        if (cacherOptions.storeUndefinedObjects === undefined || typeof cacherOptions.storeUndefinedObjects !== 'boolean') {
            cacherOptions.storeUndefinedObjects = defaultStoreUndefinedObjects;
        }
        const cacher = new Cacher.default(cacherOptions);
        cachers.push(cacher);
        (0, logger_1.log)(`created new cacher - id: ${cacher.id}`);
        return cacher;
    },
    clear: () => {
        clearCachers();
        return cacherWrapper;
    },
    stats: () => {
        const stats = [];
        getCachers().forEach(cacher => {
            stats.push({
                id: cacher.id,
                stats: cacher.stats()
            });
        });
        (0, logger_1.log)('Stats across all cachers');
        return stats;
    },
    cacher: (id) => {
        let cacher = undefined;
        let cachers = getCachers();
        for (var i = 0; i < cachers.length; i++) {
            let currentCacher = cachers[i];
            if (currentCacher.id === id) {
                cacher = currentCacher;
                break;
            }
        }
        (0, logger_1.log)(`getting cacher - id: ${id}, found: ${cacher !== undefined && cacher !== null}`);
        return cacher;
    },
    cachers: () => {
        let cachers = getCachers();
        let ids = cachers.map((cacher) => { return cacher.id; });
        (0, logger_1.log)('getting cachers - ids', { ids });
        return cachers;
    },
    ttl: (ttl) => {
        if (ttl !== undefined && typeof ttl === 'number') {
            defaultTtl = ttl;
            (0, logger_1.log)(`Default ttl set to - ${defaultTtl}`);
        }
        return cacherWrapper;
    },
    clone: (clone) => {
        if (clone !== undefined && typeof clone === 'boolean') {
            defaultClone = clone;
        }
        return cacherWrapper;
    },
    storeUndefinedObjects: (storeUndefinedObjects) => {
        if (storeUndefinedObjects !== undefined && typeof storeUndefinedObjects === 'boolean') {
            defaultStoreUndefinedObjects = storeUndefinedObjects;
        }
        return cacherWrapper;
    },
    cleanup: (seconds) => {
        if (intervalId) {
            clearInterval(intervalId);
        }
        intervalId = setInterval(() => {
            (0, logger_1.log)(`cleaning up expired keys`);
            let count = 0;
            getCachers().forEach((cacher) => {
                cacher.keys().forEach((key) => {
                    cacher.getExpiry(key);
                });
            });
            (0, logger_1.log)(`cleaning up expired keys complete - ${count} keys`);
        }, seconds * 1000);
        return cacherWrapper;
    },
    dispose: () => {
        if (intervalId) {
            clearInterval(intervalId);
            intervalId = undefined;
        }
        clearCachers();
        cachers = [];
    },
    getCleanupIntervalId: () => {
        return intervalId;
    }
};
module.exports = cacherWrapper;
//# sourceMappingURL=index.js.map