opticore-webapp 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opticore-webapp",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "wep server",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -25,21 +25,22 @@
   "homepage": "https://github.com/guyzoum77/opticore-webApp#readme",
   "dependencies": {
     "ansi-colors": "^4.1.3",
+    "chalk": "^5.4.1",
     "cors": "^2.8.5",
     "dotenv": "^16.4.7",
-    "express": "^4.21.0",
-    "express-rate-limit": "^5.5.1",
-    "express-session": "^1.0.0",
-    "express-useragent": "^1.0.15",
     "gradient-string": "^2.0.2",
+    "opticore-catch-exception-error": "^1.0.1",
+    "opticore-env-access": "^1.0.2",
+    "opticore-express": "^1.0.3",
+    "opticore-http-response": "^1.0.3",
     "opticore-logger": "^1.0.10",
+    "opticore-requests-called-events": "^1.0.0",
     "opticore-router": "^1.0.7",
     "opticore-validator": "^1.0.3",
     "typescript": "^5.4.5"
   },
   "devDependencies": {
     "@types/cors": "^2.8.17",
-    "@types/express": "^4.17.21",
     "@types/gradient-string": "^1.1.6",
     "tsup": "^8.3.5"
   }

package/src/application/service/core.service.ts

@@ -3,12 +3,15 @@ import chalk from 'chalk';
 import * as path from "path";
 import * as fs from "fs";
 import colors from "ansi-colors";
-import {KernelModuleType} from "@webApp/domains/types/kernelModule.type";
-import express from "express";
-import StackTraceError from "@webApp/core/handlers/errors/base/stackTraceError";
-import {modulesLoadedUtils as loadedModules} from "@webApp/core/utils/modulesLoaded.utils";
-import {messageException as msg} from "@webApp/application/exceptions/messages.exception";
-import {HttpStatusCodesConstant as status} from "@webApp/domains/constants/httpStatusCodes.constant";
+
+import { HttpStatusCode as status } from "opticore-http-response";
+import { StackTraceError } from "opticore-catch-exception-error";
+import { Router } from "opticore-express";
+
+import { KernelModuleType } from "@webApp/domains/types/kernelModule.type";
+import { modulesLoadedUtils as loadedModules } from "@webApp/core/utils/modulesLoaded.utils";
+import { messageException as msg } from "@webApp/application/exceptions/messages.exception";
+
 
 
 export class CoreService {
@@ -153,12 +156,12 @@ export class CoreService {
     }
 
     public coreListenerEventLoaderModuleService<T extends KernelModuleType>(kernelModule: T) {
-        let router: express.Router[] = [];
+        let router: Router[] = [];
         let dbCon: (() => void) | undefined;
 
         kernelModule.forEach((module): void => {
             if (Array.isArray(module)) {
-                router = module as express.Router[];
+                router = module as Router[];
             } else if (typeof module === "function") {
                 dbCon = module as () => void;
             }

package/src/core/handlers/eventProcess.handler.ts

@@ -1,15 +1,18 @@
-import express, {Express} from "express";
 import process from 'node:process';
 import EventEmitter from "node:events";
-import {eventName, event} from "../../index";
-import {ServerListenEventError} from "@webApp/core/events/errors/serverListen.event.error";
+import { express, NextFunction } from "opticore-express";
+import {
+    ServerListenEventError,
+    CEventNameError as eventName,
+    CEvent as event
+} from "opticore-catch-exception-error";
 
 /**
  *
  */
 export function eventProcessHandler(): void {
     const errorEmitter = new EventEmitter();
-    const app: Express = express();
+    const app = express();
 
     /**
      * Listener for error events
@@ -100,7 +103,7 @@ export function eventProcessHandler(): void {
     /**
      * Express error-handling middleware
      */
-    app.use((err: Error, req: express.Request, res: express.Response, next: express.NextFunction): void => {
+    app.use((err: Error, req: Request, res: Response, next: NextFunction): void => {
         ServerListenEventError.expressErrorHandlingMiddleware(errorEmitter, err, req, res, next);
     });
 }

package/src/core/utils/logMessage.utils.ts

@@ -1,5 +1,5 @@
-    import colors from "ansi-colors";
-import {dateTimeFormattedUtils} from "./dateTimeFormatted.utils";
+import colors from "ansi-colors";
+import { dateTimeFormattedUtils } from "./dateTimeFormatted.utils";
 
 export class LogMessageUtils {
     static success(title: string, action: string, contentAction: string): void {

package/src/core/utils/modulesLoaded.utils.ts

@@ -1,10 +1,11 @@
 import colors from "ansi-colors";
-import express from "express";
-import {dateTimeFormattedUtils} from "./dateTimeFormatted.utils";
-import {LogMessageUtils} from "@webApp/core/utils/logMessage.utils";
+import { Router } from "opticore-express";
+import { dateTimeFormattedUtils } from "./dateTimeFormatted.utils";
+import { LogMessageUtils } from "@webApp/core/utils/logMessage.utils";
 
 
-export function modulesLoadedUtils(allAppRoutes: express.Router[], dbConChecker: () => void): void {
+
+export function modulesLoadedUtils(allAppRoutes: Router[], dbConChecker: () => void): void {
     LogMessageUtils.success("Kernel", "load kernel", "Modules app have been successfully loaded");
     console.log(`${colors.whiteBright(`  content`)} ${colors.green('Kernel :')} ${colors.cyan(`${colors.bold(`server side`)}`)} has been loaded successfully ${colors.green(`✔`)}`);
     allAppRoutes

package/src/core/webServer.core.ts

@@ -1,28 +1,33 @@
-import {Server as serverWebApp} from "http";
-import {IncomingMessage, ServerResponse} from "node:http";
-import express, {Express} from "express";
-import corsOrigin, {CorsOptions} from "cors";
-import {IRouteDefinition} from "@webApp/domains/interfaces/routeDefinition.interface";
-import {KernelModuleType} from "@webApp/domains/types/kernelModule.type";
-import {getEnvVariable} from "@webApp/domains/env/access.env";
-import {HttpStatusCodesConstant as status} from "@webApp/domains/constants/httpStatusCodes.constant";
-import StackTraceError from "@webApp/core/handlers/errors/base/stackTraceError";
-import {eventProcessHandler} from "@webApp/core/handlers/eventProcess.handler";
-import {requestCallsEvent} from "@webApp/core/events/requestCalls.event";
-import {CEventNameError as eventName} from "@webApp/domains/constants/eventNameError.constant";
-import {ServerListenEventError as eventErrorOnListeningServer} from "@webApp/core/events/errors/serverListen.event.error";
-import {CoreService} from "@webApp/application/service/core.service";
-import {dateTimeFormattedUtils as currentDate} from "@webApp/core/utils/dateTimeFormatted.utils";
+import { Server as serverWebApp } from "http";
+import { IncomingMessage, ServerResponse } from "node:http";
+import corsOrigin, { CorsOptions } from "cors";
+import {
+    CEventNameError as eventName,
+    StackTraceError,
+    ServerListenEventError as eventErrorOnListeningServer
+} from "opticore-catch-exception-error";
+import { Application, express, Express } from "opticore-express";
+import { getEnvVariable } from "opticore-env-access";
+import { requestCallsEvent } from "opticore-requests-called-events";
+import { HttpStatusCode } from "opticore-http-response";
+
+import { IRouteDefinition } from "@webApp/domains/interfaces/routeDefinition.interface";
+import { KernelModuleType } from "@webApp/domains/types/kernelModule.type";
+import { eventProcessHandler } from "@webApp/core/handlers/eventProcess.handler";
+import { CoreService } from "@webApp/application/service/core.service";
+import { dateTimeFormattedUtils as currentDate } from "@webApp/core/utils/dateTimeFormatted.utils";
+
+
 
 
 export class WebServerCore {
     private serverUtility: CoreService = new CoreService();
-    private expressApp: Express = express();
-    private readonly routerExpressApp: express.Application;
+    private expressApp = express();
+    private readonly routerExpressApp: Application;
     private readonly port: number;
     private readonly host: string;
 
-    constructor(app: express.Application, corsOriginOptions?: Partial<CorsOptions>) {
+    constructor(app: Application, corsOriginOptions?: Partial<CorsOptions>) {
         this.port = Number(getEnvVariable.appPort);
         this.host = getEnvVariable.appHost;
         this.routerExpressApp = app;
@@ -52,7 +57,7 @@ export class WebServerCore {
                         this.registerRoutes(routers);
                     }
                 } catch (err: any) {
-                    this.traceError(err.message, "Error", status.NOT_ACCEPTABLE);
+                    this.traceError(err.message, "Error", HttpStatusCode.NOT_ACCEPTABLE);
                 }
             }
         );
@@ -77,8 +82,7 @@ export class WebServerCore {
         });
     }
 
-    public kernelModules(registerRouter: { featureRoute: IRouteDefinition[] }[],
-                         dbConnection: () => void): KernelModuleType {
+    public kernelModules(registerRouter: { featureRoute: IRouteDefinition[] }[], dbConnection: () => void): KernelModuleType {
         return [registerRouter, dbConnection] as KernelModuleType
     }
 

package/src/domains/interfaces/routeDefinition.interface.ts

@@ -1,6 +1,6 @@
-import express from "express";
+import { Router } from "opticore-express";
 
 export interface IRouteDefinition {
     path: string;
-    handler: express.Router;
+    handler: Router;
 }

package/src/domains/types/kernelModule.type.ts

@@ -1,3 +1,3 @@
-import {IRouteDefinition} from "@webApp/domains/interfaces/routeDefinition.interface";
+import { IRouteDefinition } from "@webApp/domains/interfaces/routeDefinition.interface";
 
 export type KernelModuleType = [{ featureRoute: IRouteDefinition[] }[], () => void];

package/src/index.ts

@@ -1,20 +1,11 @@
 import { WebServerCore as WebServer } from "@webApp/core/webServer.core";
-import { getEnvVariable } from "@webApp/domains/env/access.env";
-import { HttpStatusCodesConstant as HttpStatusCode } from "@webApp/domains/constants/httpStatusCodes.constant";
-import { CErrorName as errorName } from "@webApp/domains/constants/errorName.constant";
-import { CEvent as event } from "@webApp/domains/constants/event.constant";
-import { CEventNameError as eventName } from "@webApp/domains/constants/eventNameError.constant";
+
 
 import { type IRouteDefinition } from "@webApp/domains/interfaces/routeDefinition.interface";
 import { type KernelModuleType } from "@webApp/domains/types/kernelModule.type";
 
 export {
-    errorName,
-    eventName,
-    event,
-    getEnvVariable,
     IRouteDefinition,
     KernelModuleType,
-    HttpStatusCode,
     WebServer,
 }

package/tsup.config.ts

@@ -1,4 +1,4 @@
-import {defineConfig} from "tsup";
+import { defineConfig } from "tsup";
 
 export default defineConfig({
     name: "opticore-webapp",

package/src/application/http/response.http.ts

@@ -1,67 +0,0 @@
-import express from "express";
-import {ValidationResultInterface} from "opticore-validator";
-
-export class ResponseHttp {
-    /**
-     *
-     * @param res
-     * @param status
-     * @param message
-     * @param apiVersion
-     */
-    static error(res: express.Response,
-                 status: number,
-                 message: string | ValidationResultInterface,
-                 apiVersion: any): express.Response<any, Record<string, any>> {
-        return res.status(status).json({
-            errorMessage: message,
-            responseStatus: status,
-            version: apiVersion
-        });
-    }
-
-    /**
-     *
-     * @param res
-     * @param status
-     * @param context
-     * @param successMessage
-     * @param apiVersion
-     */
-    static success(res: express.Response,
-                    status: number,
-                    context: string,
-                    successMessage: string,
-                    apiVersion: any): express.Response<any, Record<string, any>> {
-        return res.status(200).json({
-            "@context": context,
-            message: successMessage,
-            responseStatus: status,
-            version: apiVersion
-        });
-    }
-
-    /**
-     *
-     * @param res
-     * @param status
-     * @param context
-     * @param successMessage
-     * @param data
-     * @param apiVersion
-     */
-    static successWithData (res: express.Response,
-                            status: number,
-                            context: string,
-                            successMessage: string,
-                            data: any,
-                            apiVersion: any): express.Response<any, Record<string, any>> {
-        return res.status(200).json({
-            "@context": context,
-            message: successMessage,
-            dataResponse: data,
-            responseStatus: status,
-            version: apiVersion
-        });
-    }
-}

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

@@ -1,335 +0,0 @@
-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";
-import {LoggerCore} from "opticore-logger";
-
-
-export class ServerListenEventError {
-    private static logger: LoggerCore = new LoggerCore();
-    private static stackTrace: StackTraceError;
-
-    /**
-     *
-     */
-    static hostPortUndefined(): void {
-        this.stackTrace = this.traceError(msg.errorHostUrl, msg.listening, status.BAD_REQUEST);
-        this.logger.error(this.stackTrace.message, msg.webServer, msg.badHost, this.stackTrace.stack, status.BAD_REQUEST);
-        process.exit();
-    }
-
-    /**
-     *
-     */
-    static hostUndefined(): void {
-        this.stackTrace = this.traceError(msg.badHost, msg.listening, status.BAD_REQUEST);
-        this.logger.error(this.stackTrace.message, msg.webServer, msg.badHost, this.stackTrace.stack, status.BAD_REQUEST);
-        process.exit();
-    }
-
-    /**
-     *
-     */
-    static portUndefined(): void {
-        this.stackTrace = this.traceError(msg.badPort, msg.listening, status.BAD_REQUEST);
-        this.logger.error(this.stackTrace.message, msg.webServer, msg.badHost, this.stackTrace.stack, status.BAD_REQUEST);
-        process.exit();
-    }
-
-    /**
-     *
-     * @param err
-     */
-    static onEventError(err: Error): void {
-        this.logger.error(err.message, "Server start error", "Error", err.stack, status.SERVICE_UNAVAILABLE);
-    }
-
-    /**
-     *
-     * @param error
-     */
-    static listenerError(error: Error): void {
-        this.stackTrace = this.traceError(error.message, error.name, status.BAD_REQUEST);
-        this.logger.error(this.stackTrace.message, "Event error", "Error", error.stack, status.BAD_REQUEST);
-    }
-
-    /**
-     *
-     * @param code
-     */
-    static processBeforeExit(code: number): void {
-        this.stackTrace = this.traceError(`Process will exit with code: ${code}`, "BeforeExit", status.SERVICE_UNAVAILABLE);
-        this.logger.error(this.stackTrace.message, "BeforeExit", "process before exit", this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-        process.exit(code);
-    }
-
-    /**
-     *
-     */
-    static processDisconnected(): void {
-        this.stackTrace = this.traceError("Child process disconnected", "process disconnected", status.SERVICE_UNAVAILABLE);
-        this.logger.error(this.stackTrace.message, "Disconnected", "process disconnected", this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-        process.exit();
-    }
-
-    /**
-     *
-     * @param code
-     */
-    static exited(code: number){
-        switch (code) {
-            case 0:
-                this.logger.success("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:
-                this.stackTrace = this.traceError("Something went wrong", "General Errors", status.SERVICE_UNAVAILABLE);
-                this.logger.error(this.stackTrace.message, "Exited", "General Errors", this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-                break
-            case 2:
-                this.stackTrace = this.traceError("Incorrect using of shell commands", "Misuse of shell builtins", status.SERVICE_UNAVAILABLE);
-                this.logger.error(this.stackTrace.message, "Exited", "Incorrect using of shell commands", this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-                break;
-            case 126:
-                this.stackTrace = this.traceError(
-                    "Incorrect using of shell commands",
-                    "The command is found but is not executable (e.g., trying to execute a directory)",
-                    status.SERVICE_UNAVAILABLE
-                );
-                this.logger.error(this.stackTrace.message, "Exited", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-                break
-            case 127:
-                this.stackTrace = this.traceError(
-                    "Command not found",
-                    "The command was not found in the system's PATH or is misspelled",
-                    status.SERVICE_UNAVAILABLE
-                );
-                this.logger.error(this.stackTrace.message, "Exited", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-                break;
-            case 128:
-                this.stackTrace = this.traceError(
-                    "The command was not found in the system's PATH or is misspelled",
-                    "Invalid argument",
-                    status.SERVICE_UNAVAILABLE
-                );
-                this.logger.error(this.stackTrace.message, "Exited", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-                break;
-            case 130:
-                this.stackTrace = this.traceError(
-                    "Indicates that the script was manually terminated by the user using the Control-C (SIGINT) signal",
-                    "Script terminated",
-                    status.SERVICE_UNAVAILABLE
-                );
-                this.logger.error(this.stackTrace.message, "Exited", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-                break;
-            case 137:
-                this.stackTrace = this.traceError(
-                    "Indicates that the process was terminated by a SIGKILL signal, possibly due to an out-of-memory situation",
-                    "SIGKILL",
-                    status.SERVICE_UNAVAILABLE
-                );
-                this.logger.error(this.stackTrace.message, "Exited", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-                break;
-            case 139:
-                this.stackTrace = this.traceError(
-                    "Indicates that the process accessed an illegal memory address (segfault)",
-                    "Segmentation fault",
-                    status.SERVICE_UNAVAILABLE
-                );
-                this.logger.error(this.stackTrace.message, "Exited", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-                break;
-            case 143:
-                this.stackTrace = this.traceError(
-                    "Indicates that the process received a SIGTERM signal to terminate",
-                    "process received a SIGTERM",
-                    status.SERVICE_UNAVAILABLE
-                );
-                this.logger.error(this.stackTrace.message, "Exited", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-                break;
-            case 255:
-                this.stackTrace = this.traceError(
-                    "An exit code that is outside the allowable range (0-255 for Unix-like systems)",
-                    "out of range",
-                    status.SERVICE_UNAVAILABLE
-                );
-                this.logger.error(this.stackTrace.message, "Exited", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-                break;
-            default:
-                this.stackTrace = this.traceError(
-                    "Error is occurring",
-                    "errors",
-                    status.SERVICE_UNAVAILABLE
-                );
-                this.logger.error(this.stackTrace.message, "Exited", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-                break;
-        }
-    }
-
-    /**
-     *
-     * @param promise
-     */
-    static promiseRejectionHandled(promise: Promise<any>): void {
-        this.stackTrace = this.traceError(
-            `Promise rejection is handled at : ${promise}`,
-            "rejection promise",
-            status.SERVICE_UNAVAILABLE
-        );
-        this.logger.error(this.stackTrace.message, "PromiseRejectionHandled", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-    }
-
-    /**
-     *
-     * @param error
-     */
-    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 {
-            this.stackTrace = this.traceError(error.message, "uncaught exception handled", status.SERVICE_UNAVAILABLE);
-            this.logger.error(this.stackTrace.message, "UncaughtException", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-        }
-    }
-
-    /**
-     *
-     * @param error
-     */
-    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("");
-        }
-    }
-
-    /**
-     *
-     * @param reason
-     * @param promise
-     */
-    static unhandledRejection(reason: any, promise: Promise<any>): void{
-        this.stackTrace = this.traceError(
-            `Unhandled Rejection at: Promise ${promise} -- reason ${reason}`,
-            "Unhandled rejection",
-            status.SERVICE_UNAVAILABLE
-        );
-        this.logger.error(this.stackTrace.message, "UnhandledRejection", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-    }
-
-    /**
-     *
-     * @param warning
-     */
-    static warning(warning: any): void {
-        this.stackTrace = this.traceError(warning.message, "warning", status.SERVICE_UNAVAILABLE);
-        this.logger.error(this.stackTrace.message, "Warning", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-    }
-
-    /**
-     *
-     * @param message
-     */
-    static message(message: any): void {
-        this.stackTrace = this.traceError(
-            `process got message ${message}`,
-            "message exception",
-            status.SERVICE_UNAVAILABLE
-        );
-        this.logger.error(this.stackTrace.message, "Message", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-    }
-
-    /**
-     *
-     * @param type
-     * @param promise
-     * @param reason
-     */
-    static multipleResolves(type: string, promise: Promise<any>, reason: any): void {
-        this.stackTrace = this.traceError(
-            `${promise} -- ${reason}`,
-            `Multiple resolves detected : ${type}`,
-            status.SERVICE_UNAVAILABLE
-        );
-        this.logger.error(this.stackTrace.message, "multipleResolves", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-    }
-
-    /**
-     *
-     */
-    static processInterrupted(): void {
-        this.logger.success("[ OK ] Success", "The Web server has been stopped !")
-        process.exit(0);
-    }
-
-    /**
-     *
-     * @param signal
-     */
-    static sigtermSignalReceived(signal: any): void {
-        this.stackTrace = this.traceError(
-            `Process ${process.pid} received a SIGTERM signal : ${signal.toString()}`,
-            "SIGTERM",
-            status.NOT_ACCEPTABLE
-        );
-        this.logger.error(this.stackTrace.message, "SIGTERM", this.stackTrace.name, this.stackTrace.stack, 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`);
-    }
-
-    /**
-     *
-     * @param errorEmitter
-     * @param err
-     * @param req
-     * @param res
-     * @param next
-     */
-    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');
-            }
-
-            this.stackTrace = this.traceError(err.message, "Express error", status.NOT_ACCEPTABLE);
-            this.logger.error(this.stackTrace.message, "Express error-handling middleware", this.stackTrace.name, this.stackTrace.stack, status.SERVICE_UNAVAILABLE);
-        } else {
-            next();
-        }
-    }
-
-    private static traceError(props: string, name: string, status: number): StackTraceError {
-        return new StackTraceError(props, name, status, true);
-    }
-}