opticore-webapp-core 1.0.8 → 1.0.10

package/dist/index.js

@@ -173,27 +173,30 @@ var SLoggerFileConfiguration = () => {
 
 // src/application/services/asymmetricCryptionDataWithPrivateRSAKey.service.ts
 var SAsymmetricCryptionDataWithPrivateRSAKey = class {
-  static log = SLoggerFileConfiguration();
+  log = SLoggerFileConfiguration();
+  localeLanguage;
+  constructor(localeLanguage) {
+    this.localeLanguage = localeLanguage;
+  }
   /**
    * 
    * @param rsaKey
    * @param keyType
-   * @param localeLanguage
    * @protected
    * 
    * Return ErrorHandler | string
    */
-  static verifyExistingKey(rsaKey, keyType, localeLanguage) {
+  verifyExistingKey(rsaKey, keyType) {
     if (!rsaKey) {
       const stackTrace = this.traceError(
-        keyType + " " + TranslationLoader.t("rsaKeyNotFound", localeLanguage, this.log),
-        TranslationLoader.t("erBadDbError", localeLanguage, this.log),
+        keyType + " " + TranslationLoader.t("rsaKeyNotFound", this.localeLanguage, this.log),
+        TranslationLoader.t("erBadDbError", this.localeLanguage, this.log),
         status.NOT_FOUND
       );
       this.log.error(
-        TranslationLoader.t("rsaKeyNotFound", localeLanguage, this.log),
-        TranslationLoader.t("verifyExistingKey", localeLanguage, this.log),
-        TranslationLoader.t("erBadDbError", localeLanguage, this.log),
+        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
       );
@@ -205,26 +208,25 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
    *
    * @param privateKey
    * @param payload
-   * @param localeLanguage
    * @private
    *
    * Return Buffer
    */
-  static encryptionWithPrivateKey(privateKey, payload, localeLanguage) {
-    this.verifyExistingKey(privateKey, CSignRSAKeyComponent.keyType.private, localeLanguage);
+  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", localeLanguage, this.log),
-        TranslationLoader.t("encryptionFailed", localeLanguage, this.log),
+        TranslationLoader.t("encryptionWithPrivateKeyFailed", this.localeLanguage, this.log),
+        TranslationLoader.t("encryptionFailed", this.localeLanguage, this.log),
         status.NOT_FOUND
       );
       this.log.error(
         err.message,
-        TranslationLoader.t("encryptionFailed", localeLanguage, this.log),
-        TranslationLoader.t("encryptionWithPrivateKeyFailed", localeLanguage, this.log),
+        TranslationLoader.t("encryptionFailed", this.localeLanguage, this.log),
+        TranslationLoader.t("encryptionWithPrivateKeyFailed", this.localeLanguage, this.log),
         stackTrace.stack,
         status.NOT_FOUND
       );
@@ -236,25 +238,24 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
    * @param privateKey
    * @param publicKey
    * @param payload
-   * @param localeLanguage
    * @private
    */
-  static decryptionWithPublicKey(privateKey, publicKey, payload, localeLanguage) {
-    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public, localeLanguage);
+  decryptionWithPublicKey(privateKey, publicKey, payload) {
+    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
     try {
-      const encryptedPayload = this.encryptionWithPrivateKey(privateKey, payload, localeLanguage);
+      const encryptedPayload = this.encryptionWithPrivateKey(privateKey, payload);
       return RSAKeyDecryption.publicDecrypt(publicKey, encryptedPayload);
     } catch (error) {
       const stackTrace = this.traceError(
-        TranslationLoader.t("errorDecryption", localeLanguage, this.log),
-        TranslationLoader.t("decryptionFailed", localeLanguage, this.log),
+        TranslationLoader.t("errorDecryption", this.localeLanguage, this.log),
+        TranslationLoader.t("decryptionFailed", this.localeLanguage, this.log),
         status.NOT_ACCEPTABLE
       );
       this.log.error(
-        TranslationLoader.t("decryptionWithPublicKeyFailed", localeLanguage, this.log),
-        TranslationLoader.t("decryptionFailed", localeLanguage, this.log),
+        TranslationLoader.t("decryptionWithPublicKeyFailed", this.localeLanguage, this.log),
+        TranslationLoader.t("decryptionFailed", this.localeLanguage, this.log),
         stackTrace.stack,
-        TranslationLoader.t("errorDecryption", localeLanguage, this.log),
+        TranslationLoader.t("errorDecryption", this.localeLanguage, this.log),
         status.NOT_ACCEPTABLE
       );
       throw new Error();
@@ -264,11 +265,10 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
    *
    * @param privateKey
    * @param payload
-   * @param localeLanguage
    * @private
    */
-  static signWithRSAKey(privateKey, payload, localeLanguage) {
-    this.verifyExistingKey(privateKey, CSignRSAKeyComponent.keyType.private, localeLanguage);
+  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);
@@ -278,28 +278,27 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
    * @param privateKey
    * @param publicKey
    * @param payload
-   * @param localeLanguage
    */
-  static verifyRSAKey(privateKey, publicKey, payload, localeLanguage) {
+  verifyRSAKey(privateKey, publicKey, payload) {
     try {
       const verify = crypto3.createVerify(CSignRSAKeyComponent.algorithm.sha256);
       verify.update(payload);
-      const signature = this.signWithRSAKey(privateKey, payload, localeLanguage);
+      const signature = this.signWithRSAKey(privateKey, payload);
       const isVerified = verify.verify(publicKey, signature, CSignRSAKeyComponent.outputFormat.base64);
       if (isVerified) {
-        const decryptedData = this.decryptionWithPublicKey(privateKey, publicKey, payload, localeLanguage);
+        const decryptedData = this.decryptionWithPublicKey(privateKey, publicKey, payload);
         return decryptedData.toString(CSignRSAKeyComponent.encodingFormat.utf_8);
       } else {
         const stackTrace = this.traceError(
-          TranslationLoader.t("signatureRSAKeyFailed", localeLanguage, this.log),
-          TranslationLoader.t("verifyRSAKeyFailed", localeLanguage, this.log),
+          TranslationLoader.t("signatureRSAKeyFailed", this.localeLanguage, this.log),
+          TranslationLoader.t("verifyRSAKeyFailed", this.localeLanguage, this.log),
           status.NOT_ACCEPTABLE
         );
         this.log.error(
-          TranslationLoader.t("verifyRSAKey", localeLanguage, this.log),
-          TranslationLoader.t("verifyRSAKeyFailed", localeLanguage, this.log),
+          TranslationLoader.t("verifyRSAKey", this.localeLanguage, this.log),
+          TranslationLoader.t("verifyRSAKeyFailed", this.localeLanguage, this.log),
           stackTrace.stack,
-          TranslationLoader.t("signatureRSAKeyFailed", localeLanguage, this.log),
+          TranslationLoader.t("signatureRSAKeyFailed", this.localeLanguage, this.log),
           status.NOT_FOUND
         );
         return new Error();
@@ -307,12 +306,12 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
     } catch (err) {
       const stackTrace = this.traceError(
         err.name,
-        TranslationLoader.t("signatureRSAKeysError", localeLanguage, this.log),
+        TranslationLoader.t("signatureRSAKeysError", this.localeLanguage, this.log),
         status.NOT_ACCEPTABLE
       );
       this.log.error(
-        TranslationLoader.t("signatureRSAKeysError", localeLanguage, this.log),
-        TranslationLoader.t("errorNameNotVerifyingRSAKey", localeLanguage, this.log),
+        TranslationLoader.t("signatureRSAKeysError", this.localeLanguage, this.log),
+        TranslationLoader.t("errorNameNotVerifyingRSAKey", this.localeLanguage, this.log),
         stackTrace.stack,
         err.message,
         status.NOT_FOUND
@@ -327,7 +326,7 @@ var SAsymmetricCryptionDataWithPrivateRSAKey = class {
    * @param status
    * @private
    */
-  static traceError(props, name, status7) {
+  traceError(props, name, status7) {
     return new ErrorHandler(props, name, status7, true);
   }
 };
@@ -338,26 +337,30 @@ 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 logger = SLoggerFileConfiguration();
+  logger = SLoggerFileConfiguration();
+  localeLanguage;
+  constructor(localeLanguage) {
+    this.localeLanguage = localeLanguage;
+  }
   /**
    *
    * @param rsaKey
    * @param keyType
-   * @param localeLanguage
+   * 
    * @protected
    */
-  static verifyExistingKey(rsaKey, keyType, localeLanguage) {
+  verifyExistingKey(rsaKey, keyType) {
     if (!rsaKey) {
       const stackTrace = this.traceError(
-        keyType + TranslationLoader2.t("verifyExistingKey", localeLanguage, this.logger),
-        TranslationLoader2.t("verifyExistingKey", localeLanguage, this.logger),
+        keyType + TranslationLoader2.t("verifyExistingKey", this.localeLanguage, this.logger),
+        TranslationLoader2.t("verifyExistingKey", this.localeLanguage, this.logger),
         status2.NOT_FOUND
       );
       this.logger.error(
-        TranslationLoader2.t("verifyExistingKey", localeLanguage, this.logger),
+        TranslationLoader2.t("verifyExistingKey", this.localeLanguage, this.logger),
         "key verification",
         stackTrace.stack,
-        TranslationLoader2.t("verifyExistingKeyError", localeLanguage, this.logger),
+        TranslationLoader2.t("verifyExistingKeyError", this.localeLanguage, this.logger),
         status2.NOT_FOUND
       );
       return new Error();
@@ -368,23 +371,23 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
    *
    * @param publicKey
    * @param payload
-   * @param localeLanguage
+   * 
    * @private
    */
-  static encryptionWithPublicKey(publicKey, payload, localeLanguage) {
-    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public, localeLanguage);
+  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", localeLanguage, this.logger),
+        TranslationLoader2.t("encryptionWithPublicKey", this.localeLanguage, this.logger),
         status2.NOT_ACCEPTABLE
       );
       this.logger.error(
-        TranslationLoader2.t("errorEncryptionPublicKey", localeLanguage, this.logger),
-        TranslationLoader2.t("encryptionWithPublicKey", localeLanguage, this.logger),
+        TranslationLoader2.t("errorEncryptionPublicKey", this.localeLanguage, this.logger),
+        TranslationLoader2.t("encryptionWithPublicKey", this.localeLanguage, this.logger),
         stackTrace.stack,
         err.message,
         status2.NOT_ACCEPTABLE
@@ -397,23 +400,23 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
    * @param privateKey
    * @param publicKey
    * @param payload
-   * @param localeLanguage
+   * 
    * @private
    */
-  static decryptionWithPrivateKey(privateKey, publicKey, payload, localeLanguage) {
-    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public, localeLanguage);
+  decryptionWithPrivateKey(privateKey, publicKey, payload) {
+    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
     try {
-      const encryptedPayload = this.encryptionWithPublicKey(publicKey, payload, localeLanguage);
+      const encryptedPayload = this.encryptionWithPublicKey(publicKey, payload);
       return RSAKeyDecryption.privateDecrypt(privateKey, encryptedPayload);
     } catch (err) {
       const stackTrace = this.traceError(
         err.code,
-        TranslationLoader2.t("errorDecryption", localeLanguage, this.logger),
+        TranslationLoader2.t("errorDecryption", this.localeLanguage, this.logger),
         status2.NOT_ACCEPTABLE
       );
       this.logger.error(
-        TranslationLoader2.t("errorDecryptionWithPrivateKey", localeLanguage, this.logger),
-        TranslationLoader2.t("errorDecryption", localeLanguage, this.logger),
+        TranslationLoader2.t("errorDecryptionWithPrivateKey", this.localeLanguage, this.logger),
+        TranslationLoader2.t("errorDecryption", this.localeLanguage, this.logger),
         stackTrace.stack,
         err.message,
         status2.NOT_ACCEPTABLE
@@ -425,11 +428,11 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
    *
    * @param publicKey
    * @param payload
-   * @param localeLanguage
+   * 
    * @private
    */
-  static signWithPublicRSAKey(publicKey, payload, localeLanguage) {
-    this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.private, localeLanguage);
+  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);
@@ -439,28 +442,28 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
    * @param privateKey
    * @param publicKey
    * @param payload
-   * @param localeLanguage
+   * 
    */
-  static verifyPublicRSAKey(privateKey, publicKey, payload, localeLanguage) {
+  verifyPublicRSAKey(privateKey, publicKey, payload) {
     try {
       const verify = crypto4.createVerify(CSignRSAKeyComponent.algorithm.sha256);
       verify.update(payload);
-      const signature = this.signWithPublicRSAKey(publicKey, payload, localeLanguage);
+      const signature = this.signWithPublicRSAKey(publicKey, payload);
       const isVerified = verify.verify(publicKey, signature, CSignRSAKeyComponent.outputFormat.base64);
       if (isVerified) {
-        const decryptedData = this.decryptionWithPrivateKey(privateKey, publicKey, payload, localeLanguage);
+        const decryptedData = this.decryptionWithPrivateKey(privateKey, publicKey, payload);
         return decryptedData.toString(CSignRSAKeyComponent.encodingFormat.utf_8);
       } else {
         const stackTrace = this.traceError(
-          TranslationLoader2.t("verifyPublicRSAKeyError", localeLanguage, this.logger),
-          TranslationLoader2.t("signatureRSAKeyFailed", localeLanguage, this.logger),
+          TranslationLoader2.t("verifyPublicRSAKeyError", this.localeLanguage, this.logger),
+          TranslationLoader2.t("signatureRSAKeyFailed", this.localeLanguage, this.logger),
           status2.NOT_FOUND
         );
         this.logger.error(
-          TranslationLoader2.t("verifyPublicRSAKey", localeLanguage, this.logger),
-          TranslationLoader2.t("signatureRSAKeyFailed", localeLanguage, this.logger),
+          TranslationLoader2.t("verifyPublicRSAKey", this.localeLanguage, this.logger),
+          TranslationLoader2.t("signatureRSAKeyFailed", this.localeLanguage, this.logger),
           stackTrace.stack,
-          TranslationLoader2.t("verifyPublicRSAKeyError", localeLanguage, this.logger),
+          TranslationLoader2.t("verifyPublicRSAKeyError", this.localeLanguage, this.logger),
           status2.NOT_FOUND
         );
         return stackTrace;
@@ -468,12 +471,12 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
     } catch (err) {
       const stackTrace = this.traceError(
         err.code,
-        TranslationLoader2.t("verifyPublicRSAKey", localeLanguage, this.logger),
+        TranslationLoader2.t("verifyPublicRSAKey", this.localeLanguage, this.logger),
         status2.NOT_ACCEPTABLE
       );
       this.logger.error(
-        TranslationLoader2.t("verifyPublicRSAKey", localeLanguage, this.logger),
-        TranslationLoader2.t("errorDecryption", localeLanguage, this.logger),
+        TranslationLoader2.t("verifyPublicRSAKey", this.localeLanguage, this.logger),
+        TranslationLoader2.t("errorDecryption", this.localeLanguage, this.logger),
         stackTrace.stack,
         err.message,
         status2.NOT_ACCEPTABLE
@@ -481,7 +484,7 @@ var SAsymmetricCryptionDataWithPublicRSAKey = class {
       throw new Error();
     }
   }
-  static traceError(props, name, status7) {
+  traceError(props, name, status7) {
     return new StackTraceError(props, name, status7, true);
   }
 };
@@ -660,22 +663,21 @@ var translateWebAppCoreLanguageLoader = () => {
 
 // src/utils/parsing/parsingYaml.utils.ts
 var YamlParsing = class {
-  static logger = new LoggerCore3(loggerConfig);
-  static localeLanguage;
-  static __init(localeLanguage) {
-    translateWebAppCoreLanguageLoader();
+  logger = new LoggerCore3(loggerConfig);
+  localeLanguage;
+  constructor(localeLanguage) {
     this.localeLanguage = localeLanguage;
-    return this;
+    translateWebAppCoreLanguageLoader();
   }
-  static async readFile(filePath, localeLanguage) {
+  async readFile(filePath) {
     try {
       const yamlContent = await readFile(filePath, "utf-8");
-      await this.parsing(yamlContent, localeLanguage);
+      await this.parsing(yamlContent);
     } catch (error) {
       this.logger.error(
         error.message,
-        TranslationLoader7.t("parsingFailed", localeLanguage, this.logger),
-        TranslationLoader7.t("readingError", localeLanguage, this.logger),
+        TranslationLoader7.t("parsingFailed", this.localeLanguage, this.logger),
+        TranslationLoader7.t("readingError", this.localeLanguage, this.logger),
         error.stack,
         HttpStatusCode.NOT_ACCEPTABLE
       );
@@ -684,10 +686,9 @@ var YamlParsing = class {
   /**
    *
    * @param content
-   * @param localeLanguage
    * @private
    */
-  static async parsing(content, localeLanguage) {
+  async parsing(content) {
     const result = {};
     const lines = content.split("\n");
     let currentKey = null;
@@ -707,9 +708,9 @@ var YamlParsing = class {
         }
       } else {
         this.logger.error(
-          TranslationLoader7.t("badFormat", localeLanguage, { line }),
-          TranslationLoader7.t("parsingFailed", localeLanguage, this.logger),
-          TranslationLoader7.t("unsupportedFormat", localeLanguage, this.logger),
+          TranslationLoader7.t("badFormat", this.localeLanguage, { line }),
+          TranslationLoader7.t("parsingFailed", this.localeLanguage, this.logger),
+          TranslationLoader7.t("unsupportedFormat", this.localeLanguage, this.logger),
           content,
           HttpStatusCode.NOT_ACCEPTABLE
         );
@@ -746,81 +747,81 @@ import { LoggerCore as LoggerCore4 } from "opticore-logger";
 import { StackTraceError as StackTraceError2 } from "opticore-catch-exception-error";
 import { TranslationLoader as TranslationLoader8 } from "opticore-translator";
 var DbConnexionConfigError = class {
-  static logger = new LoggerCore4(loggerConfig);
+  logger = new LoggerCore4(loggerConfig);
+  localeLanguage;
+  constructor(localeLanguage) {
+    this.localeLanguage = localeLanguage;
+  }
   /**
    *
-   * @param localLanguage
    * @param e
    */
-  static mongoDBAuthenticationFailed(localLanguage, e) {
+  mongoDBAuthenticationFailed(e) {
     const stackTrace = this.traceError(
-      TranslationLoader8.t("mongoDBConnection", localLanguage, { e }),
-      TranslationLoader8.t("mongoDBAuthentication", localLanguage),
+      TranslationLoader8.t("mongoDBConnection", this.localeLanguage, { e }),
+      TranslationLoader8.t("mongoDBAuthentication", this.localeLanguage),
       status5.UNAUTHORIZED
     );
     this.logger.error(
-      TranslationLoader8.t("mongoDBAuthenticationError", localLanguage),
-      TranslationLoader8.t("mongoDBConnection", localLanguage),
-      TranslationLoader8.t("mongoDBAuthenticationFailed", localLanguage),
+      TranslationLoader8.t("mongoDBAuthenticationError", this.localeLanguage),
+      TranslationLoader8.t("mongoDBConnection", this.localeLanguage),
+      TranslationLoader8.t("mongoDBAuthenticationFailed", this.localeLanguage),
       stackTrace.stack,
       status5.UNAUTHORIZED
     );
   }
   /**
    *
-   * @param localLanguage
    * @param err
    * @param dbHost
    * @param dbPort
    */
-  static mongoDBInvalidUrl(localLanguage, err, dbHost, dbPort) {
+  mongoDBInvalidUrl(err, dbHost, dbPort) {
     const stackTrace = this.traceError(
-      TranslationLoader8.t("mongoDBConnection", localLanguage, { err }),
-      TranslationLoader8.t("mongoDBUnableParsingUrl", localLanguage),
+      TranslationLoader8.t("mongoDBConnection", this.localeLanguage, { err }),
+      TranslationLoader8.t("mongoDBUnableParsingUrl", this.localeLanguage),
       status5.BAD_REQUEST
     );
     this.logger.error(
-      TranslationLoader8.t("dbUrlParsingError", localLanguage, { dbHost, dbPort }),
-      TranslationLoader8.t("mongoDBConnection", localLanguage),
-      TranslationLoader8.t("mongoDBUnableParsingUrl", localLanguage),
+      TranslationLoader8.t("dbUrlParsingError", this.localeLanguage, { dbHost, dbPort }),
+      TranslationLoader8.t("mongoDBConnection", this.localeLanguage),
+      TranslationLoader8.t("mongoDBUnableParsingUrl", this.localeLanguage),
       stackTrace.stack,
       status5.BAD_REQUEST
     );
   }
   /**
    *
-   * @param localLanguage
    * @param err
    * @param dbHost
    */
-  static mongoDBEaiAgain(localLanguage, err, dbHost) {
+  mongoDBEaiAgain(err, dbHost) {
     const stackTrace = this.traceError(
-      TranslationLoader8.t("mongoDBConnection", localLanguage, { err }),
-      TranslationLoader8.t("mongoDBServerSelection", localLanguage),
+      TranslationLoader8.t("mongoDBConnection", this.localeLanguage, { err }),
+      TranslationLoader8.t("mongoDBServerSelection", this.localeLanguage),
       status5.BAD_REQUEST
     );
     this.logger.error(
-      TranslationLoader8.t("mongoServerError", localLanguage, { dbHost }),
-      TranslationLoader8.t("mongoDBConnection", localLanguage),
-      TranslationLoader8.t("mongoDBServerSelection", localLanguage),
+      TranslationLoader8.t("mongoServerError", this.localeLanguage, { dbHost }),
+      TranslationLoader8.t("mongoDBConnection", this.localeLanguage),
+      TranslationLoader8.t("mongoDBServerSelection", this.localeLanguage),
       stackTrace.stack,
       status5.BAD_REQUEST
     );
   }
   /**
    *
-   * @param localLanguage
    * @param err
    */
-  static mongoDbGlobalError(localLanguage, err) {
+  mongoDbGlobalError(err) {
     const stackTrace = this.traceError(
-      TranslationLoader8.t("mongoDBConnection", localLanguage, { err }),
-      TranslationLoader8.t("mongoDBConnection", localLanguage),
+      TranslationLoader8.t("mongoDBConnection", this.localeLanguage, { err }),
+      TranslationLoader8.t("mongoDBConnection", this.localeLanguage),
       status5.NOT_ACCEPTABLE
     );
     this.logger.error(
-      TranslationLoader8.t("mongoDBConnection", localLanguage),
-      TranslationLoader8.t("mongoDBConnectionError", localLanguage),
+      TranslationLoader8.t("mongoDBConnection", this.localeLanguage),
+      TranslationLoader8.t("mongoDBConnectionError", this.localeLanguage),
       stackTrace.stack,
       err.message,
       status5.NOT_ACCEPTABLE
@@ -833,7 +834,7 @@ var DbConnexionConfigError = class {
    * @param status
    * @private
    */
-  static traceError(props, name, status7) {
+  traceError(props, name, status7) {
     return new StackTraceError2(props, name, status7, true);
   }
 };
@@ -843,10 +844,15 @@ import { StackTraceError as ErrorHandler2 } from "opticore-catch-exception-error
 var DatabaseConnectionConfig = class {
   env = new Environment(getEnvVariable3);
   logger = new LoggerCore5(loggerConfig);
+  localeLanguage;
+  DbConnexionConfigError;
+  constructor(localeLanguage) {
+    this.localeLanguage = localeLanguage;
+    this.DbConnexionConfigError = new DbConnexionConfigError(localeLanguage);
+  }
   /**
    *
    * @param optionalArgumentConnection
-   * @param localeLanguage
    *
    * MySQL database connection with an optional arguments
    * Establish the connection between app and Database Management System.
@@ -854,46 +860,44 @@ var DatabaseConnectionConfig = class {
    * 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, localeLanguage) {
+  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(localeLanguage, dbConnection, this.env.get("dataBaseUser"), this.env.get("dataBaseName"), this.env.get("dataBaseHost"), this.env.get("dataBasePassword"));
+    return SCheckerMySqlDatabaseConnection(this.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, localeLanguage) {
+  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", localeLanguage, loggerConfig),
-        TranslationLoader9.t("mongoConnectionSuccess", localeLanguage, loggerConfig)
+        TranslationLoader9.t("mongoDBConnectionChecker", this.localeLanguage, loggerConfig),
+        TranslationLoader9.t("mongoConnectionSuccess", this.localeLanguage, loggerConfig)
       );
       console.log("");
     } catch (e) {
       if (e.code === 18) {
-        DbConnexionConfigError.mongoDBAuthenticationFailed(e);
+        this.DbConnexionConfigError.mongoDBAuthenticationFailed(e);
       }
       if (e.cause.code === "ERR_INVALID_URL") {
-        DbConnexionConfigError.mongoDBInvalidUrl(e, this.env.get("dataBaseHost"), this.env.get("dataBasePort"));
+        this.DbConnexionConfigError.mongoDBInvalidUrl(e, this.env.get("dataBaseHost"), this.env.get("dataBasePort"));
       }
       if (e.code === void 0) {
-        DbConnexionConfigError.mongoDBEaiAgain(e, this.env.get("dataBaseHost"));
+        this.DbConnexionConfigError.mongoDBEaiAgain(e, this.env.get("dataBaseHost"));
       } else {
-        DbConnexionConfigError.mongoDbGlobalError(e);
+        this.DbConnexionConfigError.mongoDbGlobalError(e);
       }
     }
   }
   /**
    *
-   * @param localeLanguage
    * @param keepAlive
    * @param stream
    * @param statement_timeout
@@ -908,11 +912,11 @@ var DatabaseConnectionConfig = class {
    *
    * Postgres database connection with optional connection arguments
    */
-  async databasePostgresDBConnectionChecker(localeLanguage, keepAlive, stream, statement_timeout, ssl, query_timeout, keepAliveInitialDelayMillis, idle_in_transaction_session_timeout, application_name, connectionTimeoutMillis, types, options) {
+  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(
-        localeLanguage,
+        this.localeLanguage,
         url,
         keepAlive,
         stream,
@@ -927,13 +931,13 @@ var DatabaseConnectionConfig = class {
         options
       );
       this.logger.success(
-        TranslationLoader9.t("postgresDBConnectionChecker", localeLanguage, loggerConfig),
-        TranslationLoader9.t("postgresConnectionSuccess", localeLanguage, loggerConfig)
+        TranslationLoader9.t("postgresDBConnectionChecker", this.localeLanguage, loggerConfig),
+        TranslationLoader9.t("postgresConnectionSuccess", this.localeLanguage, loggerConfig)
       );
       console.log("");
     } catch (err) {
       const stackTrace = this.traceError(
-        TranslationLoader9.t(`${err.message}`, localeLanguage, loggerConfig),
+        TranslationLoader9.t(`${err.message}`, this.localeLanguage, loggerConfig),
         "PostgresConnectionError",
         status6.NOT_ACCEPTABLE
       );
@@ -953,21 +957,20 @@ var DatabaseConnectionConfig = class {
 
 // src/core/config/database/middleware/mongoChecker.database.ts
 var MMongoCheckerDatabase = (optionalArgumentConnection, localLanguage) => {
-  const DbConnexion = new DatabaseConnectionConfig();
-  return DbConnexion.databaseMongoDBConnectionChecker(optionalArgumentConnection, localLanguage);
+  const DbConnexion = new DatabaseConnectionConfig(localLanguage);
+  return DbConnexion.databaseMongoDBConnectionChecker(optionalArgumentConnection);
 };
 
 // src/core/config/database/middleware/mySqlChecker.database.ts
 var MMySqlCheckerDatabase = (optionalArgumentConnection, localLanguage) => {
-  const DbConnexion = new DatabaseConnectionConfig();
-  return DbConnexion.databaseMySQLConnexionChecker(optionalArgumentConnection, localLanguage);
+  const DbConnexion = new DatabaseConnectionConfig(localLanguage);
+  return DbConnexion.databaseMySQLConnexionChecker(optionalArgumentConnection);
 };
 
 // src/core/config/database/middleware/postgresChecker.database.ts
 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();
+  const DbConnexion = new DatabaseConnectionConfig(localLanguage);
   return DbConnexion.databasePostgresDBConnectionChecker(
-    localLanguage,
     keepAlive,
     stream,
     statement_timeout,
@@ -1122,14 +1125,17 @@ import { LoggerCore as LoggerCore6 } from "opticore-logger";
 import { HttpStatusCode as HttpStatusCode2 } from "opticore-http-response";
 import { TranslationLoader as TranslationLoader11 } from "opticore-translator";
 var PathModuleVerifier = class {
-  static log = new LoggerCore6(loggerConfig);
+  log = new LoggerCore6(loggerConfig);
+  localeLanguage;
+  constructor(localeLanguage) {
+    this.localeLanguage = localeLanguage;
+  }
   /**
    * 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(localLanguage, modulePaths) {
+  verifyModulePaths(modulePaths) {
     const notLoadedPaths = [];
     for (const modulePath of modulePaths) {
       if (!this.isModulePathLoaded(modulePath)) {
@@ -1138,7 +1144,7 @@ var PathModuleVerifier = class {
     }
     if (notLoadedPaths.length > 0) {
       this.log.error(
-        TranslationLoader11.t("moduleNotLoaded", localLanguage, { notLoadedPaths: notLoadedPaths.join(", ") }),
+        TranslationLoader11.t("moduleNotLoaded", this.localeLanguage, { notLoadedPaths: notLoadedPaths.join(", ") }),
         "",
         "",
         modulePaths,
@@ -1152,7 +1158,7 @@ var PathModuleVerifier = class {
    * @param modulePath - The path to the module.
    * @returns True if the module is loaded, false otherwise.
    */
-  static isModulePathLoaded(modulePath) {
+  isModulePathLoaded(modulePath) {
     try {
       const resolvedPath = resolve(modulePath);
       return __require.cache[resolvedPath] !== void 0;