opticore-webapp-core 1.0.7 → 1.0.8

package/dist/index.js

@@ -8,8 +8,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 // 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 { TranslationLoader } from "opticore-translator";
 import { StackTraceError as ErrorHandler } from "opticore-catch-exception-error";
 
 // src/utils/cryptography/encryption/rsaKey.encryption.ts
@@ -138,6 +137,9 @@ var RSAKeyDecryption = class {
   }
 };
 
+// src/application/services/loggerFileConfiguration.service.ts
+import { LoggerCore } from "opticore-logger";
+
 // src/core/config/logger/logger.config.ts
 import { getEnvVariable } from "opticore-env-access";
 var loggerConfig = {
@@ -164,28 +166,34 @@ var loggerConfig = {
   }
 };
 
+// src/application/services/loggerFileConfiguration.service.ts
+var SLoggerFileConfiguration = () => {
+  return new LoggerCore(loggerConfig);
+};
+
 // src/application/services/asymmetricCryptionDataWithPrivateRSAKey.service.ts
 var SAsymmetricCryptionDataWithPrivateRSAKey = class {
-  static log = new LoggerCore(loggerConfig);
+  static log = SLoggerFileConfiguration();
   /**
-   *
+   * 
    * @param rsaKey
    * @param keyType
+   * @param localeLanguage
    * @protected
-   *
+   * 
    * Return ErrorHandler | string
    */
-  static verifyExistingKey(rsaKey, keyType) {
+  static verifyExistingKey(rsaKey, keyType, localeLanguage) {
     if (!rsaKey) {
       const stackTrace = this.traceError(
-        keyType + " " + TranslationLoader.t("rsaKeyNotFound", CLocal),
-        TranslationLoader.t("erBadDbError", CLocal),
+        keyType + " " + TranslationLoader.t("rsaKeyNotFound", localeLanguage, this.log),
+        TranslationLoader.t("erBadDbError", localeLanguage, this.log),
         status.NOT_FOUND
       );
       this.log.error(
-        TranslationLoader.t("rsaKeyNotFound", CLocal),
-        TranslationLoader.t("verifyExistingKey", CLocal),
-        TranslationLoader.t("erBadDbError", CLocal),
+        TranslationLoader.t("rsaKeyNotFound", localeLanguage, this.log),
+        TranslationLoader.t("verifyExistingKey", localeLanguage, this.log),
+        TranslationLoader.t("erBadDbError", localeLanguage, this.log),
         stackTrace.stack,
         status.NOT_FOUND
       );
@@ -197,25 +205,26 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
    *
    * @param privateKey
    * @param payload
+   * @param localeLanguage
    * @private
    *
    * Return Buffer
    */
-  static encryptionWithPrivateKey(privateKey, payload) {
-    this.verifyExistingKey(privateKey, CSignRSAKeyComponent.keyType.private);
+  static encryptionWithPrivateKey(privateKey, payload, localeLanguage) {
+    this.verifyExistingKey(privateKey, CSignRSAKeyComponent.keyType.private, localeLanguage);
     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),
+        TranslationLoader.t("encryptionWithPrivateKeyFailed", localeLanguage, this.log),
+        TranslationLoader.t("encryptionFailed", localeLanguage, this.log),
         status.NOT_FOUND
       );
       this.log.error(
         err.message,
-        TranslationLoader.t("encryptionFailed", CLocal),
-        TranslationLoader.t("encryptionWithPrivateKeyFailed", CLocal),
+        TranslationLoader.t("encryptionFailed", localeLanguage, this.log),
+        TranslationLoader.t("encryptionWithPrivateKeyFailed", localeLanguage, this.log),
         stackTrace.stack,
         status.NOT_FOUND
       );
@@ -227,24 +236,25 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
    * @param privateKey
    * @param publicKey
    * @param payload
+   * @param localeLanguage
    * @private
    */
-  static decryptionWithPublicKey(privateKey, publicKey, payload) {
-    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
+  static decryptionWithPublicKey(privateKey, publicKey, payload, localeLanguage) {
+    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public, localeLanguage);
     try {
-      const encryptedPayload = this.encryptionWithPrivateKey(privateKey, payload);
+      const encryptedPayload = this.encryptionWithPrivateKey(privateKey, payload, localeLanguage);
       return RSAKeyDecryption.publicDecrypt(publicKey, encryptedPayload);
     } catch (error) {
       const stackTrace = this.traceError(
-        TranslationLoader.t("errorDecryption", CLocal),
-        TranslationLoader.t("decryptionFailed", CLocal),
+        TranslationLoader.t("errorDecryption", localeLanguage, this.log),
+        TranslationLoader.t("decryptionFailed", localeLanguage, this.log),
         status.NOT_ACCEPTABLE
       );
       this.log.error(
-        TranslationLoader.t("decryptionWithPublicKeyFailed", CLocal),
-        TranslationLoader.t("decryptionFailed", CLocal),
+        TranslationLoader.t("decryptionWithPublicKeyFailed", localeLanguage, this.log),
+        TranslationLoader.t("decryptionFailed", localeLanguage, this.log),
         stackTrace.stack,
-        TranslationLoader.t("errorDecryption", CLocal),
+        TranslationLoader.t("errorDecryption", localeLanguage, this.log),
         status.NOT_ACCEPTABLE
       );
       throw new Error();
@@ -254,10 +264,11 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
    *
    * @param privateKey
    * @param payload
+   * @param localeLanguage
    * @private
    */
-  static signWithRSAKey(privateKey, payload) {
-    this.verifyExistingKey(privateKey, CSignRSAKeyComponent.keyType.private);
+  static signWithRSAKey(privateKey, payload, localeLanguage) {
+    this.verifyExistingKey(privateKey, CSignRSAKeyComponent.keyType.private, localeLanguage);
     const sign = crypto3.createSign(CSignRSAKeyComponent.algorithm.sha256);
     sign.update(payload);
     return sign.sign(privateKey, CSignRSAKeyComponent.outputFormat.base64);
@@ -267,27 +278,28 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
    * @param privateKey
    * @param publicKey
    * @param payload
+   * @param localeLanguage
    */
-  static verifyRSAKey(privateKey, publicKey, payload) {
+  static verifyRSAKey(privateKey, publicKey, payload, localeLanguage) {
     try {
       const verify = crypto3.createVerify(CSignRSAKeyComponent.algorithm.sha256);
       verify.update(payload);
-      const signature = this.signWithRSAKey(privateKey, payload);
+      const signature = this.signWithRSAKey(privateKey, payload, localeLanguage);
       const isVerified = verify.verify(publicKey, signature, CSignRSAKeyComponent.outputFormat.base64);
       if (isVerified) {
-        const decryptedData = this.decryptionWithPublicKey(privateKey, publicKey, payload);
+        const decryptedData = this.decryptionWithPublicKey(privateKey, publicKey, payload, localeLanguage);
         return decryptedData.toString(CSignRSAKeyComponent.encodingFormat.utf_8);
       } else {
         const stackTrace = this.traceError(
-          TranslationLoader.t("signatureRSAKeyFailed", CLocal),
-          TranslationLoader.t("verifyRSAKeyFailed", CLocal),
+          TranslationLoader.t("signatureRSAKeyFailed", localeLanguage, this.log),
+          TranslationLoader.t("verifyRSAKeyFailed", localeLanguage, this.log),
           status.NOT_ACCEPTABLE
         );
         this.log.error(
-          TranslationLoader.t("verifyRSAKey", CLocal),
-          TranslationLoader.t("verifyRSAKeyFailed", CLocal),
+          TranslationLoader.t("verifyRSAKey", localeLanguage, this.log),
+          TranslationLoader.t("verifyRSAKeyFailed", localeLanguage, this.log),
           stackTrace.stack,
-          TranslationLoader.t("signatureRSAKeyFailed", CLocal),
+          TranslationLoader.t("signatureRSAKeyFailed", localeLanguage, this.log),
           status.NOT_FOUND
         );
         return new Error();
@@ -295,12 +307,12 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
     } catch (err) {
       const stackTrace = this.traceError(
         err.name,
-        TranslationLoader.t("signatureRSAKeysError", CLocal),
+        TranslationLoader.t("signatureRSAKeysError", localeLanguage, this.log),
         status.NOT_ACCEPTABLE
       );
       this.log.error(
-        TranslationLoader.t("signatureRSAKeysError", CLocal),
-        TranslationLoader.t("errorNameNotVerifyingRSAKey", CLocal),
+        TranslationLoader.t("signatureRSAKeysError", localeLanguage, this.log),
+        TranslationLoader.t("errorNameNotVerifyingRSAKey", localeLanguage, this.log),
         stackTrace.stack,
         err.message,
         status.NOT_FOUND
@@ -322,30 +334,30 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
 
 // 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 { TranslationLoader as TranslationLoader2 } from "opticore-translator";
 import { HttpStatusCode as status2 } from "opticore-http-response";
 import { StackTraceError } from "opticore-catch-exception-error";
 var SAsymmetricCryptionDataWithPublicRSAKey = class {
-  static log = new LoggerCore2(loggerConfig);
+  static logger = SLoggerFileConfiguration();
   /**
    *
    * @param rsaKey
    * @param keyType
+   * @param localeLanguage
    * @protected
    */
-  static verifyExistingKey(rsaKey, keyType) {
+  static verifyExistingKey(rsaKey, keyType, localeLanguage) {
     if (!rsaKey) {
       const stackTrace = this.traceError(
-        keyType + TranslationLoader2.t("verifyExistingKey", CLocal2),
-        TranslationLoader2.t("verifyExistingKey", CLocal2),
+        keyType + TranslationLoader2.t("verifyExistingKey", localeLanguage, this.logger),
+        TranslationLoader2.t("verifyExistingKey", localeLanguage, this.logger),
         status2.NOT_FOUND
       );
-      this.log.error(
-        TranslationLoader2.t("verifyExistingKey", CLocal2),
+      this.logger.error(
+        TranslationLoader2.t("verifyExistingKey", localeLanguage, this.logger),
         "key verification",
         stackTrace.stack,
-        TranslationLoader2.t("verifyExistingKeyError", CLocal2),
+        TranslationLoader2.t("verifyExistingKeyError", localeLanguage, this.logger),
         status2.NOT_FOUND
       );
       return new Error();
@@ -356,22 +368,23 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
    *
    * @param publicKey
    * @param payload
+   * @param localeLanguage
    * @private
    */
-  static encryptionWithPublicKey(publicKey, payload) {
-    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
+  static encryptionWithPublicKey(publicKey, payload, localeLanguage) {
+    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public, localeLanguage);
     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),
+        TranslationLoader2.t("encryptionWithPublicKey", localeLanguage, this.logger),
         status2.NOT_ACCEPTABLE
       );
-      this.log.error(
-        TranslationLoader2.t("errorEncryptionPublicKey", CLocal2),
-        TranslationLoader2.t("encryptionWithPublicKey", CLocal2),
+      this.logger.error(
+        TranslationLoader2.t("errorEncryptionPublicKey", localeLanguage, this.logger),
+        TranslationLoader2.t("encryptionWithPublicKey", localeLanguage, this.logger),
         stackTrace.stack,
         err.message,
         status2.NOT_ACCEPTABLE
@@ -384,22 +397,23 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
    * @param privateKey
    * @param publicKey
    * @param payload
+   * @param localeLanguage
    * @private
    */
-  static decryptionWithPrivateKey(privateKey, publicKey, payload) {
-    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
+  static decryptionWithPrivateKey(privateKey, publicKey, payload, localeLanguage) {
+    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public, localeLanguage);
     try {
-      const encryptedPayload = this.encryptionWithPublicKey(publicKey, payload);
+      const encryptedPayload = this.encryptionWithPublicKey(publicKey, payload, localeLanguage);
       return RSAKeyDecryption.privateDecrypt(privateKey, encryptedPayload);
     } catch (err) {
       const stackTrace = this.traceError(
         err.code,
-        TranslationLoader2.t("errorDecryption", CLocal2),
+        TranslationLoader2.t("errorDecryption", localeLanguage, this.logger),
         status2.NOT_ACCEPTABLE
       );
-      this.log.error(
-        TranslationLoader2.t("errorDecryptionWithPrivateKey", CLocal2),
-        TranslationLoader2.t("errorDecryption", CLocal2),
+      this.logger.error(
+        TranslationLoader2.t("errorDecryptionWithPrivateKey", localeLanguage, this.logger),
+        TranslationLoader2.t("errorDecryption", localeLanguage, this.logger),
         stackTrace.stack,
         err.message,
         status2.NOT_ACCEPTABLE
@@ -411,10 +425,11 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
    *
    * @param publicKey
    * @param payload
+   * @param localeLanguage
    * @private
    */
-  static signWithPublicRSAKey(publicKey, payload) {
-    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.private);
+  static signWithPublicRSAKey(publicKey, payload, localeLanguage) {
+    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.private, localeLanguage);
     const sign = crypto4.createSign(CSignRSAKeyComponent.algorithm.sha256);
     sign.update(payload);
     return sign.sign(publicKey, CSignRSAKeyComponent.outputFormat.base64);
@@ -424,27 +439,28 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
    * @param privateKey
    * @param publicKey
    * @param payload
+   * @param localeLanguage
    */
-  static verifyPublicRSAKey(privateKey, publicKey, payload) {
+  static verifyPublicRSAKey(privateKey, publicKey, payload, localeLanguage) {
     try {
       const verify = crypto4.createVerify(CSignRSAKeyComponent.algorithm.sha256);
       verify.update(payload);
-      const signature = this.signWithPublicRSAKey(publicKey, payload);
+      const signature = this.signWithPublicRSAKey(publicKey, payload, localeLanguage);
       const isVerified = verify.verify(publicKey, signature, CSignRSAKeyComponent.outputFormat.base64);
       if (isVerified) {
-        const decryptedData = this.decryptionWithPrivateKey(privateKey, publicKey, payload);
+        const decryptedData = this.decryptionWithPrivateKey(privateKey, publicKey, payload, localeLanguage);
         return decryptedData.toString(CSignRSAKeyComponent.encodingFormat.utf_8);
       } else {
         const stackTrace = this.traceError(
-          TranslationLoader2.t("verifyPublicRSAKeyError", CLocal2),
-          TranslationLoader2.t("signatureRSAKeyFailed", CLocal2),
+          TranslationLoader2.t("verifyPublicRSAKeyError", localeLanguage, this.logger),
+          TranslationLoader2.t("signatureRSAKeyFailed", localeLanguage, this.logger),
           status2.NOT_FOUND
         );
-        this.log.error(
-          TranslationLoader2.t("verifyPublicRSAKey", CLocal2),
-          TranslationLoader2.t("signatureRSAKeyFailed", CLocal2),
+        this.logger.error(
+          TranslationLoader2.t("verifyPublicRSAKey", localeLanguage, this.logger),
+          TranslationLoader2.t("signatureRSAKeyFailed", localeLanguage, this.logger),
           stackTrace.stack,
-          TranslationLoader2.t("verifyPublicRSAKeyError", CLocal2),
+          TranslationLoader2.t("verifyPublicRSAKeyError", localeLanguage, this.logger),
           status2.NOT_FOUND
         );
         return stackTrace;
@@ -452,12 +468,12 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
     } catch (err) {
       const stackTrace = this.traceError(
         err.code,
-        TranslationLoader2.t("verifyPublicRSAKey", CLocal2),
+        TranslationLoader2.t("verifyPublicRSAKey", localeLanguage, this.logger),
         status2.NOT_ACCEPTABLE
       );
-      this.log.error(
-        TranslationLoader2.t("verifyPublicRSAKey", CLocal2),
-        TranslationLoader2.t("errorDecryption", CLocal2),
+      this.logger.error(
+        TranslationLoader2.t("verifyPublicRSAKey", localeLanguage, this.logger),
+        TranslationLoader2.t("errorDecryption", localeLanguage, this.logger),
         stackTrace.stack,
         err.message,
         status2.NOT_ACCEPTABLE
@@ -483,44 +499,44 @@ async function SCheckerMongoDatabaseConnection(url, user, password, dbName) {
 }
 
 // src/core/handlers/errors/database/mySqlError.handler.database.ts
-import { LoggerCore as LoggerCore3 } from "opticore-logger";
+import { LoggerCore as LoggerCore2 } 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);
+import { TranslationLoader as TranslationLoader3 } from "opticore-translator";
+function mySqlErrorHandlerDatabase(localLanguage, err, dbHost, database, user, password) {
+  const logger = new LoggerCore2(loggerConfig);
   switch (err.code) {
     case "EAI_AGAIN":
       logger.error(
-        TranslationLoader3.t("errorDBHost", CLocal3, { dbHost }),
-        TranslationLoader3.t("mySQLError", CLocal3),
-        TranslationLoader3.t("eAiAgain", CLocal3),
+        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", CLocal3),
-        TranslationLoader3.t("dbConnection", CLocal3),
-        TranslationLoader3.t("erNotSupportedAuthMode", CLocal3),
+        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", CLocal3, { user, password }),
-        TranslationLoader3.t("dbConnection", CLocal3),
-        TranslationLoader3.t("erAccessDeniedError", CLocal3),
+        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", CLocal3, { database }),
-        TranslationLoader3.t("dbConnection", CLocal3),
-        TranslationLoader3.t("erBadDbError", CLocal3),
+        TranslationLoader3.t("unknownDB", localLanguage, { database }),
+        TranslationLoader3.t("dbConnection", localLanguage),
+        TranslationLoader3.t("erBadDbError", localLanguage),
         err.stack,
         status3.NOT_ACCEPTABLE
       );
@@ -528,8 +544,8 @@ function mySqlErrorHandlerDatabase(err, dbHost, database, user, password) {
     default:
       logger.error(
         err.message,
-        TranslationLoader3.t("dbConnection", CLocal3),
-        TranslationLoader3.t("mysqlErrorCon", CLocal3),
+        TranslationLoader3.t("dbConnection", localLanguage),
+        TranslationLoader3.t("mysqlErrorCon", localLanguage),
         err.stack,
         status3.NOT_ACCEPTABLE
       );
@@ -538,25 +554,24 @@ function mySqlErrorHandlerDatabase(err, dbHost, database, user, password) {
 }
 
 // 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);
+import { TranslationLoader as TranslationLoader4 } from "opticore-translator";
+function SCheckerMySqlDatabaseConnection(localeLanguage, dbConnection, user, database, dbHost, password) {
+  const logger = SLoggerFileConfiguration();
   dbConnection.connect((err) => {
     if (err) {
-      return mySqlErrorHandlerDatabase(err, dbHost, database, user, password);
+      return mySqlErrorHandlerDatabase(localeLanguage, err, dbHost, database, user, password);
     } else {
-      log.success(
-        TranslationLoader4.t("dbConnection", CLocal4),
-        TranslationLoader4.t("dbConnexionSuccess", CLocal4)
+      logger.success(
+        TranslationLoader4.t("dbConnection", localeLanguage, logger),
+        TranslationLoader4.t("dbConnexionSuccess", localeLanguage, logger)
       );
       return dbConnection.end((endConErr) => {
         if (endConErr) {
-          return mySqlErrorHandlerDatabase(err, dbHost, database, user, password);
+          return mySqlErrorHandlerDatabase(localeLanguage, err, dbHost, database, user, password);
         } else {
-          log.success(
-            TranslationLoader4.t("dbConnection", CLocal4),
-            TranslationLoader4.t("dbConnectionClosed", CLocal4)
+          logger.success(
+            TranslationLoader4.t("dbConnection", localeLanguage, logger),
+            TranslationLoader4.t("dbConnectionClosed", localeLanguage, logger)
           );
           console.log("");
         }
@@ -567,11 +582,10 @@ function SCheckerMySqlDatabaseConnection(dbConnection, user, database, dbHost, p
 
 // 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);
+import pg from "pg";
+import { TranslationLoader as TranslationLoader5 } from "opticore-translator";
+async function SCheckerPostgresDatabaseConnection(localeLanguage, connectionString, keepAlive, stream, statement_timeout, ssl, query_timeout, keepAliveInitialDelayMillis, idle_in_transaction_session_timeout, application_name, connectionTimeoutMillis, types, options) {
+  const logger = SLoggerFileConfiguration();
   const configOptions = {
     connectionString,
     keepAlive,
@@ -586,20 +600,20 @@ async function SCheckerPostgresDatabaseConnection(connectionString, keepAlive, s
     types,
     options
   };
-  const client = new Client(configOptions);
+  const client = new pg.Client(configOptions);
   await client.connect();
   await client.end().then(
     () => {
       logger.success(
-        TranslationLoader5.t("postgresSuccessConn", CLocal5),
-        TranslationLoader5.t("postgresClosingConnSuccess", CLocal5)
+        TranslationLoader5.t("postgresSuccessConn", localeLanguage, logger),
+        TranslationLoader5.t("postgresClosingConnSuccess", localeLanguage, logger)
       );
     },
     (onRejected) => {
       logger.error(
-        TranslationLoader5.t("postgresEndClientRejection", CLocal5),
-        TranslationLoader5.t("postgresClientError", CLocal5),
-        TranslationLoader5.t("postgresEndRejection", CLocal5),
+        TranslationLoader5.t("postgresEndClientRejection", localeLanguage, logger),
+        TranslationLoader5.t("postgresClientError", localeLanguage, logger),
+        TranslationLoader5.t("postgresEndRejection", localeLanguage, logger),
         onRejected,
         status4.BAD_REQUEST
       );
@@ -607,8 +621,8 @@ async function SCheckerPostgresDatabaseConnection(connectionString, keepAlive, s
   ).catch((onError) => {
     logger.error(
       onError.message,
-      TranslationLoader5.t("postgresConnError", CLocal5),
-      TranslationLoader5.t("postgresException", CLocal5),
+      TranslationLoader5.t("postgresConnError", localeLanguage, logger),
+      TranslationLoader5.t("postgresException", localeLanguage, logger),
       onError.stack,
       status4.BAD_REQUEST
     );
@@ -630,51 +644,50 @@ 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 TranslationLoader7 } from "opticore-translator";
+import { LoggerCore as LoggerCore3 } from "opticore-logger";
+import { TranslationLoader as TranslationLoader7 } 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";
-var translateWebAppCoreLanguageLoader = (defaultLocalLang) => {
+var translateWebAppCoreLanguageLoader = () => {
   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, defaultLocalLang);
+  TranslationLoader6.loadTranslations(translateMsgJsonFilePath);
 };
 
 // src/utils/parsing/parsingYaml.utils.ts
 var YamlParsing = class {
-  static logger = new LoggerCore6(loggerConfig);
-  static async readFile(filePath) {
+  static logger = new LoggerCore3(loggerConfig);
+  static localeLanguage;
+  static __init(localeLanguage) {
+    translateWebAppCoreLanguageLoader();
+    this.localeLanguage = localeLanguage;
+    return this;
+  }
+  static async readFile(filePath, localeLanguage) {
     try {
       const yamlContent = await readFile(filePath, "utf-8");
-      await this.parsing(yamlContent);
+      await this.parsing(yamlContent, localeLanguage);
     } catch (error) {
       this.logger.error(
         error.message,
-        TranslationLoader7.t("parsingFailed", CLocal6),
-        TranslationLoader7.t("readingError", CLocal6),
+        TranslationLoader7.t("parsingFailed", localeLanguage, this.logger),
+        TranslationLoader7.t("readingError", localeLanguage, this.logger),
         error.stack,
         HttpStatusCode.NOT_ACCEPTABLE
       );
     }
   }
-  /**
-   *
-   * @param defaultLocalLang
-   */
-  static __init(defaultLocalLang) {
-    translateWebAppCoreLanguageLoader(defaultLocalLang);
-    return this;
-  }
   /**
    *
    * @param content
+   * @param localeLanguage
    * @private
    */
-  static async parsing(content) {
+  static async parsing(content, localeLanguage) {
     const result = {};
     const lines = content.split("\n");
     let currentKey = null;
@@ -694,9 +707,9 @@ var YamlParsing = class {
         }
       } else {
         this.logger.error(
-          TranslationLoader7.t("badFormat", CLocal6, { line }),
-          TranslationLoader7.t("parsingFailed", CLocal6),
-          TranslationLoader7.t("unsupportedFormat", CLocal6),
+          TranslationLoader7.t("badFormat", localeLanguage, { line }),
+          TranslationLoader7.t("parsingFailed", localeLanguage, this.logger),
+          TranslationLoader7.t("unsupportedFormat", localeLanguage, this.logger),
           content,
           HttpStatusCode.NOT_ACCEPTABLE
         );
@@ -724,86 +737,90 @@ var Environment = class {
 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 TranslationLoader9 } from "opticore-translator";
+import { LoggerCore as LoggerCore5 } 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 { LoggerCore as LoggerCore7 } from "opticore-logger";
+import { LoggerCore as LoggerCore4 } from "opticore-logger";
 import { StackTraceError as StackTraceError2 } from "opticore-catch-exception-error";
-import { CLocal as CLocal7, TranslationLoader as TranslationLoader8 } from "opticore-translator";
+import { TranslationLoader as TranslationLoader8 } from "opticore-translator";
 var DbConnexionConfigError = class {
-  static logger = new LoggerCore7(loggerConfig);
+  static logger = new LoggerCore4(loggerConfig);
   /**
    *
+   * @param localLanguage
    * @param e
    */
-  static mongoDBAuthenticationFailed(e) {
+  static mongoDBAuthenticationFailed(localLanguage, e) {
     const stackTrace = this.traceError(
-      TranslationLoader8.t("mongoDBConnection", CLocal7),
-      TranslationLoader8.t("mongoDBAuthentication", CLocal7),
+      TranslationLoader8.t("mongoDBConnection", localLanguage, { e }),
+      TranslationLoader8.t("mongoDBAuthentication", localLanguage),
       status5.UNAUTHORIZED
     );
     this.logger.error(
-      TranslationLoader8.t("mongoDBAuthenticationError", CLocal7),
-      TranslationLoader8.t("mongoDBConnection", CLocal7),
-      TranslationLoader8.t("mongoDBAuthenticationFailed", CLocal7),
+      TranslationLoader8.t("mongoDBAuthenticationError", localLanguage),
+      TranslationLoader8.t("mongoDBConnection", localLanguage),
+      TranslationLoader8.t("mongoDBAuthenticationFailed", localLanguage),
       stackTrace.stack,
       status5.UNAUTHORIZED
     );
   }
   /**
    *
+   * @param localLanguage
    * @param err
    * @param dbHost
    * @param dbPort
    */
-  static mongoDBInvalidUrl(err, dbHost, dbPort) {
+  static mongoDBInvalidUrl(localLanguage, err, dbHost, dbPort) {
     const stackTrace = this.traceError(
-      TranslationLoader8.t("mongoDBConnection", CLocal7),
-      TranslationLoader8.t("mongoDBUnableParsingUrl", CLocal7),
+      TranslationLoader8.t("mongoDBConnection", localLanguage, { err }),
+      TranslationLoader8.t("mongoDBUnableParsingUrl", localLanguage),
       status5.BAD_REQUEST
     );
     this.logger.error(
-      TranslationLoader8.t("dbUrlParsingError", CLocal7, { dbHost, dbPort }),
-      TranslationLoader8.t("mongoDBConnection", CLocal7),
-      TranslationLoader8.t("mongoDBUnableParsingUrl", CLocal7),
+      TranslationLoader8.t("dbUrlParsingError", localLanguage, { dbHost, dbPort }),
+      TranslationLoader8.t("mongoDBConnection", localLanguage),
+      TranslationLoader8.t("mongoDBUnableParsingUrl", localLanguage),
       stackTrace.stack,
       status5.BAD_REQUEST
     );
   }
   /**
    *
+   * @param localLanguage
    * @param err
    * @param dbHost
    */
-  static mongoDBEaiAgain(err, dbHost) {
+  static mongoDBEaiAgain(localLanguage, err, dbHost) {
     const stackTrace = this.traceError(
-      TranslationLoader8.t("mongoDBConnection", CLocal7),
-      TranslationLoader8.t("mongoDBServerSelection", CLocal7),
+      TranslationLoader8.t("mongoDBConnection", localLanguage, { err }),
+      TranslationLoader8.t("mongoDBServerSelection", localLanguage),
       status5.BAD_REQUEST
     );
     this.logger.error(
-      TranslationLoader8.t("mongoServerError", CLocal7, { dbHost }),
-      TranslationLoader8.t("mongoDBConnection", CLocal7),
-      TranslationLoader8.t("mongoDBServerSelection", CLocal7),
+      TranslationLoader8.t("mongoServerError", localLanguage, { dbHost }),
+      TranslationLoader8.t("mongoDBConnection", localLanguage),
+      TranslationLoader8.t("mongoDBServerSelection", localLanguage),
       stackTrace.stack,
       status5.BAD_REQUEST
     );
   }
   /**
    *
+   * @param localLanguage
    * @param err
    */
-  static mongoDbGlobalError(err) {
+  static mongoDbGlobalError(localLanguage, err) {
     const stackTrace = this.traceError(
-      err.message,
-      TranslationLoader8.t("mongoDBConnection", CLocal7),
+      TranslationLoader8.t("mongoDBConnection", localLanguage, { err }),
+      TranslationLoader8.t("mongoDBConnection", localLanguage),
       status5.NOT_ACCEPTABLE
     );
     this.logger.error(
-      TranslationLoader8.t("mongoDBConnection", CLocal7),
-      TranslationLoader8.t("mongoDBConnectionError", CLocal7),
+      TranslationLoader8.t("mongoDBConnection", localLanguage),
+      TranslationLoader8.t("mongoDBConnectionError", localLanguage),
       stackTrace.stack,
       err.message,
       status5.NOT_ACCEPTABLE
@@ -825,34 +842,39 @@ var DbConnexionConfigError = class {
 import { StackTraceError as ErrorHandler2 } from "opticore-catch-exception-error";
 var DatabaseConnectionConfig = class {
   env = new Environment(getEnvVariable3);
-  logger = new LoggerCore8(loggerConfig);
+  logger = new LoggerCore5(loggerConfig);
   /**
+   *
+   * @param optionalArgumentConnection
+   * @param localeLanguage
+   *
    * 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) {
+  databaseMySQLConnexionChecker(optionalArgumentConnection, localeLanguage) {
     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"));
+    return SCheckerMySqlDatabaseConnection(localeLanguage, dbConnection, this.env.get("dataBaseUser"), this.env.get("dataBaseName"), this.env.get("dataBaseHost"), this.env.get("dataBasePassword"));
   }
   /**
    *
    * @param optionalArgumentConnection
+   * @param localeLanguage
    *
    * Mongo database connection with optional connection arguments
    */
-  async databaseMongoDBConnectionChecker(optionalArgumentConnection) {
+  async databaseMongoDBConnectionChecker(optionalArgumentConnection, localeLanguage) {
     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", CLocal8),
-        TranslationLoader9.t("mongoConnectionSuccess", CLocal8)
+        TranslationLoader9.t("mongoDBConnectionChecker", localeLanguage, loggerConfig),
+        TranslationLoader9.t("mongoConnectionSuccess", localeLanguage, loggerConfig)
       );
       console.log("");
     } catch (e) {
@@ -871,6 +893,7 @@ var DatabaseConnectionConfig = class {
   }
   /**
    *
+   * @param localeLanguage
    * @param keepAlive
    * @param stream
    * @param statement_timeout
@@ -885,10 +908,11 @@ var DatabaseConnectionConfig = class {
    *
    * 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) {
+  async databasePostgresDBConnectionChecker(localeLanguage, 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(
+        localeLanguage,
         url,
         keepAlive,
         stream,
@@ -902,11 +926,14 @@ var DatabaseConnectionConfig = class {
         types,
         options
       );
-      this.logger.success(TranslationLoader9.t("postgresDBConnectionChecker", CLocal8), TranslationLoader9.t("postgresConnectionSuccess", CLocal8));
+      this.logger.success(
+        TranslationLoader9.t("postgresDBConnectionChecker", localeLanguage, loggerConfig),
+        TranslationLoader9.t("postgresConnectionSuccess", localeLanguage, loggerConfig)
+      );
       console.log("");
     } catch (err) {
       const stackTrace = this.traceError(
-        TranslationLoader9.t(`${err.message}`, CLocal8),
+        TranslationLoader9.t(`${err.message}`, localeLanguage, loggerConfig),
         "PostgresConnectionError",
         status6.NOT_ACCEPTABLE
       );
@@ -925,21 +952,34 @@ var DatabaseConnectionConfig = class {
 };
 
 // src/core/config/database/middleware/mongoChecker.database.ts
-var MMongoCheckerDatabase = (optionalArgumentConnection) => {
+var MMongoCheckerDatabase = (optionalArgumentConnection, localLanguage) => {
   const DbConnexion = new DatabaseConnectionConfig();
-  return DbConnexion.databaseMongoDBConnectionChecker(optionalArgumentConnection);
+  return DbConnexion.databaseMongoDBConnectionChecker(optionalArgumentConnection, localLanguage);
 };
 
 // src/core/config/database/middleware/mySqlChecker.database.ts
-var MMySqlCheckerDatabase = (optionalArgumentConnection) => {
+var MMySqlCheckerDatabase = (optionalArgumentConnection, localLanguage) => {
   const DbConnexion = new DatabaseConnectionConfig();
-  return DbConnexion.databaseMySQLConnexionChecker(optionalArgumentConnection);
+  return DbConnexion.databaseMySQLConnexionChecker(optionalArgumentConnection, localLanguage);
 };
 
 // src/core/config/database/middleware/postgresChecker.database.ts
-var MPostgresCheckerDatabase = (optionalArgumentConnection) => {
+var MPostgresCheckerDatabase = (localLanguage, keepAlive, stream, statement_timeout, ssl, query_timeout, keepAliveInitialDelayMillis, idle_in_transaction_session_timeout, application_name, connectionTimeoutMillis, types, options) => {
   const DbConnexion = new DatabaseConnectionConfig();
-  return DbConnexion.databasePostgresDBConnectionChecker(optionalArgumentConnection);
+  return DbConnexion.databasePostgresDBConnectionChecker(
+    localLanguage,
+    keepAlive,
+    stream,
+    statement_timeout,
+    ssl,
+    query_timeout,
+    keepAliveInitialDelayMillis,
+    idle_in_transaction_session_timeout,
+    application_name,
+    connectionTimeoutMillis,
+    types,
+    options
+  );
 };
 
 // src/utils/utility.utils.ts
@@ -948,8 +988,12 @@ import chalk from "chalk";
 import colors from "ansi-colors";
 import path2 from "path";
 import fs from "fs";
-import { CLocal as CLocal9, TranslationLoader as TranslationLoader10 } from "opticore-translator";
+import { TranslationLoader as TranslationLoader10 } from "opticore-translator";
 var Utility = class {
+  localLang;
+  constructor(localLanguage) {
+    this.localLang = localLanguage;
+  }
   /**
    *
    * @param data
@@ -1041,19 +1085,19 @@ var Utility = class {
     this.getEnvFileLoading(".env");
     const isDevelopment = process.env.NODE_ENV === "development";
     if (isDevelopment) {
-      return `${TranslationLoader10.t("serverRunning", CLocal9)} ${colors.bgBlue(`${colors.bold(`${development}`)}`)} mode`;
+      return `${TranslationLoader10.t("serverRunning", this.localLang)} ${colors.bgBlue(`${colors.bold(`${development}`)}`)} mode`;
     } else {
-      return `${TranslationLoader10.t("serverRunning", CLocal9)} ${colors.bgBlue(`${colors.bold(`${production}`)}`)} mode`;
+      return `${TranslationLoader10.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", CLocal9)}`;
+    const msg1 = ` ${TranslationLoader10.t("okServerListening", this.localLang)}`;
     const msg2Value = `${colors.bgBlue(`${colors.bold(`${nodeVersion}`)}`)}`;
-    const msg2 = ` ${TranslationLoader10.t("webServerUseNodeVersion", CLocal9)}`;
+    const msg2 = ` ${TranslationLoader10.t("webServerUseNodeVersion", this.localLang)}`;
     const msg3Value = `${colors.bgBlue(`${colors.bold(`${startingTime}`)}`)}`;
-    const msg3 = ` ${TranslationLoader10.t("startupTime", CLocal9)}`;
+    const msg3 = ` ${TranslationLoader10.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, " ")));
@@ -1064,27 +1108,28 @@ 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", CLocal9)}`} ${colors.cyan(`${colors.bold(`${rss}`)}`)}`);
-    console.log(`${`${TranslationLoader10.t("memoryUsedDuringExecution", CLocal9)}`} ${colors.cyan(`${colors.bold(`${heapUsed}`)}`)}`);
-    console.log(`${`${TranslationLoader10.t("memoryUsedByUser", CLocal9)}`} ${colors.cyan(`${colors.bold(`${user}`)}`)}`);
-    console.log(`${`${TranslationLoader10.t("memoryUsedBySystem", CLocal9)}`} ${colors.cyan(`${colors.bold(`${system}`)}`)}`);
+    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(``);
   }
 };
 
 // src/core/events/pathModuleVerifier.event.ts
 import { resolve } from "path";
-import { LoggerCore as LoggerCore9 } from "opticore-logger";
+import { LoggerCore as LoggerCore6 } from "opticore-logger";
 import { HttpStatusCode as HttpStatusCode2 } from "opticore-http-response";
-import { CLocal as CLocal10, TranslationLoader as TranslationLoader11 } from "opticore-translator";
+import { TranslationLoader as TranslationLoader11 } from "opticore-translator";
 var PathModuleVerifier = class {
-  static log = new LoggerCore9(loggerConfig);
+  static log = new LoggerCore6(loggerConfig);
   /**
    * Verifies if modules at specific paths are loaded.
    * If any module is not loaded, it throws an error.
+   * @param localLanguage
    * @param modulePaths - An array of paths to the modules to verify.
    */
-  static verifyModulePaths(modulePaths) {
+  static verifyModulePaths(localLanguage, modulePaths) {
     const notLoadedPaths = [];
     for (const modulePath of modulePaths) {
       if (!this.isModulePathLoaded(modulePath)) {
@@ -1093,7 +1138,7 @@ var PathModuleVerifier = class {
     }
     if (notLoadedPaths.length > 0) {
       this.log.error(
-        TranslationLoader11.t("moduleNotLoaded", CLocal10, { notLoadedPaths: notLoadedPaths.join(", ") }),
+        TranslationLoader11.t("moduleNotLoaded", localLanguage, { notLoadedPaths: notLoadedPaths.join(", ") }),
         "",
         "",
         modulePaths,