@expressots/core 1.0.1 → 1.2.0

package/lib/esm/application/application.js

@@ -0,0 +1,96 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var Application_1;
+import express from "express";
+import { provide } from "inversify-binding-decorators";
+import { InversifyExpressServer } from "inversify-express-utils";
+import process from "process";
+import { Console } from "../console/console";
+import errorHandler from "../error/error-handler-middleware";
+/**
+ * Enum representing possible server environments.
+ */
+var ServerEnvironment;
+(function (ServerEnvironment) {
+    ServerEnvironment["Development"] = "development";
+    ServerEnvironment["Staging"] = "staging";
+    ServerEnvironment["Production"] = "production";
+})(ServerEnvironment || (ServerEnvironment = {}));
+/**
+ * The Application class provides a way to configure and manage an Express application.
+ * @provide Application
+ */
+let Application = Application_1 = class Application {
+    app;
+    port;
+    environment;
+    /**
+     * Constructs a new instance of the Application class.
+     */
+    constructor() { }
+    /**
+     * Configure services that should be initialized before the server starts.
+     */
+    configureServices() { }
+    /**
+     * Configure services that should be executed after the server starts.
+     */
+    postServerInitialization() { }
+    /**
+     * Perform actions or cleanup after the server is shutdown.
+     */
+    serverShutdown() {
+        process.exit(0);
+    }
+    /**
+     * Create and configure the Express application.
+     * @param container - The InversifyJS container.
+     * @param middlewares - An array of Express middlewares to be applied.
+     * @returns The configured Application instance.
+     */
+    create(container, middlewares = []) {
+        this.configureServices();
+        const expressServer = new InversifyExpressServer(container);
+        expressServer.setConfig((app) => {
+            /* Default body parser application/json */
+            app.use(express.json());
+            /* Default body parser application/x-www-form-urlencoded */
+            app.use(express.urlencoded({ extended: true }));
+            middlewares.forEach(middleware => {
+                app.use(middleware);
+            });
+        });
+        this.app = expressServer.build();
+        /* Add the error handler middleware */
+        this.app.use(errorHandler);
+        return this;
+    }
+    /**
+     * Start listening on the given port and environment.
+     * @param port - The port number to listen on.
+     * @param environment - The server environment.
+     * @param consoleMessage - Optional message to display in the console.
+     */
+    listen(port, environment, consoleMessage) {
+        this.port = port;
+        this.environment = environment;
+        this.app.listen(this.port, () => {
+            new Console().messageServer(this.port, this.environment, consoleMessage);
+            process.on("SIGINT", this.serverShutdown.bind(this));
+        });
+        this.postServerInitialization();
+    }
+};
+Application = Application_1 = __decorate([
+    provide(Application_1),
+    __metadata("design:paramtypes", [])
+], Application);
+const appServerInstance = new Application();
+export { appServerInstance as AppInstance, Application, ServerEnvironment };

package/{application/index.d.ts → lib/esm/application/index.js}

@@ -1,2 +1,2 @@
-export { AppInstance, Application, ServerEnvironment } from './application';
-export { AppContainer } from './app-container';
+export { AppInstance, Application, ServerEnvironment } from './application';
+export { AppContainer } from './app-container';

package/lib/esm/common/index.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/common/project-config.provider.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/console/console.js

@@ -0,0 +1,76 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Console_1;
+import chalk from "chalk";
+import { provide } from "inversify-binding-decorators";
+/**
+ * Enum representing possible color styles for console output.
+ */
+var ColorStyle;
+(function (ColorStyle) {
+    ColorStyle[ColorStyle["None"] = 0] = "None";
+    ColorStyle[ColorStyle["Yellow"] = 1] = "Yellow";
+    ColorStyle[ColorStyle["Blue"] = 2] = "Blue";
+    ColorStyle[ColorStyle["Green"] = 3] = "Green";
+    ColorStyle[ColorStyle["Red"] = 4] = "Red";
+})(ColorStyle || (ColorStyle = {}));
+/**
+ * The Console class provides methods for displaying styled messages in the console.
+ * @provide Console
+ */
+let Console = Console_1 = class Console {
+    /**
+     * Print a message to the console with the specified color style.
+     * @param message - The message to be printed.
+     * @param colorStyle - The color style for the message.
+     */
+    async printColor(message, colorStyle) {
+        switch (colorStyle) {
+            case ColorStyle.Yellow:
+                return console.log(chalk.bgYellow.black(message));
+            case ColorStyle.Blue:
+                return console.log(chalk.bgBlue.black(message));
+            case ColorStyle.Green:
+                return console.log(chalk.bgGreen.black(message));
+            case ColorStyle.Red:
+                return console.log(chalk.bgRed.black(message));
+        }
+    }
+    /**
+     * Display a message in the console with details about the running server.
+     * @param port - The port number the server is running on.
+     * @param environment - The server environment.
+     * @param consoleMessage - Optional application message details for console output.
+     */
+    async messageServer(port, environment, consoleMessage) {
+        const appConsoleMessage = {
+            appName: consoleMessage?.appName || "Application",
+            appVersion: consoleMessage?.appVersion || "not provided",
+        };
+        let terminalColor = ColorStyle.None;
+        switch (environment.toLowerCase()) {
+            case "development":
+                terminalColor = ColorStyle.Yellow;
+                break;
+            case "staging":
+                terminalColor = ColorStyle.Blue;
+                break;
+            case "production":
+                terminalColor = ColorStyle.Green;
+                break;
+            default:
+                terminalColor = ColorStyle.Red;
+                break;
+        }
+        this.printColor(`${appConsoleMessage.appName} version ${appConsoleMessage.appVersion} is running on ` +
+            `port ${port} - Environment: ${environment}`, terminalColor);
+    }
+};
+Console = Console_1 = __decorate([
+    provide(Console_1)
+], Console);
+export { Console };

package/lib/esm/console/index.js

@@ -0,0 +1 @@
+export { Console } from "./console";

package/lib/esm/container-module/container-module.js

@@ -0,0 +1,53 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var BaseModule_1;
+import { ContainerModule } from "inversify";
+import { provide } from "inversify-binding-decorators";
+/**
+ * The BaseModule class provides methods for creating InversifyJS container modules.
+ * @provide BaseModule
+ */
+let BaseModule = BaseModule_1 = class BaseModule {
+    constructor() { }
+    /**
+     * Create a map of symbols for the provided controllers.
+     * @param controllers - An array of controller classes.
+     * @returns A map of symbols mapped to controller constructor functions.
+     */
+    static createSymbols(controllers) {
+        const symbols = new Map();
+        for (const controller of controllers) {
+            const target = controller;
+            const symbol = Symbol.for(target.name);
+            symbols.set(symbol, target);
+        }
+        return symbols;
+    }
+    /**
+    * Create an InversifyJS ContainerModule for the provided controllers.
+    * @param controllers - An array of controller classes.
+    * @returns A ContainerModule with the controller bindings.
+    */
+    static createContainerModule(controllers) {
+        const symbols = BaseModule_1.createSymbols(controllers);
+        return new ContainerModule(bind => {
+            for (const symbol of symbols) {
+                const target = symbol.valueOf();
+                bind(target[0]).to(target[1]);
+            }
+        });
+    }
+};
+BaseModule = BaseModule_1 = __decorate([
+    provide(BaseModule_1),
+    __metadata("design:paramtypes", [])
+], BaseModule);
+const CreateModule = BaseModule.createContainerModule;
+export { CreateModule };

package/{container-module/index.d.ts → lib/esm/container-module/index.js}

@@ -1 +1 @@
-export { CreateModule } from "./container-module";
+export { CreateModule } from "./container-module";

package/lib/esm/controller/base-controller.js

@@ -0,0 +1,64 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var BaseController_1;
+import { provide } from 'inversify-binding-decorators';
+import { Report } from '../error';
+/**
+ * The BaseController class is an abstract base class for controllers.
+ * It provides methods for handling use case calls and sending appropriate responses.
+ * @provide BaseController
+ */
+let BaseController = BaseController_1 = class BaseController {
+    serviceName;
+    /**
+     * Constructs a new BaseController instance with a specified service name.
+     * @param serviceName - The name of the service associated with the controller.
+     */
+    constructor(serviceName) {
+        this.serviceName = serviceName;
+    }
+    /**
+     * Calls an asynchronous use case and sends an appropriate response based on the result.
+     * @param useCase - A promise representing the asynchronous use case to call.
+     * @param res - The Express response object.
+     * @param successStatusCode - The HTTP status code to return upon successful execution.
+     */
+    async callUseCaseAsync(useCase, res, successStatusCode) {
+        let dataReturn;
+        try {
+            dataReturn = await useCase;
+            return res.status(successStatusCode).json(dataReturn);
+        }
+        catch (error) {
+            Report.Error(error);
+        }
+    }
+    /**
+     * Calls a use case and sends an appropriate response based on the result.
+     * @param useCase - The use case to call.
+     * @param res - The Express response object.
+     * @param successStatusCode - The HTTP status code to return upon successful execution.
+     */
+    callUseCase(useCase, res, successStatusCode) {
+        let dataReturn;
+        try {
+            dataReturn = useCase;
+            return res.status(successStatusCode).json(dataReturn);
+        }
+        catch (error) {
+            Report.Error(error);
+        }
+    }
+};
+BaseController = BaseController_1 = __decorate([
+    provide(BaseController_1),
+    __metadata("design:paramtypes", [String])
+], BaseController);
+export { BaseController };

package/{controller/index.d.ts → lib/esm/controller/index.js}

@@ -1 +1 @@
-export { BaseController } from './base-controller';
+export { BaseController } from './base-controller';

package/lib/esm/environment/env-validator.js

@@ -0,0 +1,80 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var EnvValidatorProvider_1;
+import fs from "fs";
+import path from "path";
+import dotenv from "dotenv";
+import { provide } from "inversify-binding-decorators";
+import { LogLevel, log } from "../logger";
+/**
+ * The EnvValidatorProvider class provides utility methods for working with environment variables.
+ * It validates, loads, and retrieves environment variables from the .env file.
+ * @provide EnvValidatorProvider
+ */
+let EnvValidatorProvider = EnvValidatorProvider_1 = class EnvValidatorProvider {
+    /**
+     * Retrieves the value of an environment variable, or a default value if the variable is not set.
+     * @param key - The key of the environment variable.
+     * @param defaultValue - The default value to return if the environment variable is not set.
+     * @returns The value of the environment variable, or the default value if not set.
+     */
+    static get(key, defaultValue = undefined) {
+        return process.env[key] ?? defaultValue;
+    }
+    /**
+     * Validates and loads all environment variables from the .env file.
+     * If the .env file does not exist or any environment variables are not set, the process will exit with an error.
+     */
+    static checkAll() {
+        /* Load .env file */
+        dotenv.config();
+        /* Verify if .env file exists */
+        const envFilePath = path.join(process.cwd(), ".", ".env");
+        if (!fs.existsSync(envFilePath)) {
+            log(LogLevel.Info, "Environment file .env is not defined.", "env-validator-provider");
+            process.exit(1);
+        }
+        const regexIgnoreDefaultEnvKeys = /^npm_config_/;
+        let hasError = false;
+        for (const key in process.env) {
+            if (regexIgnoreDefaultEnvKeys.test(key)) {
+                continue;
+            }
+            if (!process.env[key] || process.env[key] === "") {
+                log(LogLevel.Info, `Environment variable ${key} is not defined.`, "env-validator-provider");
+                hasError = true;
+            }
+        }
+        if (hasError) {
+            process.exit(1);
+        }
+    }
+};
+EnvValidatorProvider = EnvValidatorProvider_1 = __decorate([
+    provide(EnvValidatorProvider_1)
+], EnvValidatorProvider);
+String.prototype.AsBoolean = function () {
+    switch (this.toLowerCase().trim()) {
+        case "true":
+        case "1":
+        case "yes":
+            return true;
+        case "false":
+        case "0":
+        case "no":
+            return false;
+        default:
+            return undefined;
+    }
+};
+String.prototype.AsNumber = function () {
+    return Number(this);
+};
+String.prototype.AsString = function () {
+    return String(this);
+};
+export { EnvValidatorProvider as Environments };

package/{environment/index.d.ts → lib/esm/environment/index.js}

@@ -1 +1 @@
-export { Environments } from './env-validator';
+export { Environments } from './env-validator';

package/lib/esm/error/application-error.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var AppError_1;
+import { provide } from "inversify-binding-decorators";
+/**
+ * The AppError class extends the built-in Error class, adding a status code and service property.
+ * It is designed for handling application-specific errors with more detailed information.
+ * @provide AppError
+ */
+let AppError = AppError_1 = class AppError extends Error {
+    statusCode;
+    service;
+    /**
+     * Constructs a new AppError instance.
+     * @param statusCode - The status code associated with the error.
+     * @param message - The error message.
+     * @param service - An optional service name related to the error.
+     */
+    constructor(statusCode, message, service) {
+        super(message);
+        this.statusCode = statusCode;
+        this.service = service;
+    }
+};
+AppError = AppError_1 = __decorate([
+    provide(AppError_1),
+    __metadata("design:paramtypes", [Number, String, String])
+], AppError);
+export { AppError };

package/lib/esm/error/error-handler-middleware.js

@@ -0,0 +1,15 @@
+import { StatusCode } from "./status-code";
+import { LogLevel, log } from "../logger";
+/**
+ * errorHandler is a custom Express error-handling middleware function.
+ * It logs the error, sets the status code, and sends a JSON response containing the status code and error message.
+ * @param error - An instance of AppError containing error details.
+ * @param req - The Express request object.
+ * @param res - The Express response object.
+ * @param next - The Express next function for passing control to the next middleware function.
+ */
+function errorHandler(error, req, res, next) {
+    log(LogLevel.Error, error, error.service || "service-undefined");
+    res.status(error.statusCode || StatusCode.InternalServerError).json({ statusCode: error.statusCode, error: error.message });
+}
+export default errorHandler;

package/{error/index.d.ts → lib/esm/error/index.js}

@@ -1,3 +1,3 @@
-export { StatusCode } from './status-code';
-export { AppError } from './application-error';
-export { Report } from './report';
+export { StatusCode } from './status-code';
+export { AppError } from './application-error';
+export { Report } from './report';

package/lib/esm/error/report.js

@@ -0,0 +1,24 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Report_1;
+import { provide } from "inversify-binding-decorators";
+/**
+ * Report class is a utility class to manage and throw application-specific errors.
+ */
+let Report = Report_1 = class Report {
+    /**
+     * Error method takes an instance of AppError and throws it.
+     * @param error - An instance of AppError containing error details.
+     */
+    static Error(error) {
+        throw error;
+    }
+};
+Report = Report_1 = __decorate([
+    provide(Report_1)
+], Report);
+export { Report };

package/lib/esm/error/status-code.js

@@ -0,0 +1,80 @@
+/* Http Error Code Response */
+var InformationResponse;
+(function (InformationResponse) {
+    InformationResponse[InformationResponse["Continue"] = 100] = "Continue";
+    InformationResponse[InformationResponse["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+    InformationResponse[InformationResponse["Processing"] = 102] = "Processing";
+    InformationResponse[InformationResponse["eEarlyHints"] = 103] = "eEarlyHints";
+})(InformationResponse || (InformationResponse = {}));
+var SuccessfulResponse;
+(function (SuccessfulResponse) {
+    SuccessfulResponse[SuccessfulResponse["OK"] = 200] = "OK";
+    SuccessfulResponse[SuccessfulResponse["Created"] = 201] = "Created";
+    SuccessfulResponse[SuccessfulResponse["Accepted"] = 202] = "Accepted";
+    SuccessfulResponse[SuccessfulResponse["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+    SuccessfulResponse[SuccessfulResponse["NoContent"] = 204] = "NoContent";
+    SuccessfulResponse[SuccessfulResponse["ResetContent"] = 205] = "ResetContent";
+    SuccessfulResponse[SuccessfulResponse["PartialContent"] = 206] = "PartialContent";
+    SuccessfulResponse[SuccessfulResponse["MultiStatus"] = 207] = "MultiStatus";
+    SuccessfulResponse[SuccessfulResponse["AlreadyReported"] = 208] = "AlreadyReported";
+    SuccessfulResponse[SuccessfulResponse["IMUsed"] = 226] = "IMUsed";
+})(SuccessfulResponse || (SuccessfulResponse = {}));
+var RedirectionMessage;
+(function (RedirectionMessage) {
+    RedirectionMessage[RedirectionMessage["MultipleChoices"] = 300] = "MultipleChoices";
+    RedirectionMessage[RedirectionMessage["MovedPermanently"] = 301] = "MovedPermanently";
+    RedirectionMessage[RedirectionMessage["Found"] = 302] = "Found";
+    RedirectionMessage[RedirectionMessage["SeeOther"] = 303] = "SeeOther";
+    RedirectionMessage[RedirectionMessage["NotModified"] = 304] = "NotModified";
+    RedirectionMessage[RedirectionMessage["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+    RedirectionMessage[RedirectionMessage["PermanentRedirect"] = 308] = "PermanentRedirect";
+})(RedirectionMessage || (RedirectionMessage = {}));
+var ClientErrorResponse;
+(function (ClientErrorResponse) {
+    ClientErrorResponse[ClientErrorResponse["BadRequest"] = 400] = "BadRequest";
+    ClientErrorResponse[ClientErrorResponse["Unauthorized"] = 401] = "Unauthorized";
+    ClientErrorResponse[ClientErrorResponse["PaymentRequired"] = 402] = "PaymentRequired";
+    ClientErrorResponse[ClientErrorResponse["Forbidden"] = 403] = "Forbidden";
+    ClientErrorResponse[ClientErrorResponse["NotFound"] = 404] = "NotFound";
+    ClientErrorResponse[ClientErrorResponse["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+    ClientErrorResponse[ClientErrorResponse["NotAcceptable"] = 406] = "NotAcceptable";
+    ClientErrorResponse[ClientErrorResponse["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+    ClientErrorResponse[ClientErrorResponse["RequestTimeout"] = 408] = "RequestTimeout";
+    ClientErrorResponse[ClientErrorResponse["Conflict"] = 409] = "Conflict";
+    ClientErrorResponse[ClientErrorResponse["Gone"] = 410] = "Gone";
+    ClientErrorResponse[ClientErrorResponse["LengthRequired"] = 411] = "LengthRequired";
+    ClientErrorResponse[ClientErrorResponse["PreconditionFailed"] = 412] = "PreconditionFailed";
+    ClientErrorResponse[ClientErrorResponse["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+    ClientErrorResponse[ClientErrorResponse["URITooLong"] = 414] = "URITooLong";
+    ClientErrorResponse[ClientErrorResponse["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+    ClientErrorResponse[ClientErrorResponse["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+    ClientErrorResponse[ClientErrorResponse["ExpectationFailed"] = 417] = "ExpectationFailed";
+    ClientErrorResponse[ClientErrorResponse["ImATeapot"] = 418] = "ImATeapot";
+    ClientErrorResponse[ClientErrorResponse["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+    ClientErrorResponse[ClientErrorResponse["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+    ClientErrorResponse[ClientErrorResponse["Locked"] = 423] = "Locked";
+    ClientErrorResponse[ClientErrorResponse["FailedDependency"] = 424] = "FailedDependency";
+    ClientErrorResponse[ClientErrorResponse["TooEarly"] = 425] = "TooEarly";
+    ClientErrorResponse[ClientErrorResponse["UpgradeRequired"] = 426] = "UpgradeRequired";
+    ClientErrorResponse[ClientErrorResponse["PreconditionRequired"] = 428] = "PreconditionRequired";
+    ClientErrorResponse[ClientErrorResponse["TooManyRequests"] = 429] = "TooManyRequests";
+    ClientErrorResponse[ClientErrorResponse["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+    ClientErrorResponse[ClientErrorResponse["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+})(ClientErrorResponse || (ClientErrorResponse = {}));
+var ServerErrorResponse;
+(function (ServerErrorResponse) {
+    ServerErrorResponse[ServerErrorResponse["InternalServerError"] = 500] = "InternalServerError";
+    ServerErrorResponse[ServerErrorResponse["NotImplemented"] = 501] = "NotImplemented";
+    ServerErrorResponse[ServerErrorResponse["BadGateway"] = 502] = "BadGateway";
+    ServerErrorResponse[ServerErrorResponse["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    ServerErrorResponse[ServerErrorResponse["GatewayTimeout"] = 504] = "GatewayTimeout";
+    ServerErrorResponse[ServerErrorResponse["HTTPVersionNotSupported"] = 505] = "HTTPVersionNotSupported";
+    ServerErrorResponse[ServerErrorResponse["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+    ServerErrorResponse[ServerErrorResponse["InsufficientStorage"] = 507] = "InsufficientStorage";
+    ServerErrorResponse[ServerErrorResponse["LoopDetected"] = 508] = "LoopDetected";
+    ServerErrorResponse[ServerErrorResponse["NotExtended"] = 510] = "NotExtended";
+    ServerErrorResponse[ServerErrorResponse["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+})(ServerErrorResponse || (ServerErrorResponse = {}));
+const HttpStatusErrorCode = { ...InformationResponse, ...SuccessfulResponse, ...RedirectionMessage, ...ClientErrorResponse, ...ServerErrorResponse };
+const StatusCode = { ...HttpStatusErrorCode };
+export { StatusCode };

package/{index.d.ts → lib/esm/index.mjs}

@@ -1,7 +1,8 @@
-export * from "./application";
-export * from "./console";
-export * from "./container-module";
-export * from "./controller";
-export * from "./environment";
-export * from "./error";
-export * from "./logger";
+export * from "./application";
+export * from "./common";
+export * from "./console";
+export * from "./container-module";
+export * from "./controller";
+export * from "./environment";
+export * from "./error";
+export * from "./logger";