@depup/nestjs__common 11.1.16-depup.1

package/services/logger.service.d.ts

@@ -0,0 +1,152 @@
+export declare const LOG_LEVELS: ["verbose", "debug", "log", "warn", "error", "fatal"];
+/**
+ * @publicApi
+ */
+export type LogLevel = (typeof LOG_LEVELS)[number];
+/**
+ * @publicApi
+ */
+export interface LoggerService {
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'fatal' level log.
+     */
+    fatal?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Set log levels.
+     * @param levels log levels
+     */
+    setLogLevels?(levels: LogLevel[]): any;
+}
+interface LogBufferRecord {
+    /**
+     * Method to execute.
+     */
+    methodRef: Function;
+    /**
+     * Arguments to pass to the method.
+     */
+    arguments: unknown[];
+}
+/**
+ * @publicApi
+ */
+export declare class Logger implements LoggerService {
+    protected context?: string | undefined;
+    protected options: {
+        timestamp?: boolean;
+    };
+    protected static logBuffer: LogBufferRecord[];
+    protected static staticInstanceRef?: LoggerService;
+    protected static logLevels?: LogLevel[];
+    private static isBufferAttached;
+    protected localInstanceRef?: LoggerService;
+    private static WrapBuffer;
+    constructor();
+    constructor(context: string);
+    constructor(context: string, options?: {
+        timestamp?: boolean;
+    });
+    get localInstance(): LoggerService;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: any, stack?: string, context?: string): void;
+    error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: any, context?: string): void;
+    log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: any, context?: string): void;
+    warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug(message: any, context?: string): void;
+    debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose(message: any, context?: string): void;
+    verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log.
+     */
+    fatal(message: any, context?: string): void;
+    fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write an 'error' level log.
+     */
+    static error(message: any, stackOrContext?: string): void;
+    static error(message: any, context?: string): void;
+    static error(message: any, stack?: string, context?: string): void;
+    static error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'log' level log.
+     */
+    static log(message: any, context?: string): void;
+    static log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'warn' level log.
+     */
+    static warn(message: any, context?: string): void;
+    static warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    static debug(message: any, context?: string): void;
+    static debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log.
+     */
+    static verbose(message: any, context?: string): void;
+    static verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log.
+     */
+    static fatal(message: any, context?: string): void;
+    static fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Print buffered logs and detach buffer.
+     */
+    static flush(): void;
+    /**
+     * Attach buffer.
+     * Turns on initialization logs buffering.
+     */
+    static attachBuffer(): void;
+    /**
+     * Detach buffer.
+     * Turns off initialization logs buffering.
+     */
+    static detachBuffer(): void;
+    static getTimestamp(): string;
+    static overrideLogger(logger: LoggerService | LogLevel[] | boolean): any;
+    static isLevelEnabled(level: LogLevel): boolean;
+    private registerLocalInstanceRef;
+}
+export {};

package/services/logger.service.js

@@ -0,0 +1,251 @@
+"use strict";
+var Logger_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LOG_LEVELS = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("../decorators/core");
+const shared_utils_1 = require("../utils/shared.utils");
+const console_logger_service_1 = require("./console-logger.service");
+const utils_1 = require("./utils");
+exports.LOG_LEVELS = [
+    'verbose',
+    'debug',
+    'log',
+    'warn',
+    'error',
+    'fatal',
+];
+const DEFAULT_LOGGER = new console_logger_service_1.ConsoleLogger();
+const dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
+    year: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric',
+    day: '2-digit',
+    month: '2-digit',
+});
+/**
+ * @publicApi
+ */
+let Logger = Logger_1 = class Logger {
+    constructor(context, options = {}) {
+        this.context = context;
+        this.options = options;
+    }
+    get localInstance() {
+        if (Logger_1.staticInstanceRef === DEFAULT_LOGGER) {
+            return this.registerLocalInstanceRef();
+        }
+        else if (Logger_1.staticInstanceRef instanceof Logger_1) {
+            const prototype = Object.getPrototypeOf(Logger_1.staticInstanceRef);
+            if (prototype.constructor === Logger_1) {
+                return this.registerLocalInstanceRef();
+            }
+        }
+        return Logger_1.staticInstanceRef;
+    }
+    error(message, ...optionalParams) {
+        optionalParams = this.context
+            ? (optionalParams.length ? optionalParams : [undefined]).concat(this.context)
+            : optionalParams;
+        this.localInstance?.error(message, ...optionalParams);
+    }
+    log(message, ...optionalParams) {
+        optionalParams = this.context
+            ? optionalParams.concat(this.context)
+            : optionalParams;
+        this.localInstance?.log(message, ...optionalParams);
+    }
+    warn(message, ...optionalParams) {
+        optionalParams = this.context
+            ? optionalParams.concat(this.context)
+            : optionalParams;
+        this.localInstance?.warn(message, ...optionalParams);
+    }
+    debug(message, ...optionalParams) {
+        optionalParams = this.context
+            ? optionalParams.concat(this.context)
+            : optionalParams;
+        this.localInstance?.debug?.(message, ...optionalParams);
+    }
+    verbose(message, ...optionalParams) {
+        optionalParams = this.context
+            ? optionalParams.concat(this.context)
+            : optionalParams;
+        this.localInstance?.verbose?.(message, ...optionalParams);
+    }
+    fatal(message, ...optionalParams) {
+        optionalParams = this.context
+            ? optionalParams.concat(this.context)
+            : optionalParams;
+        this.localInstance?.fatal?.(message, ...optionalParams);
+    }
+    static error(message, ...optionalParams) {
+        this.staticInstanceRef?.error(message, ...optionalParams);
+    }
+    static log(message, ...optionalParams) {
+        this.staticInstanceRef?.log(message, ...optionalParams);
+    }
+    static warn(message, ...optionalParams) {
+        this.staticInstanceRef?.warn(message, ...optionalParams);
+    }
+    static debug(message, ...optionalParams) {
+        this.staticInstanceRef?.debug?.(message, ...optionalParams);
+    }
+    static verbose(message, ...optionalParams) {
+        this.staticInstanceRef?.verbose?.(message, ...optionalParams);
+    }
+    static fatal(message, ...optionalParams) {
+        this.staticInstanceRef?.fatal?.(message, ...optionalParams);
+    }
+    /**
+     * Print buffered logs and detach buffer.
+     */
+    static flush() {
+        this.isBufferAttached = false;
+        this.logBuffer.forEach(item => item.methodRef(...item.arguments));
+        this.logBuffer = [];
+    }
+    /**
+     * Attach buffer.
+     * Turns on initialization logs buffering.
+     */
+    static attachBuffer() {
+        this.isBufferAttached = true;
+    }
+    /**
+     * Detach buffer.
+     * Turns off initialization logs buffering.
+     */
+    static detachBuffer() {
+        this.isBufferAttached = false;
+    }
+    static getTimestamp() {
+        return dateTimeFormatter.format(Date.now());
+    }
+    static overrideLogger(logger) {
+        if (Array.isArray(logger)) {
+            Logger_1.logLevels = logger;
+            return this.staticInstanceRef?.setLogLevels?.(logger);
+        }
+        if ((0, shared_utils_1.isObject)(logger)) {
+            if (logger instanceof Logger_1 && logger.constructor !== Logger_1) {
+                const errorMessage = `Using the "extends Logger" instruction is not allowed in Nest v9. Please, use "extends ConsoleLogger" instead.`;
+                this.staticInstanceRef?.error(errorMessage);
+                throw new Error(errorMessage);
+            }
+            this.staticInstanceRef = logger;
+        }
+        else {
+            this.staticInstanceRef = undefined;
+        }
+    }
+    static isLevelEnabled(level) {
+        const logLevels = Logger_1.logLevels;
+        return (0, utils_1.isLogLevelEnabled)(level, logLevels);
+    }
+    registerLocalInstanceRef() {
+        if (this.localInstanceRef) {
+            return this.localInstanceRef;
+        }
+        this.localInstanceRef = new console_logger_service_1.ConsoleLogger(this.context, {
+            timestamp: this.options?.timestamp,
+            logLevels: Logger_1.logLevels,
+        });
+        return this.localInstanceRef;
+    }
+};
+exports.Logger = Logger;
+Logger.logBuffer = new Array();
+Logger.staticInstanceRef = DEFAULT_LOGGER;
+Logger.WrapBuffer = (target, propertyKey, descriptor) => {
+    const originalFn = descriptor.value;
+    descriptor.value = function (...args) {
+        if (Logger_1.isBufferAttached) {
+            Logger_1.logBuffer.push({
+                methodRef: originalFn.bind(this),
+                arguments: args,
+            });
+            return;
+        }
+        return originalFn.call(this, ...args);
+    };
+};
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "error", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "log", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "warn", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "debug", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "verbose", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "fatal", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "error", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "log", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "warn", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "debug", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "verbose", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "fatal", null);
+exports.Logger = Logger = Logger_1 = tslib_1.__decorate([
+    (0, core_1.Injectable)(),
+    tslib_1.__param(0, (0, core_1.Optional)()),
+    tslib_1.__param(1, (0, core_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [String, Object])
+], Logger);

package/services/utils/filter-log-levels.util.d.ts

@@ -0,0 +1,5 @@
+import { LogLevel } from '../logger.service';
+/**
+ * @publicApi
+ */
+export declare function filterLogLevels(parseableString?: string): LogLevel[];

package/services/utils/filter-log-levels.util.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterLogLevels = filterLogLevels;
+const logger_service_1 = require("../logger.service");
+const is_log_level_util_1 = require("./is-log-level.util");
+/**
+ * @publicApi
+ */
+function filterLogLevels(parseableString = '') {
+    const sanitizedString = parseableString.replaceAll(' ', '').toLowerCase();
+    if (sanitizedString[0] === '>') {
+        const orEqual = sanitizedString[1] === '=';
+        const logLevelIndex = logger_service_1.LOG_LEVELS.indexOf(sanitizedString.substring(orEqual ? 2 : 1));
+        if (logLevelIndex === -1) {
+            throw new Error(`parse error (unknown log level): ${sanitizedString}`);
+        }
+        return logger_service_1.LOG_LEVELS.slice(orEqual ? logLevelIndex : logLevelIndex + 1);
+    }
+    else if (sanitizedString.includes(',')) {
+        return sanitizedString.split(',').filter(is_log_level_util_1.isLogLevel);
+    }
+    return (0, is_log_level_util_1.isLogLevel)(sanitizedString) ? [sanitizedString] : logger_service_1.LOG_LEVELS;
+}

package/services/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './filter-log-levels.util';
+export * from './is-log-level-enabled.util';
+export * from './is-log-level.util';

package/services/utils/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./filter-log-levels.util"), exports);
+tslib_1.__exportStar(require("./is-log-level-enabled.util"), exports);
+tslib_1.__exportStar(require("./is-log-level.util"), exports);

package/services/utils/is-log-level-enabled.util.d.ts

@@ -0,0 +1,7 @@
+import { LogLevel } from '../logger.service';
+/**
+ * Checks if target level is enabled.
+ * @param targetLevel target level
+ * @param logLevels array of enabled log levels
+ */
+export declare function isLogLevelEnabled(targetLevel: LogLevel, logLevels: LogLevel[] | undefined): boolean;

package/services/utils/is-log-level-enabled.util.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLogLevelEnabled = isLogLevelEnabled;
+const LOG_LEVEL_VALUES = {
+    verbose: 0,
+    debug: 1,
+    log: 2,
+    warn: 3,
+    error: 4,
+    fatal: 5,
+};
+/**
+ * Checks if target level is enabled.
+ * @param targetLevel target level
+ * @param logLevels array of enabled log levels
+ */
+function isLogLevelEnabled(targetLevel, logLevels) {
+    if (!logLevels || (Array.isArray(logLevels) && logLevels?.length === 0)) {
+        return false;
+    }
+    if (logLevels.includes(targetLevel)) {
+        return true;
+    }
+    let highestLogLevelValue = -Infinity;
+    for (const level of logLevels) {
+        const v = LOG_LEVEL_VALUES[level];
+        if (v > highestLogLevelValue)
+            highestLogLevelValue = v;
+    }
+    const targetLevelValue = LOG_LEVEL_VALUES[targetLevel];
+    return targetLevelValue >= highestLogLevelValue;
+}

package/services/utils/is-log-level.util.d.ts

@@ -0,0 +1,5 @@
+import { LogLevel } from '../logger.service';
+/**
+ * @publicApi
+ */
+export declare function isLogLevel(maybeLogLevel: any): maybeLogLevel is LogLevel;

package/services/utils/is-log-level.util.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLogLevel = isLogLevel;
+const logger_service_1 = require("../logger.service");
+/**
+ * @publicApi
+ */
+function isLogLevel(maybeLogLevel) {
+    return logger_service_1.LOG_LEVELS.includes(maybeLogLevel);
+}

package/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.build.json",
+  "compilerOptions": {
+    "outDir": ".",
+    "rootDir": ".",
+    "paths": {}
+  },
+  "exclude": ["node_modules", "dist", "test/**/*", "*.spec.ts"],
+  "references": []
+}

package/utils/assign-custom-metadata.util.d.ts

@@ -0,0 +1,4 @@
+import { ParamData, RouteParamMetadata } from '../decorators/http/route-params.decorator';
+import { PipeTransform, Type } from '../interfaces';
+import { CustomParamFactory } from '../interfaces/features/custom-route-param-factory.interface';
+export declare function assignCustomParameterMetadata(args: Record<number, RouteParamMetadata>, paramtype: number | string, index: number, factory: CustomParamFactory, data?: ParamData, ...pipes: (Type<PipeTransform> | PipeTransform)[]): {};

package/utils/assign-custom-metadata.util.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignCustomParameterMetadata = assignCustomParameterMetadata;
+const constants_1 = require("../constants");
+function assignCustomParameterMetadata(args, paramtype, index, factory, data, ...pipes) {
+    return {
+        ...args,
+        [`${paramtype}${constants_1.CUSTOM_ROUTE_ARGS_METADATA}:${index}`]: {
+            index,
+            factory,
+            data,
+            pipes,
+        },
+    };
+}

package/utils/cli-colors.util.d.ts

@@ -0,0 +1,10 @@
+export declare const isColorAllowed: () => boolean;
+export declare const clc: {
+    bold: (text: string) => string;
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    red: (text: string) => string;
+    magentaBright: (text: string) => string;
+    cyanBright: (text: string) => string;
+};
+export declare const yellow: (text: string) => string;

package/utils/cli-colors.util.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yellow = exports.clc = exports.isColorAllowed = void 0;
+const isColorAllowed = () => !process.env.NO_COLOR;
+exports.isColorAllowed = isColorAllowed;
+const colorIfAllowed = (colorFn) => (text) => (0, exports.isColorAllowed)() ? colorFn(text) : text;
+exports.clc = {
+    bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
+    green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
+    yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
+    red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
+    magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
+    cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`),
+};
+exports.yellow = colorIfAllowed((text) => `\x1B[38;5;3m${text}\x1B[39m`);

package/utils/extend-metadata.util.d.ts

@@ -0,0 +1 @@
+export declare function extendArrayMetadata<T extends Array<unknown>>(key: string, metadata: T, target: Function): void;

package/utils/extend-metadata.util.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendArrayMetadata = extendArrayMetadata;
+function extendArrayMetadata(key, metadata, target) {
+    const previousValue = Reflect.getMetadata(key, target) || [];
+    const value = [...previousValue, ...metadata];
+    Reflect.defineMetadata(key, value, target);
+}

package/utils/forward-ref.util.d.ts

@@ -0,0 +1,5 @@
+import { ForwardReference } from '../interfaces/modules/forward-reference.interface';
+/**
+ * @publicApi
+ */
+export declare const forwardRef: (fn: () => any) => ForwardReference;

package/utils/forward-ref.util.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forwardRef = void 0;
+/**
+ * @publicApi
+ */
+const forwardRef = (fn) => ({
+    forwardRef: fn,
+});
+exports.forwardRef = forwardRef;

package/utils/http-error-by-code.util.d.ts

@@ -0,0 +1,4 @@
+import { HttpStatus } from '../enums';
+import { Type } from '../interfaces';
+export type ErrorHttpStatusCode = HttpStatus.BAD_GATEWAY | HttpStatus.BAD_REQUEST | HttpStatus.CONFLICT | HttpStatus.FORBIDDEN | HttpStatus.GATEWAY_TIMEOUT | HttpStatus.GONE | HttpStatus.I_AM_A_TEAPOT | HttpStatus.INTERNAL_SERVER_ERROR | HttpStatus.METHOD_NOT_ALLOWED | HttpStatus.NOT_ACCEPTABLE | HttpStatus.NOT_FOUND | HttpStatus.NOT_IMPLEMENTED | HttpStatus.PAYLOAD_TOO_LARGE | HttpStatus.PRECONDITION_FAILED | HttpStatus.REQUEST_TIMEOUT | HttpStatus.SERVICE_UNAVAILABLE | HttpStatus.UNAUTHORIZED | HttpStatus.UNPROCESSABLE_ENTITY | HttpStatus.UNSUPPORTED_MEDIA_TYPE;
+export declare const HttpErrorByCode: Record<ErrorHttpStatusCode, Type<unknown>>;

package/utils/http-error-by-code.util.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpErrorByCode = void 0;
+const enums_1 = require("../enums");
+const exceptions_1 = require("../exceptions");
+exports.HttpErrorByCode = {
+    [enums_1.HttpStatus.BAD_GATEWAY]: exceptions_1.BadGatewayException,
+    [enums_1.HttpStatus.BAD_REQUEST]: exceptions_1.BadRequestException,
+    [enums_1.HttpStatus.CONFLICT]: exceptions_1.ConflictException,
+    [enums_1.HttpStatus.FORBIDDEN]: exceptions_1.ForbiddenException,
+    [enums_1.HttpStatus.GATEWAY_TIMEOUT]: exceptions_1.GatewayTimeoutException,
+    [enums_1.HttpStatus.GONE]: exceptions_1.GoneException,
+    [enums_1.HttpStatus.I_AM_A_TEAPOT]: exceptions_1.ImATeapotException,
+    [enums_1.HttpStatus.INTERNAL_SERVER_ERROR]: exceptions_1.InternalServerErrorException,
+    [enums_1.HttpStatus.METHOD_NOT_ALLOWED]: exceptions_1.MethodNotAllowedException,
+    [enums_1.HttpStatus.NOT_ACCEPTABLE]: exceptions_1.NotAcceptableException,
+    [enums_1.HttpStatus.NOT_FOUND]: exceptions_1.NotFoundException,
+    [enums_1.HttpStatus.NOT_IMPLEMENTED]: exceptions_1.NotImplementedException,
+    [enums_1.HttpStatus.PAYLOAD_TOO_LARGE]: exceptions_1.PayloadTooLargeException,
+    [enums_1.HttpStatus.PRECONDITION_FAILED]: exceptions_1.PreconditionFailedException,
+    [enums_1.HttpStatus.REQUEST_TIMEOUT]: exceptions_1.RequestTimeoutException,
+    [enums_1.HttpStatus.SERVICE_UNAVAILABLE]: exceptions_1.ServiceUnavailableException,
+    [enums_1.HttpStatus.UNAUTHORIZED]: exceptions_1.UnauthorizedException,
+    [enums_1.HttpStatus.UNPROCESSABLE_ENTITY]: exceptions_1.UnprocessableEntityException,
+    [enums_1.HttpStatus.UNSUPPORTED_MEDIA_TYPE]: exceptions_1.UnsupportedMediaTypeException,
+};

package/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './forward-ref.util';

package/utils/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./forward-ref.util"), exports);

package/utils/load-package.util.d.ts

@@ -0,0 +1 @@
+export declare function loadPackage(packageName: string, context: string, loaderFn?: Function): any;

package/utils/load-package.util.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPackage = loadPackage;
+const logger_service_1 = require("../services/logger.service");
+const MISSING_REQUIRED_DEPENDENCY = (name, reason) => `The "${name}" package is missing. Please, make sure to install it to take advantage of ${reason}.`;
+const logger = new logger_service_1.Logger('PackageLoader');
+function loadPackage(packageName, context, loaderFn) {
+    try {
+        return loaderFn ? loaderFn() : require(packageName);
+    }
+    catch (e) {
+        logger.error(MISSING_REQUIRED_DEPENDENCY(packageName, context));
+        logger_service_1.Logger.flush();
+        process.exit(1);
+    }
+}

package/utils/merge-with-values.util.d.ts

@@ -0,0 +1,4 @@
+export type Constructor<T> = new (...args: any[]) => T;
+export declare const MergeWithValues: <T extends Constructor<{}>>(data: {
+    [param: string]: any;
+}) => (Metatype: T) => any;