opticore-webapp 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1080 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HttpStatusCode: () => HttpStatusCodesConstant,
+  WebServer: () => WebServerCore,
+  errorName: () => CErrorName,
+  event: () => CEvent,
+  eventName: () => CEventNameError,
+  getEnvVariable: () => getEnvVariable
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/webServer.core.ts
+var import_express2 = __toESM(require("express"), 1);
+var import_cors = __toESM(require("cors"), 1);
+
+// src/domains/env/access.env.ts
+var import_dotenv = __toESM(require("dotenv"), 1);
+var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B;
+var getEnvVariable = {
+  appHost: String((_b = (_a = import_dotenv.default.config()) == null ? void 0 : _a.parsed) == null ? void 0 : _b.APP_HOST),
+  appPort: String((_d = (_c = import_dotenv.default.config()) == null ? void 0 : _c.parsed) == null ? void 0 : _d.APP_PORT),
+  prodEnv: String((_f = (_e = import_dotenv.default.config()) == null ? void 0 : _e.parsed) == null ? void 0 : _f.ENV_PROD),
+  devEnv: String((_h = (_g = import_dotenv.default.config()) == null ? void 0 : _g.parsed) == null ? void 0 : _h.ENV_DEV),
+  dataBaseHost: String((_j = (_i = import_dotenv.default.config()) == null ? void 0 : _i.parsed) == null ? void 0 : _j.DATA_BASE_HOST),
+  dataBasePort: String((_l = (_k = import_dotenv.default.config()) == null ? void 0 : _k.parsed) == null ? void 0 : _l.DATA_BASE_PORT),
+  dataBaseUser: String((_n = (_m = import_dotenv.default.config()) == null ? void 0 : _m.parsed) == null ? void 0 : _n.DATA_BASE_USER),
+  dataBasePassword: String((_p = (_o = import_dotenv.default.config()) == null ? void 0 : _o.parsed) == null ? void 0 : _p.DATA_BASE_PASSWORD),
+  dataBaseName: String((_r = (_q = import_dotenv.default.config()) == null ? void 0 : _q.parsed) == null ? void 0 : _r.DATA_BASE_NAME),
+  apiVersion: String((_t = (_s = import_dotenv.default.config()) == null ? void 0 : _s.parsed) == null ? void 0 : _t.API_VERSION),
+  usernameField: String((_v = (_u = import_dotenv.default.config()) == null ? void 0 : _u.parsed) == null ? void 0 : _v.USERNAME_FIELD),
+  passwordField: String((_x = (_w = import_dotenv.default.config()) == null ? void 0 : _w.parsed) == null ? void 0 : _x.PASSWORD_FIELD),
+  argumentsDatabaseConnection: String((_z = (_y = import_dotenv.default.config()) == null ? void 0 : _y.parsed) == null ? void 0 : _z.ARGUMENTS_DATABASE_CONNECTION),
+  logEnv: String((_B = (_A = import_dotenv.default.config()) == null ? void 0 : _A.parsed) == null ? void 0 : _B.LOG_ENVIRONMENT)
+};
+
+// src/domains/constants/httpStatusCodes.constant.ts
+var HttpStatusCodesConstant = /* @__PURE__ */ ((HttpStatusCodesConstant2) => {
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["CONTINUE"] = 100] = "CONTINUE";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["PROCESSING"] = 102] = "PROCESSING";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["OK"] = 200] = "OK";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["CREATED"] = 201] = "CREATED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["ACCEPTED"] = 202] = "ACCEPTED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["NO_CONTENT"] = 204] = "NO_CONTENT";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["IM_USED"] = 226] = "IM_USED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["FOUND"] = 302] = "FOUND";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["SEE_OTHER"] = 303] = "SEE_OTHER";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["USE_PROXY"] = 305] = "USE_PROXY";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["SWITCH_PROXY"] = 306] = "SWITCH_PROXY";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["CONFLICT"] = 409] = "CONFLICT";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["GONE"] = 410] = "GONE";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["LOCKED"] = 423] = "LOCKED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+  HttpStatusCodesConstant2[HttpStatusCodesConstant2["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+  return HttpStatusCodesConstant2;
+})(HttpStatusCodesConstant || {});
+
+// src/core/handlers/errors/base/stackTraceError.ts
+var StackTraceError = class extends Error {
+  // Centralized error objet that derives from Node's Error.
+  constructor(props, name, httpCode, isOperational) {
+    super(props);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = name;
+    this.httpCode = httpCode;
+    this.isOperational = isOperational;
+    Error.captureStackTrace(this);
+  }
+};
+
+// src/core/handlers/eventProcess.handler.ts
+var import_express = __toESM(require("express"), 1);
+var import_node_process = __toESM(require("process"), 1);
+var import_node_events = __toESM(require("events"), 1);
+var import_serverListen_event = require("@/errors/serverListen.event.error");
+function eventProcessHandler() {
+  const errorEmitter = new import_node_events.default();
+  const app = (0, import_express.default)();
+  errorEmitter.on(CEventNameError.error, (error) => {
+    import_serverListen_event.ServerListenEventError.listenerError(error);
+  });
+  import_node_process.default.on(CEvent.beforeExit, (code) => {
+    setTimeout(() => {
+      import_serverListen_event.ServerListenEventError.processBeforeExit(code);
+    }, 100);
+  });
+  import_node_process.default.on(CEvent.disconnect, () => {
+    import_serverListen_event.ServerListenEventError.processDisconnected();
+  });
+  import_node_process.default.on(CEvent.exit, (code) => {
+    import_serverListen_event.ServerListenEventError.exited(code);
+  });
+  import_node_process.default.on(CEvent.rejectionHandled, (promise) => {
+    import_serverListen_event.ServerListenEventError.promiseRejectionHandled(promise);
+  });
+  import_node_process.default.on(CEvent.uncaughtException, (error) => {
+    import_serverListen_event.ServerListenEventError.uncaughtException(error);
+  });
+  import_node_process.default.on(CEvent.uncaughtExceptionMonitor, (error) => {
+    import_serverListen_event.ServerListenEventError.uncaughtExceptionMonitor(error);
+  });
+  import_node_process.default.on(CEvent.unhandledRejection, (reason, promise) => {
+    import_serverListen_event.ServerListenEventError.unhandledRejection(reason, promise);
+  });
+  import_node_process.default.on(CEvent.warning, (warning) => {
+    import_serverListen_event.ServerListenEventError.warning(warning);
+  });
+  import_node_process.default.on(CEvent.message, (message) => {
+    import_serverListen_event.ServerListenEventError.message(message);
+  });
+  import_node_process.default.on(CEvent.multipleResolves, (type, promise, reason) => {
+    import_serverListen_event.ServerListenEventError.multipleResolves(type, promise, reason);
+  });
+  import_node_process.default.on(CEvent.sigint, () => {
+    import_serverListen_event.ServerListenEventError.processInterrupted();
+  });
+  import_node_process.default.on(CEvent.sigterm, (signal) => {
+    import_serverListen_event.ServerListenEventError.sigtermSignalReceived(signal);
+  });
+  app.use((err, req, res, next) => {
+    import_serverListen_event.ServerListenEventError.expressErrorHandlingMiddleware(errorEmitter, err, req, res, next);
+  });
+}
+
+// src/core/events/requestCalls.event.ts
+var import_ansi_colors = __toESM(require("ansi-colors"), 1);
+var import_opticore_logger = require("opticore-logger");
+function requestCallsEvent(req, res, host, port, loadingTime) {
+  const logger = new import_opticore_logger.LoggerCore();
+  const currentDatePath = `Request called`;
+  if (req.originalUrl === "undefined") {
+    console.log(`[ ${import_ansi_colors.default.red(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.bgRed(`${import_ansi_colors.default.white(` Not found `)}`)} [ Host ] http://${host}:${port} - [ Route ] The route do not exist. - [ Status ] ${import_ansi_colors.default.red(`${import_ansi_colors.default.white(` 404 `)}`)}`);
+    logger.error("The route do not exist.");
+  } else {
+    switch (res.statusCode) {
+      case 200:
+        switch (req.method) {
+          case "POST":
+            console.log(`[ ${import_ansi_colors.default.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.bgGreen(`${import_ansi_colors.default.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${import_ansi_colors.default.bgCyan(`${import_ansi_colors.default.white(` 200 `)}`)}`);
+            logger.info(`[ ${import_ansi_colors.default.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.bgGreen(`${import_ansi_colors.default.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${import_ansi_colors.default.bgCyan(`${import_ansi_colors.default.white(` 200 `)}`)}`);
+            break;
+          case "GET":
+          case "PUT":
+            console.log(`[ ${import_ansi_colors.default.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.bgGreen(`${import_ansi_colors.default.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${import_ansi_colors.default.bgCyan(`${import_ansi_colors.default.white(` 200 `)}`)}`);
+            logger.info(`[ ${import_ansi_colors.default.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.bgGreen(`${import_ansi_colors.default.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${import_ansi_colors.default.bgCyan(`${import_ansi_colors.default.white(` 200 `)}`)}`);
+            break;
+          case "DELETE":
+            console.log(`[ ${import_ansi_colors.default.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.bgGreen(`${import_ansi_colors.default.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${import_ansi_colors.default.bgCyan(`${import_ansi_colors.default.white(` 200 `)}`)}`);
+            logger.info(`[ ${import_ansi_colors.default.cyan(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.bgGreen(`${import_ansi_colors.default.white(` Success `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${import_ansi_colors.default.bgCyan(`${import_ansi_colors.default.white(` 200 `)}`)}`);
+            break;
+        }
+        break;
+      case 404:
+        switch (req.method) {
+          case "POST":
+            console.log(`[ ${import_ansi_colors.default.red(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.bgRed(`${import_ansi_colors.default.white(` Not found `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${import_ansi_colors.default.red(`${import_ansi_colors.default.white(` 404 `)}`)}`);
+            break;
+          case "GET":
+            console.log(`[ ${import_ansi_colors.default.red(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.bgRed(`${import_ansi_colors.default.white(` Not found `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${import_ansi_colors.default.red(`${import_ansi_colors.default.bold(` 404 `)}`)}`);
+            break;
+          case "PUT":
+            console.log(`[ ${import_ansi_colors.default.red(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.bgRed(`${import_ansi_colors.default.white(` Not found `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${import_ansi_colors.default.red(`${import_ansi_colors.default.bold(` 404 `)}`)}`);
+            break;
+          case "DELETE":
+            console.log(`[ ${import_ansi_colors.default.red(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.bgRed(`${import_ansi_colors.default.white(` Not found `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${import_ansi_colors.default.red(`${import_ansi_colors.default.bold(` 404 `)}`)}`);
+            break;
+        }
+        break;
+      case 401:
+        switch (req.method) {
+          case "POST":
+            console.log(`[ ${import_ansi_colors.default.yellowBright(`${currentDatePath}`)} ] ${loadingTime} |  ${import_ansi_colors.default.bgYellowBright(`${import_ansi_colors.default.white(` Unauthorized `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${import_ansi_colors.default.bgYellow(`${import_ansi_colors.default.bold(` 401 `)}`)}`);
+            break;
+          case "GET":
+            console.log(`[ ${import_ansi_colors.default.yellowBright(`${currentDatePath}`)} ] ${loadingTime} |  ${import_ansi_colors.default.bgYellowBright(`${import_ansi_colors.default.white(` Unauthorized `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${import_ansi_colors.default.bgYellow(`${import_ansi_colors.default.bold(` 401 `)}`)}`);
+            break;
+          case "PUT":
+            console.log(`[ ${import_ansi_colors.default.yellowBright(`${currentDatePath}`)} ] ${loadingTime} |  ${import_ansi_colors.default.bgYellowBright(`${import_ansi_colors.default.white(` Unauthorized `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${import_ansi_colors.default.bgYellow(`${import_ansi_colors.default.bold(` 401 `)}`)}`);
+            break;
+          case "DELETE":
+            console.log(`[ ${import_ansi_colors.default.yellowBright(`${currentDatePath}`)} ] ${loadingTime} |  ${import_ansi_colors.default.bgYellowBright(`${import_ansi_colors.default.white(` Unauthorized `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${import_ansi_colors.default.bgYellow(`${import_ansi_colors.default.bold(` 401 `)}`)}`);
+            break;
+        }
+        break;
+      case 500:
+        switch (req.method) {
+          case "POST":
+            console.log(`[ ${import_ansi_colors.default.red(`${currentDatePath}`)} ]  ${loadingTime} | ${import_ansi_colors.default.bgRed(`${import_ansi_colors.default.white(` Server error `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${import_ansi_colors.default.red(`${import_ansi_colors.default.bold(` 500 `)}`)}`);
+            break;
+          case "GET":
+            console.log(`[ ${import_ansi_colors.default.red(`${currentDatePath}`)} ]  ${loadingTime} | ${import_ansi_colors.default.bgRed(`${import_ansi_colors.default.white(` Server error `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${import_ansi_colors.default.red(`${import_ansi_colors.default.bold(` 500 `)}`)}`);
+            break;
+          case "PUT":
+            console.log(`[ ${import_ansi_colors.default.red(`${currentDatePath}`)} ]  ${loadingTime} | ${import_ansi_colors.default.bgRed(`${import_ansi_colors.default.white(` Server error `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${import_ansi_colors.default.red(`${import_ansi_colors.default.bold(` 500 `)}`)}`);
+            break;
+          case "DELETE":
+            console.log(`[ ${import_ansi_colors.default.red(`${currentDatePath}`)} ]  ${loadingTime} | ${import_ansi_colors.default.bgRed(`${import_ansi_colors.default.white(` Server error `)}`)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ query ] ${JSON.stringify(req.query)} - [ params ] ${JSON.stringify(req.params)} - [ Status ] ${import_ansi_colors.default.red(`${import_ansi_colors.default.bold(` 500 `)}`)}`);
+            break;
+        }
+        break;
+      default:
+        console.log(`[ ${import_ansi_colors.default.blueBright(`${currentDatePath}`)} ] ${loadingTime} | ${import_ansi_colors.default.blueBright(` ${res.statusMessage} `)} [ Host ] http://${host}:${port} - [ Route ] ${req.originalUrl} - [ Status ] ${import_ansi_colors.default.blueBright(` ${res.req.socket._httpMessage.statusCode} `)}`);
+        break;
+    }
+  }
+}
+
+// src/domains/constants/eventNameError.constant.ts
+var CEventNameError = {
+  error: "error",
+  listening: "listening",
+  close: "close",
+  connection: "connection",
+  drop: "drop",
+  request: "request"
+};
+
+// src/core/events/errors/serverListen.event.error.ts
+var import_process = __toESM(require("process"), 1);
+var import_ansi_colors4 = __toESM(require("ansi-colors"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
+
+// src/core/utils/logMessage.utils.ts
+var import_ansi_colors2 = __toESM(require("ansi-colors"), 1);
+
+// src/core/utils/dateTimeFormatted.utils.ts
+var dateTimeFormattedUtils = `${(/* @__PURE__ */ new Date()).getMonth()}-${(/* @__PURE__ */ new Date()).getDate()}-${(/* @__PURE__ */ new Date()).getFullYear()} ${(/* @__PURE__ */ new Date()).getHours()}:${(/* @__PURE__ */ new Date()).getMinutes()}:${(/* @__PURE__ */ new Date()).getSeconds()}`;
+
+// src/core/utils/logMessage.utils.ts
+var LogMessageUtils = class {
+  static success(title, action, contentAction) {
+    console.log(`${import_ansi_colors2.default.green(`\u2714`)} ${import_ansi_colors2.default.bgGreen(` ${import_ansi_colors2.default.bold(`${import_ansi_colors2.default.white(`${title}`)}`)} `)}  ${dateTimeFormattedUtils} | ${import_ansi_colors2.default.bgGreen(`${import_ansi_colors2.default.white(` Success `)}`)} [ ${action} ] ${contentAction} - [ Status ] ${import_ansi_colors2.default.bgGreen(`${import_ansi_colors2.default.white(` 200 `)}`)}`);
+  }
+  static warning(title, action, contentAction) {
+    console.warn(`${import_ansi_colors2.default.yellow(`\u26A0\uFE0F`)} ${import_ansi_colors2.default.bgYellow(` ${import_ansi_colors2.default.bold(`${import_ansi_colors2.default.white(`${title}`)}`)} `)}  ${dateTimeFormattedUtils} | ${import_ansi_colors2.default.bgYellow(`${import_ansi_colors2.default.white(` Warning `)}`)} ${contentAction}`);
+  }
+  static info(title, action, contentAction) {
+    console.info(`${import_ansi_colors2.default.cyan(`\u24D8`)} ${import_ansi_colors2.default.bgCyan(` ${import_ansi_colors2.default.bold(`${import_ansi_colors2.default.white(`${title}`)}`)} `)}  ${dateTimeFormattedUtils} | ${import_ansi_colors2.default.bgCyan(`${import_ansi_colors2.default.white(` Info `)}`)} ${contentAction}`);
+  }
+  static error(title, errorType, stackTrace, messageContent, httpCodeValue) {
+    console.error(`${import_ansi_colors2.default.red(`\u2718`)} ${import_ansi_colors2.default.bgRed(` ${import_ansi_colors2.default.bold(`${import_ansi_colors2.default.white(`${title}`)}`)} `)} | ${dateTimeFormattedUtils} | [ ${import_ansi_colors2.default.red(`${import_ansi_colors2.default.bold(` ${errorType} `)}`)} ] | [ ${import_ansi_colors2.default.bold(`stack trace`)} ] ${import_ansi_colors2.default.red(`${stackTrace}`)} - ${import_ansi_colors2.default.red(`${messageContent}`)} - [ ${import_ansi_colors2.default.red(`${import_ansi_colors2.default.bold(` HttpCode `)}`)} ] ${import_ansi_colors2.default.red(`${import_ansi_colors2.default.bold(` ${httpCodeValue} `)}`)} `);
+  }
+  static requestError(title, errorName, errorMessage, errorCode) {
+    console.error(`[ ${import_ansi_colors2.default.red(`${title}`)} ] ${dateTimeFormattedUtils} | ${import_ansi_colors2.default.bgRed(`${import_ansi_colors2.default.white(` ERROR `)}`)} ${import_ansi_colors2.default.red(`[ ${errorName} ]`)} ${import_ansi_colors2.default.red(`${errorMessage}`)} - [ Status ] ${import_ansi_colors2.default.bgRed(`${import_ansi_colors2.default.white(` ${errorCode} `)}`)}`);
+  }
+};
+
+// src/application/exceptions/messages.exception.ts
+var import_ansi_colors3 = __toESM(require("ansi-colors"), 1);
+var messageException = {
+  dbConnection: "DataBase connection",
+  dbConnectionClosed: "MySQL connection is closed",
+  mysqlErrorCon: "MysqlError connection",
+  mySQLError: "MysqlError",
+  mySqlCloseConnection: "MySql close connection",
+  verifyExistingKey: "Verify Existing Key",
+  invalidRequest: "Invalid request",
+  tokenNotProvided: "No token provided.",
+  ExpiresToken: "Expires Token. You're not authorize",
+  privateKeyNotExist: "A private key doesn't exist.",
+  publicKeyNotExist: "A public key doesn't exist.",
+  errorNamePublicKeyNotExist: "No public key",
+  errorAuthorPublicKeyNotExist: "PublicKey not existing",
+  errorDecryption: "Error decryption with private key",
+  rsaKeyNotFound: "RSA key provided is not found.",
+  notVerifyingRSAKey: "Not verify RSA Key",
+  errorNameNotVerifyingRSAKey: "Error Verify RSA Key",
+  errorEncryptionPublicKey: "Error encryption with public key",
+  errorEncryptionPrivateKey: "Error encryption with private key",
+  errorNameRsaVerifyExistingKey: "Verify existing key",
+  signatureRSAKeyFailed: "Signature verification failed.",
+  encryptionWithPrivateKeyFailed: "Encryption With PrivateKey",
+  encryptionFailed: "Encryption failed",
+  decryptionWithPublicKeyFailed: "Decryption With PublicKey",
+  decryptionFailed: "Decryption failed",
+  verifyRSAKey: "Verify RSA Keys",
+  verifyRSAKeyFailed: "Verify RSA Keys Failed",
+  notVerifying: "Verification failed",
+  signatureRSAKeysError: "Signature RSA Keys Error",
+  encryptionWithPublicKey: "Encryption error",
+  errorDecryptionWithPrivateKey: "Error Decryption With PrivateKey",
+  verifyPublicRSAKey: "Verify Public RSA Key",
+  PostgresDBConnectionChecker: "PostgresDB Connection Checker",
+  PostgresConnection: "connection",
+  MongoDBConnectionChecker: "MongoDB Connection Checker",
+  MongoConnection: "connection",
+  mongoDBAuthentication: "authentication",
+  mongoDBConnection: "MongoDB connection",
+  mongoDBAuthenticationFailed: "failed",
+  mongoDBUnableParsingUrl: "unable to parse",
+  mongoDBConnectionUrl: "url",
+  mongoDBServerSelection: "MongoServer selection error",
+  mongoDBServer: "MongoServer",
+  mongoDBConnectionError: "connection error",
+  mongoDBError: "error",
+  loadedModules: "Loading core modules",
+  loadedModulesError: "Required core modules are not loaded properly",
+  dbConnexionSuccess: "The database connection was successful  \u{1F680}",
+  mongoConnectionSuccess: "Connection to database is successfully.",
+  PostgresConnectionSuccess: "Connection to database is successfully.",
+  verifyExistingKeyError: "The provided key is not found",
+  webServer: "Web server",
+  listening: "listening",
+  webHost: "host",
+  badHost: "bad host",
+  hostNotFound: "not found",
+  errorHostUrl: "The host and port are not define, please define them in .env",
+  badPort: "bad port",
+  errorPort: "The port is not correct. Please define a right port with number port.",
+  errorHost: "The host can't be empty or blank. Please define a string host in .env",
+  accessDeniedToDBCon: (user, password) => `Access denied for user ${user}. Database credentials in .env file are User: ${user} and Password: ${password}.  '${user}''${password}'@'localhost'. Try to set user and password in .env file`,
+  unknownDB: (database) => `Database ${database} is unknown. Please try to use Database CLI to create your database, or do it manually in your Database Management System`,
+  errorDBHost: (host) => `A database host ${host} does not allow connection. Please either set the host like this: ${import_ansi_colors3.default.bgRed(`${import_ansi_colors3.default.white(`localhost`)}`)} in your .env file`
+};
+
+// src/core/events/errors/serverListen.event.error.ts
+var ServerListenEventError2 = class {
+  static hostPortUndefined() {
+    const stackTrace = this.traceError(messageException.errorHostUrl, messageException.listening, 400 /* BAD_REQUEST */);
+    LogMessageUtils.error(
+      messageException.webServer,
+      messageException.badHost,
+      stackTrace.stack,
+      messageException.errorHostUrl,
+      400 /* BAD_REQUEST */
+    );
+    import_process.default.exit();
+  }
+  static hostUndefined() {
+    const stackTrace = this.traceError(messageException.badHost, messageException.listening, 400 /* BAD_REQUEST */);
+    LogMessageUtils.error(
+      messageException.webServer,
+      messageException.badHost,
+      stackTrace.stack,
+      messageException.errorHost,
+      400 /* BAD_REQUEST */
+    );
+    import_process.default.exit();
+  }
+  static portUndefined() {
+    const stackTrace = this.traceError(messageException.badPort, messageException.listening, 400 /* BAD_REQUEST */);
+    LogMessageUtils.error(
+      messageException.webServer,
+      messageException.badPort,
+      stackTrace.stack,
+      messageException.errorPort,
+      400 /* BAD_REQUEST */
+    );
+    import_process.default.exit();
+  }
+  static onEventError(err) {
+    LogMessageUtils.error(
+      "Server start error",
+      "Error",
+      err.stack,
+      err.message,
+      503 /* SERVICE_UNAVAILABLE */
+    );
+  }
+  static listenerError(error) {
+    const stackTrace = this.traceError(
+      error.message,
+      error.name,
+      400 /* BAD_REQUEST */
+    );
+    LogMessageUtils.error(
+      "Event error",
+      "Error",
+      error.stack,
+      stackTrace.message,
+      503 /* SERVICE_UNAVAILABLE */
+    );
+  }
+  static processBeforeExit(code) {
+    const stackTrace = this.traceError(
+      `Process will exit with code: ${code}`,
+      "BeforeExit",
+      503 /* SERVICE_UNAVAILABLE */
+    );
+    LogMessageUtils.error(
+      "BeforeExit",
+      "process before exit",
+      stackTrace.stack,
+      `Process will exit with code: ${code}`,
+      503 /* SERVICE_UNAVAILABLE */
+    );
+    import_process.default.exit(code);
+  }
+  static processDisconnected() {
+    const stackTrace = this.traceError(
+      "Child process disconnected",
+      "process disconnected",
+      503 /* SERVICE_UNAVAILABLE */
+    );
+    LogMessageUtils.error(
+      "Disconnected",
+      "process disconnected",
+      stackTrace.stack,
+      "Child process disconnected",
+      503 /* SERVICE_UNAVAILABLE */
+    );
+    import_process.default.exit();
+  }
+  static exited(code) {
+    switch (code) {
+      case 0:
+        LogMessageUtils.success(
+          "Exited",
+          "completed",
+          "The process finished as expected and everything is ok"
+        );
+        console.log("");
+        const paddingLength = 35;
+        const msg0 = " ".padEnd(paddingLength, " ");
+        console.log(import_chalk.default.bgGreen.white(msg0.padEnd(paddingLength, " ")));
+        console.log(`${import_ansi_colors4.default.bgGreen(` [OK] The server shutting down     `)}`);
+        console.log(import_chalk.default.bgGreen.white(msg0.padEnd(paddingLength, " ")));
+        break;
+      case 1:
+        const gnleStackTrace = this.traceError(
+          "Something went wrong",
+          "General Errors",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        LogMessageUtils.error(
+          "Exited",
+          "General Errors",
+          gnleStackTrace.stack,
+          "Something went wrong",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        break;
+      case 2:
+        const incrCmdStackTrace = this.traceError(
+          "Incorrect using of shell commands",
+          "Misuse of shell builtins",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        LogMessageUtils.error(
+          "Exited",
+          incrCmdStackTrace.name,
+          incrCmdStackTrace.stack,
+          "Incorrect using of shell commands",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        break;
+      case 126:
+        const notExeCmdStackTrace = this.traceError(
+          "Incorrect using of shell commands",
+          "Misuse of shell builtins",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        LogMessageUtils.error(
+          "Exited",
+          `command invoked`,
+          notExeCmdStackTrace.stack,
+          "The command is found but is not executable (e.g., trying to execute a directory)",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        break;
+      case 127:
+        const cmdNotFoundStackTrace = this.traceError(
+          "The command was not found in the system's PATH or is misspelled",
+          "Exited",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        LogMessageUtils.error(
+          "Exited",
+          "Command not found",
+          cmdNotFoundStackTrace.stack,
+          "The command was not found in the system's PATH or is misspelled",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        break;
+      case 128:
+        const cmdSysNotFoundStackTrace = this.traceError(
+          "The command was not found in the system's PATH or is misspelled",
+          "Exited",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        LogMessageUtils.error(
+          "Exited",
+          "Invalid argument",
+          cmdSysNotFoundStackTrace.stack,
+          "The command was not found in the system's PATH or is misspelled",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        break;
+      case 130:
+        const endScriptStackTrace = this.traceError(
+          "Indicates that the script was manually terminated by the user using the Control-C (SIGINT) signal",
+          "Exited",
+          503 /* 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",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        break;
+      case 137:
+        const prcKillStackTrace = this.traceError(
+          "Indicates that the process was terminated by a SIGKILL signal, possibly due to an out-of-memory situation",
+          "Exited",
+          503 /* 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",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        break;
+      case 139:
+        const illegalAccessStackTrace = this.traceError(
+          "Indicates that the process accessed an illegal memory address (segfault)",
+          "Exited",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        LogMessageUtils.error(
+          "Exited",
+          "Segmentation fault",
+          illegalAccessStackTrace.stack,
+          "Indicates that the process accessed an illegal memory address (segfault)",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        break;
+      case 143:
+        const sigtermStackTrace = this.traceError(
+          "Indicates that the process received a SIGTERM signal to terminate",
+          "Exited",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        LogMessageUtils.error(
+          "Exited",
+          "process received a SIGTERM",
+          sigtermStackTrace.stack,
+          "Indicates that the process received a SIGTERM signal to terminate",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        break;
+      case 255:
+        const outsideStackTrace = this.traceError(
+          "An exit code that is outside the allowable range (0-255 for Unix-like systems)",
+          "Exited",
+          503 /* 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)",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        break;
+      default:
+        const globalStackTrace = this.traceError(
+          "Error is occurring",
+          "Exited",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        LogMessageUtils.error(
+          "Exited",
+          "errors",
+          globalStackTrace.stack,
+          "Error is occurring",
+          503 /* SERVICE_UNAVAILABLE */
+        );
+        break;
+    }
+  }
+  static promiseRejectionHandled(promise) {
+    const globalStackTrace = this.traceError(
+      `Promise rejection is handled at : ${promise}`,
+      "rejection promise",
+      503 /* SERVICE_UNAVAILABLE */
+    );
+    LogMessageUtils.error(
+      "PromiseRejectionHandled",
+      "rejection promise",
+      globalStackTrace.stack,
+      `Promise rejection is handled at : ${promise}`,
+      503 /* SERVICE_UNAVAILABLE */
+    );
+  }
+  static uncaughtException(error) {
+    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 = this.traceError(
+        error.message,
+        "uncaught exception handled",
+        503 /* SERVICE_UNAVAILABLE */
+      );
+      LogMessageUtils.error(
+        "UncaughtException",
+        "uncaught exception handled",
+        tackTrace.stack,
+        error.message,
+        503 /* SERVICE_UNAVAILABLE */
+      );
+    }
+  }
+  static uncaughtExceptionMonitor(error) {
+    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, promise) {
+    const stackTrace = this.traceError(
+      `Unhandled Rejection at: Promise ${promise} -- reason ${reason}`,
+      "Unhandled rejection",
+      503 /* SERVICE_UNAVAILABLE */
+    );
+    LogMessageUtils.error(
+      "UnhandledRejection",
+      "Unhandled rejection",
+      stackTrace.stack,
+      `Unhandled Rejection at: Promise ${promise} -- reason ${reason}`,
+      503 /* SERVICE_UNAVAILABLE */
+    );
+  }
+  static warning(warning) {
+    const stackTrace = this.traceError(warning.message, "warning", 503 /* SERVICE_UNAVAILABLE */);
+    LogMessageUtils.error(
+      "Warning",
+      "warning",
+      stackTrace.stack,
+      warning.message,
+      503 /* SERVICE_UNAVAILABLE */
+    );
+  }
+  static message(message) {
+    const stackTrace = this.traceError(
+      `process got message ${message}`,
+      "message exception",
+      503 /* SERVICE_UNAVAILABLE */
+    );
+    LogMessageUtils.error(
+      "Message",
+      "message exception",
+      stackTrace.stack,
+      `process got message ${message}`,
+      503 /* SERVICE_UNAVAILABLE */
+    );
+  }
+  static multipleResolves(type, promise, reason) {
+    const stackTrace = this.traceError(
+      `${promise} -- ${reason}`,
+      "multipleResolves",
+      503 /* SERVICE_UNAVAILABLE */
+    );
+    LogMessageUtils.error(
+      "multipleResolves",
+      `Multiple resolves detected : ${type}`,
+      stackTrace.stack,
+      `${promise} -- ${reason}`,
+      503 /* SERVICE_UNAVAILABLE */
+    );
+  }
+  static processInterrupted() {
+    LogMessageUtils.success(
+      "[ OK ] Success",
+      `Process ${import_process.default.pid} has been interrupted`,
+      "The Web server has been stopped !"
+    );
+    import_process.default.exit(0);
+  }
+  static sigtermSignalReceived(signal) {
+    const stackTrace = this.traceError(
+      `Process ${import_process.default.pid} received a SIGTERM signal`,
+      "SIGTERM",
+      406 /* NOT_ACCEPTABLE */
+    );
+    LogMessageUtils.error(
+      "SIGTERM",
+      "SIGTERM",
+      stackTrace.stack,
+      `Process ${import_process.default.pid} received a SIGTERM signal : ${signal.toString()}`,
+      406 /* NOT_ACCEPTABLE */
+    );
+    import_process.default.exit(0);
+  }
+  static serverClosing() {
+    console.log(`${import_ansi_colors4.default.bgCyanBright(` ${import_ansi_colors4.default.bold(`${import_ansi_colors4.default.white(` INFO `)}`)}`)} All processes are stopped`);
+    console.log("       Server is closed");
+    import_process.default.exit();
+  }
+  static dropNewConnection() {
+    console.log(`${import_ansi_colors4.default.cyan(`\u24D8`)} ${import_ansi_colors4.default.bgCyan(` ${import_ansi_colors4.default.bold(`${import_ansi_colors4.default.white(` Server maxConnection `)}`)} `)}  ${dateTimeFormattedUtils} | ${import_ansi_colors4.default.bgCyan(`${import_ansi_colors4.default.white(` Info `)}`)} The server dropped new connections`);
+  }
+  static expressErrorHandlingMiddleware(errorEmitter, err, req, res, next) {
+    if (err) {
+      errorEmitter.emit(CEventNameError.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 = this.traceError(err.message, "Express error", 406 /* NOT_ACCEPTABLE */);
+      LogMessageUtils.error(
+        "Express error-handling middleware",
+        "Express error",
+        stackTrace.stack,
+        err.message,
+        503 /* SERVICE_UNAVAILABLE */
+      );
+    } else {
+      next();
+    }
+  }
+  static traceError(props, name, status) {
+    return new StackTraceError(props, name, status, true);
+  }
+};
+
+// src/application/service/core.service.ts
+var import_node_process2 = __toESM(require("process"), 1);
+var import_chalk2 = __toESM(require("chalk"), 1);
+var path = __toESM(require("path"), 1);
+var fs = __toESM(require("fs"), 1);
+var import_ansi_colors6 = __toESM(require("ansi-colors"), 1);
+
+// src/core/utils/modulesLoaded.utils.ts
+var import_ansi_colors5 = __toESM(require("ansi-colors"), 1);
+function modulesLoadedUtils(allAppRoutes, dbConChecker) {
+  LogMessageUtils.success("Kernel", "load kernel", "Modules app have been successfully loaded");
+  console.log(`${import_ansi_colors5.default.whiteBright(`  content`)} ${import_ansi_colors5.default.green("Kernel :")} ${import_ansi_colors5.default.cyan(`${import_ansi_colors5.default.bold(`server side`)}`)} has been loaded successfully ${import_ansi_colors5.default.green(`\u2714`)}`);
+  allAppRoutes ? console.log(`${import_ansi_colors5.default.whiteBright(`  content`)} ${import_ansi_colors5.default.green("Kernel :")} ${import_ansi_colors5.default.cyan(`${import_ansi_colors5.default.bold(`Routers service`)} `)} has been loaded successfully ${import_ansi_colors5.default.green(`\u2714`)}`) : console.log(`${import_ansi_colors5.default.red(`\u2718`)} ${import_ansi_colors5.default.bgRed(` ${import_ansi_colors5.default.bold(`${import_ansi_colors5.default.white(` Register routes `)}`)} `)} | ${dateTimeFormattedUtils} | [ ${import_ansi_colors5.default.red(`${import_ansi_colors5.default.bold(` fail `)}`)} ] | [ ${import_ansi_colors5.default.bold(` loading `)} ] - ${import_ansi_colors5.default.red(` routers `)} - The route register failed to load `);
+  typeof dbConChecker == "function" ? console.log(`${import_ansi_colors5.default.whiteBright(`  content`)} ${import_ansi_colors5.default.green("Kernel :")} ${import_ansi_colors5.default.cyan(`${import_ansi_colors5.default.bold(`database checker connection`)}`)} has been loaded successfully ${import_ansi_colors5.default.green(`\u2714`)}`) : "";
+}
+
+// src/application/service/core.service.ts
+var CoreService = class {
+  /**
+   *
+   * @param data
+   * @private
+   * Return a string converted in MegaBytes
+   */
+  formatMemoryUsage(data) {
+    return `${Math.round(data / 1024 / 1024 * 100) / 100} MB`;
+  }
+  /**
+   * Returns an Object containing a node version, openssl, and v0
+   */
+  getVersions() {
+    const { node, openssl, v8 } = import_node_process2.default.versions;
+    const data = {
+      "node version": node,
+      "openssl": openssl,
+      "v8": v8
+    };
+    return {
+      "nodeVersion": data["node version"],
+      "openssl": data.openssl,
+      "v8": data.v8
+    };
+  }
+  /**
+   * Return an Object containing a Resident Set Size - total memory allocated for the process execution
+   * Total size of the allocated heap
+   * Actual memory used during the execution
+   * Memory usage user
+   * and Memory usage system
+   */
+  getUsageMemory() {
+    const memoryData = import_node_process2.default.memoryUsage();
+    const data = {
+      "Resident Set Size - total memory allocated for the process execution": this.formatMemoryUsage(memoryData.rss),
+      "Total size of the allocated heap": this.formatMemoryUsage(memoryData.heapTotal),
+      "Actual memory used during the execution": this.formatMemoryUsage(memoryData.heapUsed),
+      "V8 external memory": this.formatMemoryUsage(memoryData.external),
+      "Memory usage user": this.formatMemoryUsage(import_node_process2.default.cpuUsage().user),
+      "Memory usage system": this.formatMemoryUsage(import_node_process2.default.cpuUsage().system)
+    };
+    return {
+      "rss": data["Resident Set Size - total memory allocated for the process execution"],
+      "heapTotal": data["Total size of the allocated heap"],
+      "heapUsed": data["Actual memory used during the execution"],
+      "external": data["V8 external memory"],
+      "user": data["Memory usage user"],
+      "system": data["Memory usage system"]
+    };
+  }
+  /**
+   * Return an Object containing a project path and running server time
+   */
+  getProjectInfo() {
+    const startTime = import_node_process2.default.hrtime();
+    const endTime = import_node_process2.default.hrtime(startTime);
+    const executionTime = (endTime[0] * 1e9 + endTime[1]) / 1e6;
+    return {
+      "projectPath": path.join(import_node_process2.default.cwd()),
+      "startingTime": `${executionTime.toFixed(5)} ms`
+    };
+  }
+  /**
+   *
+   * @param filePath
+   * @private
+   */
+  getEnvFileLoading(filePath) {
+    const fullPath = path.resolve(import_node_process2.default.cwd(), filePath);
+    if (fs.existsSync(fullPath)) {
+      const env = fs.readFileSync(fullPath, "utf-8");
+      const lines = env.split("\n");
+      lines.forEach((line) => {
+        const match = line.match(/^([^#=]+)=([^#]+)$/);
+        if (match) {
+          const key = match[1].trim();
+          import_node_process2.default.env[key] = match[2].trim();
+        }
+      });
+    }
+  }
+  /**
+   *
+   * @param development
+   * @param production
+   */
+  getServerRunningMode(development, production) {
+    this.getEnvFileLoading(".env");
+    const isDevelopment = import_node_process2.default.env.NODE_ENV === "development";
+    if (isDevelopment) {
+      return `The server is running in ${import_ansi_colors6.default.bgBlue(`${import_ansi_colors6.default.bold(`${development}`)}`)} mode`;
+    } else {
+      return `The server is running in ${import_ansi_colors6.default.bgBlue(`${import_ansi_colors6.default.bold(`${production}`)}`)} mode`;
+    }
+  }
+  infoServer(nodeVersion, startingTime, host, port, rss, heapUsed, user, system) {
+    const paddingLength = 52;
+    const msg0 = " ".padEnd(paddingLength, " ");
+    const msg1 = " [OK] Web server listening";
+    const msg2Value = `${import_ansi_colors6.default.bgBlue(`${import_ansi_colors6.default.bold(`${nodeVersion}`)}`)}`;
+    const msg2 = ` The Web server is using Node.js version`;
+    const msg3Value = `${import_ansi_colors6.default.bgBlue(`${import_ansi_colors6.default.bold(`${startingTime}`)}`)}`;
+    const msg3 = ` Startup time:`;
+    const msg4 = ` ${this.getServerRunningMode("development", "production")}`;
+    const msg5 = ` ${import_ansi_colors6.default.underline(`http://${host}:${port}`)}`;
+    console.log(import_chalk2.default.bgGreen.white(msg0.padEnd(paddingLength, " ")));
+    console.log(import_chalk2.default.bgGreen.white(msg1.padEnd(paddingLength, " ")));
+    console.log(import_chalk2.default.bgGreen.white(msg2, msg2Value.padEnd(30.5, " ")));
+    console.log(import_chalk2.default.bgGreen.white(msg3, msg3Value.padEnd(56, " ")));
+    console.log(import_chalk2.default.bgGreen.white(msg4.padEnd(71, " ")));
+    console.log(import_chalk2.default.bgGreen.white(msg5.padEnd(61, " ")));
+    console.log(import_chalk2.default.bgGreen.white(msg0.padEnd(paddingLength, " ")));
+    console.log(``);
+    console.log(`${`Resident Set Size - total memory allocated for the process execution :`} ${import_ansi_colors6.default.cyan(`${import_ansi_colors6.default.bold(`${rss}`)}`)}`);
+    console.log(`${`Actual memory used during the execution :`} ${import_ansi_colors6.default.cyan(`${import_ansi_colors6.default.bold(`${heapUsed}`)}`)}`);
+    console.log(`${`Memory usage by user :`} ${import_ansi_colors6.default.cyan(`${import_ansi_colors6.default.bold(`${user}`)}`)}`);
+    console.log(`${`Memory usage by system :`} ${import_ansi_colors6.default.cyan(`${import_ansi_colors6.default.bold(`${system}`)}`)}`);
+    console.log(``);
+  }
+  coreListenerEventLoaderModuleService(kernelModule) {
+    let router = [];
+    let dbCon;
+    kernelModule.forEach((module2) => {
+      if (Array.isArray(module2)) {
+        router = module2;
+      } else if (typeof module2 === "function") {
+        dbCon = module2;
+      }
+    });
+    if (router && dbCon) {
+      modulesLoadedUtils(router, dbCon);
+      (() => {
+        dbCon();
+      })();
+    } else {
+      const stackTrace = new StackTraceError(
+        messageException.loadedModulesError,
+        messageException.loadedModules,
+        406 /* NOT_ACCEPTABLE */,
+        true
+      );
+      throw new Error(stackTrace.message);
+    }
+  }
+};
+
+// src/core/webServer.core.ts
+var WebServerCore = class {
+  constructor(app, corsOriginOptions) {
+    this.serverUtility = new CoreService();
+    this.expressApp = (0, import_express2.default)();
+    this.port = Number(getEnvVariable.appPort);
+    this.host = getEnvVariable.appHost;
+    this.routerExpressApp = app;
+    this.expressApp.use(import_express2.default.json());
+    this.expressApp.use(import_express2.default.raw());
+    this.expressApp.use(import_express2.default.text());
+    this.expressApp.use(import_express2.default.urlencoded({ extended: true }));
+    this.expressApp.use((0, import_cors.default)(corsOriginOptions));
+    this.stackTraceErrorHandling();
+  }
+  onStartServer(routers) {
+    return this.expressApp.listen(
+      this.port,
+      this.host,
+      () => {
+        try {
+          if (this.host === "" && this.port === 0) {
+            ServerListenEventError2.hostPortUndefined();
+          } else if (this.host === "") {
+            ServerListenEventError2.hostUndefined();
+          } else if (this.port === 0) {
+            ServerListenEventError2.portUndefined();
+          } else {
+            this.registerRoutes(routers);
+          }
+        } catch (err) {
+          this.traceError(err.message, "Error", 406 /* NOT_ACCEPTABLE */);
+        }
+      }
+    );
+  }
+  onListeningOnServerEvent(serverWeb, kernelModule) {
+    serverWeb.on(CEventNameError.error, (err) => {
+      ServerListenEventError2.onEventError(err);
+    }).on(CEventNameError.close, () => {
+      ServerListenEventError2.serverClosing();
+    }).on(CEventNameError.drop, () => {
+      ServerListenEventError2.dropNewConnection();
+    }).on(CEventNameError.listening, () => {
+      this.infoWebApp();
+      this.serverUtility.coreListenerEventLoaderModuleService(kernelModule);
+    });
+  }
+  onRequestOnServerEvent(serverWeb) {
+    serverWeb.on(CEventNameError.request, (req, res) => {
+      requestCallsEvent(req, res, this.host, this.port, dateTimeFormattedUtils);
+    });
+  }
+  kernelModules(registerRouter, dbConnection) {
+    return [registerRouter, dbConnection];
+  }
+  registerRoutes(allFeatureRoutes) {
+    allFeatureRoutes.map((router) => {
+      router.featureRoute.map((route) => {
+        this.expressApp.use(route.path, route.handler);
+      });
+    });
+  }
+  stackTraceErrorHandling() {
+    eventProcessHandler();
+  }
+  infoWebApp() {
+    this.serverUtility.infoServer(
+      this.serverUtility.getVersions().nodeVersion,
+      this.serverUtility.getProjectInfo().startingTime,
+      getEnvVariable.appHost,
+      Number(getEnvVariable.appPort),
+      this.serverUtility.getUsageMemory().rss,
+      this.serverUtility.getUsageMemory().heapUsed,
+      this.serverUtility.getUsageMemory().user,
+      this.serverUtility.getUsageMemory().system
+    );
+  }
+  traceError(props, name, status) {
+    return new StackTraceError(props, name, status, true);
+  }
+};
+
+// src/domains/constants/errorName.constant.ts
+var CErrorName = {
+  evalError: "EvalError",
+  syntaxError: "SyntaxError",
+  rangeError: "RangeError",
+  referenceError: "ReferenceError",
+  typeError: "TypeError",
+  uriError: "URIError",
+  systemError: "SystemError",
+  assertionError: "AssertionError",
+  openSSLError: "OpenSSLError",
+  generalError: "GeneralError"
+};
+
+// src/domains/constants/event.constant.ts
+var CEvent = {
+  beforeExit: "beforeExit",
+  disconnect: "disconnect",
+  exit: "exit",
+  rejectionHandled: "rejectionHandled",
+  uncaughtException: "uncaughtException",
+  uncaughtExceptionMonitor: "uncaughtExceptionMonitor",
+  unhandledRejection: "unhandledRejection",
+  warning: "warning",
+  message: "message",
+  multipleResolves: "multipleResolves",
+  worker: "worker",
+  sigint: "SIGINT",
+  sigterm: "SIGTERM"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpStatusCode,
+  WebServer,
+  errorName,
+  event,
+  eventName,
+  getEnvVariable
+});