opticore-webapp-core 1.0.19 → 1.0.21

package/src/application/services/asymmetricCryptionDataWithPublicRSAKey.service.ts

@@ -0,0 +1,188 @@
+import crypto from "crypto";
+import { BinaryToTextEncoding } from "node:crypto";
+import { LoggerCore } from "opticore-logger";
+import { TranslationLoader } from "opticore-translator";
+import { HttpStatusCode } from "opticore-http-response";
+
+import { StackTraceError } from "opticore-catch-exception-error";
+import { RSAKeyEncryption } from "@webAppCore/utils/cryptography/encryption/rsaKey.encryption";
+import { CSignRSAKeyComponent } from "@webAppCore/core/constants/signRSAKeyComponent.constant";
+import { RSAKeyDecryption } from "@webAppCore/utils/cryptography/decryption/rsaKey.decryption";
+import { SLoggerFileConfiguration } from "@webAppCore/application/services/loggerFileConfiguration.service";
+
+
+export class SAsymmetricCryptionDataWithPublicRSAKey {
+    private readonly logger: LoggerCore;
+    private readonly localeLanguage: string;
+
+    constructor(localeLanguage: string, environnementPath: any) {
+        this.localeLanguage = localeLanguage;
+        this.logger = SLoggerFileConfiguration(environnementPath);
+    }
+    
+    /**
+     *
+     * @param rsaKey
+     * @param keyType
+     * 
+     * @protected
+     */
+    protected verifyExistingKey(rsaKey: string, keyType: string): string | Error {
+        if (!rsaKey) {
+            const stackTrace: StackTraceError = this.traceError(
+                keyType + TranslationLoader.t("verifyExistingKey", this.localeLanguage),
+                TranslationLoader.t("verifyExistingKey", this.localeLanguage),
+                HttpStatusCode.NOT_FOUND
+            );
+
+            this.logger.error({
+                message: TranslationLoader.t("verifyExistingKey", this.localeLanguage),
+                title: "key verification",
+                errorType: TranslationLoader.t("verifyExistingKeyError", this.localeLanguage),
+                stackTrace: stackTrace.stack!,
+                httpCodeValue: HttpStatusCode.NOT_FOUND
+            });
+        }
+
+        return rsaKey;
+    }
+
+
+    /**
+     *
+     * @param publicKey
+     * @param payload
+     * 
+     * @private
+     */
+    private encryptionWithPublicKey(publicKey: string, payload: any): Buffer {
+        this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
+
+        try {
+            const bufferedData: Buffer = Buffer.from(payload, Number(CSignRSAKeyComponent.encodingFormat));
+            return RSAKeyEncryption.publicEncrypt(publicKey, bufferedData);
+        } catch (err: any) {
+            const stackTrace: StackTraceError = this.traceError(
+                err.message,
+                TranslationLoader.t("encryptionWithPublicKey", this.localeLanguage),
+                HttpStatusCode.NOT_ACCEPTABLE
+            );
+
+            this.logger.error({
+                message: TranslationLoader.t("errorEncryptionPublicKey", this.localeLanguage),
+                title: TranslationLoader.t("encryptionWithPublicKey", this.localeLanguage),
+                errorType: err.code,
+                stackTrace: stackTrace.stack,
+                httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+            });
+            process.exit();
+        }
+    }
+
+
+    /**
+     *
+     * @param privateKey
+     * @param publicKey
+     * @param payload
+     * 
+     * @private
+     */
+    private decryptionWithPrivateKey(privateKey: string, publicKey: string, payload: any): Buffer {
+        this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
+
+        try {
+            const encryptedPayload: Buffer = this.encryptionWithPublicKey(publicKey, payload);
+            return RSAKeyDecryption.privateDecrypt(privateKey, encryptedPayload);
+        } catch (err: any) {
+            const stackTrace: StackTraceError = this.traceError(
+                err.code,
+                TranslationLoader.t("errorDecryption", this.localeLanguage),
+                HttpStatusCode.NOT_ACCEPTABLE
+            );
+
+            this.logger.error({
+                message: TranslationLoader.t("errorDecryptionWithPrivateKey", this.localeLanguage),
+                title: TranslationLoader.t("errorDecryption", this.localeLanguage),
+                errorType: err.message,
+                stackTrace: stackTrace.stack,
+                httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+            });
+            process.exit();
+        }
+    }
+
+
+    /**
+     *
+     * @param publicKey
+     * @param payload
+     * 
+     * @private
+     */
+    private signWithPublicRSAKey(publicKey: string, payload: any): string {
+        this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.private);
+
+        const sign: crypto.Sign = crypto.createSign(CSignRSAKeyComponent.algorithm.sha256);
+        sign.update(payload);
+
+        return sign.sign(publicKey, CSignRSAKeyComponent.outputFormat.base64 as BinaryToTextEncoding);
+    }
+
+
+    /**
+     *
+     * @param privateKey
+     * @param publicKey
+     * @param payload
+     * 
+     */
+    public verifyPublicRSAKey(privateKey: string, publicKey: string, payload: any): string | StackTraceError {
+        try {
+            const verify: crypto.Verify = crypto.createVerify(CSignRSAKeyComponent.algorithm.sha256);
+            verify.update(payload);
+
+            const signature: string = this.signWithPublicRSAKey(publicKey, payload);
+            const isVerified: boolean = verify.verify(publicKey, signature, CSignRSAKeyComponent.outputFormat.base64 as BinaryToTextEncoding);
+
+            if (isVerified) {
+                const decryptedData: Buffer = this.decryptionWithPrivateKey(privateKey, publicKey, payload);
+                return decryptedData.toString(CSignRSAKeyComponent.encodingFormat.utf_8 as BufferEncoding | undefined);
+            } else {
+                const stackTrace: StackTraceError = this.traceError(
+                    TranslationLoader.t("verifyPublicRSAKeyError", this.localeLanguage),
+                    TranslationLoader.t("signatureRSAKeyFailed", this.localeLanguage),
+                    HttpStatusCode.NOT_FOUND
+                );
+                this.logger.error({
+                    message: TranslationLoader.t("verifyPublicRSAKey", this.localeLanguage),
+                    title: TranslationLoader.t("signatureRSAKeyFailed", this.localeLanguage),
+                    errorType: TranslationLoader.t("verifyPublicRSAKeyError", this.localeLanguage),
+                    stackTrace: stackTrace.stack,
+                    httpCodeValue: HttpStatusCode.NOT_FOUND
+                });
+                
+                return stackTrace;
+            }
+        } catch (err: any) {
+            const stackTrace: StackTraceError = this.traceError(
+                err.code,
+                TranslationLoader.t("verifyPublicRSAKey", this.localeLanguage),
+                HttpStatusCode.NOT_ACCEPTABLE
+            );
+
+            this.logger.error({
+                message: TranslationLoader.t("verifyPublicRSAKey", this.localeLanguage),
+                title: TranslationLoader.t("errorDecryption", this.localeLanguage),
+                errorType: err.message,
+                stackTrace: stackTrace.stack,
+                httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+            });
+            process.exit();
+        }
+    }
+
+    private traceError(props: string, name: string, HttpStatusCode: number): StackTraceError {
+        return new StackTraceError(props, name, HttpStatusCode, true);
+    }
+}

package/src/application/services/loggerFileConfiguration.service.ts

@@ -0,0 +1,6 @@
+import { ILoggerConfig, LoggerCore } from "opticore-logger";
+import { loggerConfig } from "@webAppCore/core/config/logger/logger.config";
+
+export const SLoggerFileConfiguration: (environmentPath: any) => LoggerCore = (environmentPath: any): LoggerCore => {
+    return new LoggerCore(loggerConfig(environmentPath) as ILoggerConfig);
+}

package/src/core/config/database/connexion.config.database.ts

@@ -0,0 +1,116 @@
+import mySQL from "mysql";
+import stream from "stream";
+import { CustomTypesConfig } from "pg";
+import { ConnectionOptions } from "tls";
+import { HttpStatusCode as status } from "opticore-http-response";
+import { ILoggerConfig, LoggerCore } from "opticore-logger";
+import { TranslationLoader } from "opticore-translator";
+
+
+import { DbConnexionConfigError } from "@webAppCore/core/errors/databaseConnexion.error";
+import { Environment as env } from "@webAppCore/utils/environment.utils";
+import { StackTraceError as ErrorHandler } from "opticore-catch-exception-error";
+import { loggerConfig } from "@webAppCore/core/config/logger/logger.config";
+import { MPostgresCheckerDatabase } from "@webAppCore/core/config/database/middleware/postgresChecker.database";
+
+
+
+
+/**
+ * ConnexionConfigDatabase is a class extending on the EnvConfig class so that by inheritance,
+ * certain methods make it possible to retrieve the variable values defined in
+ * the .env environment file to establish the connection with the database service.
+ */
+export class DatabaseConnectionConfig {
+    private env: env<any>;
+    private logger: LoggerCore;
+    private readonly localeLanguage: string;
+    private readonly environmentPath: string;
+    private DbConnexionConfigError: DbConnexionConfigError ;
+
+
+    constructor(localeLanguage: string, environmentPath: any) {
+        this.localeLanguage = localeLanguage;
+        this.environmentPath = environmentPath;
+
+        this.DbConnexionConfigError = new DbConnexionConfigError(localeLanguage, environmentPath);
+        this.env = new env(environmentPath);
+        this.logger = new LoggerCore(loggerConfig(environmentPath) as ILoggerConfig)
+    }
+
+
+    /**
+     *
+     * @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
+     */
+    public async databasePostgresDBConnectionChecker(keepAlive?: boolean | undefined,
+                                                     stream?: (() => (stream.Duplex | undefined)) | undefined,
+                                                     statement_timeout?: false | number | undefined,
+                                                     ssl?: boolean | ConnectionOptions | undefined,
+                                                     query_timeout?: number | undefined,
+                                                     keepAliveInitialDelayMillis?: number | undefined,
+                                                     idle_in_transaction_session_timeout?: number | undefined,
+                                                     application_name?: string | undefined,
+                                                     connectionTimeoutMillis?: number | undefined,
+                                                     types?: CustomTypesConfig | undefined,
+                                                     options?: string | undefined): Promise<void> {
+        const url: string = `postgresql:/${this.env.get("dataBaseUser")}:${this.env.get("dataBasePassword")}@${this.env.get("dataBaseHost")}:${this.env.get("dataBasePort")}/${this.env.get("dataBaseName")}`;
+        try {
+            await MPostgresCheckerDatabase(
+                this.localeLanguage,
+                this.environmentPath,
+                url,
+                keepAlive,
+                stream,
+                statement_timeout,
+                ssl,
+                query_timeout,
+                keepAliveInitialDelayMillis,
+                idle_in_transaction_session_timeout,
+                application_name,
+                connectionTimeoutMillis,
+                types,
+                options
+            );
+
+            this.logger.success({
+                title: TranslationLoader.t("postgresDBConnectionChecker", this.localeLanguage, loggerConfig),
+                message: TranslationLoader.t("postgresConnectionSuccess", this.localeLanguage, loggerConfig)
+            });
+            console.log("");
+        } catch (err: any) {
+            const stackTrace: ErrorHandler = this.traceError(
+                TranslationLoader.t(
+                    err.message,
+                    this.localeLanguage,
+                    loggerConfig
+                ),
+                "PostgresConnectionError",
+                status.NOT_ACCEPTABLE
+            );
+            this.logger.error({
+                message: err.message,
+                title: "PostgresConnectionError",
+                errorType: "Postgres connection error",
+                stackTrace: stackTrace.stack,
+                httpCodeValue: status.NOT_ACCEPTABLE
+            });
+        }
+    }
+
+    private traceError(props: string, name: string, status: number): ErrorHandler {
+        return new ErrorHandler(props, name, status, true);
+    }
+}

package/src/core/config/database/middleware/postgresChecker.database.ts

@@ -0,0 +1,35 @@
+import {ConnectionOptions} from "tls";
+import {CustomTypesConfig} from "pg";
+import stream from "stream";
+import { DatabaseConnectionConfig } from "@webAppCore/core/config/database/connexion.config.database";
+
+export const MPostgresCheckerDatabase = (localLanguage: string,
+                                         environmentPath: any,
+                                         host?: string | undefined,
+                                         keepAlive?: boolean | undefined,
+                                         stream?: (() => (stream.Duplex | undefined)) | undefined,
+                                         statement_timeout?: false | number | undefined,
+                                         ssl?: boolean | ConnectionOptions | undefined,
+                                         query_timeout?: number | undefined,
+                                         keepAliveInitialDelayMillis?: number | undefined,
+                                         idle_in_transaction_session_timeout?: number | undefined,
+                                         application_name?: string | undefined,
+                                         connectionTimeoutMillis?: number | undefined,
+                                         types?: CustomTypesConfig | undefined,
+                                         options?: string | undefined) => {
+    const DbConnexion: DatabaseConnectionConfig = new DatabaseConnectionConfig(localLanguage, environmentPath);
+    return DbConnexion.databasePostgresDBConnectionChecker(
+        host,
+        keepAlive,
+        stream,
+        statement_timeout,
+        ssl,
+        query_timeout,
+        keepAliveInitialDelayMillis,
+        idle_in_transaction_session_timeout,
+        application_name,
+        connectionTimeoutMillis,
+        types,
+        options
+    );
+}

package/src/core/config/loaders/localLanguage.loader.ts

@@ -0,0 +1,31 @@
+import path from "path";
+import { TranslationLoader } from "opticore-translator";
+import { SLoggerFileConfiguration } from "@webAppCore/application/services/loggerFileConfiguration.service";
+import { HttpStatusCode } from "opticore-http-response";
+
+
+
+export class LocalLanguageLoader {
+    private readonly localeLanguage: string;
+    private readonly environmentPath: string;
+
+    constructor(localeLanguage: string, environmentPath: any) {
+        this.localeLanguage = localeLanguage;
+        this.environmentPath = environmentPath;
+    }
+
+    public load(): void {
+        try {
+            const translateMsgJsonFilePath: string = path.join(process.cwd(), "src", "utils", "translations");
+            TranslationLoader.loadTranslations(translateMsgJsonFilePath);
+        } catch (err: any) {
+            SLoggerFileConfiguration(this.environmentPath).error({
+                message: err.message,
+                title: err.code,
+                errorType: err.code,
+                stackTrace: err.stackTrace,
+                httpCodeValue: HttpStatusCode.INTERNAL_SERVER_ERROR
+            });
+        }
+    }
+}

package/src/core/config/loaders/translateLanguage.loader.ts

@@ -0,0 +1,27 @@
+import path from "path";
+import { createRequire } from "module";
+import { TranslationLoader } from "opticore-translator";
+import { SLoggerFileConfiguration } from "@webAppCore/application/services/loggerFileConfiguration.service";
+import { HttpStatusCode } from "opticore-http-response";
+
+
+export const translateWebAppCoreLanguageLoader: (environmentPath: any,
+                                                 localLang: string) => void = (environmentPath: any, localLang: string): void => {
+    try {
+        const require: NodeJS.Require = createRequire(import.meta.url);
+        const packagePath: string = path.dirname(require.resolve("opticore-webapp-core"));
+
+        // Relative path based on package root
+        const translateMsgJsonFilePath: string = path.join(packagePath, "utils", "translations");
+        TranslationLoader.loadTranslations(translateMsgJsonFilePath);
+
+    } catch (err: any) {
+        SLoggerFileConfiguration(environmentPath).error({
+            message: TranslationLoader.t(err.message, localLang),
+            title: err.code,
+            errorType: err.code,
+            stackTrace: err.stackTrace,
+            httpCodeValue: HttpStatusCode.INTERNAL_SERVER_ERROR
+        });
+    }
+}

package/src/core/config/logger/logger.config.ts

@@ -0,0 +1,33 @@
+import { getEnvironmentValue, IEnvVariables } from "opticore-env-access";
+
+/**
+ *
+ * @param envDir
+ */
+export const loggerConfig = (envDir: any) => {
+    const getEnvAccess: IEnvVariables = getEnvironmentValue(envDir);
+
+    return {
+        logLevels: [
+            getEnvAccess.logLevelInfo,
+            getEnvAccess.logLevelWarning,
+            getEnvAccess.logLevelSuccess,
+            getEnvAccess.logLevelError,
+            getEnvAccess.logLevelDebug,
+        ],
+        transports: {
+            file: {
+                enabled: getEnvAccess.logFileEnabled,
+                maxSizeMB: getEnvAccess.logFileMaxSize,
+                rotate: getEnvAccess.logFileRotate,
+            },
+            console: {
+                enabled: getEnvAccess.logConsoleEnabled,
+            },
+            remote: {
+                enabled: getEnvAccess.logRemoteEnabled,
+                endpoint: getEnvAccess.logRemoteEndPoint,
+            },
+        }
+    };
+}

package/src/core/constants/signRSA/algorithm.constant.ts

@@ -0,0 +1,54 @@
+export const CAlgorithm = {
+    RSA_MD5: "RSA-MD5",
+    RSA_RIPEMD160: "RSA-RIPEMD160",
+    RSA_SHA1: "RSA-SHA1",
+    RSA_SHA1_2: "RSA-SHA1-2",
+    RSA_SHA224: "RSA-SHA224",
+    RSA_SHA256: "RSA-SHA256",
+    RSA_SHA3_224: "RSA-SHA3-224",
+    RSA_SHA3_256: "RSA-SHA3-256",
+    RSA_SHA3_384: "RSA-SHA3-384",
+    RSA_SHA3_512: "RSA-SHA3-512",
+    RSA_SHA384: "RSA-SHA384",
+    RSA_SHA512: "RSA-SHA512",
+    RSA_SHA512_224: "RSA-SHA512/224",
+    RSA_SHA512_256: "RSA-SHA512/256",
+    RSA_SM3: "RSA-SM3",
+    blake2b512: "blake2b512",
+    blake2s256: "blake2s256",
+    id_rsassa_pkcs1_v1_5_with_sha3_224: "id-rsassa-pkcs1-v1_5-with-sha3-224",
+    id_rsassa_pkcs1_v1_5_with_sha3_256: "id-rsassa-pkcs1-v1_5-with-sha3-256",
+    id_rsassa_pkcs1_v1_5_with_sha3_384: "id-rsassa-pkcs1-v1_5-with-sha3-384",
+    id_rsassa_pkcs1_v1_5_with_sha3_512: "id-rsassa-pkcs1-v1_5-with-sha3-512",
+    md5: "md5",
+    md5_sha1: "md5-sha1",
+    md5WithRSAEncryption: "md5WithRSAEncryption",
+    ripemd: "ripemd",
+    ripemd160: "ripemd160",
+    ripemd160WithRSA: "ripemd160WithRSA",
+    rmd160: "rmd160",
+    sha1: "sha1",
+    sha1WithRSAEncryption: "sha1WithRSAEncryption",
+    sha224: "sha224",
+    sha224WithRSAEncryption: "sha224WithRSAEncryption",
+    sha256: "SHA256",
+    sha256WithRSAEncryption: "sha256WithRSAEncryption",
+    sha3_224: "sha3-224",
+    sha3_256: "sha3-256",
+    sha3_384: "sha3-384",
+    sha3_512: "sha3-512",
+    sha384: "sha384",
+    sha384WithRSAEncryption: "sha384WithRSAEncryption",
+    sha512: "sha512",
+    sha512_224: "sha512-224",
+    sha512_224WithRSAEncryption: "sha512-224WithRSAEncryption",
+    sha512_256: "sha512-256",
+    sha512_256WithRSAEncryption: "sha512-256WithRSAEncryption",
+    sha512WithRSAEncryption: "sha512WithRSAEncryption",
+    shake128: "shake128",
+    shake256: "shake256",
+    sm3: "sm3",
+    sm3WithRSAEncryption: "sm3WithRSAEncryption",
+    ssl3_md5: "ssl3-md5",
+    ssl3_sha1: "ssl3-sha1"
+}

package/src/core/constants/signRSA/encodingFormat.constant.ts

@@ -0,0 +1,14 @@
+export const CEncodingFormat = {
+    ascii: "ascii",
+    utf8: "utf8",
+    utf_8 :"utf-8",
+    utf16le: "utf16le",
+    utf_16le: "utf-16le",
+    ucs2: "ucs2",
+    ucs_2: "ucs-2",
+    base64: "base64",
+    base64url: "base64url",
+    latin1: "latin1",
+    binary: "binary",
+    hex: "hex"
+}

package/src/core/constants/signRSA/keyType.constant.ts

@@ -0,0 +1,4 @@
+export const CKeyType = {
+    private: "Private",
+    public: "Public",
+}

package/src/core/constants/signRSA/outputFormat.constant.ts

@@ -0,0 +1,6 @@
+export const COutputFormat = {
+    base64: "base64",
+    base64url: "base64url",
+    hex: "hex",
+    binary: "binary"
+}

package/src/core/constants/signRSAKeyComponent.constant.ts

@@ -0,0 +1,11 @@
+import { CAlgorithm } from "@webAppCore/core/constants/signRSA/algorithm.constant";
+import { CKeyType } from "@webAppCore/core/constants/signRSA/keyType.constant";
+import { COutputFormat } from "@webAppCore/core/constants/signRSA/outputFormat.constant";
+import { CEncodingFormat } from "@webAppCore/core/constants/signRSA/encodingFormat.constant";
+
+export const CSignRSAKeyComponent = {
+    algorithm: CAlgorithm,
+    keyType: CKeyType,
+    outputFormat: COutputFormat,
+    encodingFormat: CEncodingFormat
+}

package/src/core/errors/databaseConnexion.error.ts

@@ -0,0 +1,107 @@
+import { HttpStatusCode as status } from "opticore-http-response";
+import { LoggerCore } from "opticore-logger";
+
+import { StackTraceError } from "opticore-catch-exception-error";
+import { TranslationLoader } from "opticore-translator";
+import { SLoggerFileConfiguration } from "@webAppCore/application/services/loggerFileConfiguration.service";
+
+export class DbConnexionConfigError {
+
+    private logger: LoggerCore;
+    private readonly localeLanguage: string;
+    
+    constructor(localeLanguage: string, environmentPath: any) {
+        this.localeLanguage = localeLanguage;
+        this.logger = SLoggerFileConfiguration(environmentPath);
+    }
+
+    /**
+     *
+     * @param e
+     */
+    public mongoDBAuthenticationFailed(e: any): void  {
+        const stackTrace: StackTraceError = this.traceError(
+            TranslationLoader.t("mongoDBConnection", this.localeLanguage, { e: e }),
+            TranslationLoader.t("mongoDBAuthentication", this.localeLanguage),
+            status.UNAUTHORIZED
+        );
+        this.logger.error({
+            message: TranslationLoader.t("mongoDBAuthenticationError", this.localeLanguage),
+            title: TranslationLoader.t("mongoDBConnection", this.localeLanguage),
+            errorType: TranslationLoader.t("mongoDBAuthenticationFailed", this.localeLanguage),
+            stackTrace: stackTrace.stack!,
+            httpCodeValue: status.UNAUTHORIZED
+        });
+    }
+
+    /**
+     *
+     * @param err
+     * @param dbHost
+     * @param dbPort
+     */
+    public mongoDBInvalidUrl(err: any, dbHost: string, dbPort: string): void {
+        const stackTrace: StackTraceError = this.traceError(
+            TranslationLoader.t("mongoDBConnection", this.localeLanguage, { err: err }),
+            TranslationLoader.t("mongoDBUnableParsingUrl", this.localeLanguage),
+            status.BAD_REQUEST
+        );
+        this.logger.error({
+            message: TranslationLoader.t("dbUrlParsingError", this.localeLanguage, {dbHost: dbHost, dbPort: dbPort}),
+            title: TranslationLoader.t("mongoDBConnection", this.localeLanguage),
+            errorType: TranslationLoader.t("mongoDBUnableParsingUrl", this.localeLanguage),
+            stackTrace: stackTrace.stack!,
+            httpCodeValue: status.BAD_REQUEST
+        });
+    }
+
+    /**
+     *
+     * @param err
+     * @param dbHost
+     */
+    public mongoDBEaiAgain(err: any, dbHost: string): void {
+        const stackTrace: StackTraceError = this.traceError(
+            TranslationLoader.t("mongoDBConnection", this.localeLanguage, { err: err }),
+            TranslationLoader.t("mongoDBServerSelection", this.localeLanguage),
+            status.BAD_REQUEST
+        );
+        this.logger.error({
+            message: TranslationLoader.t("mongoServerError", this.localeLanguage, {dbHost: dbHost}),
+            title: TranslationLoader.t("mongoDBConnection", this.localeLanguage),
+            errorType: TranslationLoader.t("mongoDBServerSelection", this.localeLanguage),
+            stackTrace: stackTrace.stack!,
+            httpCodeValue: status.BAD_REQUEST
+        });
+    }
+
+    /**
+     *
+     * @param err
+     */
+    public mongoDbGlobalError (err: any): void {
+        const stackTrace: StackTraceError = this.traceError(
+            TranslationLoader.t("mongoDBConnection", this.localeLanguage, { err: err }),
+            TranslationLoader.t("mongoDBConnection", this.localeLanguage),
+            status.NOT_ACCEPTABLE
+        );
+        this.logger.error({
+            message: TranslationLoader.t("mongoDBConnection", this.localeLanguage),
+            title: TranslationLoader.t("mongoDBConnectionError", this.localeLanguage),
+            stackTrace: stackTrace.stack!,
+            errorType: err.code,
+            httpCodeValue:status.NOT_ACCEPTABLE
+        });
+    }
+
+    /**
+     *
+     * @param props
+     * @param name
+     * @param status
+     * @private
+     */
+    private traceError(props: string, name: string, status: number): StackTraceError {
+        return new StackTraceError(props, name, status, true);
+    }
+}