opticore-webapp-core 1.0.18 → 1.0.20

package/dist/index.js

@@ -141,9 +141,9 @@ var RSAKeyDecryption = class {
 import { LoggerCore } from "opticore-logger";
 
 // src/core/config/logger/logger.config.ts
-import { getEnvironnementValue } from "opticore-env-access";
+import { getEnvironmentValue } from "opticore-env-access";
 var loggerConfig = (envDir) => {
-  const getEnvAccess = getEnvironnementValue(envDir);
+  const getEnvAccess = getEnvironmentValue(envDir);
   return {
     logLevels: [
       getEnvAccess.logLevelInfo,
@@ -170,8 +170,8 @@ var loggerConfig = (envDir) => {
 };
 
 // src/application/services/loggerFileConfiguration.service.ts
-var SLoggerFileConfiguration = (environnementPath) => {
-  return new LoggerCore(loggerConfig(environnementPath));
+var SLoggerFileConfiguration = (environmentPath) => {
+  return new LoggerCore(loggerConfig(environmentPath));
 };
 
 // src/application/services/asymmetricCryptionDataWithPrivateRSAKey.service.ts
@@ -197,14 +197,13 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
         TranslationLoader.t("erBadDbError", this.localeLanguage, this.log),
         status.NOT_FOUND
       );
-      this.log.error(
-        TranslationLoader.t("rsaKeyNotFound", this.localeLanguage, this.log),
-        TranslationLoader.t("verifyExistingKey", this.localeLanguage, this.log),
-        TranslationLoader.t("erBadDbError", this.localeLanguage, this.log),
-        stackTrace.stack,
-        status.NOT_FOUND
-      );
-      throw new Error();
+      this.log.error({
+        message: TranslationLoader.t("rsaKeyNotFound", this.localeLanguage, this.log),
+        title: TranslationLoader.t("verifyExistingKey", this.localeLanguage, this.log),
+        errorType: TranslationLoader.t("erBadDbError", this.localeLanguage, this.log),
+        stackTrace: stackTrace.stack,
+        httpCodeValue: status.NOT_FOUND
+      });
     }
     return rsaKey;
   }
@@ -227,14 +226,14 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
         TranslationLoader.t("encryptionFailed", this.localeLanguage, this.log),
         status.NOT_FOUND
       );
-      this.log.error(
-        err.message,
-        TranslationLoader.t("encryptionFailed", this.localeLanguage, this.log),
-        TranslationLoader.t("encryptionWithPrivateKeyFailed", this.localeLanguage, this.log),
-        stackTrace.stack,
-        status.NOT_FOUND
-      );
-      throw new Error();
+      this.log.error({
+        message: err.message,
+        title: TranslationLoader.t("encryptionFailed", this.localeLanguage, this.log),
+        errorType: TranslationLoader.t("encryptionWithPrivateKeyFailed", this.localeLanguage, this.log),
+        stackTrace: stackTrace.stack,
+        httpCodeValue: status.NOT_FOUND
+      });
+      process.exit();
     }
   }
   /**
@@ -255,14 +254,14 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
         TranslationLoader.t("decryptionFailed", this.localeLanguage, this.log),
         status.NOT_ACCEPTABLE
       );
-      this.log.error(
-        TranslationLoader.t("decryptionWithPublicKeyFailed", this.localeLanguage, this.log),
-        TranslationLoader.t("decryptionFailed", this.localeLanguage, this.log),
-        stackTrace.stack,
-        TranslationLoader.t("errorDecryption", this.localeLanguage, this.log),
-        status.NOT_ACCEPTABLE
-      );
-      throw new Error();
+      this.log.error({
+        message: TranslationLoader.t("decryptionWithPublicKeyFailed", this.localeLanguage, this.log),
+        title: TranslationLoader.t("decryptionFailed", this.localeLanguage, this.log),
+        errorType: TranslationLoader.t("errorDecryption", this.localeLanguage, this.log),
+        stackTrace: stackTrace.stack,
+        httpCodeValue: status.NOT_ACCEPTABLE
+      });
+      process.exit();
     }
   }
   /**
@@ -298,14 +297,14 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
           TranslationLoader.t("verifyRSAKeyFailed", this.localeLanguage, this.log),
           status.NOT_ACCEPTABLE
         );
-        this.log.error(
-          TranslationLoader.t("verifyRSAKey", this.localeLanguage, this.log),
-          TranslationLoader.t("verifyRSAKeyFailed", this.localeLanguage, this.log),
-          stackTrace.stack,
-          TranslationLoader.t("signatureRSAKeyFailed", this.localeLanguage, this.log),
-          status.NOT_FOUND
-        );
-        return new Error();
+        this.log.error({
+          message: TranslationLoader.t("verifyRSAKey", this.localeLanguage, this.log),
+          title: TranslationLoader.t("verifyRSAKeyFailed", this.localeLanguage, this.log),
+          errorType: TranslationLoader.t("signatureRSAKeyFailed", this.localeLanguage, this.log),
+          stackTrace: stackTrace.stack,
+          httpCodeValue: status.NOT_FOUND
+        });
+        process.exit();
       }
     } catch (err) {
       const stackTrace = this.traceError(
@@ -313,14 +312,14 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
         TranslationLoader.t("signatureRSAKeysError", this.localeLanguage, this.log),
         status.NOT_ACCEPTABLE
       );
-      this.log.error(
-        TranslationLoader.t("signatureRSAKeysError", this.localeLanguage, this.log),
-        TranslationLoader.t("errorNameNotVerifyingRSAKey", this.localeLanguage, this.log),
-        stackTrace.stack,
-        err.message,
-        status.NOT_FOUND
-      );
-      throw new Error();
+      this.log.error({
+        message: TranslationLoader.t("signatureRSAKeysError", this.localeLanguage, this.log),
+        title: TranslationLoader.t("errorNameNotVerifyingRSAKey", this.localeLanguage, this.log),
+        errorType: err.name,
+        stackTrace: stackTrace.stack,
+        httpCodeValue: status.NOT_FOUND
+      });
+      process.exit();
     }
   }
   /**
@@ -330,15 +329,15 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
    * @param status
    * @private
    */
-  traceError(props, name, status7) {
-    return new ErrorHandler(props, name, status7, true);
+  traceError(props, name, status2) {
+    return new ErrorHandler(props, name, status2, true);
   }
 };
 
 // src/application/services/asymmetricCryptionDataWithPublicRSAKey.service.ts
 import crypto4 from "crypto";
 import { TranslationLoader as TranslationLoader2 } from "opticore-translator";
-import { HttpStatusCode as status2 } from "opticore-http-response";
+import { HttpStatusCode } from "opticore-http-response";
 import { StackTraceError } from "opticore-catch-exception-error";
 var SAsymmetricCryptionDataWithPublicRSAKey = class {
   logger;
@@ -357,18 +356,17 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
   verifyExistingKey(rsaKey, keyType) {
     if (!rsaKey) {
       const stackTrace = this.traceError(
-        keyType + TranslationLoader2.t("verifyExistingKey", this.localeLanguage, this.logger),
-        TranslationLoader2.t("verifyExistingKey", this.localeLanguage, this.logger),
-        status2.NOT_FOUND
+        keyType + TranslationLoader2.t("verifyExistingKey", this.localeLanguage),
+        TranslationLoader2.t("verifyExistingKey", this.localeLanguage),
+        HttpStatusCode.NOT_FOUND
       );
-      this.logger.error(
-        TranslationLoader2.t("verifyExistingKey", this.localeLanguage, this.logger),
-        "key verification",
-        stackTrace.stack,
-        TranslationLoader2.t("verifyExistingKeyError", this.localeLanguage, this.logger),
-        status2.NOT_FOUND
-      );
-      return new Error();
+      this.logger.error({
+        message: TranslationLoader2.t("verifyExistingKey", this.localeLanguage),
+        title: "key verification",
+        errorType: TranslationLoader2.t("verifyExistingKeyError", this.localeLanguage),
+        stackTrace: stackTrace.stack,
+        httpCodeValue: HttpStatusCode.NOT_FOUND
+      });
     }
     return rsaKey;
   }
@@ -387,17 +385,17 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
     } catch (err) {
       const stackTrace = this.traceError(
         err.message,
-        TranslationLoader2.t("encryptionWithPublicKey", this.localeLanguage, this.logger),
-        status2.NOT_ACCEPTABLE
+        TranslationLoader2.t("encryptionWithPublicKey", this.localeLanguage),
+        HttpStatusCode.NOT_ACCEPTABLE
       );
-      this.logger.error(
-        TranslationLoader2.t("errorEncryptionPublicKey", this.localeLanguage, this.logger),
-        TranslationLoader2.t("encryptionWithPublicKey", this.localeLanguage, this.logger),
-        stackTrace.stack,
-        err.message,
-        status2.NOT_ACCEPTABLE
-      );
-      throw new Error();
+      this.logger.error({
+        message: TranslationLoader2.t("errorEncryptionPublicKey", this.localeLanguage),
+        title: TranslationLoader2.t("encryptionWithPublicKey", this.localeLanguage),
+        errorType: err.code,
+        stackTrace: stackTrace.stack,
+        httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+      });
+      process.exit();
     }
   }
   /**
@@ -416,17 +414,17 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
     } catch (err) {
       const stackTrace = this.traceError(
         err.code,
-        TranslationLoader2.t("errorDecryption", this.localeLanguage, this.logger),
-        status2.NOT_ACCEPTABLE
-      );
-      this.logger.error(
-        TranslationLoader2.t("errorDecryptionWithPrivateKey", this.localeLanguage, this.logger),
-        TranslationLoader2.t("errorDecryption", this.localeLanguage, this.logger),
-        stackTrace.stack,
-        err.message,
-        status2.NOT_ACCEPTABLE
+        TranslationLoader2.t("errorDecryption", this.localeLanguage),
+        HttpStatusCode.NOT_ACCEPTABLE
       );
-      throw new Error();
+      this.logger.error({
+        message: TranslationLoader2.t("errorDecryptionWithPrivateKey", this.localeLanguage),
+        title: TranslationLoader2.t("errorDecryption", this.localeLanguage),
+        errorType: err.message,
+        stackTrace: stackTrace.stack,
+        httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+      });
+      process.exit();
     }
   }
   /**
@@ -460,183 +458,40 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
         return decryptedData.toString(CSignRSAKeyComponent.encodingFormat.utf_8);
       } else {
         const stackTrace = this.traceError(
-          TranslationLoader2.t("verifyPublicRSAKeyError", this.localeLanguage, this.logger),
-          TranslationLoader2.t("signatureRSAKeyFailed", this.localeLanguage, this.logger),
-          status2.NOT_FOUND
-        );
-        this.logger.error(
-          TranslationLoader2.t("verifyPublicRSAKey", this.localeLanguage, this.logger),
-          TranslationLoader2.t("signatureRSAKeyFailed", this.localeLanguage, this.logger),
-          stackTrace.stack,
-          TranslationLoader2.t("verifyPublicRSAKeyError", this.localeLanguage, this.logger),
-          status2.NOT_FOUND
+          TranslationLoader2.t("verifyPublicRSAKeyError", this.localeLanguage),
+          TranslationLoader2.t("signatureRSAKeyFailed", this.localeLanguage),
+          HttpStatusCode.NOT_FOUND
         );
+        this.logger.error({
+          message: TranslationLoader2.t("verifyPublicRSAKey", this.localeLanguage),
+          title: TranslationLoader2.t("signatureRSAKeyFailed", this.localeLanguage),
+          errorType: TranslationLoader2.t("verifyPublicRSAKeyError", this.localeLanguage),
+          stackTrace: stackTrace.stack,
+          httpCodeValue: HttpStatusCode.NOT_FOUND
+        });
         return stackTrace;
       }
     } catch (err) {
       const stackTrace = this.traceError(
         err.code,
-        TranslationLoader2.t("verifyPublicRSAKey", this.localeLanguage, this.logger),
-        status2.NOT_ACCEPTABLE
+        TranslationLoader2.t("verifyPublicRSAKey", this.localeLanguage),
+        HttpStatusCode.NOT_ACCEPTABLE
       );
-      this.logger.error(
-        TranslationLoader2.t("verifyPublicRSAKey", this.localeLanguage, this.logger),
-        TranslationLoader2.t("errorDecryption", this.localeLanguage, this.logger),
-        stackTrace.stack,
-        err.message,
-        status2.NOT_ACCEPTABLE
-      );
-      throw new Error();
+      this.logger.error({
+        message: TranslationLoader2.t("verifyPublicRSAKey", this.localeLanguage),
+        title: TranslationLoader2.t("errorDecryption", this.localeLanguage),
+        errorType: err.message,
+        stackTrace: stackTrace.stack,
+        httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+      });
+      process.exit();
     }
   }
-  traceError(props, name, status7) {
-    return new StackTraceError(props, name, status7, true);
+  traceError(props, name, HttpStatusCode6) {
+    return new StackTraceError(props, name, HttpStatusCode6, true);
   }
 };
 
-// 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 LoggerCore2 } from "opticore-logger";
-import { HttpStatusCode as status3 } from "opticore-http-response";
-import { TranslationLoader as TranslationLoader3 } from "opticore-translator";
-function mySqlErrorHandlerDatabase(localLanguage, environnementPath, err, dbHost, database, user, password) {
-  const logger = new LoggerCore2(loggerConfig(environnementPath));
-  switch (err.code) {
-    case "EAI_AGAIN":
-      logger.error(
-        TranslationLoader3.t("errorDBHost", localLanguage, { dbHost }),
-        TranslationLoader3.t("mySQLError", localLanguage),
-        TranslationLoader3.t("eAiAgain", localLanguage),
-        err.stack,
-        status3.NOT_ACCEPTABLE
-      );
-      break;
-    case "ER_NOT_SUPPORTED_AUTH_MODE":
-      logger.error(
-        TranslationLoader3.t("erNotSupportedAuthModeError", localLanguage),
-        TranslationLoader3.t("dbConnection", localLanguage),
-        TranslationLoader3.t("erNotSupportedAuthMode", localLanguage),
-        err.stack,
-        status3.NOT_ACCEPTABLE
-      );
-      break;
-    case "ER_ACCESS_DENIED_ERROR":
-      logger.error(
-        TranslationLoader3.t("accessDeniedToDBCon", localLanguage, { user, password }),
-        TranslationLoader3.t("dbConnection", localLanguage),
-        TranslationLoader3.t("erAccessDeniedError", localLanguage),
-        err.stack,
-        status3.NOT_ACCEPTABLE
-      );
-      break;
-    case "ER_BAD_DB_ERROR":
-      logger.error(
-        TranslationLoader3.t("unknownDB", localLanguage, { database }),
-        TranslationLoader3.t("dbConnection", localLanguage),
-        TranslationLoader3.t("erBadDbError", localLanguage),
-        err.stack,
-        status3.NOT_ACCEPTABLE
-      );
-      break;
-    default:
-      logger.error(
-        err.message,
-        TranslationLoader3.t("dbConnection", localLanguage),
-        TranslationLoader3.t("mysqlErrorCon", localLanguage),
-        err.stack,
-        status3.NOT_ACCEPTABLE
-      );
-      break;
-  }
-}
-
-// src/application/services/checkerMySqlDatabaseConnection.service.ts
-import { TranslationLoader as TranslationLoader4 } from "opticore-translator";
-function SCheckerMySqlDatabaseConnection(localeLanguage, environnementPath, dbConnection, user, database, dbHost, password) {
-  const logger = SLoggerFileConfiguration(environnementPath);
-  dbConnection.connect((err) => {
-    if (err) {
-      return mySqlErrorHandlerDatabase(localeLanguage, environnementPath, err, dbHost, database, user, password);
-    } else {
-      logger.success(
-        TranslationLoader4.t("dbConnection", localeLanguage, logger),
-        TranslationLoader4.t("dbConnexionSuccess", localeLanguage, logger)
-      );
-      return dbConnection.end((endConErr) => {
-        if (endConErr) {
-          return mySqlErrorHandlerDatabase(localeLanguage, environnementPath, err, dbHost, database, user, password);
-        } else {
-          logger.success(
-            TranslationLoader4.t("dbConnection", localeLanguage, logger),
-            TranslationLoader4.t("dbConnectionClosed", localeLanguage, logger)
-          );
-          console.log("");
-        }
-      });
-    }
-  });
-}
-
-// src/application/services/checkerPostgresDatabaseConnection.service.ts
-import { HttpStatusCode as status4 } from "opticore-http-response";
-import pg from "pg";
-import { TranslationLoader as TranslationLoader5 } from "opticore-translator";
-async function SCheckerPostgresDatabaseConnection(localeLanguage, environnementPath, connectionString, keepAlive, stream, statement_timeout, ssl, query_timeout, keepAliveInitialDelayMillis, idle_in_transaction_session_timeout, application_name, connectionTimeoutMillis, types, options) {
-  const logger = SLoggerFileConfiguration(environnementPath);
-  const configOptions = {
-    connectionString,
-    keepAlive,
-    stream,
-    statement_timeout,
-    ssl,
-    query_timeout,
-    keepAliveInitialDelayMillis,
-    idle_in_transaction_session_timeout,
-    application_name,
-    connectionTimeoutMillis,
-    types,
-    options
-  };
-  const client = new pg.Client(configOptions);
-  await client.connect();
-  await client.end().then(
-    () => {
-      logger.success(
-        TranslationLoader5.t("postgresSuccessConn", localeLanguage, logger),
-        TranslationLoader5.t("postgresClosingConnSuccess", localeLanguage, logger)
-      );
-    },
-    (onRejected) => {
-      logger.error(
-        TranslationLoader5.t("postgresEndClientRejection", localeLanguage, logger),
-        TranslationLoader5.t("postgresClientError", localeLanguage, logger),
-        TranslationLoader5.t("postgresEndRejection", localeLanguage, logger),
-        onRejected,
-        status4.BAD_REQUEST
-      );
-    }
-  ).catch((onError) => {
-    logger.error(
-      onError.message,
-      TranslationLoader5.t("postgresConnError", localeLanguage, logger),
-      TranslationLoader5.t("postgresException", localeLanguage, logger),
-      onError.stack,
-      status4.BAD_REQUEST
-    );
-  });
-}
-
 // src/domains/constants/logLevel.constant.ts
 var CLogLevel = {
   debug: "DEBUG",
@@ -645,38 +500,31 @@ var CLogLevel = {
   error: "ERROR"
 };
 
-// src/utils/connection/optionalArgumentConnection.util.ts
-import { getEnvironnementValue as getEnvironnementValue2 } from "opticore-env-access";
-var UOptionalArgumentConnection = (environnementPath) => {
-  const envPath = getEnvironnementValue2(environnementPath);
-  return envPath.argumentsDatabaseConnection;
-};
-
 // src/utils/parsing/parsingYaml.utils.ts
 import { readFile } from "fs/promises";
-import { HttpStatusCode as HttpStatusCode2 } from "opticore-http-response";
-import { LoggerCore as LoggerCore3 } from "opticore-logger";
-import { TranslationLoader as TranslationLoader7 } from "opticore-translator";
+import { HttpStatusCode as HttpStatusCode3 } from "opticore-http-response";
+import { LoggerCore as LoggerCore2 } from "opticore-logger";
+import { TranslationLoader as TranslationLoader4 } from "opticore-translator";
 
 // src/core/config/loaders/translateLanguage.loader.ts
 import path from "path";
 import { createRequire } from "module";
-import { TranslationLoader as TranslationLoader6 } from "opticore-translator";
-import { HttpStatusCode } from "opticore-http-response";
-var translateWebAppCoreLanguageLoader = (environnementPath, localLang) => {
+import { TranslationLoader as TranslationLoader3 } from "opticore-translator";
+import { HttpStatusCode as HttpStatusCode2 } from "opticore-http-response";
+var translateWebAppCoreLanguageLoader = (environmentPath, localLang) => {
   try {
     const require2 = createRequire(import.meta.url);
     const packagePath = path.dirname(require2.resolve("opticore-webapp-core"));
     const translateMsgJsonFilePath = path.join(packagePath, "utils", "translations");
-    TranslationLoader6.loadTranslations(translateMsgJsonFilePath);
+    TranslationLoader3.loadTranslations(translateMsgJsonFilePath);
   } catch (err) {
-    SLoggerFileConfiguration(environnementPath).error(
-      TranslationLoader6.t(err.message, localLang),
-      err.code,
-      err.code,
-      err.stackTrace,
-      HttpStatusCode.INTERNAL_SERVER_ERROR
-    );
+    SLoggerFileConfiguration(environmentPath).error({
+      message: TranslationLoader3.t(err.message, localLang),
+      title: err.code,
+      errorType: err.code,
+      stackTrace: err.stackTrace,
+      httpCodeValue: HttpStatusCode2.INTERNAL_SERVER_ERROR
+    });
   }
 };
 
@@ -685,10 +533,10 @@ import path2 from "path";
 var YamlParsing = class {
   logger;
   localeLanguage;
-  constructor(localeLanguage, environnementPath) {
-    translateWebAppCoreLanguageLoader(environnementPath, localeLanguage);
+  constructor(localeLanguage, environmentPath) {
+    translateWebAppCoreLanguageLoader(environmentPath, localeLanguage);
     this.localeLanguage = localeLanguage;
-    this.logger = new LoggerCore3(loggerConfig(environnementPath));
+    this.logger = new LoggerCore2(loggerConfig(environmentPath));
   }
   absolutPath() {
     return path2.join(process.cwd(), "src", "utils", "translations");
@@ -698,13 +546,13 @@ var YamlParsing = class {
       const yamlContent = await readFile(filePath, "utf-8");
       await this.parsing(yamlContent);
     } catch (error) {
-      this.logger.error(
-        error.message,
-        TranslationLoader7.t("parsingFailed", this.localeLanguage, this.logger),
-        TranslationLoader7.t("readingError", this.localeLanguage, this.logger),
-        error.stack,
-        HttpStatusCode2.NOT_ACCEPTABLE
-      );
+      this.logger.error({
+        message: error.message,
+        title: TranslationLoader4.t("parsingFailed", this.localeLanguage, this.logger),
+        errorType: TranslationLoader4.t("readingError", this.localeLanguage, this.logger),
+        stackTrace: error.stack,
+        httpCodeValue: HttpStatusCode3.NOT_ACCEPTABLE
+      });
     }
   }
   /**
@@ -731,13 +579,13 @@ var YamlParsing = class {
           result[key] = value?.trim() || null;
         }
       } else {
-        this.logger.error(
-          TranslationLoader7.t("badFormat", this.localeLanguage, { line }),
-          TranslationLoader7.t("parsingFailed", this.localeLanguage, this.logger),
-          TranslationLoader7.t("unsupportedFormat", this.localeLanguage, this.logger),
-          content,
-          HttpStatusCode2.NOT_ACCEPTABLE
-        );
+        this.logger.error({
+          message: TranslationLoader4.t("badFormat", this.localeLanguage, { line }),
+          title: TranslationLoader4.t("parsingFailed", this.localeLanguage, this.logger),
+          errorType: TranslationLoader4.t("unsupportedFormat", this.localeLanguage, this.logger),
+          stackTrace: content,
+          httpCodeValue: HttpStatusCode3.NOT_ACCEPTABLE
+        });
       }
     }
     return result;
@@ -758,258 +606,13 @@ var Environment = class {
   }
 };
 
-// src/core/config/database/connexion.config.database.ts
-import mySQL from "mysql";
-import { HttpStatusCode as status6 } from "opticore-http-response";
-import { LoggerCore as LoggerCore4 } from "opticore-logger";
-import { TranslationLoader as TranslationLoader9 } from "opticore-translator";
-
-// src/core/errors/databaseConnexion.error.ts
-import { HttpStatusCode as status5 } from "opticore-http-response";
-import { StackTraceError as StackTraceError2 } from "opticore-catch-exception-error";
-import { TranslationLoader as TranslationLoader8 } from "opticore-translator";
-var DbConnexionConfigError = class {
-  logger;
-  localeLanguage;
-  constructor(localeLanguage, environnementPath) {
-    this.localeLanguage = localeLanguage;
-    this.logger = SLoggerFileConfiguration(environnementPath);
-  }
-  /**
-   *
-   * @param e
-   */
-  mongoDBAuthenticationFailed(e) {
-    const stackTrace = this.traceError(
-      TranslationLoader8.t("mongoDBConnection", this.localeLanguage, { e }),
-      TranslationLoader8.t("mongoDBAuthentication", this.localeLanguage),
-      status5.UNAUTHORIZED
-    );
-    this.logger.error(
-      TranslationLoader8.t("mongoDBAuthenticationError", this.localeLanguage),
-      TranslationLoader8.t("mongoDBConnection", this.localeLanguage),
-      TranslationLoader8.t("mongoDBAuthenticationFailed", this.localeLanguage),
-      stackTrace.stack,
-      status5.UNAUTHORIZED
-    );
-  }
-  /**
-   *
-   * @param err
-   * @param dbHost
-   * @param dbPort
-   */
-  mongoDBInvalidUrl(err, dbHost, dbPort) {
-    const stackTrace = this.traceError(
-      TranslationLoader8.t("mongoDBConnection", this.localeLanguage, { err }),
-      TranslationLoader8.t("mongoDBUnableParsingUrl", this.localeLanguage),
-      status5.BAD_REQUEST
-    );
-    this.logger.error(
-      TranslationLoader8.t("dbUrlParsingError", this.localeLanguage, { dbHost, dbPort }),
-      TranslationLoader8.t("mongoDBConnection", this.localeLanguage),
-      TranslationLoader8.t("mongoDBUnableParsingUrl", this.localeLanguage),
-      stackTrace.stack,
-      status5.BAD_REQUEST
-    );
-  }
-  /**
-   *
-   * @param err
-   * @param dbHost
-   */
-  mongoDBEaiAgain(err, dbHost) {
-    const stackTrace = this.traceError(
-      TranslationLoader8.t("mongoDBConnection", this.localeLanguage, { err }),
-      TranslationLoader8.t("mongoDBServerSelection", this.localeLanguage),
-      status5.BAD_REQUEST
-    );
-    this.logger.error(
-      TranslationLoader8.t("mongoServerError", this.localeLanguage, { dbHost }),
-      TranslationLoader8.t("mongoDBConnection", this.localeLanguage),
-      TranslationLoader8.t("mongoDBServerSelection", this.localeLanguage),
-      stackTrace.stack,
-      status5.BAD_REQUEST
-    );
-  }
-  /**
-   *
-   * @param err
-   */
-  mongoDbGlobalError(err) {
-    const stackTrace = this.traceError(
-      TranslationLoader8.t("mongoDBConnection", this.localeLanguage, { err }),
-      TranslationLoader8.t("mongoDBConnection", this.localeLanguage),
-      status5.NOT_ACCEPTABLE
-    );
-    this.logger.error(
-      TranslationLoader8.t("mongoDBConnection", this.localeLanguage),
-      TranslationLoader8.t("mongoDBConnectionError", this.localeLanguage),
-      stackTrace.stack,
-      err.message,
-      status5.NOT_ACCEPTABLE
-    );
-  }
-  /**
-   *
-   * @param props
-   * @param name
-   * @param status
-   * @private
-   */
-  traceError(props, name, status7) {
-    return new StackTraceError2(props, name, status7, true);
-  }
-};
-
-// src/core/config/database/connexion.config.database.ts
-import { StackTraceError as ErrorHandler2 } from "opticore-catch-exception-error";
-var DatabaseConnectionConfig = class {
-  env;
-  logger;
-  localeLanguage;
-  environnementPath;
-  DbConnexionConfigError;
-  constructor(localeLanguage, environnementPath) {
-    this.localeLanguage = localeLanguage;
-    this.environnementPath = environnementPath;
-    this.DbConnexionConfigError = new DbConnexionConfigError(localeLanguage, environnementPath);
-    this.env = new Environment(environnementPath);
-    this.logger = new LoggerCore4(loggerConfig(environnementPath));
-  }
-  /**
-   *
-   * @param optionalArgumentConnection
-   *
-   * 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(this.localeLanguage, this.environnementPath, 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(
-        TranslationLoader9.t("mongoDBConnectionChecker", this.localeLanguage, loggerConfig),
-        TranslationLoader9.t("mongoConnectionSuccess", this.localeLanguage, loggerConfig)
-      );
-      console.log("");
-    } catch (e) {
-      if (e.code === 18) {
-        this.DbConnexionConfigError.mongoDBAuthenticationFailed(e);
-      }
-      if (e.cause.code === "ERR_INVALID_URL") {
-        this.DbConnexionConfigError.mongoDBInvalidUrl(e, this.env.get("dataBaseHost"), this.env.get("dataBasePort"));
-      }
-      if (e.code === void 0) {
-        this.DbConnexionConfigError.mongoDBEaiAgain(e, this.env.get("dataBaseHost"));
-      } else {
-        this.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(
-        this.localeLanguage,
-        this.environnementPath,
-        url,
-        keepAlive,
-        stream,
-        statement_timeout,
-        ssl,
-        query_timeout,
-        keepAliveInitialDelayMillis,
-        idle_in_transaction_session_timeout,
-        application_name,
-        connectionTimeoutMillis,
-        types,
-        options
-      );
-      this.logger.success(
-        TranslationLoader9.t("postgresDBConnectionChecker", this.localeLanguage, loggerConfig),
-        TranslationLoader9.t("postgresConnectionSuccess", this.localeLanguage, loggerConfig)
-      );
-      console.log("");
-    } catch (err) {
-      const stackTrace = this.traceError(TranslationLoader9.t(`${err.message}`, this.localeLanguage, loggerConfig), "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, localLanguage, environnementPath) => {
-  const DbConnexion = new DatabaseConnectionConfig(localLanguage, environnementPath);
-  return DbConnexion.databaseMongoDBConnectionChecker(optionalArgumentConnection);
-};
-
-// src/core/config/database/middleware/mySqlChecker.database.ts
-var MMySqlCheckerDatabase = (optionalArgumentConnection, localLanguage, environnementPath) => {
-  const DbConnexion = new DatabaseConnectionConfig(localLanguage, environnementPath);
-  return DbConnexion.databaseMySQLConnexionChecker(optionalArgumentConnection);
-};
-
-// src/core/config/database/middleware/postgresChecker.database.ts
-var MPostgresCheckerDatabase = (localLanguage, environnementPath, keepAlive, stream, statement_timeout, ssl, query_timeout, keepAliveInitialDelayMillis, idle_in_transaction_session_timeout, application_name, connectionTimeoutMillis, types, options) => {
-  const DbConnexion = new DatabaseConnectionConfig(localLanguage, environnementPath);
-  return DbConnexion.databasePostgresDBConnectionChecker(
-    keepAlive,
-    stream,
-    statement_timeout,
-    ssl,
-    query_timeout,
-    keepAliveInitialDelayMillis,
-    idle_in_transaction_session_timeout,
-    application_name,
-    connectionTimeoutMillis,
-    types,
-    options
-  );
-};
-
 // src/utils/utility.utils.ts
 import process2 from "node:process";
 import chalk from "chalk";
 import colors from "ansi-colors";
 import path3 from "path";
 import fs from "fs";
-import { TranslationLoader as TranslationLoader10 } from "opticore-translator";
+import { TranslationLoader as TranslationLoader5 } from "opticore-translator";
 var Utility = class {
   localLang;
   constructor(localLanguage) {
@@ -1106,19 +709,19 @@ var Utility = class {
     this.getEnvFileLoading(".env");
     const isDevelopment = process2.env.NODE_ENV === "development";
     if (isDevelopment) {
-      return `${TranslationLoader10.t("serverRunning", this.localLang)} ${colors.bgBlue(`${colors.bold(`${development}`)}`)} mode`;
+      return `${TranslationLoader5.t("serverRunning", this.localLang)} ${colors.bgBlue(`${colors.bold(`${development}`)}`)} mode`;
     } else {
-      return `${TranslationLoader10.t("serverRunning", this.localLang)} ${colors.bgBlue(`${colors.bold(`${production}`)}`)} mode`;
+      return `${TranslationLoader5.t("serverRunning", this.localLang)} ${colors.bgBlue(`${colors.bold(`${production}`)}`)} mode`;
     }
   }
   infoServer(nodeVersion, startingTime, host, port, rss, heapUsed, user, system) {
     const paddingLength = 52;
     const msg0 = " ".padEnd(paddingLength, " ");
-    const msg1 = ` ${TranslationLoader10.t("okServerListening", this.localLang)}`;
+    const msg1 = ` ${TranslationLoader5.t("okServerListening", this.localLang)}`;
     const msg2Value = `${colors.bgBlue(`${colors.bold(`${nodeVersion}`)}`)}`;
-    const msg2 = ` ${TranslationLoader10.t("webServerUseNodeVersion", this.localLang)}`;
+    const msg2 = ` ${TranslationLoader5.t("webServerUseNodeVersion", this.localLang)}`;
     const msg3Value = `${colors.bgBlue(`${colors.bold(`${startingTime}`)}`)}`;
-    const msg3 = ` ${TranslationLoader10.t("startupTime", this.localLang)}`;
+    const msg3 = ` ${TranslationLoader5.t("startupTime", this.localLang)}`;
     const msg4 = ` ${this.getServerRunningMode("development", "production")}`;
     const msg5 = ` ${colors.underline(`http://${host}:${port}`)}`;
     console.log(chalk.bgGreen.white(msg0.padEnd(paddingLength, " ")));
@@ -1129,24 +732,24 @@ var Utility = class {
     console.log(chalk.bgGreen.white(msg5.padEnd(61, " ")));
     console.log(chalk.bgGreen.white(msg0.padEnd(paddingLength, " ")));
     console.log(``);
-    console.log(`${`${TranslationLoader10.t("totalMemory", this.localLang)}`} ${colors.cyan(`${colors.bold(`${rss}`)}`)}`);
-    console.log(`${`${TranslationLoader10.t("memoryUsedDuringExecution", this.localLang)}`} ${colors.cyan(`${colors.bold(`${heapUsed}`)}`)}`);
-    console.log(`${`${TranslationLoader10.t("memoryUsedByUser", this.localLang)}`} ${colors.cyan(`${colors.bold(`${user}`)}`)}`);
-    console.log(`${`${TranslationLoader10.t("memoryUsedBySystem", this.localLang)}`} ${colors.cyan(`${colors.bold(`${system}`)}`)}`);
+    console.log(`${`${TranslationLoader5.t("totalMemory", this.localLang)}`} ${colors.cyan(`${colors.bold(`${rss}`)}`)}`);
+    console.log(`${`${TranslationLoader5.t("memoryUsedDuringExecution", this.localLang)}`} ${colors.cyan(`${colors.bold(`${heapUsed}`)}`)}`);
+    console.log(`${`${TranslationLoader5.t("memoryUsedByUser", this.localLang)}`} ${colors.cyan(`${colors.bold(`${user}`)}`)}`);
+    console.log(`${`${TranslationLoader5.t("memoryUsedBySystem", this.localLang)}`} ${colors.cyan(`${colors.bold(`${system}`)}`)}`);
     console.log(``);
   }
 };
 
 // src/core/events/pathModuleVerifier.event.ts
 import { resolve } from "path";
-import { HttpStatusCode as HttpStatusCode3 } from "opticore-http-response";
-import { TranslationLoader as TranslationLoader11 } from "opticore-translator";
+import { HttpStatusCode as HttpStatusCode4 } from "opticore-http-response";
+import { TranslationLoader as TranslationLoader6 } from "opticore-translator";
 var PathModuleVerifier = class {
   log;
   localeLanguage;
-  constructor(localeLanguage, environnementPath) {
+  constructor(localeLanguage, environmentPath) {
     this.localeLanguage = localeLanguage;
-    this.log = SLoggerFileConfiguration(environnementPath);
+    this.log = SLoggerFileConfiguration(environmentPath);
   }
   /**
    * Verifies if modules at specific paths are loaded.
@@ -1161,13 +764,13 @@ var PathModuleVerifier = class {
       }
     }
     if (notLoadedPaths.length > 0) {
-      this.log.error(
-        TranslationLoader11.t("moduleNotLoaded", this.localeLanguage, { notLoadedPaths: notLoadedPaths.join(", ") }),
-        "",
-        "",
-        modulePaths,
-        HttpStatusCode3.NOT_ACCEPTABLE
-      );
+      this.log.error({
+        message: TranslationLoader6.t("moduleNotLoaded", this.localeLanguage, { notLoadedPaths: notLoadedPaths.join(", ") }),
+        title: "",
+        errorType: "",
+        stackTrace: modulePaths,
+        httpCodeValue: HttpStatusCode4.NOT_ACCEPTABLE
+      });
       throw new Error();
     }
   }
@@ -1188,28 +791,27 @@ var PathModuleVerifier = class {
 
 // src/core/config/loaders/localLanguage.loader.ts
 import path4 from "path";
-import { TranslationLoader as TranslationLoader12 } from "opticore-translator";
-import { HttpStatusCode as HttpStatusCode4 } from "opticore-http-response";
+import { TranslationLoader as TranslationLoader7 } from "opticore-translator";
+import { HttpStatusCode as HttpStatusCode5 } from "opticore-http-response";
 var LocalLanguageLoader = class {
   localeLanguage;
-  environnementPath;
-  constructor(localeLanguage, environnementPath) {
+  environmentPath;
+  constructor(localeLanguage, environmentPath) {
     this.localeLanguage = localeLanguage;
-    this.environnementPath = environnementPath;
+    this.environmentPath = environmentPath;
   }
   load() {
     try {
       const translateMsgJsonFilePath = path4.join(process.cwd(), "src", "utils", "translations");
-      TranslationLoader12.loadTranslations(translateMsgJsonFilePath);
+      TranslationLoader7.loadTranslations(translateMsgJsonFilePath);
     } catch (err) {
-      SLoggerFileConfiguration(this.environnementPath).error(
-        //TranslationLoader.t(err.message, this.localeLanguage),
-        err.message,
-        err.code,
-        err.code,
-        err.stackTrace,
-        HttpStatusCode4.INTERNAL_SERVER_ERROR
-      );
+      SLoggerFileConfiguration(this.environmentPath).error({
+        message: err.message,
+        title: err.code,
+        errorType: err.code,
+        stackTrace: err.stackTrace,
+        httpCodeValue: HttpStatusCode5.INTERNAL_SERVER_ERROR
+      });
     }
   }
 };
@@ -1218,18 +820,11 @@ export {
   CSignRSAKeyComponent,
   Environment,
   LocalLanguageLoader,
-  MMongoCheckerDatabase,
-  MMySqlCheckerDatabase,
-  MPostgresCheckerDatabase,
   PathModuleVerifier,
   RSAKeyDecryption,
   RSAKeyEncryption,
   SAsymmetricCryptionDataWithPrivateRSAKey,
   SAsymmetricCryptionDataWithPublicRSAKey,
-  SCheckerMongoDatabaseConnection,
-  SCheckerMySqlDatabaseConnection,
-  SCheckerPostgresDatabaseConnection,
-  UOptionalArgumentConnection,
   Utility,
   YamlParsing,
   dateTimeFormatted,