opticore-webapp-core 1.0.0

package/dist/index.js

@@ -0,0 +1,1128 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/application/services/asymmetricCryptionDataWithPrivateRSAKey.service.ts
+import crypto3 from "crypto";
+import { HttpStatusCode as status } from "opticore-http-response";
+import { LoggerCore } from "opticore-logger";
+import { CLocal, TranslationLoader } from "opticore-translator";
+import { StackTraceError as ErrorHandler } from "opticore-catch-exception-error";
+
+// src/utils/cryptography/encryption/rsaKey.encryption.ts
+import crypto from "crypto";
+
+// 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 crypto.privateEncrypt(rsaPrivateKey, bufferData);
+  }
+  static publicEncrypt(publicKey, encryptData) {
+    const rsaPublicKey = { key: publicKey };
+    const bufferData = Buffer.from(encryptData, CSignRSAKeyComponent.encodingFormat.utf8);
+    return crypto.publicEncrypt(rsaPublicKey, bufferData);
+  }
+};
+
+// src/utils/cryptography/decryption/rsaKey.decryption.ts
+import crypto2 from "crypto";
+var RSAKeyDecryption = class {
+  static privateDecrypt(privateKey, decryptData) {
+    const rsaPrivateKey = { key: privateKey };
+    return crypto2.privateDecrypt(rsaPrivateKey, decryptData);
+  }
+  static publicDecrypt(publicKey, decryptData) {
+    const rsaPublicKey = { key: publicKey };
+    return crypto2.publicDecrypt(rsaPublicKey, decryptData);
+  }
+};
+
+// src/core/config/logger/logger.config.ts
+import { getEnvVariable } from "opticore-env-access";
+var loggerConfig = {
+  logLevels: [
+    getEnvVariable.logLevelInfo,
+    getEnvVariable.logLevelWarning,
+    getEnvVariable.logLevelSuccess,
+    getEnvVariable.logLevelError,
+    getEnvVariable.logLevelDebug
+  ],
+  transports: {
+    file: {
+      enabled: getEnvVariable.logFileEnabled,
+      maxSizeMB: getEnvVariable.logFileMaxSize,
+      rotate: getEnvVariable.logFileRotate
+    },
+    console: {
+      enabled: getEnvVariable.logConsoleEnabled
+    },
+    remote: {
+      enabled: getEnvVariable.logRemoteEnabled,
+      endpoint: 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 + " " + TranslationLoader.t("rsaKeyNotFound", CLocal),
+        TranslationLoader.t("erBadDbError", CLocal),
+        status.NOT_FOUND
+      );
+      this.log.error(
+        TranslationLoader.t("rsaKeyNotFound", CLocal),
+        TranslationLoader.t("verifyExistingKey", CLocal),
+        TranslationLoader.t("erBadDbError", CLocal),
+        stackTrace.stack,
+        status.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(
+        TranslationLoader.t("encryptionWithPrivateKeyFailed", CLocal),
+        TranslationLoader.t("encryptionFailed", CLocal),
+        status.NOT_FOUND
+      );
+      this.log.error(
+        err.message,
+        TranslationLoader.t("encryptionFailed", CLocal),
+        TranslationLoader.t("encryptionWithPrivateKeyFailed", CLocal),
+        stackTrace.stack,
+        status.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(
+        TranslationLoader.t("errorDecryption", CLocal),
+        TranslationLoader.t("decryptionFailed", CLocal),
+        status.NOT_ACCEPTABLE
+      );
+      this.log.error(
+        TranslationLoader.t("decryptionWithPublicKeyFailed", CLocal),
+        TranslationLoader.t("decryptionFailed", CLocal),
+        stackTrace.stack,
+        TranslationLoader.t("errorDecryption", CLocal),
+        status.NOT_ACCEPTABLE
+      );
+      throw new Error();
+    }
+  }
+  /**
+   *
+   * @param privateKey
+   * @param payload
+   * @private
+   */
+  static signWithRSAKey(privateKey, payload) {
+    this.verifyExistingKey(privateKey, CSignRSAKeyComponent.keyType.private);
+    const sign = crypto3.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 = crypto3.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(
+          TranslationLoader.t("signatureRSAKeyFailed", CLocal),
+          TranslationLoader.t("verifyRSAKeyFailed", CLocal),
+          status.NOT_ACCEPTABLE
+        );
+        this.log.error(
+          TranslationLoader.t("verifyRSAKey", CLocal),
+          TranslationLoader.t("verifyRSAKeyFailed", CLocal),
+          stackTrace.stack,
+          TranslationLoader.t("signatureRSAKeyFailed", CLocal),
+          status.NOT_FOUND
+        );
+        return new Error();
+      }
+    } catch (err) {
+      const stackTrace = this.traceError(
+        err.name,
+        TranslationLoader.t("signatureRSAKeysError", CLocal),
+        status.NOT_ACCEPTABLE
+      );
+      this.log.error(
+        TranslationLoader.t("signatureRSAKeysError", CLocal),
+        TranslationLoader.t("errorNameNotVerifyingRSAKey", CLocal),
+        stackTrace.stack,
+        err.message,
+        status.NOT_FOUND
+      );
+      throw new Error();
+    }
+  }
+  /**
+   *
+   * @param props
+   * @param name
+   * @param status
+   * @private
+   */
+  static traceError(props, name, status7) {
+    return new ErrorHandler(props, name, status7, true);
+  }
+};
+SAsymmetricCryptionDataWithPrivateRSAKey.log = new LoggerCore(loggerConfig);
+
+// src/application/services/asymmetricCryptionDataWithPublicRSAKey.service.ts
+import crypto4 from "crypto";
+import { LoggerCore as LoggerCore2 } from "opticore-logger";
+import { CLocal as CLocal2, TranslationLoader as TranslationLoader2 } from "opticore-translator";
+import { HttpStatusCode as status2 } from "opticore-http-response";
+import { StackTraceError } from "opticore-catch-exception-error";
+var SAsymmetricCryptionDataWithPublicRSAKey = class {
+  /**
+   *
+   * @param rsaKey
+   * @param keyType
+   * @protected
+   */
+  static verifyExistingKey(rsaKey, keyType) {
+    if (!rsaKey) {
+      const stackTrace = this.traceError(
+        keyType + TranslationLoader2.t("verifyExistingKey", CLocal2),
+        TranslationLoader2.t("verifyExistingKey", CLocal2),
+        status2.NOT_FOUND
+      );
+      this.log.error(
+        TranslationLoader2.t("verifyExistingKey", CLocal2),
+        "key verification",
+        stackTrace.stack,
+        TranslationLoader2.t("verifyExistingKeyError", CLocal2),
+        status2.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,
+        TranslationLoader2.t("encryptionWithPublicKey", CLocal2),
+        status2.NOT_ACCEPTABLE
+      );
+      this.log.error(
+        TranslationLoader2.t("errorEncryptionPublicKey", CLocal2),
+        TranslationLoader2.t("encryptionWithPublicKey", CLocal2),
+        stackTrace.stack,
+        err.message,
+        status2.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,
+        TranslationLoader2.t("errorDecryption", CLocal2),
+        status2.NOT_ACCEPTABLE
+      );
+      this.log.error(
+        TranslationLoader2.t("errorDecryptionWithPrivateKey", CLocal2),
+        TranslationLoader2.t("errorDecryption", CLocal2),
+        stackTrace.stack,
+        err.message,
+        status2.NOT_ACCEPTABLE
+      );
+      throw new Error();
+    }
+  }
+  /**
+   *
+   * @param publicKey
+   * @param payload
+   * @private
+   */
+  static signWithPublicRSAKey(publicKey, payload) {
+    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.private);
+    const sign = crypto4.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 = crypto4.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(
+          TranslationLoader2.t("verifyPublicRSAKeyError", CLocal2),
+          TranslationLoader2.t("signatureRSAKeyFailed", CLocal2),
+          status2.NOT_FOUND
+        );
+        this.log.error(
+          TranslationLoader2.t("verifyPublicRSAKey", CLocal2),
+          TranslationLoader2.t("signatureRSAKeyFailed", CLocal2),
+          stackTrace.stack,
+          TranslationLoader2.t("verifyPublicRSAKeyError", CLocal2),
+          status2.NOT_FOUND
+        );
+        return stackTrace;
+      }
+    } catch (err) {
+      const stackTrace = this.traceError(
+        err.code,
+        TranslationLoader2.t("verifyPublicRSAKey", CLocal2),
+        status2.NOT_ACCEPTABLE
+      );
+      this.log.error(
+        TranslationLoader2.t("verifyPublicRSAKey", CLocal2),
+        TranslationLoader2.t("errorDecryption", CLocal2),
+        stackTrace.stack,
+        err.message,
+        status2.NOT_ACCEPTABLE
+      );
+      throw new Error();
+    }
+  }
+  static traceError(props, name, status7) {
+    return new StackTraceError(props, name, status7, true);
+  }
+};
+SAsymmetricCryptionDataWithPublicRSAKey.log = new LoggerCore2(loggerConfig);
+
+// src/application/services/checkerMongoDatabaseConnection.service.ts
+import { MongoClient } from "mongodb";
+async function SCheckerMongoDatabaseConnection(url, user, password, dbName) {
+  const client = new MongoClient(
+    url,
+    {
+      auth: { username: user, password }
+    }
+  );
+  await client.connect();
+}
+
+// src/core/handlers/errors/database/mySqlError.handler.database.ts
+import { LoggerCore as LoggerCore3 } from "opticore-logger";
+import { HttpStatusCode as status3 } from "opticore-http-response";
+import { CLocal as CLocal3, TranslationLoader as TranslationLoader3 } from "opticore-translator";
+function mySqlErrorHandlerDatabase(err, dbHost, database, user, password) {
+  const logger = new LoggerCore3(loggerConfig);
+  switch (err.code) {
+    case "EAI_AGAIN":
+      logger.error(
+        TranslationLoader3.t("errorDBHost", CLocal3, { dbHost }),
+        TranslationLoader3.t("mySQLError", CLocal3),
+        TranslationLoader3.t("eAiAgain", CLocal3),
+        err.stack,
+        status3.NOT_ACCEPTABLE
+      );
+      break;
+    case "ER_NOT_SUPPORTED_AUTH_MODE":
+      logger.error(
+        TranslationLoader3.t("erNotSupportedAuthModeError", CLocal3),
+        TranslationLoader3.t("dbConnection", CLocal3),
+        TranslationLoader3.t("erNotSupportedAuthMode", CLocal3),
+        err.stack,
+        status3.NOT_ACCEPTABLE
+      );
+      break;
+    case "ER_ACCESS_DENIED_ERROR":
+      logger.error(
+        TranslationLoader3.t("accessDeniedToDBCon", CLocal3, { user, password }),
+        TranslationLoader3.t("dbConnection", CLocal3),
+        TranslationLoader3.t("erAccessDeniedError", CLocal3),
+        err.stack,
+        status3.NOT_ACCEPTABLE
+      );
+      break;
+    case "ER_BAD_DB_ERROR":
+      logger.error(
+        TranslationLoader3.t("unknownDB", CLocal3, { database }),
+        TranslationLoader3.t("dbConnection", CLocal3),
+        TranslationLoader3.t("erBadDbError", CLocal3),
+        err.stack,
+        status3.NOT_ACCEPTABLE
+      );
+      break;
+    default:
+      logger.error(
+        err.message,
+        TranslationLoader3.t("dbConnection", CLocal3),
+        TranslationLoader3.t("mysqlErrorCon", CLocal3),
+        err.stack,
+        status3.NOT_ACCEPTABLE
+      );
+      break;
+  }
+}
+
+// src/application/services/checkerMySqlDatabaseConnection.service.ts
+import { LoggerCore as LoggerCore4 } from "opticore-logger";
+import { CLocal as CLocal4, TranslationLoader as TranslationLoader4 } from "opticore-translator";
+function SCheckerMySqlDatabaseConnection(dbConnection, user, database, dbHost, password) {
+  const log = new LoggerCore4(loggerConfig);
+  dbConnection.connect((err) => {
+    if (err) {
+      return mySqlErrorHandlerDatabase(err, dbHost, database, user, password);
+    } else {
+      log.success(
+        TranslationLoader4.t("dbConnection", CLocal4),
+        TranslationLoader4.t("dbConnexionSuccess", CLocal4)
+      );
+      return dbConnection.end((endConErr) => {
+        if (endConErr) {
+          return mySqlErrorHandlerDatabase(err, dbHost, database, user, password);
+        } else {
+          log.success(
+            TranslationLoader4.t("dbConnection", CLocal4),
+            TranslationLoader4.t("dbConnectionClosed", CLocal4)
+          );
+          console.log("");
+        }
+      });
+    }
+  });
+}
+
+// src/application/services/checkerPostgresDatabaseConnection.service.ts
+import { HttpStatusCode as status4 } from "opticore-http-response";
+import { Client } from "pg";
+import { LoggerCore as LoggerCore5 } from "opticore-logger";
+import { CLocal as CLocal5, TranslationLoader as TranslationLoader5 } from "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 LoggerCore5(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 Client(configOptions);
+  await client.connect();
+  await client.end().then(
+    () => {
+      logger.success(
+        TranslationLoader5.t("postgresSuccessConn", CLocal5),
+        TranslationLoader5.t("postgresClosingConnSuccess", CLocal5)
+      );
+    },
+    (onRejected) => {
+      logger.error(
+        TranslationLoader5.t("postgresEndClientRejection", CLocal5),
+        TranslationLoader5.t("postgresClientError", CLocal5),
+        TranslationLoader5.t("postgresEndRejection", CLocal5),
+        onRejected,
+        status4.BAD_REQUEST
+      );
+    }
+  ).catch((onError) => {
+    logger.error(
+      onError.message,
+      TranslationLoader5.t("postgresConnError", CLocal5),
+      TranslationLoader5.t("postgresException", CLocal5),
+      onError.stack,
+      status4.BAD_REQUEST
+    );
+  });
+}
+
+// src/domains/constants/logLevel.constant.ts
+var CLogLevel = {
+  debug: "DEBUG",
+  info: "INFO",
+  warn: "WARN",
+  error: "ERROR"
+};
+
+// src/utils/connection/optionalArgumentConnection.util.ts
+import { getEnvVariable as getEnvVariable2 } from "opticore-env-access";
+var optionalArgumentConnectionUtil = getEnvVariable2.argumentsDatabaseConnection;
+
+// src/utils/parsing/parsingYaml.utils.ts
+import { readFile } from "fs/promises";
+import { HttpStatusCode } from "opticore-http-response";
+import { LoggerCore as LoggerCore6 } from "opticore-logger";
+import { CLocal as CLocal6, TranslationLoader as TranslationLoader6 } from "opticore-translator";
+var YamlParsing = class {
+  static async readFile(filePath) {
+    try {
+      const yamlContent = await readFile(filePath, "utf-8");
+      await this.parsing(yamlContent);
+    } catch (error) {
+      this.logger.error(
+        error.message,
+        TranslationLoader6.t("parsingFailed", CLocal6),
+        TranslationLoader6.t("readingError", CLocal6),
+        error.stack,
+        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(
+          TranslationLoader6.t("badFormat", CLocal6, { line }),
+          TranslationLoader6.t("parsingFailed", CLocal6),
+          TranslationLoader6.t("unsupportedFormat", CLocal6),
+          content,
+          HttpStatusCode.NOT_ACCEPTABLE
+        );
+      }
+    }
+    return result;
+  }
+};
+YamlParsing.logger = new LoggerCore6(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
+import mySQL from "mysql";
+import { HttpStatusCode as status6 } from "opticore-http-response";
+import { getEnvVariable as getEnvVariable3 } from "opticore-env-access";
+import { LoggerCore as LoggerCore8 } from "opticore-logger";
+import { CLocal as CLocal8, TranslationLoader as TranslationLoader8 } from "opticore-translator";
+
+// src/core/errors/databaseConnexion.error.ts
+import { HttpStatusCode as status5 } from "opticore-http-response";
+import { LoggerCore as LoggerCore7 } from "opticore-logger";
+import { StackTraceError as StackTraceError2 } from "opticore-catch-exception-error";
+import { CLocal as CLocal7, TranslationLoader as TranslationLoader7 } from "opticore-translator";
+var DbConnexionConfigError = class {
+  /**
+   *
+   * @param e
+   */
+  static mongoDBAuthenticationFailed(e) {
+    const stackTrace = this.traceError(
+      TranslationLoader7.t("mongoDBConnection", CLocal7),
+      TranslationLoader7.t("mongoDBAuthentication", CLocal7),
+      status5.UNAUTHORIZED
+    );
+    this.logger.error(
+      TranslationLoader7.t("mongoDBAuthenticationError", CLocal7),
+      TranslationLoader7.t("mongoDBConnection", CLocal7),
+      TranslationLoader7.t("mongoDBAuthenticationFailed", CLocal7),
+      stackTrace.stack,
+      status5.UNAUTHORIZED
+    );
+  }
+  /**
+   *
+   * @param err
+   * @param dbHost
+   * @param dbPort
+   */
+  static mongoDBInvalidUrl(err, dbHost, dbPort) {
+    const stackTrace = this.traceError(
+      TranslationLoader7.t("mongoDBConnection", CLocal7),
+      TranslationLoader7.t("mongoDBUnableParsingUrl", CLocal7),
+      status5.BAD_REQUEST
+    );
+    this.logger.error(
+      TranslationLoader7.t("dbUrlParsingError", CLocal7, { dbHost, dbPort }),
+      TranslationLoader7.t("mongoDBConnection", CLocal7),
+      TranslationLoader7.t("mongoDBUnableParsingUrl", CLocal7),
+      stackTrace.stack,
+      status5.BAD_REQUEST
+    );
+  }
+  /**
+   *
+   * @param err
+   * @param dbHost
+   */
+  static mongoDBEaiAgain(err, dbHost) {
+    const stackTrace = this.traceError(
+      TranslationLoader7.t("mongoDBConnection", CLocal7),
+      TranslationLoader7.t("mongoDBServerSelection", CLocal7),
+      status5.BAD_REQUEST
+    );
+    this.logger.error(
+      TranslationLoader7.t("mongoServerError", CLocal7, { dbHost }),
+      TranslationLoader7.t("mongoDBConnection", CLocal7),
+      TranslationLoader7.t("mongoDBServerSelection", CLocal7),
+      stackTrace.stack,
+      status5.BAD_REQUEST
+    );
+  }
+  /**
+   *
+   * @param err
+   */
+  static mongoDbGlobalError(err) {
+    const stackTrace = this.traceError(
+      err.message,
+      TranslationLoader7.t("mongoDBConnection", CLocal7),
+      status5.NOT_ACCEPTABLE
+    );
+    this.logger.error(
+      TranslationLoader7.t("mongoDBConnection", CLocal7),
+      TranslationLoader7.t("mongoDBConnectionError", CLocal7),
+      stackTrace.stack,
+      err.message,
+      status5.NOT_ACCEPTABLE
+    );
+  }
+  /**
+   *
+   * @param props
+   * @param name
+   * @param status
+   * @private
+   */
+  static traceError(props, name, status7) {
+    return new StackTraceError2(props, name, status7, true);
+  }
+};
+DbConnexionConfigError.logger = new LoggerCore7(loggerConfig);
+
+// src/core/config/database/connexion.config.database.ts
+import { StackTraceError as ErrorHandler2 } from "opticore-catch-exception-error";
+var DatabaseConnectionConfig = class {
+  constructor() {
+    this.env = new Environment(getEnvVariable3);
+    this.logger = new LoggerCore8(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 = mySQL.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(
+        TranslationLoader8.t("mongoDBConnectionChecker", CLocal8),
+        TranslationLoader8.t("mongoConnectionSuccess", CLocal8)
+      );
+      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(TranslationLoader8.t("postgresDBConnectionChecker", CLocal8), TranslationLoader8.t("postgresConnectionSuccess", CLocal8));
+      console.log("");
+    } catch (err) {
+      const stackTrace = this.traceError(
+        TranslationLoader8.t(`${err.message}`, CLocal8),
+        "PostgresConnectionError",
+        status6.NOT_ACCEPTABLE
+      );
+      this.logger.error(
+        err.message,
+        "PostgresConnectionError",
+        "Postgres connection error",
+        stackTrace.stack,
+        status6.NOT_ACCEPTABLE
+      );
+    }
+  }
+  traceError(props, name, status7) {
+    return new ErrorHandler2(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
+import process2 from "node:process";
+import chalk from "chalk";
+import colors from "ansi-colors";
+import path from "path";
+import fs from "fs";
+import { CLocal as CLocal9, TranslationLoader as TranslationLoader9 } from "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 = process2.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 = process2.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(process2.cpuUsage().user),
+      "Memory usage system": this.formatMemoryUsage(process2.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 = process2.hrtime();
+    const endTime = process2.hrtime(startTime);
+    const executionTime = (endTime[0] * 1e9 + endTime[1]) / 1e6;
+    return {
+      "projectPath": path.join(process2.cwd()),
+      "startingTime": `${executionTime.toFixed(5)} ms`
+    };
+  }
+  /**
+   *
+   * @param filePath
+   * @private
+   */
+  getEnvFileLoading(filePath) {
+    const fullPath = path.resolve(process2.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();
+          process2.env[key] = match[2].trim();
+        }
+      });
+    }
+  }
+  /**
+   *
+   * @param development
+   * @param production
+   */
+  getServerRunningMode(development, production) {
+    this.getEnvFileLoading(".env");
+    const isDevelopment = process2.env.NODE_ENV === "development";
+    if (isDevelopment) {
+      return `${TranslationLoader9.t("serverRunning", CLocal9)} ${colors.bgBlue(`${colors.bold(`${development}`)}`)} mode`;
+    } else {
+      return `${TranslationLoader9.t("serverRunning", CLocal9)} ${colors.bgBlue(`${colors.bold(`${production}`)}`)} mode`;
+    }
+  }
+  infoServer(nodeVersion, startingTime, host, port, rss, heapUsed, user, system) {
+    const paddingLength = 52;
+    const msg0 = " ".padEnd(paddingLength, " ");
+    const msg1 = ` ${TranslationLoader9.t("okServerListening", CLocal9)}`;
+    const msg2Value = `${colors.bgBlue(`${colors.bold(`${nodeVersion}`)}`)}`;
+    const msg2 = ` ${TranslationLoader9.t("webServerUseNodeVersion", CLocal9)}`;
+    const msg3Value = `${colors.bgBlue(`${colors.bold(`${startingTime}`)}`)}`;
+    const msg3 = ` ${TranslationLoader9.t("startupTime", CLocal9)}`;
+    const msg4 = ` ${this.getServerRunningMode("development", "production")}`;
+    const msg5 = ` ${colors.underline(`http://${host}:${port}`)}`;
+    console.log(chalk.bgGreen.white(msg0.padEnd(paddingLength, " ")));
+    console.log(chalk.bgGreen.white(msg1.padEnd(paddingLength, " ")));
+    console.log(chalk.bgGreen.white(msg2, msg2Value.padEnd(30.5, " ")));
+    console.log(chalk.bgGreen.white(msg3, msg3Value.padEnd(56, " ")));
+    console.log(chalk.bgGreen.white(msg4.padEnd(71, " ")));
+    console.log(chalk.bgGreen.white(msg5.padEnd(61, " ")));
+    console.log(chalk.bgGreen.white(msg0.padEnd(paddingLength, " ")));
+    console.log(``);
+    console.log(`${`${TranslationLoader9.t("totalMemory", CLocal9)}`} ${colors.cyan(`${colors.bold(`${rss}`)}`)}`);
+    console.log(`${`${TranslationLoader9.t("memoryUsedDuringExecution", CLocal9)}`} ${colors.cyan(`${colors.bold(`${heapUsed}`)}`)}`);
+    console.log(`${`${TranslationLoader9.t("memoryUsedByUser", CLocal9)}`} ${colors.cyan(`${colors.bold(`${user}`)}`)}`);
+    console.log(`${`${TranslationLoader9.t("memoryUsedBySystem", CLocal9)}`} ${colors.cyan(`${colors.bold(`${system}`)}`)}`);
+    console.log(``);
+  }
+};
+
+// src/core/events/pathModuleVerifier.event.ts
+import { resolve } from "path";
+import { LoggerCore as LoggerCore9 } from "opticore-logger";
+import { HttpStatusCode as HttpStatusCode2 } from "opticore-http-response";
+import { CLocal as CLocal10, TranslationLoader as TranslationLoader10 } from "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(
+        TranslationLoader10.t("moduleNotLoaded", CLocal10, { notLoadedPaths: notLoadedPaths.join(", ") }),
+        "",
+        "",
+        modulePaths,
+        HttpStatusCode2.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 = resolve(modulePath);
+      return __require.cache[resolvedPath] !== void 0;
+    } catch (e) {
+      return false;
+    }
+  }
+};
+PathModuleVerifier.log = new LoggerCore9(loggerConfig);
+
+// src/core/config/loaders/translateLanguage.loader.ts
+import path2 from "path";
+import { TranslationLoader as TranslationLoader11 } from "opticore-translator";
+import { getEnvVariable as getEnvVariable4 } from "opticore-env-access";
+var translateLanguageLoader = () => {
+  TranslationLoader11.loadTranslations(path2.join(process.cwd(), "src", "utils", "translations"), getEnvVariable4.defaultLocal);
+};
+export {
+  CLogLevel,
+  CSignRSAKeyComponent,
+  Environment,
+  MMongoCheckerDatabase,
+  MMySqlCheckerDatabase,
+  MPostgresCheckerDatabase,
+  PathModuleVerifier,
+  RSAKeyDecryption,
+  RSAKeyEncryption,
+  SAsymmetricCryptionDataWithPrivateRSAKey,
+  SAsymmetricCryptionDataWithPublicRSAKey,
+  SCheckerMongoDatabaseConnection,
+  SCheckerMySqlDatabaseConnection,
+  SCheckerPostgresDatabaseConnection,
+  Utility,
+  YamlParsing,
+  dateTimeFormatted,
+  loggerConfig,
+  optionalArgumentConnectionUtil,
+  translateLanguageLoader
+};