@expressots/core 1.0.0

package/README.md

@@ -0,0 +1,153 @@
+<p align="center">
+  <a href="https://expresso-ts.com/" target="blank"><img src="https://github.com/expressots/expressots/blob/main/media/alogo.png" width="120" alt="Expresso TS Logo" /></a>
+</p>
+
+# Expresso TS
+
+A Typescript + [Node.js]("https://nodejs.org/en/") lightweight framework for quick building scalable, easy to read and maintain, server-side applications 🚀
+
+## Philosophy
+
+Expresso TS is a framework designed to make the lives of the developers easier by providing a structure for building server-side applications that is clear to read, maintain and scale. The philosophy is centered around the idea that developers should not have to waste time on repetitive tasks such as setting up a logging system, authentication, error handling, database connection, and organizing the project for better maintainability.
+
+Expresso TS offers a solution that is designed to help developers jump ahead and focus on the most important part of the development process, writing code. The framework provides capability to the developers to quickly extend the framework functionalities by creating providers and adding them to the dependency injection system. This way, developers can use these new functionalities throughout the entire application without having to worry about the complexities of integrating it into the system.
+
+## The Project Structure
+
+### Clean code using solid principles with Nodejs and Typescript
+
+The idea of this project is to offer a clean and concise architecture boilerplate for those trying to navigate on node development.
+
+It respects the fundamentals of clean code and some of the SOLID concepts. This boilerplate has my own flavour, which means that I don't follow follow strictly all the concepts, I rather customize to my own needs. I tried to extract the best practices of the 5 main principles:
+
+-   **_S_**: Single responsibility
+-   **_O_**: Open-Close
+-   **_L_**: Liskov substitution
+-   **_I_**: Interface segregation
+-   **_D_**: Dependency inversion
+
+`Reference:` [Uncle Bob article](http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod)
+
+> ![Clean Architecture](https://github.com/rsaz/cleanArchitecture01/blob/main/media/CleanArchitecture.jpg)
+
+-   **_Entities_**: class definitions, or models with their attributes, properties and methods.
+-   **_Providers_**: is the layer responsible to provide externals resources such as database, email services. Everything external to the application.
+-   **_Repositories_**: is the layer responsible to communicate with the database.
+-   **_Use Cases_**: use cases represents the implementation of an operation that can be performed in the system
+
+## Key Features
+
+-   Module mapping (tsconfig-paths) : Entity, Provider, Use case, repository, controller examples
+-   IOC (Inversion of control): Dependency Injection with InversifyJS
+-   API Decorators: HttpGet, HttpPost, HttpPut, HttpDelete, HttpPatch, HttpOptions, HttpHead
+-   Error handling
+-   API Logger : Morgan
+-   Application General Logger: Winston
+-   App container and module creation
+
+## Feature Details
+
+-   **Module Mapping**: Using the tsconfig-paths module, we are mapping the entities, providers, repositories, use cases folders, so that we can import them using relative paths. This allows us to create a project structure that is configured using a development pattern.
+
+```json
+"paths": {
+      "@entities/*": ["entities/*"],
+      "@providers/*": ["providers/*"],
+      "@repositories/*": ["repositories/*"],
+      "@useCases/*": ["useCases/*"],
+    },
+```
+
+-   **IOC**: Using InversifyJS we are creating the IoC container and registering all the dependencies. The project contains AppContainer class to register the modules, and a mechanism to create modules in which controllers can bind to it.
+
+AppContainer for registering the modules:
+
+```typescript
+const container = new Container();
+
+container.load(buildProviderModule(), UserContainerModule);
+
+export { container };
+```
+
+Creating the modules and registering the controllers:
+
+```typescript
+export const UserContainerModule = CreateModule([
+    CreateUserController,
+    DeleteUserController,
+    FindByIdController,
+    UpdateUserController,
+    FindAllUsersController,
+]);
+```
+
+-   **API Decorators**: Using the decorators we are creating the endpoints for the controllers.
+
+```typescript
+@controller('/user/create')
+   @httpPost('/')
+```
+
+-   **Entity, Provider, Use case, repository, controller examples**: Folders organization for the clean architecture.
+
+-   **Error handling**: Using `Report.Error()` we can report errors using predefined error codes. This is useful when we want to report known errors to the client. Inside of `Report.Error()` there is a try catch block encapsulating the error.
+
+```typescript
+type ErrorType = GeneralErrorCode | ApplicationErrorCode | HttpStatusErrorCode;
+
+// Reporting errors
+if (userExist) {
+    const error = Report.Error(new ApplicationError(StatusCode.BadRequest, "User already exist!"), "user-create");
+    return error;
+}
+```
+
+-   **API Request Logger**: Morgan is a logger for nodejs. It is a middleware that logs the requests and responses in a file.
+
+```Text
+[localhost ::ffff:127.0.0.1]-[2023-02-02 17:2:16]-[pid: 48644] POST /user/create 151 - 0.007 ms - -
+```
+
+-   **Application General Logger**: Winston is a logger for nodejs. It is a middleware that logs all the other exceptions in a file.
+
+```Text
+[2023-02-01 20:27:58] [core-api] [user-create] error: User already exist! - (Error) [file:  CreateUserUseCase.<anonymous> (<app_path>\src\useCases\user\create\CreateUser.UseCase.ts:31:50)]
+```
+
+How To Log:
+
+```typescript
+Log(LogLevel.Error, error, this.serviceName);
+```
+
+-   LogLevel: enum with the following values: Debug, Error, Info
+-   error: Error object
+-   serviceName: is the name of the service that is generating the error
+
+## Getting Started
+
+To get started with Expresso TS, simply clone the repository and follow the below steps
+
+```
+1. run `yarn install` to install all dependencies
+2. run `yarn start` to start the project
+
+3. run the docker-compose file to create the mongodb container
+4. create the user and password in mongodb and apply management rights
+5. add the user and password to the .env file
+```
+
+## Documentation
+
+To be developed
+
+## Contributing Guide
+
+```
+1. Clone it to your local
+2. Contribute to it
+3. Push it to your remote repo
+4. Send a PR to the main repo with your branch
+5. Your contribution will be evaluated then we will merge your changes with the original repository.
+```

package/application/app-container.d.ts

@@ -0,0 +1,7 @@
+import { Container, ContainerModule } from "inversify";
+declare class AppContainer {
+    private container;
+    constructor();
+    create(modules: ContainerModule[]): Container;
+}
+export { AppContainer };

package/application/app-container.js

@@ -0,0 +1,20 @@
+"use strict";
+var AppContainer_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppContainer = void 0;
+const tslib_1 = require("tslib");
+const inversify_1 = require("inversify");
+const inversify_binding_decorators_1 = require("inversify-binding-decorators");
+let AppContainer = AppContainer_1 = class AppContainer {
+    constructor() { }
+    create(modules) {
+        this.container = new inversify_1.Container();
+        this.container.load((0, inversify_binding_decorators_1.buildProviderModule)(), ...modules);
+        return this.container;
+    }
+};
+AppContainer = AppContainer_1 = tslib_1.__decorate([
+    (0, inversify_binding_decorators_1.provide)(AppContainer_1),
+    tslib_1.__metadata("design:paramtypes", [])
+], AppContainer);
+exports.AppContainer = AppContainer;

package/application/application.d.ts

@@ -0,0 +1,21 @@
+import express from "express";
+import { Container } from "inversify";
+import { IApplicationMessageToConsole } from "../console/console";
+declare enum ServerEnvironment {
+    Development = "development",
+    Staging = "staging",
+    Production = "production"
+}
+declare class Application {
+    private app;
+    private port;
+    private environment;
+    constructor();
+    protected configureServices(): void;
+    protected postServerInitialization(): void;
+    protected serverShutdown(): void;
+    create(container: Container, middlewares?: express.RequestHandler[]): Application;
+    listen(port: number, environment: ServerEnvironment, consoleMessage?: IApplicationMessageToConsole): void;
+}
+declare const appServerInstance: Application;
+export { appServerInstance as AppInstance, Application, ServerEnvironment };

package/application/application.js

@@ -0,0 +1,62 @@
+"use strict";
+var Application_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerEnvironment = exports.Application = exports.AppInstance = void 0;
+const tslib_1 = require("tslib");
+const express_1 = tslib_1.__importDefault(require("express"));
+const inversify_binding_decorators_1 = require("inversify-binding-decorators");
+const inversify_express_utils_1 = require("inversify-express-utils");
+const process_1 = tslib_1.__importDefault(require("process"));
+const console_1 = require("../console/console");
+const error_handler_middleware_1 = tslib_1.__importDefault(require("../error/error-handler-middleware"));
+var ServerEnvironment;
+(function (ServerEnvironment) {
+    ServerEnvironment["Development"] = "development";
+    ServerEnvironment["Staging"] = "staging";
+    ServerEnvironment["Production"] = "production";
+})(ServerEnvironment || (ServerEnvironment = {}));
+exports.ServerEnvironment = ServerEnvironment;
+let Application = Application_1 = class Application {
+    constructor() { }
+    /* Add any service that you want to be initialized before the server starts */
+    configureServices() { }
+    /* Add any service that you want to execute after the server starts */
+    postServerInitialization() { }
+    /* Add any service that you want to execute after server is shutdown */
+    serverShutdown() {
+        process_1.default.exit(0);
+    }
+    create(container, middlewares = []) {
+        this.configureServices();
+        const expressServer = new inversify_express_utils_1.InversifyExpressServer(container);
+        expressServer.setConfig((app) => {
+            /* Default body parser application/json */
+            app.use(express_1.default.json());
+            /* Default body parser application/x-www-form-urlencoded */
+            app.use(express_1.default.urlencoded({ extended: true }));
+            middlewares.forEach(middleware => {
+                app.use(middleware);
+            });
+        });
+        this.app = expressServer.build();
+        /* Add the error handler middleware */
+        this.app.use(error_handler_middleware_1.default);
+        return this;
+    }
+    listen(port, environment, consoleMessage) {
+        this.port = port;
+        this.environment = environment;
+        this.app.listen(this.port, () => {
+            new console_1.Console().messageServer(this.port, this.environment, consoleMessage);
+            process_1.default.on("SIGINT", this.serverShutdown.bind(this));
+        });
+        this.postServerInitialization();
+    }
+};
+Application = Application_1 = tslib_1.__decorate([
+    (0, inversify_binding_decorators_1.provide)(Application_1),
+    tslib_1.__metadata("design:paramtypes", [])
+], Application);
+exports.Application = Application;
+const appServerInstance = new Application();
+exports.AppInstance = appServerInstance;

package/application/index.d.ts

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

package/application/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppContainer = exports.ServerEnvironment = exports.Application = exports.AppInstance = void 0;
+var application_1 = require("./application");
+Object.defineProperty(exports, "AppInstance", { enumerable: true, get: function () { return application_1.AppInstance; } });
+Object.defineProperty(exports, "Application", { enumerable: true, get: function () { return application_1.Application; } });
+Object.defineProperty(exports, "ServerEnvironment", { enumerable: true, get: function () { return application_1.ServerEnvironment; } });
+var app_container_1 = require("./app-container");
+Object.defineProperty(exports, "AppContainer", { enumerable: true, get: function () { return app_container_1.AppContainer; } });

package/console/console.d.ts

@@ -0,0 +1,9 @@
+interface IApplicationMessageToConsole {
+    appName: string;
+    appVersion: string;
+}
+declare class Console {
+    private printColor;
+    messageServer(port: any, environment: string, consoleMessage?: IApplicationMessageToConsole): Promise<void>;
+}
+export { Console, IApplicationMessageToConsole };

package/console/console.js

@@ -0,0 +1,56 @@
+"use strict";
+var Console_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Console = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const inversify_binding_decorators_1 = require("inversify-binding-decorators");
+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 = {}));
+let Console = Console_1 = class Console {
+    async printColor(message, colorStyle) {
+        switch (colorStyle) {
+            case ColorStyle.Yellow:
+                return console.log(chalk_1.default.bgYellow.black(message));
+            case ColorStyle.Blue:
+                return console.log(chalk_1.default.bgBlue.black(message));
+            case ColorStyle.Green:
+                return console.log(chalk_1.default.bgGreen.black(message));
+            case ColorStyle.Red:
+                return console.log(chalk_1.default.bgRed.black(message));
+        }
+    }
+    async messageServer(port, environment, consoleMessage) {
+        const appConsoleMessage = {
+            appName: (consoleMessage === null || consoleMessage === void 0 ? void 0 : consoleMessage.appName) || "Application",
+            appVersion: (consoleMessage === null || consoleMessage === void 0 ? void 0 : 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 = tslib_1.__decorate([
+    (0, inversify_binding_decorators_1.provide)(Console_1)
+], Console);
+exports.Console = Console;

package/console/index.d.ts

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

package/console/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Console = void 0;
+var console_1 = require("./console");
+Object.defineProperty(exports, "Console", { enumerable: true, get: function () { return console_1.Console; } });

package/container-module/container-module.d.ts

@@ -0,0 +1,8 @@
+import { ContainerModule } from "inversify";
+declare class BaseModule {
+    constructor();
+    private static createSymbols;
+    static createContainerModule(controllers: any[]): ContainerModule;
+}
+declare const CreateModule: typeof BaseModule.createContainerModule;
+export { CreateModule };

package/container-module/container-module.js

@@ -0,0 +1,34 @@
+"use strict";
+var BaseModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateModule = void 0;
+const tslib_1 = require("tslib");
+const inversify_1 = require("inversify");
+const inversify_binding_decorators_1 = require("inversify-binding-decorators");
+let BaseModule = BaseModule_1 = class BaseModule {
+    constructor() { }
+    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;
+    }
+    static createContainerModule(controllers) {
+        const symbols = BaseModule_1.createSymbols(controllers);
+        return new inversify_1.ContainerModule(bind => {
+            for (const symbol of symbols) {
+                const target = symbol.valueOf();
+                bind(target[0]).to(target[1]);
+            }
+        });
+    }
+};
+BaseModule = BaseModule_1 = tslib_1.__decorate([
+    (0, inversify_binding_decorators_1.provide)(BaseModule_1),
+    tslib_1.__metadata("design:paramtypes", [])
+], BaseModule);
+const CreateModule = BaseModule.createContainerModule;
+exports.CreateModule = CreateModule;

package/container-module/index.d.ts

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

package/container-module/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateModule = void 0;
+var container_module_1 = require("./container-module");
+Object.defineProperty(exports, "CreateModule", { enumerable: true, get: function () { return container_module_1.CreateModule; } });

package/controller/base-controller.d.ts

@@ -0,0 +1,8 @@
+import { interfaces } from 'inversify-express-utils';
+declare abstract class BaseController implements interfaces.Controller {
+    private serviceName;
+    constructor(serviceName: string);
+    protected callUseCaseAsync(useCase: Promise<any>, res: any, successStatusCode: number): Promise<any>;
+    protected callUseCase(useCase: any, res: any, successStatusCode: number): any;
+}
+export { BaseController };

package/controller/base-controller.js

@@ -0,0 +1,37 @@
+"use strict";
+var BaseController_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseController = void 0;
+const tslib_1 = require("tslib");
+const inversify_binding_decorators_1 = require("inversify-binding-decorators");
+const error_1 = require("../error");
+let BaseController = BaseController_1 = class BaseController {
+    constructor(serviceName) {
+        this.serviceName = serviceName;
+    }
+    async callUseCaseAsync(useCase, res, successStatusCode) {
+        let dataReturn;
+        try {
+            dataReturn = await useCase;
+            return res.status(successStatusCode).json(dataReturn);
+        }
+        catch (error) {
+            error_1.Report.Error(error);
+        }
+    }
+    callUseCase(useCase, res, successStatusCode) {
+        let dataReturn;
+        try {
+            dataReturn = useCase;
+            return res.status(successStatusCode).json(dataReturn);
+        }
+        catch (error) {
+            error_1.Report.Error(error);
+        }
+    }
+};
+BaseController = BaseController_1 = tslib_1.__decorate([
+    (0, inversify_binding_decorators_1.provide)(BaseController_1),
+    tslib_1.__metadata("design:paramtypes", [String])
+], BaseController);
+exports.BaseController = BaseController;

package/controller/index.d.ts

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

package/controller/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseController = void 0;
+var base_controller_1 = require("./base-controller");
+Object.defineProperty(exports, "BaseController", { enumerable: true, get: function () { return base_controller_1.BaseController; } });

package/environment/env-validator.d.ts

@@ -0,0 +1,12 @@
+declare class EnvValidatorProvider {
+    static get(key: string, defaultValue?: any): any;
+    static checkAll(): void;
+}
+declare global {
+    interface String {
+        AsBoolean(): boolean | undefined;
+        AsNumber(): number | undefined;
+        AsString(): string | undefined;
+    }
+}
+export { EnvValidatorProvider as Environments };

package/environment/env-validator.js

@@ -0,0 +1,64 @@
+"use strict";
+var EnvValidatorProvider_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environments = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const dotenv_1 = tslib_1.__importDefault(require("dotenv"));
+const inversify_binding_decorators_1 = require("inversify-binding-decorators");
+const logger_1 = require("../logger");
+let EnvValidatorProvider = EnvValidatorProvider_1 = class EnvValidatorProvider {
+    static get(key, defaultValue = undefined) {
+        var _a;
+        return (_a = process.env[key]) !== null && _a !== void 0 ? _a : defaultValue;
+    }
+    static checkAll() {
+        /* Load .env file */
+        dotenv_1.default.config();
+        /* Verify if .env file exists */
+        const envFilePath = path_1.default.join(process.cwd(), ".", ".env");
+        if (!fs_1.default.existsSync(envFilePath)) {
+            (0, logger_1.log)(logger_1.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] === "") {
+                (0, logger_1.log)(logger_1.LogLevel.Info, `Environment variable ${key} is not defined.`, "env-validator-provider");
+                hasError = true;
+            }
+        }
+        if (hasError) {
+            process.exit(1);
+        }
+    }
+};
+EnvValidatorProvider = EnvValidatorProvider_1 = tslib_1.__decorate([
+    (0, inversify_binding_decorators_1.provide)(EnvValidatorProvider_1)
+], EnvValidatorProvider);
+exports.Environments = 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);
+};

package/environment/index.d.ts

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

package/environment/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environments = void 0;
+var env_validator_1 = require("./env-validator");
+Object.defineProperty(exports, "Environments", { enumerable: true, get: function () { return env_validator_1.Environments; } });

package/error/application-error.d.ts

@@ -0,0 +1,6 @@
+declare class AppError extends Error {
+    statusCode: number;
+    service: string;
+    constructor(statusCode: number, message: string, service?: string);
+}
+export { AppError };

package/error/application-error.js

@@ -0,0 +1,18 @@
+"use strict";
+var AppError_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppError = void 0;
+const tslib_1 = require("tslib");
+const inversify_binding_decorators_1 = require("inversify-binding-decorators");
+let AppError = AppError_1 = class AppError extends Error {
+    constructor(statusCode, message, service) {
+        super(message);
+        this.statusCode = statusCode;
+        this.service = service;
+    }
+};
+AppError = AppError_1 = tslib_1.__decorate([
+    (0, inversify_binding_decorators_1.provide)(AppError_1),
+    tslib_1.__metadata("design:paramtypes", [Number, String, String])
+], AppError);
+exports.AppError = AppError;

package/error/error-handler-middleware.d.ts

@@ -0,0 +1,4 @@
+import { NextFunction, Request, Response } from "express";
+import { AppError } from "./application-error";
+declare function errorHandler(error: AppError, req: Request, res: Response, next: NextFunction): void;
+export default errorHandler;

package/error/error-handler-middleware.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const status_code_1 = require("./status-code");
+const logger_1 = require("../logger");
+function errorHandler(error, req, res, next) {
+    (0, logger_1.log)(logger_1.LogLevel.Error, error, error.service || "service-undefined");
+    res.status(error.statusCode || status_code_1.StatusCode.InternalServerError).json({ statusCode: error.statusCode, error: error.message });
+}
+exports.default = errorHandler;

package/error/index.d.ts

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

package/error/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Report = exports.AppError = exports.StatusCode = void 0;
+var status_code_1 = require("./status-code");
+Object.defineProperty(exports, "StatusCode", { enumerable: true, get: function () { return status_code_1.StatusCode; } });
+var application_error_1 = require("./application-error");
+Object.defineProperty(exports, "AppError", { enumerable: true, get: function () { return application_error_1.AppError; } });
+var report_1 = require("./report");
+Object.defineProperty(exports, "Report", { enumerable: true, get: function () { return report_1.Report; } });

package/error/report.d.ts

@@ -0,0 +1,5 @@
+import { AppError } from "./application-error";
+declare class Report {
+    static Error(error: AppError): void;
+}
+export { Report };

package/error/report.js

@@ -0,0 +1,15 @@
+"use strict";
+var Report_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Report = void 0;
+const tslib_1 = require("tslib");
+const inversify_binding_decorators_1 = require("inversify-binding-decorators");
+let Report = Report_1 = class Report {
+    static Error(error) {
+        throw error;
+    }
+};
+Report = Report_1 = tslib_1.__decorate([
+    (0, inversify_binding_decorators_1.provide)(Report_1)
+], Report);
+exports.Report = Report;

package/error/status-code.d.ts

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

package/error/status-code.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusCode = void 0;
+/* 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 = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, InformationResponse), SuccessfulResponse), RedirectionMessage), ClientErrorResponse), ServerErrorResponse);
+const StatusCode = Object.assign({}, HttpStatusErrorCode);
+exports.StatusCode = StatusCode;

package/index.d.ts

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

package/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./application"), exports);
+tslib_1.__exportStar(require("./console"), exports);
+tslib_1.__exportStar(require("./container-module"), exports);
+tslib_1.__exportStar(require("./controller"), exports);
+tslib_1.__exportStar(require("./environment"), exports);
+tslib_1.__exportStar(require("./error"), exports);
+tslib_1.__exportStar(require("./logger"), exports);

package/logger/general-logger.d.ts

@@ -0,0 +1,16 @@
+declare enum LogLevel {
+    Debug = 0,
+    Error = 1,
+    Info = 2
+}
+declare class GeneralLogger {
+    private logger;
+    constructor();
+    private createConsoleTransport;
+    private createRotationalFileTransport;
+    private createLoggerOptions;
+    private getPathAndLine;
+    log(logLevel: LogLevel, content: Error | string, service?: string): void;
+}
+declare const log: any;
+export { LogLevel, GeneralLogger, log };

package/logger/general-logger.js

@@ -0,0 +1,92 @@
+"use strict";
+var GeneralLogger_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.GeneralLogger = exports.LogLevel = void 0;
+const tslib_1 = require("tslib");
+const winston_1 = require("winston");
+const winston_daily_rotate_file_1 = tslib_1.__importDefault(require("winston-daily-rotate-file"));
+const inversify_binding_decorators_1 = require("inversify-binding-decorators");
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["Debug"] = 0] = "Debug";
+    LogLevel[LogLevel["Error"] = 1] = "Error";
+    LogLevel[LogLevel["Info"] = 2] = "Info";
+})(LogLevel || (LogLevel = {}));
+exports.LogLevel = LogLevel;
+let GeneralLogger = GeneralLogger_1 = class GeneralLogger {
+    constructor() {
+        this.logger = (0, winston_1.createLogger)(this.createLoggerOptions());
+    }
+    createConsoleTransport() {
+        const consoleTransport = new winston_1.transports.Console({
+            level: "debug",
+            handleExceptions: true,
+            handleRejections: true
+        });
+        return consoleTransport;
+    }
+    createRotationalFileTransport() {
+        const rotationalFileTransport = new winston_daily_rotate_file_1.default({
+            level: "error",
+            filename: "logs/general-%DATE%.log",
+            datePattern: "YYYY-MM-DD",
+            zippedArchive: true,
+            maxSize: "20m",
+            maxFiles: "7d",
+            silent: false
+        });
+        return rotationalFileTransport;
+    }
+    createLoggerOptions() {
+        const loggerOptions = {
+            transports: [
+                this.createConsoleTransport(),
+                this.createRotationalFileTransport()
+            ],
+            defaultMeta: { service: "service-unknown" },
+            format: winston_1.format.combine(winston_1.format.splat(), winston_1.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), winston_1.format.label({ label: "core-api" }), winston_1.format.printf(({ timestamp, level, message, service, label }) => {
+                return `[${timestamp}] [${label}] [${service}] ${level}: ${message}`;
+            }))
+        };
+        return loggerOptions;
+    }
+    getPathAndLine(error) {
+        let pathLine = "";
+        if (error.stack) {
+            let callerLine = error.stack.split("\n")[1];
+            let index = callerLine.indexOf("at ");
+            pathLine = callerLine.substring(index + +2, callerLine.length);
+        }
+        return pathLine;
+    }
+    log(logLevel, content, service) {
+        let pathLine = "";
+        let logMessageFormat = "";
+        if (typeof content === "object") {
+            pathLine = this.getPathAndLine(content);
+            logMessageFormat = `${content.message} - (${content.name}) [file: %s]`;
+        }
+        else {
+            logMessageFormat = content;
+        }
+        switch (logLevel) {
+            case LogLevel.Debug:
+                console.log(logMessageFormat, pathLine, { service });
+                break;
+            case LogLevel.Error:
+                this.logger.error(logMessageFormat, pathLine, { service });
+                break;
+            case LogLevel.Info:
+                this.logger.info(content, { service });
+                break;
+        }
+    }
+};
+GeneralLogger = GeneralLogger_1 = tslib_1.__decorate([
+    (0, inversify_binding_decorators_1.provide)(GeneralLogger_1),
+    tslib_1.__metadata("design:paramtypes", [])
+], GeneralLogger);
+exports.GeneralLogger = GeneralLogger;
+const Log = new GeneralLogger();
+const log = Log.log.bind(Log);
+exports.log = log;

package/logger/index.d.ts

@@ -0,0 +1 @@
+export { GeneralLogger, LogLevel, log } from './general-logger';

package/logger/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.LogLevel = exports.GeneralLogger = void 0;
+var general_logger_1 = require("./general-logger");
+Object.defineProperty(exports, "GeneralLogger", { enumerable: true, get: function () { return general_logger_1.GeneralLogger; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return general_logger_1.LogLevel; } });
+Object.defineProperty(exports, "log", { enumerable: true, get: function () { return general_logger_1.log; } });

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@expressots/core",
+  "version": "1.0.0",
+  "description": "Expressots - modern, fast, lightweight nodejs web framework (@core)",
+  "author": "Richard Zampieri",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "homepage": "https://expresso-ts.com",
+  "funding": {
+    "type": "",
+    "url": ""
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/expressots/expressots"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.10.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "postbuild": "xcopy \"package.json\" \"dist\" /y && xcopy \"README.md\" \"dist\" /y",
+    "release": "npm run build && npm run postbuild",
+    "test": "jest"
+  },
+  "keywords": [],
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "dotenv": "^16.0.3",
+    "express": "^4.18.2",
+    "inversify": "^6.0.1",
+    "inversify-binding-decorators": "^4.0.0",
+    "inversify-express-utils": "^6.3.2",
+    "reflect-metadata": "^0.1.13",
+    "typescript": "^4.9.5",
+    "winston": "^3.8.1",
+    "winston-daily-rotate-file": "^4.7.1"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "@types/jest": "^29.4.0",
+    "jest": "^29.4.2",
+    "ts-jest": "^29.0.5",
+    "ts-node-dev": "^2.0.0"
+  }
+}