opticore-webapp-core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1177 @@
+"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, {
+  CLogLevel: () => CLogLevel,
+  CSignRSAKeyComponent: () => CSignRSAKeyComponent,
+  Environment: () => Environment,
+  MMongoCheckerDatabase: () => MMongoCheckerDatabase,
+  MMySqlCheckerDatabase: () => MMySqlCheckerDatabase,
+  MPostgresCheckerDatabase: () => MPostgresCheckerDatabase,
+  PathModuleVerifier: () => PathModuleVerifier,
+  RSAKeyDecryption: () => RSAKeyDecryption,
+  RSAKeyEncryption: () => RSAKeyEncryption,
+  SAsymmetricCryptionDataWithPrivateRSAKey: () => SAsymmetricCryptionDataWithPrivateRSAKey,
+  SAsymmetricCryptionDataWithPublicRSAKey: () => SAsymmetricCryptionDataWithPublicRSAKey,
+  SCheckerMongoDatabaseConnection: () => SCheckerMongoDatabaseConnection,
+  SCheckerMySqlDatabaseConnection: () => SCheckerMySqlDatabaseConnection,
+  SCheckerPostgresDatabaseConnection: () => SCheckerPostgresDatabaseConnection,
+  Utility: () => Utility,
+  YamlParsing: () => YamlParsing,
+  dateTimeFormatted: () => dateTimeFormatted,
+  loggerConfig: () => loggerConfig,
+  optionalArgumentConnectionUtil: () => optionalArgumentConnectionUtil,
+  translateLanguageLoader: () => translateLanguageLoader
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/application/services/asymmetricCryptionDataWithPrivateRSAKey.service.ts
+var import_crypto3 = __toESM(require("crypto"), 1);
+var import_opticore_http_response = require("opticore-http-response");
+var import_opticore_logger = require("opticore-logger");
+var import_opticore_translator = require("opticore-translator");
+var import_opticore_catch_exception_error = require("opticore-catch-exception-error");
+
+// src/utils/cryptography/encryption/rsaKey.encryption.ts
+var import_crypto = __toESM(require("crypto"), 1);
+
+// src/core/constants/signRSA/algorithm.constant.ts
+var CAlgorithm = {
+  RSA_MD5: "RSA-MD5",
+  RSA_RIPEMD160: "RSA-RIPEMD160",
+  RSA_SHA1: "RSA-SHA1",
+  RSA_SHA1_2: "RSA-SHA1-2",
+  RSA_SHA224: "RSA-SHA224",
+  RSA_SHA256: "RSA-SHA256",
+  RSA_SHA3_224: "RSA-SHA3-224",
+  RSA_SHA3_256: "RSA-SHA3-256",
+  RSA_SHA3_384: "RSA-SHA3-384",
+  RSA_SHA3_512: "RSA-SHA3-512",
+  RSA_SHA384: "RSA-SHA384",
+  RSA_SHA512: "RSA-SHA512",
+  RSA_SHA512_224: "RSA-SHA512/224",
+  RSA_SHA512_256: "RSA-SHA512/256",
+  RSA_SM3: "RSA-SM3",
+  blake2b512: "blake2b512",
+  blake2s256: "blake2s256",
+  id_rsassa_pkcs1_v1_5_with_sha3_224: "id-rsassa-pkcs1-v1_5-with-sha3-224",
+  id_rsassa_pkcs1_v1_5_with_sha3_256: "id-rsassa-pkcs1-v1_5-with-sha3-256",
+  id_rsassa_pkcs1_v1_5_with_sha3_384: "id-rsassa-pkcs1-v1_5-with-sha3-384",
+  id_rsassa_pkcs1_v1_5_with_sha3_512: "id-rsassa-pkcs1-v1_5-with-sha3-512",
+  md5: "md5",
+  md5_sha1: "md5-sha1",
+  md5WithRSAEncryption: "md5WithRSAEncryption",
+  ripemd: "ripemd",
+  ripemd160: "ripemd160",
+  ripemd160WithRSA: "ripemd160WithRSA",
+  rmd160: "rmd160",
+  sha1: "sha1",
+  sha1WithRSAEncryption: "sha1WithRSAEncryption",
+  sha224: "sha224",
+  sha224WithRSAEncryption: "sha224WithRSAEncryption",
+  sha256: "SHA256",
+  sha256WithRSAEncryption: "sha256WithRSAEncryption",
+  sha3_224: "sha3-224",
+  sha3_256: "sha3-256",
+  sha3_384: "sha3-384",
+  sha3_512: "sha3-512",
+  sha384: "sha384",
+  sha384WithRSAEncryption: "sha384WithRSAEncryption",
+  sha512: "sha512",
+  sha512_224: "sha512-224",
+  sha512_224WithRSAEncryption: "sha512-224WithRSAEncryption",
+  sha512_256: "sha512-256",
+  sha512_256WithRSAEncryption: "sha512-256WithRSAEncryption",
+  sha512WithRSAEncryption: "sha512WithRSAEncryption",
+  shake128: "shake128",
+  shake256: "shake256",
+  sm3: "sm3",
+  sm3WithRSAEncryption: "sm3WithRSAEncryption",
+  ssl3_md5: "ssl3-md5",
+  ssl3_sha1: "ssl3-sha1"
+};
+
+// src/core/constants/signRSA/keyType.constant.ts
+var CKeyType = {
+  private: "Private",
+  public: "Public"
+};
+
+// src/core/constants/signRSA/outputFormat.constant.ts
+var COutputFormat = {
+  base64: "base64",
+  base64url: "base64url",
+  hex: "hex",
+  binary: "binary"
+};
+
+// src/core/constants/signRSA/encodingFormat.constant.ts
+var CEncodingFormat = {
+  ascii: "ascii",
+  utf8: "utf8",
+  utf_8: "utf-8",
+  utf16le: "utf16le",
+  utf_16le: "utf-16le",
+  ucs2: "ucs2",
+  ucs_2: "ucs-2",
+  base64: "base64",
+  base64url: "base64url",
+  latin1: "latin1",
+  binary: "binary",
+  hex: "hex"
+};
+
+// src/core/constants/signRSAKeyComponent.constant.ts
+var CSignRSAKeyComponent = {
+  algorithm: CAlgorithm,
+  keyType: CKeyType,
+  outputFormat: COutputFormat,
+  encodingFormat: CEncodingFormat
+};
+
+// src/utils/cryptography/encryption/rsaKey.encryption.ts
+var RSAKeyEncryption = class {
+  static privateEncrypt(privateKey, encryptData) {
+    const rsaPrivateKey = {
+      key: privateKey
+    };
+    const bufferData = Buffer.from(encryptData, CSignRSAKeyComponent.encodingFormat.utf8);
+    return import_crypto.default.privateEncrypt(rsaPrivateKey, bufferData);
+  }
+  static publicEncrypt(publicKey, encryptData) {
+    const rsaPublicKey = { key: publicKey };
+    const bufferData = Buffer.from(encryptData, CSignRSAKeyComponent.encodingFormat.utf8);
+    return import_crypto.default.publicEncrypt(rsaPublicKey, bufferData);
+  }
+};
+
+// src/utils/cryptography/decryption/rsaKey.decryption.ts
+var import_crypto2 = __toESM(require("crypto"), 1);
+var RSAKeyDecryption = class {
+  static privateDecrypt(privateKey, decryptData) {
+    const rsaPrivateKey = { key: privateKey };
+    return import_crypto2.default.privateDecrypt(rsaPrivateKey, decryptData);
+  }
+  static publicDecrypt(publicKey, decryptData) {
+    const rsaPublicKey = { key: publicKey };
+    return import_crypto2.default.publicDecrypt(rsaPublicKey, decryptData);
+  }
+};
+
+// src/core/config/logger/logger.config.ts
+var import_opticore_env_access = require("opticore-env-access");
+var loggerConfig = {
+  logLevels: [
+    import_opticore_env_access.getEnvVariable.logLevelInfo,
+    import_opticore_env_access.getEnvVariable.logLevelWarning,
+    import_opticore_env_access.getEnvVariable.logLevelSuccess,
+    import_opticore_env_access.getEnvVariable.logLevelError,
+    import_opticore_env_access.getEnvVariable.logLevelDebug
+  ],
+  transports: {
+    file: {
+      enabled: import_opticore_env_access.getEnvVariable.logFileEnabled,
+      maxSizeMB: import_opticore_env_access.getEnvVariable.logFileMaxSize,
+      rotate: import_opticore_env_access.getEnvVariable.logFileRotate
+    },
+    console: {
+      enabled: import_opticore_env_access.getEnvVariable.logConsoleEnabled
+    },
+    remote: {
+      enabled: import_opticore_env_access.getEnvVariable.logRemoteEnabled,
+      endpoint: import_opticore_env_access.getEnvVariable.logRemoteEndPoint
+    }
+  }
+};
+
+// src/application/services/asymmetricCryptionDataWithPrivateRSAKey.service.ts
+var SAsymmetricCryptionDataWithPrivateRSAKey = class {
+  /**
+   *
+   * @param rsaKey
+   * @param keyType
+   * @protected
+   *
+   * Return ErrorHandler | string
+   */
+  static verifyExistingKey(rsaKey, keyType) {
+    if (!rsaKey) {
+      const stackTrace = this.traceError(
+        keyType + " " + import_opticore_translator.TranslationLoader.t("rsaKeyNotFound", import_opticore_translator.CLocal),
+        import_opticore_translator.TranslationLoader.t("erBadDbError", import_opticore_translator.CLocal),
+        import_opticore_http_response.HttpStatusCode.NOT_FOUND
+      );
+      this.log.error(
+        import_opticore_translator.TranslationLoader.t("rsaKeyNotFound", import_opticore_translator.CLocal),
+        import_opticore_translator.TranslationLoader.t("verifyExistingKey", import_opticore_translator.CLocal),
+        import_opticore_translator.TranslationLoader.t("erBadDbError", import_opticore_translator.CLocal),
+        stackTrace.stack,
+        import_opticore_http_response.HttpStatusCode.NOT_FOUND
+      );
+      throw new Error();
+    }
+    return rsaKey;
+  }
+  /**
+   *
+   * @param privateKey
+   * @param payload
+   * @private
+   *
+   * Return Buffer
+   */
+  static encryptionWithPrivateKey(privateKey, payload) {
+    this.verifyExistingKey(privateKey, CSignRSAKeyComponent.keyType.private);
+    try {
+      const bufferedData = Buffer.from(payload, Number(CSignRSAKeyComponent.encodingFormat));
+      return RSAKeyEncryption.privateEncrypt(privateKey, bufferedData);
+    } catch (err) {
+      const stackTrace = this.traceError(
+        import_opticore_translator.TranslationLoader.t("encryptionWithPrivateKeyFailed", import_opticore_translator.CLocal),
+        import_opticore_translator.TranslationLoader.t("encryptionFailed", import_opticore_translator.CLocal),
+        import_opticore_http_response.HttpStatusCode.NOT_FOUND
+      );
+      this.log.error(
+        err.message,
+        import_opticore_translator.TranslationLoader.t("encryptionFailed", import_opticore_translator.CLocal),
+        import_opticore_translator.TranslationLoader.t("encryptionWithPrivateKeyFailed", import_opticore_translator.CLocal),
+        stackTrace.stack,
+        import_opticore_http_response.HttpStatusCode.NOT_FOUND
+      );
+      throw new Error();
+    }
+  }
+  /**
+   *
+   * @param privateKey
+   * @param publicKey
+   * @param payload
+   * @private
+   */
+  static decryptionWithPublicKey(privateKey, publicKey, payload) {
+    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
+    try {
+      const encryptedPayload = this.encryptionWithPrivateKey(privateKey, payload);
+      return RSAKeyDecryption.publicDecrypt(publicKey, encryptedPayload);
+    } catch (error) {
+      const stackTrace = this.traceError(
+        import_opticore_translator.TranslationLoader.t("errorDecryption", import_opticore_translator.CLocal),
+        import_opticore_translator.TranslationLoader.t("decryptionFailed", import_opticore_translator.CLocal),
+        import_opticore_http_response.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      this.log.error(
+        import_opticore_translator.TranslationLoader.t("decryptionWithPublicKeyFailed", import_opticore_translator.CLocal),
+        import_opticore_translator.TranslationLoader.t("decryptionFailed", import_opticore_translator.CLocal),
+        stackTrace.stack,
+        import_opticore_translator.TranslationLoader.t("errorDecryption", import_opticore_translator.CLocal),
+        import_opticore_http_response.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      throw new Error();
+    }
+  }
+  /**
+   *
+   * @param privateKey
+   * @param payload
+   * @private
+   */
+  static signWithRSAKey(privateKey, payload) {
+    this.verifyExistingKey(privateKey, CSignRSAKeyComponent.keyType.private);
+    const sign = import_crypto3.default.createSign(CSignRSAKeyComponent.algorithm.sha256);
+    sign.update(payload);
+    return sign.sign(privateKey, CSignRSAKeyComponent.outputFormat.base64);
+  }
+  /**
+   *
+   * @param privateKey
+   * @param publicKey
+   * @param payload
+   */
+  static verifyRSAKey(privateKey, publicKey, payload) {
+    try {
+      const verify = import_crypto3.default.createVerify(CSignRSAKeyComponent.algorithm.sha256);
+      verify.update(payload);
+      const signature = this.signWithRSAKey(privateKey, payload);
+      const isVerified = verify.verify(publicKey, signature, CSignRSAKeyComponent.outputFormat.base64);
+      if (isVerified) {
+        const decryptedData = this.decryptionWithPublicKey(privateKey, publicKey, payload);
+        return decryptedData.toString(CSignRSAKeyComponent.encodingFormat.utf_8);
+      } else {
+        const stackTrace = this.traceError(
+          import_opticore_translator.TranslationLoader.t("signatureRSAKeyFailed", import_opticore_translator.CLocal),
+          import_opticore_translator.TranslationLoader.t("verifyRSAKeyFailed", import_opticore_translator.CLocal),
+          import_opticore_http_response.HttpStatusCode.NOT_ACCEPTABLE
+        );
+        this.log.error(
+          import_opticore_translator.TranslationLoader.t("verifyRSAKey", import_opticore_translator.CLocal),
+          import_opticore_translator.TranslationLoader.t("verifyRSAKeyFailed", import_opticore_translator.CLocal),
+          stackTrace.stack,
+          import_opticore_translator.TranslationLoader.t("signatureRSAKeyFailed", import_opticore_translator.CLocal),
+          import_opticore_http_response.HttpStatusCode.NOT_FOUND
+        );
+        return new Error();
+      }
+    } catch (err) {
+      const stackTrace = this.traceError(
+        err.name,
+        import_opticore_translator.TranslationLoader.t("signatureRSAKeysError", import_opticore_translator.CLocal),
+        import_opticore_http_response.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      this.log.error(
+        import_opticore_translator.TranslationLoader.t("signatureRSAKeysError", import_opticore_translator.CLocal),
+        import_opticore_translator.TranslationLoader.t("errorNameNotVerifyingRSAKey", import_opticore_translator.CLocal),
+        stackTrace.stack,
+        err.message,
+        import_opticore_http_response.HttpStatusCode.NOT_FOUND
+      );
+      throw new Error();
+    }
+  }
+  /**
+   *
+   * @param props
+   * @param name
+   * @param status
+   * @private
+   */
+  static traceError(props, name, status7) {
+    return new import_opticore_catch_exception_error.StackTraceError(props, name, status7, true);
+  }
+};
+SAsymmetricCryptionDataWithPrivateRSAKey.log = new import_opticore_logger.LoggerCore(loggerConfig);
+
+// src/application/services/asymmetricCryptionDataWithPublicRSAKey.service.ts
+var import_crypto4 = __toESM(require("crypto"), 1);
+var import_opticore_logger2 = require("opticore-logger");
+var import_opticore_translator2 = require("opticore-translator");
+var import_opticore_http_response2 = require("opticore-http-response");
+var import_opticore_catch_exception_error2 = require("opticore-catch-exception-error");
+var SAsymmetricCryptionDataWithPublicRSAKey = class {
+  /**
+   *
+   * @param rsaKey
+   * @param keyType
+   * @protected
+   */
+  static verifyExistingKey(rsaKey, keyType) {
+    if (!rsaKey) {
+      const stackTrace = this.traceError(
+        keyType + import_opticore_translator2.TranslationLoader.t("verifyExistingKey", import_opticore_translator2.CLocal),
+        import_opticore_translator2.TranslationLoader.t("verifyExistingKey", import_opticore_translator2.CLocal),
+        import_opticore_http_response2.HttpStatusCode.NOT_FOUND
+      );
+      this.log.error(
+        import_opticore_translator2.TranslationLoader.t("verifyExistingKey", import_opticore_translator2.CLocal),
+        "key verification",
+        stackTrace.stack,
+        import_opticore_translator2.TranslationLoader.t("verifyExistingKeyError", import_opticore_translator2.CLocal),
+        import_opticore_http_response2.HttpStatusCode.NOT_FOUND
+      );
+      return new Error();
+    }
+    return rsaKey;
+  }
+  /**
+   *
+   * @param publicKey
+   * @param payload
+   * @private
+   */
+  static encryptionWithPublicKey(publicKey, payload) {
+    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
+    try {
+      const bufferedData = Buffer.from(payload, Number(CSignRSAKeyComponent.encodingFormat));
+      return RSAKeyEncryption.publicEncrypt(publicKey, bufferedData);
+    } catch (err) {
+      const stackTrace = this.traceError(
+        err.message,
+        import_opticore_translator2.TranslationLoader.t("encryptionWithPublicKey", import_opticore_translator2.CLocal),
+        import_opticore_http_response2.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      this.log.error(
+        import_opticore_translator2.TranslationLoader.t("errorEncryptionPublicKey", import_opticore_translator2.CLocal),
+        import_opticore_translator2.TranslationLoader.t("encryptionWithPublicKey", import_opticore_translator2.CLocal),
+        stackTrace.stack,
+        err.message,
+        import_opticore_http_response2.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      throw new Error();
+    }
+  }
+  /**
+   *
+   * @param privateKey
+   * @param publicKey
+   * @param payload
+   * @private
+   */
+  static decryptionWithPrivateKey(privateKey, publicKey, payload) {
+    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
+    try {
+      const encryptedPayload = this.encryptionWithPublicKey(publicKey, payload);
+      return RSAKeyDecryption.privateDecrypt(privateKey, encryptedPayload);
+    } catch (err) {
+      const stackTrace = this.traceError(
+        err.code,
+        import_opticore_translator2.TranslationLoader.t("errorDecryption", import_opticore_translator2.CLocal),
+        import_opticore_http_response2.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      this.log.error(
+        import_opticore_translator2.TranslationLoader.t("errorDecryptionWithPrivateKey", import_opticore_translator2.CLocal),
+        import_opticore_translator2.TranslationLoader.t("errorDecryption", import_opticore_translator2.CLocal),
+        stackTrace.stack,
+        err.message,
+        import_opticore_http_response2.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      throw new Error();
+    }
+  }
+  /**
+   *
+   * @param publicKey
+   * @param payload
+   * @private
+   */
+  static signWithPublicRSAKey(publicKey, payload) {
+    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.private);
+    const sign = import_crypto4.default.createSign(CSignRSAKeyComponent.algorithm.sha256);
+    sign.update(payload);
+    return sign.sign(publicKey, CSignRSAKeyComponent.outputFormat.base64);
+  }
+  /**
+   *
+   * @param privateKey
+   * @param publicKey
+   * @param payload
+   */
+  static verifyPublicRSAKey(privateKey, publicKey, payload) {
+    try {
+      const verify = import_crypto4.default.createVerify(CSignRSAKeyComponent.algorithm.sha256);
+      verify.update(payload);
+      const signature = this.signWithPublicRSAKey(publicKey, payload);
+      const isVerified = verify.verify(publicKey, signature, CSignRSAKeyComponent.outputFormat.base64);
+      if (isVerified) {
+        const decryptedData = this.decryptionWithPrivateKey(privateKey, publicKey, payload);
+        return decryptedData.toString(CSignRSAKeyComponent.encodingFormat.utf_8);
+      } else {
+        const stackTrace = this.traceError(
+          import_opticore_translator2.TranslationLoader.t("verifyPublicRSAKeyError", import_opticore_translator2.CLocal),
+          import_opticore_translator2.TranslationLoader.t("signatureRSAKeyFailed", import_opticore_translator2.CLocal),
+          import_opticore_http_response2.HttpStatusCode.NOT_FOUND
+        );
+        this.log.error(
+          import_opticore_translator2.TranslationLoader.t("verifyPublicRSAKey", import_opticore_translator2.CLocal),
+          import_opticore_translator2.TranslationLoader.t("signatureRSAKeyFailed", import_opticore_translator2.CLocal),
+          stackTrace.stack,
+          import_opticore_translator2.TranslationLoader.t("verifyPublicRSAKeyError", import_opticore_translator2.CLocal),
+          import_opticore_http_response2.HttpStatusCode.NOT_FOUND
+        );
+        return stackTrace;
+      }
+    } catch (err) {
+      const stackTrace = this.traceError(
+        err.code,
+        import_opticore_translator2.TranslationLoader.t("verifyPublicRSAKey", import_opticore_translator2.CLocal),
+        import_opticore_http_response2.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      this.log.error(
+        import_opticore_translator2.TranslationLoader.t("verifyPublicRSAKey", import_opticore_translator2.CLocal),
+        import_opticore_translator2.TranslationLoader.t("errorDecryption", import_opticore_translator2.CLocal),
+        stackTrace.stack,
+        err.message,
+        import_opticore_http_response2.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      throw new Error();
+    }
+  }
+  static traceError(props, name, status7) {
+    return new import_opticore_catch_exception_error2.StackTraceError(props, name, status7, true);
+  }
+};
+SAsymmetricCryptionDataWithPublicRSAKey.log = new import_opticore_logger2.LoggerCore(loggerConfig);
+
+// src/application/services/checkerMongoDatabaseConnection.service.ts
+var import_mongodb = require("mongodb");
+async function SCheckerMongoDatabaseConnection(url, user, password, dbName) {
+  const client = new import_mongodb.MongoClient(
+    url,
+    {
+      auth: { username: user, password }
+    }
+  );
+  await client.connect();
+}
+
+// src/core/handlers/errors/database/mySqlError.handler.database.ts
+var import_opticore_logger3 = require("opticore-logger");
+var import_opticore_http_response3 = require("opticore-http-response");
+var import_opticore_translator3 = require("opticore-translator");
+function mySqlErrorHandlerDatabase(err, dbHost, database, user, password) {
+  const logger = new import_opticore_logger3.LoggerCore(loggerConfig);
+  switch (err.code) {
+    case "EAI_AGAIN":
+      logger.error(
+        import_opticore_translator3.TranslationLoader.t("errorDBHost", import_opticore_translator3.CLocal, { dbHost }),
+        import_opticore_translator3.TranslationLoader.t("mySQLError", import_opticore_translator3.CLocal),
+        import_opticore_translator3.TranslationLoader.t("eAiAgain", import_opticore_translator3.CLocal),
+        err.stack,
+        import_opticore_http_response3.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      break;
+    case "ER_NOT_SUPPORTED_AUTH_MODE":
+      logger.error(
+        import_opticore_translator3.TranslationLoader.t("erNotSupportedAuthModeError", import_opticore_translator3.CLocal),
+        import_opticore_translator3.TranslationLoader.t("dbConnection", import_opticore_translator3.CLocal),
+        import_opticore_translator3.TranslationLoader.t("erNotSupportedAuthMode", import_opticore_translator3.CLocal),
+        err.stack,
+        import_opticore_http_response3.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      break;
+    case "ER_ACCESS_DENIED_ERROR":
+      logger.error(
+        import_opticore_translator3.TranslationLoader.t("accessDeniedToDBCon", import_opticore_translator3.CLocal, { user, password }),
+        import_opticore_translator3.TranslationLoader.t("dbConnection", import_opticore_translator3.CLocal),
+        import_opticore_translator3.TranslationLoader.t("erAccessDeniedError", import_opticore_translator3.CLocal),
+        err.stack,
+        import_opticore_http_response3.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      break;
+    case "ER_BAD_DB_ERROR":
+      logger.error(
+        import_opticore_translator3.TranslationLoader.t("unknownDB", import_opticore_translator3.CLocal, { database }),
+        import_opticore_translator3.TranslationLoader.t("dbConnection", import_opticore_translator3.CLocal),
+        import_opticore_translator3.TranslationLoader.t("erBadDbError", import_opticore_translator3.CLocal),
+        err.stack,
+        import_opticore_http_response3.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      break;
+    default:
+      logger.error(
+        err.message,
+        import_opticore_translator3.TranslationLoader.t("dbConnection", import_opticore_translator3.CLocal),
+        import_opticore_translator3.TranslationLoader.t("mysqlErrorCon", import_opticore_translator3.CLocal),
+        err.stack,
+        import_opticore_http_response3.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      break;
+  }
+}
+
+// src/application/services/checkerMySqlDatabaseConnection.service.ts
+var import_opticore_logger4 = require("opticore-logger");
+var import_opticore_translator4 = require("opticore-translator");
+function SCheckerMySqlDatabaseConnection(dbConnection, user, database, dbHost, password) {
+  const log = new import_opticore_logger4.LoggerCore(loggerConfig);
+  dbConnection.connect((err) => {
+    if (err) {
+      return mySqlErrorHandlerDatabase(err, dbHost, database, user, password);
+    } else {
+      log.success(
+        import_opticore_translator4.TranslationLoader.t("dbConnection", import_opticore_translator4.CLocal),
+        import_opticore_translator4.TranslationLoader.t("dbConnexionSuccess", import_opticore_translator4.CLocal)
+      );
+      return dbConnection.end((endConErr) => {
+        if (endConErr) {
+          return mySqlErrorHandlerDatabase(err, dbHost, database, user, password);
+        } else {
+          log.success(
+            import_opticore_translator4.TranslationLoader.t("dbConnection", import_opticore_translator4.CLocal),
+            import_opticore_translator4.TranslationLoader.t("dbConnectionClosed", import_opticore_translator4.CLocal)
+          );
+          console.log("");
+        }
+      });
+    }
+  });
+}
+
+// src/application/services/checkerPostgresDatabaseConnection.service.ts
+var import_opticore_http_response4 = require("opticore-http-response");
+var import_pg = require("pg");
+var import_opticore_logger5 = require("opticore-logger");
+var import_opticore_translator5 = require("opticore-translator");
+async function SCheckerPostgresDatabaseConnection(connectionString, keepAlive, stream, statement_timeout, ssl, query_timeout, keepAliveInitialDelayMillis, idle_in_transaction_session_timeout, application_name, connectionTimeoutMillis, types, options) {
+  const logger = new import_opticore_logger5.LoggerCore(loggerConfig);
+  const configOptions = {
+    connectionString,
+    keepAlive,
+    stream,
+    statement_timeout,
+    ssl,
+    query_timeout,
+    keepAliveInitialDelayMillis,
+    idle_in_transaction_session_timeout,
+    application_name,
+    connectionTimeoutMillis,
+    types,
+    options
+  };
+  const client = new import_pg.Client(configOptions);
+  await client.connect();
+  await client.end().then(
+    () => {
+      logger.success(
+        import_opticore_translator5.TranslationLoader.t("postgresSuccessConn", import_opticore_translator5.CLocal),
+        import_opticore_translator5.TranslationLoader.t("postgresClosingConnSuccess", import_opticore_translator5.CLocal)
+      );
+    },
+    (onRejected) => {
+      logger.error(
+        import_opticore_translator5.TranslationLoader.t("postgresEndClientRejection", import_opticore_translator5.CLocal),
+        import_opticore_translator5.TranslationLoader.t("postgresClientError", import_opticore_translator5.CLocal),
+        import_opticore_translator5.TranslationLoader.t("postgresEndRejection", import_opticore_translator5.CLocal),
+        onRejected,
+        import_opticore_http_response4.HttpStatusCode.BAD_REQUEST
+      );
+    }
+  ).catch((onError) => {
+    logger.error(
+      onError.message,
+      import_opticore_translator5.TranslationLoader.t("postgresConnError", import_opticore_translator5.CLocal),
+      import_opticore_translator5.TranslationLoader.t("postgresException", import_opticore_translator5.CLocal),
+      onError.stack,
+      import_opticore_http_response4.HttpStatusCode.BAD_REQUEST
+    );
+  });
+}
+
+// src/domains/constants/logLevel.constant.ts
+var CLogLevel = {
+  debug: "DEBUG",
+  info: "INFO",
+  warn: "WARN",
+  error: "ERROR"
+};
+
+// src/utils/connection/optionalArgumentConnection.util.ts
+var import_opticore_env_access2 = require("opticore-env-access");
+var optionalArgumentConnectionUtil = import_opticore_env_access2.getEnvVariable.argumentsDatabaseConnection;
+
+// src/utils/parsing/parsingYaml.utils.ts
+var import_promises = require("fs/promises");
+var import_opticore_http_response5 = require("opticore-http-response");
+var import_opticore_logger6 = require("opticore-logger");
+var import_opticore_translator6 = require("opticore-translator");
+var YamlParsing = class {
+  static async readFile(filePath) {
+    try {
+      const yamlContent = await (0, import_promises.readFile)(filePath, "utf-8");
+      await this.parsing(yamlContent);
+    } catch (error) {
+      this.logger.error(
+        error.message,
+        import_opticore_translator6.TranslationLoader.t("parsingFailed", import_opticore_translator6.CLocal),
+        import_opticore_translator6.TranslationLoader.t("readingError", import_opticore_translator6.CLocal),
+        error.stack,
+        import_opticore_http_response5.HttpStatusCode.NOT_ACCEPTABLE
+      );
+    }
+  }
+  /**
+   *
+   * @param content
+   * @private
+   */
+  static async parsing(content) {
+    const result = {};
+    const lines = content.split("\n");
+    let currentKey = null;
+    for (const line of lines) {
+      if (!line.trim() || line.trim().startsWith("#")) {
+        continue;
+      }
+      const keyValueMatch = line.match(/^(\s*)([a-zA-Z0-9_]+):(?:\s*(.*))?$/);
+      if (keyValueMatch) {
+        const [, indent, key, value] = keyValueMatch;
+        if (indent.length > 0 && currentKey) {
+          result[currentKey] = result[currentKey] || {};
+          result[currentKey][key] = (value == null ? void 0 : value.trim()) || null;
+        } else {
+          currentKey = key;
+          result[key] = (value == null ? void 0 : value.trim()) || null;
+        }
+      } else {
+        this.logger.error(
+          import_opticore_translator6.TranslationLoader.t("badFormat", import_opticore_translator6.CLocal, { line }),
+          import_opticore_translator6.TranslationLoader.t("parsingFailed", import_opticore_translator6.CLocal),
+          import_opticore_translator6.TranslationLoader.t("unsupportedFormat", import_opticore_translator6.CLocal),
+          content,
+          import_opticore_http_response5.HttpStatusCode.NOT_ACCEPTABLE
+        );
+      }
+    }
+    return result;
+  }
+};
+YamlParsing.logger = new import_opticore_logger6.LoggerCore(loggerConfig);
+
+// src/utils/dateTimeFormatted.utils.ts
+var dateTimeFormatted = `${(/* @__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/utils/environment.utils.ts
+var Environment = class {
+  constructor(config) {
+    this.config = config;
+  }
+  get(key) {
+    return this.config[key];
+  }
+};
+
+// src/core/config/database/connexion.config.database.ts
+var import_mysql = __toESM(require("mysql"), 1);
+var import_opticore_http_response7 = require("opticore-http-response");
+var import_opticore_env_access3 = require("opticore-env-access");
+var import_opticore_logger8 = require("opticore-logger");
+var import_opticore_translator8 = require("opticore-translator");
+
+// src/core/errors/databaseConnexion.error.ts
+var import_opticore_http_response6 = require("opticore-http-response");
+var import_opticore_logger7 = require("opticore-logger");
+var import_opticore_catch_exception_error3 = require("opticore-catch-exception-error");
+var import_opticore_translator7 = require("opticore-translator");
+var DbConnexionConfigError = class {
+  /**
+   *
+   * @param e
+   */
+  static mongoDBAuthenticationFailed(e) {
+    const stackTrace = this.traceError(
+      import_opticore_translator7.TranslationLoader.t("mongoDBConnection", import_opticore_translator7.CLocal),
+      import_opticore_translator7.TranslationLoader.t("mongoDBAuthentication", import_opticore_translator7.CLocal),
+      import_opticore_http_response6.HttpStatusCode.UNAUTHORIZED
+    );
+    this.logger.error(
+      import_opticore_translator7.TranslationLoader.t("mongoDBAuthenticationError", import_opticore_translator7.CLocal),
+      import_opticore_translator7.TranslationLoader.t("mongoDBConnection", import_opticore_translator7.CLocal),
+      import_opticore_translator7.TranslationLoader.t("mongoDBAuthenticationFailed", import_opticore_translator7.CLocal),
+      stackTrace.stack,
+      import_opticore_http_response6.HttpStatusCode.UNAUTHORIZED
+    );
+  }
+  /**
+   *
+   * @param err
+   * @param dbHost
+   * @param dbPort
+   */
+  static mongoDBInvalidUrl(err, dbHost, dbPort) {
+    const stackTrace = this.traceError(
+      import_opticore_translator7.TranslationLoader.t("mongoDBConnection", import_opticore_translator7.CLocal),
+      import_opticore_translator7.TranslationLoader.t("mongoDBUnableParsingUrl", import_opticore_translator7.CLocal),
+      import_opticore_http_response6.HttpStatusCode.BAD_REQUEST
+    );
+    this.logger.error(
+      import_opticore_translator7.TranslationLoader.t("dbUrlParsingError", import_opticore_translator7.CLocal, { dbHost, dbPort }),
+      import_opticore_translator7.TranslationLoader.t("mongoDBConnection", import_opticore_translator7.CLocal),
+      import_opticore_translator7.TranslationLoader.t("mongoDBUnableParsingUrl", import_opticore_translator7.CLocal),
+      stackTrace.stack,
+      import_opticore_http_response6.HttpStatusCode.BAD_REQUEST
+    );
+  }
+  /**
+   *
+   * @param err
+   * @param dbHost
+   */
+  static mongoDBEaiAgain(err, dbHost) {
+    const stackTrace = this.traceError(
+      import_opticore_translator7.TranslationLoader.t("mongoDBConnection", import_opticore_translator7.CLocal),
+      import_opticore_translator7.TranslationLoader.t("mongoDBServerSelection", import_opticore_translator7.CLocal),
+      import_opticore_http_response6.HttpStatusCode.BAD_REQUEST
+    );
+    this.logger.error(
+      import_opticore_translator7.TranslationLoader.t("mongoServerError", import_opticore_translator7.CLocal, { dbHost }),
+      import_opticore_translator7.TranslationLoader.t("mongoDBConnection", import_opticore_translator7.CLocal),
+      import_opticore_translator7.TranslationLoader.t("mongoDBServerSelection", import_opticore_translator7.CLocal),
+      stackTrace.stack,
+      import_opticore_http_response6.HttpStatusCode.BAD_REQUEST
+    );
+  }
+  /**
+   *
+   * @param err
+   */
+  static mongoDbGlobalError(err) {
+    const stackTrace = this.traceError(
+      err.message,
+      import_opticore_translator7.TranslationLoader.t("mongoDBConnection", import_opticore_translator7.CLocal),
+      import_opticore_http_response6.HttpStatusCode.NOT_ACCEPTABLE
+    );
+    this.logger.error(
+      import_opticore_translator7.TranslationLoader.t("mongoDBConnection", import_opticore_translator7.CLocal),
+      import_opticore_translator7.TranslationLoader.t("mongoDBConnectionError", import_opticore_translator7.CLocal),
+      stackTrace.stack,
+      err.message,
+      import_opticore_http_response6.HttpStatusCode.NOT_ACCEPTABLE
+    );
+  }
+  /**
+   *
+   * @param props
+   * @param name
+   * @param status
+   * @private
+   */
+  static traceError(props, name, status7) {
+    return new import_opticore_catch_exception_error3.StackTraceError(props, name, status7, true);
+  }
+};
+DbConnexionConfigError.logger = new import_opticore_logger7.LoggerCore(loggerConfig);
+
+// src/core/config/database/connexion.config.database.ts
+var import_opticore_catch_exception_error4 = require("opticore-catch-exception-error");
+var DatabaseConnectionConfig = class {
+  constructor() {
+    this.env = new Environment(import_opticore_env_access3.getEnvVariable);
+    this.logger = new import_opticore_logger8.LoggerCore(loggerConfig);
+  }
+  /**
+   * MySQL database connection with an optional arguments
+   * Establish the connection between app and Database Management System.
+   * Inside this class, a checker verifies if database credentials are right,
+   * and it's show off in the log that the connection has been created successfully.
+   * But if any error is occurring during trying connection, it'd specify that error by stack traces.
+   */
+  databaseMySQLConnexionChecker(optionalArgumentConnection) {
+    const dbURL = `${this.env.get("dataBaseUser")}:${this.env.get("dataBasePassword")}@${this.env.get("dataBaseHost")}:${this.env.get("dataBasePort")}/${this.env.get("dataBaseName")}`;
+    let url = `mysql://${dbURL}?${optionalArgumentConnection}`;
+    const dbConnection = import_mysql.default.createConnection(url);
+    return SCheckerMySqlDatabaseConnection(dbConnection, this.env.get("dataBaseUser"), this.env.get("dataBaseName"), this.env.get("dataBaseHost"), this.env.get("dataBasePassword"));
+  }
+  /**
+   *
+   * @param optionalArgumentConnection
+   *
+   * Mongo database connection with optional connection arguments
+   */
+  async databaseMongoDBConnectionChecker(optionalArgumentConnection) {
+    const dbUrl = `${this.env.get("dataBaseUser")}:${this.env.get("dataBasePassword")}@${this.env.get("dataBaseHost")}:${this.env.get("dataBasePort")}/${this.env.get("dataBaseName")}`;
+    const url = `mongodb://${dbUrl}${optionalArgumentConnection}`;
+    try {
+      await SCheckerMongoDatabaseConnection(url, this.env.get("dataBaseUser"), this.env.get("dataBasePassword"), this.env.get("dataBaseName"));
+      this.logger.success(
+        import_opticore_translator8.TranslationLoader.t("mongoDBConnectionChecker", import_opticore_translator8.CLocal),
+        import_opticore_translator8.TranslationLoader.t("mongoConnectionSuccess", import_opticore_translator8.CLocal)
+      );
+      console.log("");
+    } catch (e) {
+      if (e.code === 18) {
+        DbConnexionConfigError.mongoDBAuthenticationFailed(e);
+      }
+      if (e.cause.code === "ERR_INVALID_URL") {
+        DbConnexionConfigError.mongoDBInvalidUrl(e, this.env.get("dataBaseHost"), this.env.get("dataBasePort"));
+      }
+      if (e.code === void 0) {
+        DbConnexionConfigError.mongoDBEaiAgain(e, this.env.get("dataBaseHost"));
+      } else {
+        DbConnexionConfigError.mongoDbGlobalError(e);
+      }
+    }
+  }
+  /**
+   *
+   * @param keepAlive
+   * @param stream
+   * @param statement_timeout
+   * @param ssl
+   * @param query_timeout
+   * @param keepAliveInitialDelayMillis
+   * @param idle_in_transaction_session_timeout
+   * @param application_name
+   * @param connectionTimeoutMillis
+   * @param types
+   * @param options
+   *
+   * Postgres database connection with optional connection arguments
+   */
+  async databasePostgresDBConnectionChecker(keepAlive, stream, statement_timeout, ssl, query_timeout, keepAliveInitialDelayMillis, idle_in_transaction_session_timeout, application_name, connectionTimeoutMillis, types, options) {
+    const url = `postgresql:/${this.env.get("dataBaseUser")}:${this.env.get("dataBasePassword")}@${this.env.get("dataBaseHost")}:${this.env.get("dataBasePort")}/${this.env.get("dataBaseName")}`;
+    try {
+      await SCheckerPostgresDatabaseConnection(
+        url,
+        keepAlive,
+        stream,
+        statement_timeout,
+        ssl,
+        query_timeout,
+        keepAliveInitialDelayMillis,
+        idle_in_transaction_session_timeout,
+        application_name,
+        connectionTimeoutMillis,
+        types,
+        options
+      );
+      this.logger.success(import_opticore_translator8.TranslationLoader.t("postgresDBConnectionChecker", import_opticore_translator8.CLocal), import_opticore_translator8.TranslationLoader.t("postgresConnectionSuccess", import_opticore_translator8.CLocal));
+      console.log("");
+    } catch (err) {
+      const stackTrace = this.traceError(
+        import_opticore_translator8.TranslationLoader.t(`${err.message}`, import_opticore_translator8.CLocal),
+        "PostgresConnectionError",
+        import_opticore_http_response7.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      this.logger.error(
+        err.message,
+        "PostgresConnectionError",
+        "Postgres connection error",
+        stackTrace.stack,
+        import_opticore_http_response7.HttpStatusCode.NOT_ACCEPTABLE
+      );
+    }
+  }
+  traceError(props, name, status7) {
+    return new import_opticore_catch_exception_error4.StackTraceError(props, name, status7, true);
+  }
+};
+
+// src/core/config/database/middleware/mongoChecker.database.ts
+var MMongoCheckerDatabase = (optionalArgumentConnection) => {
+  const DbConnexion = new DatabaseConnectionConfig();
+  return DbConnexion.databaseMongoDBConnectionChecker(optionalArgumentConnection);
+};
+
+// src/core/config/database/middleware/mySqlChecker.database.ts
+var MMySqlCheckerDatabase = (optionalArgumentConnection) => {
+  const DbConnexion = new DatabaseConnectionConfig();
+  return DbConnexion.databaseMySQLConnexionChecker(optionalArgumentConnection);
+};
+
+// src/core/config/database/middleware/postgresChecker.database.ts
+var MPostgresCheckerDatabase = (optionalArgumentConnection) => {
+  const DbConnexion = new DatabaseConnectionConfig();
+  return DbConnexion.databasePostgresDBConnectionChecker(optionalArgumentConnection);
+};
+
+// src/utils/utility.utils.ts
+var import_node_process = __toESM(require("process"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
+var import_ansi_colors = __toESM(require("ansi-colors"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_opticore_translator9 = require("opticore-translator");
+var Utility = 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 processVers = import_node_process.default.versions;
+    const data = {
+      "node version": processVers.node,
+      "openssl": processVers.openssl,
+      "v8": processVers.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_process.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_process.default.cpuUsage().user),
+      "Memory usage system": this.formatMemoryUsage(import_node_process.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_process.default.hrtime();
+    const endTime = import_node_process.default.hrtime(startTime);
+    const executionTime = (endTime[0] * 1e9 + endTime[1]) / 1e6;
+    return {
+      "projectPath": import_path.default.join(import_node_process.default.cwd()),
+      "startingTime": `${executionTime.toFixed(5)} ms`
+    };
+  }
+  /**
+   *
+   * @param filePath
+   * @private
+   */
+  getEnvFileLoading(filePath) {
+    const fullPath = import_path.default.resolve(import_node_process.default.cwd(), filePath);
+    if (import_fs.default.existsSync(fullPath)) {
+      const env = import_fs.default.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_process.default.env[key] = match[2].trim();
+        }
+      });
+    }
+  }
+  /**
+   *
+   * @param development
+   * @param production
+   */
+  getServerRunningMode(development, production) {
+    this.getEnvFileLoading(".env");
+    const isDevelopment = import_node_process.default.env.NODE_ENV === "development";
+    if (isDevelopment) {
+      return `${import_opticore_translator9.TranslationLoader.t("serverRunning", import_opticore_translator9.CLocal)} ${import_ansi_colors.default.bgBlue(`${import_ansi_colors.default.bold(`${development}`)}`)} mode`;
+    } else {
+      return `${import_opticore_translator9.TranslationLoader.t("serverRunning", import_opticore_translator9.CLocal)} ${import_ansi_colors.default.bgBlue(`${import_ansi_colors.default.bold(`${production}`)}`)} mode`;
+    }
+  }
+  infoServer(nodeVersion, startingTime, host, port, rss, heapUsed, user, system) {
+    const paddingLength = 52;
+    const msg0 = " ".padEnd(paddingLength, " ");
+    const msg1 = ` ${import_opticore_translator9.TranslationLoader.t("okServerListening", import_opticore_translator9.CLocal)}`;
+    const msg2Value = `${import_ansi_colors.default.bgBlue(`${import_ansi_colors.default.bold(`${nodeVersion}`)}`)}`;
+    const msg2 = ` ${import_opticore_translator9.TranslationLoader.t("webServerUseNodeVersion", import_opticore_translator9.CLocal)}`;
+    const msg3Value = `${import_ansi_colors.default.bgBlue(`${import_ansi_colors.default.bold(`${startingTime}`)}`)}`;
+    const msg3 = ` ${import_opticore_translator9.TranslationLoader.t("startupTime", import_opticore_translator9.CLocal)}`;
+    const msg4 = ` ${this.getServerRunningMode("development", "production")}`;
+    const msg5 = ` ${import_ansi_colors.default.underline(`http://${host}:${port}`)}`;
+    console.log(import_chalk.default.bgGreen.white(msg0.padEnd(paddingLength, " ")));
+    console.log(import_chalk.default.bgGreen.white(msg1.padEnd(paddingLength, " ")));
+    console.log(import_chalk.default.bgGreen.white(msg2, msg2Value.padEnd(30.5, " ")));
+    console.log(import_chalk.default.bgGreen.white(msg3, msg3Value.padEnd(56, " ")));
+    console.log(import_chalk.default.bgGreen.white(msg4.padEnd(71, " ")));
+    console.log(import_chalk.default.bgGreen.white(msg5.padEnd(61, " ")));
+    console.log(import_chalk.default.bgGreen.white(msg0.padEnd(paddingLength, " ")));
+    console.log(``);
+    console.log(`${`${import_opticore_translator9.TranslationLoader.t("totalMemory", import_opticore_translator9.CLocal)}`} ${import_ansi_colors.default.cyan(`${import_ansi_colors.default.bold(`${rss}`)}`)}`);
+    console.log(`${`${import_opticore_translator9.TranslationLoader.t("memoryUsedDuringExecution", import_opticore_translator9.CLocal)}`} ${import_ansi_colors.default.cyan(`${import_ansi_colors.default.bold(`${heapUsed}`)}`)}`);
+    console.log(`${`${import_opticore_translator9.TranslationLoader.t("memoryUsedByUser", import_opticore_translator9.CLocal)}`} ${import_ansi_colors.default.cyan(`${import_ansi_colors.default.bold(`${user}`)}`)}`);
+    console.log(`${`${import_opticore_translator9.TranslationLoader.t("memoryUsedBySystem", import_opticore_translator9.CLocal)}`} ${import_ansi_colors.default.cyan(`${import_ansi_colors.default.bold(`${system}`)}`)}`);
+    console.log(``);
+  }
+};
+
+// src/core/events/pathModuleVerifier.event.ts
+var import_path2 = require("path");
+var import_opticore_logger9 = require("opticore-logger");
+var import_opticore_http_response8 = require("opticore-http-response");
+var import_opticore_translator10 = require("opticore-translator");
+var PathModuleVerifier = class {
+  /**
+   * Verifies if modules at specific paths are loaded.
+   * If any module is not loaded, it throws an error.
+   * @param modulePaths - An array of paths to the modules to verify.
+   */
+  static verifyModulePaths(modulePaths) {
+    const notLoadedPaths = [];
+    for (const modulePath of modulePaths) {
+      if (!this.isModulePathLoaded(modulePath)) {
+        notLoadedPaths.push(modulePath);
+      }
+    }
+    if (notLoadedPaths.length > 0) {
+      this.log.error(
+        import_opticore_translator10.TranslationLoader.t("moduleNotLoaded", import_opticore_translator10.CLocal, { notLoadedPaths: notLoadedPaths.join(", ") }),
+        "",
+        "",
+        modulePaths,
+        import_opticore_http_response8.HttpStatusCode.NOT_ACCEPTABLE
+      );
+      throw new Error();
+    }
+  }
+  /**
+   * Checks if a specific module at a given path is loaded in the Node.js require cache.
+   * @param modulePath - The path to the module.
+   * @returns True if the module is loaded, false otherwise.
+   */
+  static isModulePathLoaded(modulePath) {
+    try {
+      const resolvedPath = (0, import_path2.resolve)(modulePath);
+      return require.cache[resolvedPath] !== void 0;
+    } catch (e) {
+      return false;
+    }
+  }
+};
+PathModuleVerifier.log = new import_opticore_logger9.LoggerCore(loggerConfig);
+
+// src/core/config/loaders/translateLanguage.loader.ts
+var import_path3 = __toESM(require("path"), 1);
+var import_opticore_translator11 = require("opticore-translator");
+var import_opticore_env_access4 = require("opticore-env-access");
+var translateLanguageLoader = () => {
+  import_opticore_translator11.TranslationLoader.loadTranslations(import_path3.default.join(process.cwd(), "src", "utils", "translations"), import_opticore_env_access4.getEnvVariable.defaultLocal);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLogLevel,
+  CSignRSAKeyComponent,
+  Environment,
+  MMongoCheckerDatabase,
+  MMySqlCheckerDatabase,
+  MPostgresCheckerDatabase,
+  PathModuleVerifier,
+  RSAKeyDecryption,
+  RSAKeyEncryption,
+  SAsymmetricCryptionDataWithPrivateRSAKey,
+  SAsymmetricCryptionDataWithPublicRSAKey,
+  SCheckerMongoDatabaseConnection,
+  SCheckerMySqlDatabaseConnection,
+  SCheckerPostgresDatabaseConnection,
+  Utility,
+  YamlParsing,
+  dateTimeFormatted,
+  loggerConfig,
+  optionalArgumentConnectionUtil,
+  translateLanguageLoader
+});