@slickteam/nestjs-utils/dist/index.js

Utils functions and classes for Nestjs

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.LoggerParams = LoggerParams;
exports.throwErrorAndLog = throwErrorAndLog;
exports.throwErrorAndLogWithContext = throwErrorAndLogWithContext;
exports.logLevel = logLevel;
const common_1 = require("@nestjs/common");
function LoggerParams(options = 'verbose') {
    const level = typeof options === 'string' ? options : options.level || 'verbose';
    const paramNames = typeof options === 'object' && options.paramNames ? options.paramNames : undefined;
    return (target, propertyKey, descriptor) => {
        const original = descriptor.value;
        descriptor.value = function (...args) {
            let message = `${propertyKey}(`;
            for (let i = 0; i < args.length; i++) {
                const arg = args[i];
                const paramName = paramNames && paramNames[i] ? paramNames[i] : `[${i}]`;
                if (Array.isArray(arg)) {
                    message += `${paramName}=[Array(${arg.length})]`;
                }
                else if (arg === null) {
                    message += `${paramName}=null`;
                }
                else if (arg === undefined) {
                    message += `${paramName}=undefined`;
                }
                else if (typeof arg === 'object') {
                    message += `${paramName}={...}`;
                }
                else if (typeof arg === 'string') {
                    message += `${paramName}="${arg}"`;
                }
                else {
                    message += `${paramName}=${String(arg)}`;
                }
                if (i < args.length - 1) {
                    message += ', ';
                }
            }
            message += ')';
            const className = target.constructor.name;
            switch (level) {
                case 'verbose':
                    common_1.Logger.verbose(message, className);
                    break;
                case 'debug':
                    common_1.Logger.debug(message, className);
                    break;
                case 'log':
                    common_1.Logger.log(message, className);
                    break;
                case 'warn':
                    common_1.Logger.warn(message, className);
                    break;
                default:
                    common_1.Logger.error(message, className);
                    break;
            }
            const value = original.apply(this, args);
            return value;
        };
    };
}
function throwErrorAndLog(message, typeError = common_1.HttpStatus.INTERNAL_SERVER_ERROR, logger) {
    const error = new common_1.HttpException(message, typeError);
    if (logger) {
        logger?.error(message);
    }
    else {
        common_1.Logger.error(message);
    }
    throw error;
}
function throwErrorAndLogWithContext(message, typeError = common_1.HttpStatus.INTERNAL_SERVER_ERROR, context) {
    const error = new common_1.HttpException(message, typeError);
    common_1.Logger.error(message, context);
    throw error;
}
function logLevel(level) {
    const levelTab = [];
    switch (level) {
        case 'verbose':
            levelTab.push('verbose');
        case 'debug':
            levelTab.push('debug');
        case 'log':
            levelTab.push('log');
        case 'warn':
            levelTab.push('warn');
        default:
            levelTab.push('error');
    }
    return levelTab;
}
//# sourceMappingURL=index.js.map