@imqueue/rpc/src/decorators/logged.js

RPC-like client-service implementation over messaging queue

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.logged = logged;
// noinspection JSUnusedGlobalSymbols
/**
 * Logger decorator factory for class methods. Will try, catch and log errors
 * during method calls. If logger is bypassed, will use given logger, otherwise
 * will try to use logger defined on class dynamically or statically or will
 * fallback to console.
 *
 * @param {ILogger | LoggedDecoratorOptions} [options] - custom logger or
 *                                                       logged decorator
 *                                                       options
 * @return {Function} - decorator function
 */
function logged(options) {
    return (target, methodName, descriptor) => {
        const original = descriptor.value;
        const level = (options &&
            options.level)
            ? options.level
            : 'error';
        const doThrow = !options ||
            !options.doNotThrow;
        descriptor.value = async function (...args) {
            try {
                const ctx = (typeof this !== 'undefined' && this !== null)
                    ? this
                    : target;
                if (original) {
                    return await original.apply(ctx, args);
                }
            }
            catch (err) {
                const logger = (options && options.logger)
                    ? options.logger
                    : (options && options.error)
                        ? options
                        : (this && this.logger)
                            ? this.logger
                            : (target && target.logger)
                                ? target.logger
                                : console;
                logger[level](err);
                if (doThrow) {
                    throw err;
                }
            }
        };
    };
}
//# sourceMappingURL=logged.js.map