opticore-webapp 1.0.0

package/src/core/events/errors/serverListen.event.error.ts

@@ -0,0 +1,421 @@
+import process from "process";
+import colors from "ansi-colors";
+import express from "express";
+import chalk from "chalk";
+import StackTraceError from "@webApp/core/handlers/errors/base/stackTraceError";
+import {HttpStatusCodesConstant as status} from "@webApp/domains/constants/httpStatusCodes.constant";
+import {LogMessageUtils} from "@webApp/core/utils/logMessage.utils";
+import {dateTimeFormattedUtils as currentDate} from "@webApp/core/utils/dateTimeFormatted.utils";
+import {messageException as msg} from "@webApp/application/exceptions/messages.exception";
+import {CEventNameError as eventName} from "@webApp/domains/constants/eventNameError.constant";
+
+
+export class ServerListenEventError {
+    static hostPortUndefined(): void {
+        const stackTrace: StackTraceError = this.traceError(msg.errorHostUrl, msg.listening, status.BAD_REQUEST);
+        LogMessageUtils.error(
+            msg.webServer,
+            msg.badHost,
+            stackTrace.stack!,
+            msg.errorHostUrl,
+            status.BAD_REQUEST
+        );
+        process.exit();
+    }
+    static hostUndefined(): void {
+        const stackTrace: StackTraceError = this.traceError(msg.badHost, msg.listening, status.BAD_REQUEST);
+        LogMessageUtils.error(
+            msg.webServer,
+            msg.badHost,
+            stackTrace.stack!,
+            msg.errorHost,
+            status.BAD_REQUEST
+        );
+        process.exit();
+    }
+    static portUndefined(): void {
+        const stackTrace: StackTraceError = this.traceError(msg.badPort, msg.listening, status.BAD_REQUEST);
+        LogMessageUtils.error(
+            msg.webServer,
+            msg.badPort,
+            stackTrace.stack!,
+            msg.errorPort,
+            status.BAD_REQUEST
+        );
+        process.exit();
+    }
+    static onEventError(err: Error): void {
+        LogMessageUtils.error(
+            "Server start error",
+            "Error",
+            err.stack,
+            err.message,
+            status.SERVICE_UNAVAILABLE
+        );
+    }
+    static listenerError(error: Error): void {
+        const stackTrace: StackTraceError = this.traceError(
+            error.message,
+            error.name,
+            status.BAD_REQUEST
+        );
+
+        LogMessageUtils.error(
+            "Event error",
+            "Error",
+            error.stack!,
+            stackTrace.message,
+            status.SERVICE_UNAVAILABLE
+        );
+    }
+    static processBeforeExit(code: number): void {
+        const stackTrace: StackTraceError = this.traceError(
+            `Process will exit with code: ${code}`,
+            "BeforeExit",
+            status.SERVICE_UNAVAILABLE
+        );
+        LogMessageUtils.error(
+            "BeforeExit",
+            "process before exit",
+            stackTrace.stack,
+            `Process will exit with code: ${code}`,
+            status.SERVICE_UNAVAILABLE
+        );
+        process.exit(code);
+    }
+    static processDisconnected(): void {
+        const stackTrace: StackTraceError = this.traceError(
+            "Child process disconnected",
+            "process disconnected",
+            status.SERVICE_UNAVAILABLE
+        );
+        LogMessageUtils.error(
+            "Disconnected",
+            "process disconnected",
+            stackTrace.stack,
+            "Child process disconnected",
+            status.SERVICE_UNAVAILABLE
+        );
+        process.exit();
+    }
+    static exited(code: number){
+        switch (code) {
+            case 0:
+                LogMessageUtils.success(
+                    "Exited",
+                    "completed",
+                    "The process finished as expected and everything is ok"
+                );
+                console.log("");
+                const paddingLength: number = 35;
+                const msg0: string = ' '.padEnd(paddingLength, ' ');
+                console.log(chalk.bgGreen.white(msg0.padEnd(paddingLength, ' ')));
+                console.log(`${colors.bgGreen(` [OK] The server shutting down     `)}`);
+                console.log(chalk.bgGreen.white(msg0.padEnd(paddingLength, ' ')));
+                break;
+            case 1:
+                const gnleStackTrace: StackTraceError = this.traceError(
+                    "Something went wrong",
+                    "General Errors",
+                    status.SERVICE_UNAVAILABLE
+                );
+                LogMessageUtils.error(
+                    "Exited",
+                    "General Errors",
+                    gnleStackTrace.stack,
+                    "Something went wrong",
+                    status.SERVICE_UNAVAILABLE
+                );
+                break
+            case 2:
+                const incrCmdStackTrace: StackTraceError = this.traceError(
+                    "Incorrect using of shell commands",
+                    "Misuse of shell builtins",
+                    status.SERVICE_UNAVAILABLE
+                );
+                LogMessageUtils.error(
+                    "Exited",
+                    incrCmdStackTrace.name,
+                    incrCmdStackTrace.stack,
+                    "Incorrect using of shell commands",
+                    status.SERVICE_UNAVAILABLE
+                );
+                break;
+            case 126:
+                const notExeCmdStackTrace: StackTraceError = this.traceError(
+                    "Incorrect using of shell commands",
+                    "Misuse of shell builtins",
+                    status.SERVICE_UNAVAILABLE
+                );
+                LogMessageUtils.error(
+                    "Exited",
+                    `command invoked`,
+                    notExeCmdStackTrace.stack,
+                    "The command is found but is not executable (e.g., trying to execute a directory)",
+                    status.SERVICE_UNAVAILABLE
+                );
+                break
+            case 127:
+                const cmdNotFoundStackTrace: StackTraceError = this.traceError(
+                    "The command was not found in the system's PATH or is misspelled",
+                    "Exited",
+                    status.SERVICE_UNAVAILABLE
+                );
+                LogMessageUtils.error(
+                    "Exited",
+                    "Command not found",
+                    cmdNotFoundStackTrace.stack,
+                    "The command was not found in the system's PATH or is misspelled",
+                    status.SERVICE_UNAVAILABLE
+                );
+                break;
+            case 128:
+                const cmdSysNotFoundStackTrace: StackTraceError = this.traceError(
+                    "The command was not found in the system's PATH or is misspelled",
+                    "Exited",
+                    status.SERVICE_UNAVAILABLE
+                );
+                LogMessageUtils.error(
+                    "Exited",
+                    "Invalid argument",
+                    cmdSysNotFoundStackTrace.stack,
+                    "The command was not found in the system's PATH or is misspelled",
+                    status.SERVICE_UNAVAILABLE
+                );
+                break;
+            case 130:
+                const endScriptStackTrace: StackTraceError = this.traceError(
+                    "Indicates that the script was manually terminated by the user using the Control-C (SIGINT) signal",
+                    "Exited",
+                    status.SERVICE_UNAVAILABLE
+                );
+                LogMessageUtils.error(
+                    "Exited",
+                    "Script terminated",
+                    endScriptStackTrace.stack,
+                    "Indicates that the script was manually terminated by the user using the Control-C (SIGINT) signal",
+                    status.SERVICE_UNAVAILABLE
+                );
+                break;
+            case 137:
+                const prcKillStackTrace: StackTraceError = this.traceError(
+                    "Indicates that the process was terminated by a SIGKILL signal, possibly due to an out-of-memory situation",
+                    "Exited",
+                    status.SERVICE_UNAVAILABLE
+                );
+                LogMessageUtils.error(
+                    "Exited",
+                    "SIGKILL",
+                    prcKillStackTrace.stack,
+                    "Indicates that the process was terminated by a SIGKILL signal, possibly due to an out-of-memory situation",
+                    status.SERVICE_UNAVAILABLE
+                );
+                break;
+            case 139:
+                const illegalAccessStackTrace: StackTraceError = this.traceError(
+                    "Indicates that the process accessed an illegal memory address (segfault)",
+                    "Exited",
+                    status.SERVICE_UNAVAILABLE
+                );
+                LogMessageUtils.error(
+                    "Exited",
+                    "Segmentation fault",
+                    illegalAccessStackTrace.stack,
+                    "Indicates that the process accessed an illegal memory address (segfault)",
+                    status.SERVICE_UNAVAILABLE
+                );
+                break;
+            case 143:
+                const sigtermStackTrace: StackTraceError = this.traceError(
+                    "Indicates that the process received a SIGTERM signal to terminate",
+                    "Exited",
+                    status.SERVICE_UNAVAILABLE
+                );
+                LogMessageUtils.error(
+                    "Exited",
+                    "process received a SIGTERM",
+                    sigtermStackTrace.stack,
+                    "Indicates that the process received a SIGTERM signal to terminate",
+                    status.SERVICE_UNAVAILABLE
+                );
+                break;
+            case 255:
+                const outsideStackTrace: StackTraceError = this.traceError(
+                    "An exit code that is outside the allowable range (0-255 for Unix-like systems)",
+                    "Exited",
+                    status.SERVICE_UNAVAILABLE
+                );
+                LogMessageUtils.error(
+                    "Exited",
+                    "out of range",
+                    outsideStackTrace.stack,
+                    "An exit code that is outside the allowable range (0-255 for Unix-like systems)",
+                    status.SERVICE_UNAVAILABLE
+                );
+                break;
+            default:
+                const globalStackTrace: StackTraceError = this.traceError(
+                    "Error is occurring",
+                    "Exited",
+                    status.SERVICE_UNAVAILABLE
+                );
+                LogMessageUtils.error(
+                    "Exited",
+                    "errors",
+                    globalStackTrace.stack,
+                    "Error is occurring",
+                    status.SERVICE_UNAVAILABLE
+                );
+                break;
+        }
+    }
+    static promiseRejectionHandled(promise: Promise<any>): void {
+        const globalStackTrace: StackTraceError = this.traceError(
+            `Promise rejection is handled at : ${promise}`,
+            "rejection promise",
+            status.SERVICE_UNAVAILABLE
+        );
+        LogMessageUtils.error(
+            "PromiseRejectionHandled",
+            "rejection promise",
+            globalStackTrace.stack,
+            `Promise rejection is handled at : ${promise}`,
+            status.SERVICE_UNAVAILABLE
+        );
+    }
+    static uncaughtException(error: any): void {
+        if (error.message === '\'app.router\' is deprecated!\nPlease see the 3.x to 4.x migration guide for details on how to update your app.') {
+            console.log("");
+        } else {
+            const tackTrace: StackTraceError = this.traceError(
+                error.message,
+                "uncaught exception handled",
+                status.SERVICE_UNAVAILABLE
+            );
+            LogMessageUtils.error(
+                "UncaughtException",
+                "uncaught exception handled",
+                tackTrace.stack,
+                error.message,
+                status.SERVICE_UNAVAILABLE
+            );
+        }
+    }
+    static uncaughtExceptionMonitor(error: any): void {
+        if (error.message === '\'app.router\' is deprecated!\nPlease see the 3.x to 4.x migration guide for details on how to update your app.') {
+            console.log("");
+        }
+    }
+    static unhandledRejection(reason: any, promise: Promise<any>): void{
+        const stackTrace: StackTraceError = this.traceError(
+            `Unhandled Rejection at: Promise ${promise} -- reason ${reason}`,
+            "Unhandled rejection",
+            status.SERVICE_UNAVAILABLE
+        );
+        LogMessageUtils.error(
+            "UnhandledRejection",
+            "Unhandled rejection",
+            stackTrace.stack,
+            `Unhandled Rejection at: Promise ${promise} -- reason ${reason}`,
+            status.SERVICE_UNAVAILABLE
+        );
+    }
+    static warning(warning: any): void {
+        const stackTrace: StackTraceError = this.traceError(warning.message, "warning", status.SERVICE_UNAVAILABLE);
+        LogMessageUtils.error(
+            "Warning",
+            "warning",
+            stackTrace.stack,
+            warning.message,
+            status.SERVICE_UNAVAILABLE
+        );
+    }
+    static message(message: any): void {
+        const stackTrace: StackTraceError = this.traceError(
+            `process got message ${message}`,
+            "message exception",
+            status.SERVICE_UNAVAILABLE
+        );
+        LogMessageUtils.error(
+            "Message",
+            "message exception",
+            stackTrace.stack,
+            `process got message ${message}`,
+            status.SERVICE_UNAVAILABLE
+        );
+    }
+    static multipleResolves(type: string, promise: Promise<any>, reason: any): void {
+        const stackTrace: StackTraceError = this.traceError(
+            `${promise} -- ${reason}`,
+            "multipleResolves",
+            status.SERVICE_UNAVAILABLE
+        );
+        LogMessageUtils.error(
+            "multipleResolves",
+            `Multiple resolves detected : ${type}`,
+            stackTrace.stack,
+            `${promise} -- ${reason}`,
+            status.SERVICE_UNAVAILABLE
+        );
+    }
+    static processInterrupted(): void {
+        LogMessageUtils.success(
+            "[ OK ] Success",
+            `Process ${process.pid} has been interrupted`,
+            "The Web server has been stopped !"
+        );
+        process.exit(0);
+    }
+    static sigtermSignalReceived(signal: any): void {
+        const stackTrace: StackTraceError = this.traceError(
+            `Process ${process.pid} received a SIGTERM signal`,
+            "SIGTERM",
+            status.NOT_ACCEPTABLE
+        );
+        LogMessageUtils.error(
+            "SIGTERM",
+            "SIGTERM",
+            stackTrace.stack,
+            `Process ${process.pid} received a SIGTERM signal : ${signal.toString()}`,
+            status.NOT_ACCEPTABLE
+        );
+        process.exit(0);
+    }
+    static serverClosing(): void {
+        console.log(`${colors.bgCyanBright(` ${colors.bold(`${colors.white(` INFO `)}`)}`)} All processes are stopped`);
+        console.log("       Server is closed");
+        process.exit();
+    }
+    static dropNewConnection(): void {
+        console.log(`${colors.cyan(`ⓘ`)} ${colors.bgCyan(` ${colors.bold(`${colors.white(` Server maxConnection `)}`)} `)}  ${currentDate} | ${colors.bgCyan(`${colors.white(` Info `)}`)} The server dropped new connections`);
+    }
+    static expressErrorHandlingMiddleware(errorEmitter: any,
+                                          err: Error,
+                                          req: express.Request,
+                                          res: express.Response,
+                                          next: express.NextFunction): void {
+        if (err) {
+            errorEmitter.emit(eventName.error, err);
+            if (typeof res.status === 'function') {
+                res.status(500).send('Internal Server Error');
+            } else {
+                console.error('res.status is not a function');
+            }
+
+            const stackTrace: StackTraceError = this.traceError(err.message, "Express error", status.NOT_ACCEPTABLE);
+            LogMessageUtils.error(
+                "Express error-handling middleware",
+                "Express error",
+                stackTrace.stack,
+                err.message,
+                status.SERVICE_UNAVAILABLE
+            )
+        } else {
+            next();
+        }
+    }
+
+    private static traceError(props: string, name: string, status: number): StackTraceError {
+        return new StackTraceError(props, name, status, true);
+    }
+}

package/src/core/events/requestCalls.event.ts

@@ -0,0 +1,86 @@
+import colors from "ansi-colors";
+import {IncomingMessage, ServerResponse} from "node:http";
+import {LoggerCore} from "opticore-logger";
+
+export function requestCallsEvent(req: IncomingMessage, res: ServerResponse, host: string, port: number, loadingTime: any) {
+    const logger: LoggerCore = new LoggerCore();
+
+    const currentDatePath: string = `Request called`;
+    // @ts-ignore
+    if(req.originalUrl === "undefined") {
+        console.log(`[ ${colors.red(`${currentDatePath}`)} ] ${loadingTime} | ${colors.bgRed(`${colors.white(` Not found `)}`)} [ Host ] http://${host}:${port} - [ Route ] The route do not exist. - [ Status ] ${colors.red(`${colors.white(` 404 `)}`)}`);
+        logger.error("The route do not exist.");
+    } else {
+        switch (res.statusCode) {
+            case 200:
+                switch (req.method) {
+                    case 'POST': // @ts-ignore
+                        console.log(`[ ${colors.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${colors.bgGreen(`${colors.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${colors.bgCyan(`${colors.white(` 200 `)}`)}`); // @ts-ignore
+                        logger.info(`[ ${colors.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${colors.bgGreen(`${colors.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${colors.bgCyan(`${colors.white(` 200 `)}`)}`);
+                        break;
+                    case 'GET':
+                    case 'PUT': // @ts-ignore
+                        console.log(`[ ${colors.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${colors.bgGreen(`${colors.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${colors.bgCyan(`${colors.white(` 200 `)}`)}`); // @ts-ignore
+                        logger.info(`[ ${colors.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${colors.bgGreen(`${colors.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${colors.bgCyan(`${colors.white(` 200 `)}`)}`);
+                        break;
+                    case 'DELETE': // @ts-ignore
+                        console.log(`[ ${colors.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${colors.bgGreen(`${colors.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${colors.bgCyan(`${colors.white(` 200 `)}`)}`);// @ts-ignore
+                        logger.info(`[ ${colors.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${colors.bgGreen(`${colors.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${colors.bgCyan(`${colors.white(` 200 `)}`)}`);
+                        break;
+                }
+                break;
+            case 404:
+                switch (req.method) {
+                    case 'POST': // @ts-ignore
+                        console.log(`[ ${colors.red(`${currentDatePath}`)} ] ${loadingTime} | ${colors.bgRed(`${colors.white(` Not found `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${colors.red(`${colors.white(` 404 `)}`)}`);
+                        break;
+                    case 'GET': // @ts-ignore
+                        console.log(`[ ${colors.red(`${currentDatePath}`)} ] ${loadingTime} | ${colors.bgRed(`${colors.white(` Not found `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${colors.red(`${colors.bold(` 404 `)}`)}`);
+                        break;
+                    case 'PUT': // @ts-ignore
+                        console.log(`[ ${colors.red(`${currentDatePath}`)} ] ${loadingTime} | ${colors.bgRed(`${colors.white(` Not found `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${colors.red(`${colors.bold(` 404 `)}`)}`);
+                        break;
+                    case 'DELETE': // @ts-ignore
+                        console.log(`[ ${colors.red(`${currentDatePath}`)} ] ${loadingTime} | ${colors.bgRed(`${colors.white(` Not found `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${colors.red(`${colors.bold(` 404 `)}`)}`);
+                        break;
+                }
+                break;
+            case 401:
+                switch (req.method) {
+                    case 'POST': // @ts-ignore
+                        console.log(`[ ${colors.yellowBright(`${currentDatePath}`)} ] ${loadingTime} |  ${colors.bgYellowBright(`${colors.white(` Unauthorized `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${colors.bgYellow(`${colors.bold(` 401 `)}`)}`);
+                        break;
+                    case 'GET': // @ts-ignore
+                        console.log(`[ ${colors.yellowBright(`${currentDatePath}`)} ] ${loadingTime} |  ${colors.bgYellowBright(`${colors.white(` Unauthorized `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${colors.bgYellow(`${colors.bold(` 401 `)}`)}`);
+                        break;
+                    case 'PUT': // @ts-ignore
+                        console.log(`[ ${colors.yellowBright(`${currentDatePath}`)} ] ${loadingTime} |  ${colors.bgYellowBright(`${colors.white(` Unauthorized `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${colors.bgYellow(`${colors.bold(` 401 `)}`)}`);
+                        break;
+                    case 'DELETE': // @ts-ignore
+                        console.log(`[ ${colors.yellowBright(`${currentDatePath}`)} ] ${loadingTime} |  ${colors.bgYellowBright(`${colors.white(` Unauthorized `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${colors.bgYellow(`${colors.bold(` 401 `)}`)}`);
+                        break;
+                }
+                break;
+            case 500:
+                switch (req.method) {
+                    case 'POST': // @ts-ignore
+                        console.log(`[ ${colors.red(`${currentDatePath}`)} ]  ${loadingTime} | ${colors.bgRed(`${colors.white(` Server error `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${colors.red(`${colors.bold(` 500 `)}`)}`);
+                        break;
+                    case 'GET': // @ts-ignore
+                        console.log(`[ ${colors.red(`${currentDatePath}`)} ]  ${loadingTime} | ${colors.bgRed(`${colors.white(` Server error `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${colors.red(`${colors.bold(` 500 `)}`)}`);
+                        break;
+                    case 'PUT': // @ts-ignore
+                        console.log(`[ ${colors.red(`${currentDatePath}`)} ]  ${loadingTime} | ${colors.bgRed(`${colors.white(` Server error `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${colors.red(`${colors.bold(` 500 `)}`)}`);
+                        break;
+                    case 'DELETE': // @ts-ignore
+                        console.log(`[ ${colors.red(`${currentDatePath}`)} ]  ${loadingTime} | ${colors.bgRed(`${colors.white(` Server error `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${colors.red(`${colors.bold(` 500 `)}`)}`);
+                        break;
+                }
+                break;
+            default:
+                // @ts-ignore
+                console.log(`[ ${colors.blueBright(`${currentDatePath}`)} ] ${loadingTime} | ${colors.blueBright(` ${res.statusMessage} `)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${colors.blueBright(` ${res.req.socket._httpMessage.statusCode} `)}`);
+                break;
+        }
+    }
+}

package/src/core/handlers/errors/base/stackTraceError.ts

@@ -0,0 +1,23 @@
+import {HttpStatusCodesConstant} from "@webApp/domains/constants/httpStatusCodes.constant";
+
+
+/**
+ * Handling and catch a Node.js error.
+ */
+export default class StackTraceError extends Error {
+    public readonly name: string;
+    public readonly httpCode: HttpStatusCodesConstant | any;
+    public readonly isOperational: boolean;
+
+    // Centralized error objet that derives from Node's Error.
+    constructor(props: string | undefined, name: string, httpCode: HttpStatusCodesConstant | any, isOperational: boolean) {
+        super(props);
+
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = name;
+        this.httpCode = httpCode;
+        this.isOperational = isOperational;
+
+        Error.captureStackTrace(this);
+    }
+}

package/src/core/handlers/errors/stackTraceAssertionError.ts

@@ -0,0 +1,13 @@
+import StackTraceError from "./base/stackTraceError";
+import {CErrorName as errorName} from "@webApp/domains/constants/errorName.constant";
+import {HttpStatusCodesConstant as status} from "@webApp/domains/constants/httpStatusCodes.constant";
+
+
+/**
+ * Handling and catch a Node.js error.
+ */
+export default class StackTraceAssertionError extends StackTraceError {
+    constructor(message: string) {
+        super(message, errorName.evalError, status.INTERNAL_SERVER_ERROR, true);
+    }
+}

package/src/core/handlers/errors/stackTraceEvalError.ts

@@ -0,0 +1,12 @@
+import StackTraceError from "./base/stackTraceError";
+import {errorNameConstant} from "../../utils/constants/errorName.constant";
+import {HttpStatusCodesConstant as status} from "../../../domain/constants/httpStatusCodes.constant";
+
+/**
+ * Handling and catch a Node.js error.
+ */
+export default class StackTraceEvalError extends StackTraceError {
+    constructor(message: string) {
+        super(message, errorNameConstant.evalError, status.BAD_REQUEST, true);
+    }
+}

package/src/core/handlers/errors/stackTraceGeneralError.ts

@@ -0,0 +1,13 @@
+import StackTraceError from "./base/stackTraceError";
+import {errorNameConstant} from "../../utils/constants/errorName.constant";
+import {HttpStatusCodesConstant as status} from "../../../domain/constants/httpStatusCodes.constant";
+
+
+/**
+ * Handling and catch a Node.js error.
+ */
+export default class StackTraceGeneralError extends StackTraceError {
+    constructor(message: string) {
+        super(message, errorNameConstant.evalError, status.INTERNAL_SERVER_ERROR, false);
+    }
+}

package/src/core/handlers/errors/stackTraceOpenSSLError.ts

@@ -0,0 +1,12 @@
+import StackTraceError from "./base/stackTraceError";
+import {errorNameConstant} from "../../utils/constants/errorName.constant";
+import {HttpStatusCodesConstant as status} from "../../../domain/constants/httpStatusCodes.constant";
+
+/**
+ * Handling and catch a Node.js error.
+ */
+export default class StackTraceOpenSSLError extends StackTraceError {
+    constructor(message: string) {
+        super(message, errorNameConstant.evalError, status.INTERNAL_SERVER_ERROR, false);
+    }
+}

package/src/core/handlers/errors/stackTraceRangeError.ts

@@ -0,0 +1,12 @@
+import StackTraceError from "./base/stackTraceError";
+import {errorNameConstant} from "../../utils/constants/errorName.constant";
+import {HttpStatusCodesConstant as status} from "../../../domain/constants/httpStatusCodes.constant";
+
+/**
+ * Handling and catch a Node.js error.
+ */
+export default class StackTraceRangeError extends StackTraceError {
+    constructor(message: string) {
+        super(message, errorNameConstant.evalError, status.BAD_REQUEST, true);
+    }
+}

package/src/core/handlers/errors/stackTraceReferenceError.ts

@@ -0,0 +1,13 @@
+import StackTraceError from "./base/stackTraceError";
+import {errorNameConstant} from "../../utils/constants/errorName.constant";
+import {HttpStatusCodesConstant as status} from "../../../domain/constants/httpStatusCodes.constant";
+
+
+/**
+ * Handling and catch a Node.js error.
+ */
+export default class StackTraceReferenceError extends StackTraceError {
+    constructor(message: string) {
+        super(message, errorNameConstant.evalError, status.BAD_REQUEST, true);
+    }
+}

package/src/core/handlers/errors/stackTraceSyntaxError.ts

@@ -0,0 +1,12 @@
+import StackTraceError from "./base/stackTraceError";
+import {errorNameConstant} from "../../utils/constants/errorName.constant";
+import {HttpStatusCodesConstant as status} from "../../../domain/constants/httpStatusCodes.constant";
+
+/**
+ * Handling and catch a Node.js error.
+ */
+export default class StackTraceSyntaxError extends StackTraceError {
+    constructor(message: string) {
+        super(message, errorNameConstant.evalError, status.BAD_REQUEST, true);
+    }
+}

package/src/core/handlers/errors/stackTraceSystemError.ts

@@ -0,0 +1,14 @@
+import StackTraceError from "./base/stackTraceError";
+import {errorNameConstant} from "../../utils/constants/errorName.constant";
+import {HttpStatusCodesConstant as status} from "../../../domain/constants/httpStatusCodes.constant";
+
+
+/**
+ * Handling and catch a Node.js error.
+ */
+export default class StackTraceSystemError extends StackTraceError {
+    constructor(message: string, code: string) {
+        super(message, errorNameConstant.systemError, status.INTERNAL_SERVER_ERROR, false);
+        this.message = `${message} (code: ${code})`;
+    }
+}

package/src/core/handlers/errors/stackTraceTypeError.ts

@@ -0,0 +1,13 @@
+import StackTraceError from "./base/stackTraceError";
+import {errorNameConstant} from "../../utils/constants/errorName.constant";
+import {HttpStatusCodesConstant as status} from "../../../domain/constants/httpStatusCodes.constant";
+
+
+/**
+ * Handling and catch a Node.js error.
+ */
+export default class StackTraceTypeError extends StackTraceError {
+    constructor(message: string) {
+        super(message, errorNameConstant.evalError, status.BAD_REQUEST, true);
+    }
+}