@rangeljl/shared/asyncFunctionAddCache.js

A set of functions that are used in a lot of places

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const unixTimestampGet_1 = __importDefault(require("./unixTimestampGet"));
/**
 * Creates a function that caches to RAM the value given
 * @param param0
 * @returns
 */
const asyncFunctionAddCache = ({ hashArgs, originalFunction, expirationTimeInSeconds = Infinity, debugName, }) => {
    let cache = {};
    const functionWithCache = (args, isRetry) => __awaiter(void 0, void 0, void 0, function* () {
        const argsHash = hashArgs(args);
        const cachedRecord = cache[argsHash];
        if (cachedRecord) {
            const secondsSinceCache = (0, unixTimestampGet_1.default)() - cachedRecord.timestamp;
            if (secondsSinceCache < expirationTimeInSeconds) {
                if (debugName) {
                    console.log(`[${debugName}] Cache hit`);
                }
                return cachedRecord.value;
            }
        }
        if (debugName) {
            console.log(`[${debugName}] Cache miss`);
        }
        try {
            const value = yield originalFunction(args);
            cache[argsHash] = {
                value,
                timestamp: (0, unixTimestampGet_1.default)(),
            };
            return value;
        }
        catch (error) {
            if (isRetry) {
                throw error;
            }
            cache[argsHash] = undefined;
            return functionWithCache(args, true);
        }
    });
    functionWithCache.getCache = () => cache;
    functionWithCache.clearCacheRecord = (args) => {
        delete cache[hashArgs(args)];
    };
    functionWithCache.cacheClear = () => {
        cache = {};
    };
    return functionWithCache;
};
exports.default = asyncFunctionAddCache;