@gabliam/cache/src/metadatas/cache-options.js

cache plugin for gabliam

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createCacheConfig = exports.extractCacheInternalOptions = exports.getCacheGroup = exports.isCacheOptions = void 0;
const tslib_1 = require("tslib");
/* eslint-disable no-lone-blocks */
const core_1 = require("@gabliam/core");
const expression_1 = require("@gabliam/expression");
const debug_1 = tslib_1.__importDefault(require("debug"));
const constant_1 = require("../constant");
const error_1 = require("../error");
const cache_group_1 = require("./cache-group");
const debug = (0, debug_1.default)('Gabliam:Plugin:CachePlugin:CacheOptions');
function isCacheOptions(obj) {
    return (typeof obj === 'object' &&
        Object.prototype.hasOwnProperty.call(obj, 'cacheNames'));
}
exports.isCacheOptions = isCacheOptions;
const getCacheGroup = (target) => {
    const [cacheGroup] = core_1.reflection
        .annotationsOfDecorator(target, cache_group_1.CacheGroup)
        .slice(-1);
    return cacheGroup ? cacheGroup.cacheGroupName || 'default' : 'default';
};
exports.getCacheGroup = getCacheGroup;
function defaultKeyGenerator(...args) {
    const k = [];
    /* istanbul ignore next */
    if (args === undefined) {
        return undefined;
    }
    for (const arg of args) {
        try {
            if (typeof arg === 'string') {
                k.push(arg);
            }
            else {
                k.push(JSON.stringify(arg));
            }
            // eslint-disable-next-line no-empty
        }
        catch (_a) { }
    }
    return k.join('');
}
function extractCacheInternalOptions(value) {
    const cacheNames = [];
    let keyGenerator = defaultKeyGenerator;
    let key;
    let condition;
    let unless;
    if (isCacheOptions(value)) {
        if (value.cacheNames) {
            if (Array.isArray(value.cacheNames)) {
                cacheNames.push(...value.cacheNames);
            }
            else {
                cacheNames.push(value.cacheNames);
            }
        }
        ({ key, keyGenerator = defaultKeyGenerator, condition, unless } = value);
    }
    else if (value) {
        if (Array.isArray(value)) {
            cacheNames.push(...value);
        }
        else {
            cacheNames.push(value);
        }
    }
    if (cacheNames.length === 0) {
        throw new error_1.CacheNameIsMandatoryError();
    }
    return {
        cacheNames,
        key,
        keyGenerator,
        condition,
        unless,
    };
}
exports.extractCacheInternalOptions = extractCacheInternalOptions;
async function createCacheConfig(cacheGroup, container, cacheInternalOptions) {
    const { cacheNames, condition, key, unless } = cacheInternalOptions;
    let passCondition = () => true;
    if (condition !== undefined) {
        passCondition = ((e) => (...vals) => {
            try {
                const res = e.getValue({ args: vals });
                return typeof res === 'boolean' ? res : false;
            }
            catch (error) {
                /* istanbul ignore next */ {
                    debug('error condition', error);
                    return false;
                }
            }
        })(container
            .get(expression_1.ExpressionParser)
            .parseExpression(condition));
    }
    let veto = (args, result) => false;
    if (unless !== undefined) {
        veto = ((e) => (args, result) => {
            try {
                const res = e.getValue({ args, result });
                return typeof res === 'boolean' ? res : false;
            }
            catch (error) {
                /* istanbul ignore next */ {
                    debug('error condition', error);
                    return false;
                }
            }
        })(container.get(expression_1.ExpressionParser).parseExpression(unless));
    }
    let extractArgs = (...vals) => vals;
    // if a key is passed, create a key
    if (key) {
        extractArgs = ((e) => (...vals) => {
            try {
                let extractedArgs = e.getValue({ args: vals });
                if (extractedArgs) {
                    extractedArgs = Array.isArray(extractedArgs)
                        ? extractedArgs
                        : [extractedArgs];
                }
                return extractedArgs;
            }
            catch (error) {
                /* istanbul ignore next */ {
                    debug('cache Error', error);
                    return undefined;
                }
            }
        })(container.get(expression_1.ExpressionParser).parseExpression(key));
    }
    const cacheManager = container.get(constant_1.CACHE_MANAGER);
    const caches = [];
    for (const cacheName of cacheNames) {
        // eslint-disable-next-line no-await-in-loop
        const cache = await cacheManager.getCache(cacheName, cacheGroup);
        if (cache) {
            caches.push(cache);
        }
    }
    return {
        passCondition,
        extractArgs,
        caches,
        veto,
    };
}
exports.createCacheConfig = createCacheConfig;