opticore-webapp-core 1.0.19 → 1.0.21

package/src/core/events/pathModuleVerifier.event.ts

@@ -0,0 +1,58 @@
+import { resolve } from "path";
+import { LoggerCore } from "opticore-logger";
+import { HttpStatusCode } from "opticore-http-response";
+import { TranslationLoader } from "opticore-translator";
+import { SLoggerFileConfiguration } from "@webAppCore/application/services/loggerFileConfiguration.service";
+
+
+export class PathModuleVerifier {
+    private log: LoggerCore;
+    private readonly localeLanguage: string;
+
+
+    constructor(localeLanguage: string, environmentPath: any) {
+        this.localeLanguage = localeLanguage;
+        this.log = SLoggerFileConfiguration(environmentPath);
+    }
+    
+
+    /**
+     * Verifies if modules at specific paths are loaded.
+     * If any module is not loaded, it throws an error.
+     * @param modulePaths - An array of paths to the modules to verify.
+     */
+    public verifyModulePaths(modulePaths: string[]): void {
+        const notLoadedPaths: string[] = [];
+
+        for (const modulePath of modulePaths) {
+            if (!this.isModulePathLoaded(modulePath)) {
+                notLoadedPaths.push(modulePath);
+            }
+        }
+
+        if (notLoadedPaths.length > 0) {
+            this.log.error({
+                message: TranslationLoader.t("moduleNotLoaded", this.localeLanguage, {notLoadedPaths: notLoadedPaths.join(', ')}),
+                title: '',
+                errorType: '',
+                stackTrace: modulePaths,
+                httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+            });
+            throw new Error();
+        }
+    }
+
+    /**
+     * Checks if a specific module at a given path is loaded in the Node.js require cache.
+     * @param modulePath - The path to the module.
+     * @returns True if the module is loaded, false otherwise.
+     */
+    private isModulePathLoaded(modulePath: string): boolean {
+        try {
+            const resolvedPath: string = resolve(modulePath);
+            return require.cache[resolvedPath] !== undefined;
+        } catch {
+            return false;
+        }
+    }
+}

package/src/domains/constants/logLevel.constant.ts

@@ -0,0 +1,6 @@
+export const CLogLevel =  {
+    debug: "DEBUG",
+    info: "INFO",
+    warn: "WARN",
+    error: "ERROR"
+} as const;

package/src/index.ts

@@ -0,0 +1,56 @@
+import { SAsymmetricCryptionDataWithPrivateRSAKey } from "@webAppCore/application/services/asymmetricCryptionDataWithPrivateRSAKey.service";
+import { SAsymmetricCryptionDataWithPublicRSAKey } from "@webAppCore/application/services/asymmetricCryptionDataWithPublicRSAKey.service";
+import { CLogLevel } from "@webAppCore/domains/constants/logLevel.constant";
+import { RSAKeyDecryption } from "@webAppCore/utils/cryptography/decryption/rsaKey.decryption";
+import { RSAKeyEncryption } from "@webAppCore/utils/cryptography/encryption/rsaKey.encryption";
+import { YamlParsing } from "@webAppCore/utils/parsing/parsingYaml.utils";
+import { dateTimeFormatted } from "@webAppCore/utils/dateTimeFormatted.utils";
+import { Environment } from "@webAppCore/utils/environment.utils";
+import { loggerConfig } from "@webAppCore/core/config/logger/logger.config";
+import { CSignRSAKeyComponent } from "@webAppCore/core/constants/signRSAKeyComponent.constant";
+import { Utility } from "@webAppCore/utils/utility.utils";
+import { PathModuleVerifier } from "@webAppCore/core/events/pathModuleVerifier.event";
+import { LocalLanguageLoader } from "@webAppCore/core/config/loaders/localLanguage.loader";
+
+
+
+/**
+ * Interfaces exported
+ */
+export { type IBodyParserOptions } from "@webAppCore/interfaces/bodyParserOptions.interface";
+export { type IResponseBodyEndFromResponseEvent } from "@webAppCore/interfaces/responseBodyEndFromResponseEvent.interface";
+export { type IResponseBodyWriteFromResponseEvent} from "@webAppCore/interfaces/responseBodyWriteFromResponseEvent.interface";
+export { type IWrappingBodyResponse } from "@webAppCore/interfaces/wrappingBodyResponse.interface";
+
+
+/**
+ * Types exported
+ */
+export { type TLogLevel } from "@webAppCore/types/logLevel.type";
+export { type TOriginalWriteEncoding } from "@webAppCore/types/originalWriteEncoding.type";
+export { type TParseFunction } from "@webAppCore/types/parseFunction.type";
+/**
+ * Types function exported
+ */
+export { type TJSONBodyParser } from "@webAppCore/types/json.type";
+export { type TRawBodyParser } from "@webAppCore/types/raw.type";
+export { type TTextBodyParser } from "@webAppCore/types/text.type";
+export { type TUrlencodedBodyParser } from "@webAppCore/types/urlencoded.type";
+
+
+
+export {
+    CLogLevel,
+    CSignRSAKeyComponent,
+    dateTimeFormatted,
+    Environment,
+    loggerConfig,
+    LocalLanguageLoader,
+    PathModuleVerifier,
+    RSAKeyDecryption,
+    RSAKeyEncryption,
+    SAsymmetricCryptionDataWithPrivateRSAKey,
+    SAsymmetricCryptionDataWithPublicRSAKey,
+    Utility,
+    YamlParsing
+}

package/src/interfaces/bodyParserOptions.interface.ts

@@ -0,0 +1,4 @@
+export interface IBodyParserOptions {
+    type: string;
+    limit?: number; // max body size in bytes, defaults to 1MB
+}

package/src/interfaces/responseBodyEndFromResponseEvent.interface.ts

@@ -0,0 +1,7 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+
+export interface IResponseBodyEndFromResponseEvent {
+    (cb?: () => void): ServerResponse<IncomingMessage>;
+    (chunk: any, cb?: () => void): ServerResponse<IncomingMessage>;
+    (chunk: any, encoding: BufferEncoding, cb?: () => void): ServerResponse<IncomingMessage>;
+}

package/src/interfaces/responseBodyWriteFromResponseEvent.interface.ts

@@ -0,0 +1,4 @@
+export interface IResponseBodyWriteFromResponseEvent {
+    (chunk: any, callback?: (error: (Error | null | undefined)) => void): boolean;
+    (chunk: any, encoding: BufferEncoding, callback?: (error: (Error | null | undefined)) => void): boolean;
+}

package/src/interfaces/wrappingBodyResponse.interface.ts

@@ -0,0 +1,4 @@
+export interface IWrappingBodyResponse {
+    (chunk: any, callback?: (error: (Error | null | undefined)) => void): boolean;
+    (chunk: any, encoding: BufferEncoding, callback?: (error: (Error | null | undefined)) => void): boolean;
+}

package/src/types/json.type.ts

@@ -0,0 +1,18 @@
+import { IBodyParserOptions } from "@webAppCore/interfaces/bodyParserOptions.interface";
+import { MBodyParser } from "@webAppCore/application/middlewares/bodyParser.middleware";
+
+
+/**
+ *
+ * @param options
+ * @param localLanguage
+ * @param environnementPath
+ *
+ * Use by this: TJSONBodyParser({ type: 'application/vnd.custom-type' })
+ *
+ * in express, it can be used like this: app.use(TJSONBodyParser({ type: 'application/vnd.custom-type' }));
+ *
+ */
+export function TJSONBodyParser(options: IBodyParserOptions, localLanguage: string, environnementPath: any) {
+    return MBodyParser(JSON.parse, options, localLanguage, environnementPath);
+}

package/src/types/logLevel.type.ts

@@ -0,0 +1,3 @@
+import { CLogLevel} from "@webAppCore/domains/constants/logLevel.constant";
+
+export type TLogLevel = typeof CLogLevel;

package/src/types/originalWriteEncoding.type.ts

@@ -0,0 +1 @@
+export type TOriginalWriteEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "utf-16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";

package/src/types/parseFunction.type.ts

@@ -0,0 +1 @@
+export type TParseFunction = (rawBody: string) => any;

package/src/types/raw.type.ts

@@ -0,0 +1,23 @@
+import { IBodyParserOptions } from "@webAppCore/interfaces/bodyParserOptions.interface";
+import { MBodyParser } from "@webAppCore/application/middlewares/bodyParser.middleware";
+
+
+/**
+ *
+ * @param options
+ * @param localLanguage
+ * @param environnementPath
+ *
+ * Use by this: TRawBodyParser({ type: 'application/vnd.custom-type' })
+ *
+ * in express, it can be used like this: app.use(rawBodyParserType({ type: 'application/vnd.custom-type' }));
+ *
+ */
+export function TRawBodyParser(options: IBodyParserOptions, localLanguage: string, environnementPath: any) {
+    return MBodyParser(
+        (rawBody: string) => Buffer.from(rawBody, "binary"),
+        options,
+        localLanguage,
+        environnementPath
+    );
+}

package/src/types/text.type.ts

@@ -0,0 +1,18 @@
+import { MBodyParser } from "@webAppCore/application/middlewares/bodyParser.middleware";
+import { IBodyParserOptions } from "@webAppCore/interfaces/bodyParserOptions.interface";
+
+
+/**
+ *
+ * @param options
+ * @param localLanguage
+ * @param environmentPath
+ *
+ * Use by this: textBodyParserType({ type: 'text/html' })
+ *
+ * in express, it can be used like this: app.use(textBodyParserType({ type: 'text/html' }));
+ *
+ */
+export function TTextBodyParser(options: IBodyParserOptions, localLanguage: string, environmentPath: any) {
+    return MBodyParser((rawBody: string) => rawBody, options, localLanguage, environmentPath);
+}

package/src/types/urlencoded.type.ts

@@ -0,0 +1,19 @@
+import { IBodyParserOptions } from "@webAppCore/interfaces/bodyParserOptions.interface";
+import { MBodyParser } from "@webAppCore/application/middlewares/bodyParser.middleware";
+import { UParseUrlencoded } from "@webAppCore/utils/parseUrlencoded.utils";
+
+
+/**
+ *
+ * @param options
+ * @param localLanguage
+ * @param environmentPath
+ *
+ * Use by this: urlencodedBodyParserType({ type: 'application/x-www-form-urlencoded' })
+ *
+ * in express, it can be used like this: app.use(urlencodedBodyParserType({ type: 'application/x-www-form-urlencoded' }));
+ *
+ */
+export function TUrlencodedBodyParser(options: IBodyParserOptions, localLanguage: string, environmentPath: any) {
+    return MBodyParser(UParseUrlencoded, options, localLanguage, environmentPath);
+}

package/src/utils/cryptography/decryption/rsaKey.decryption.ts

@@ -0,0 +1,19 @@
+import crypto from "crypto";
+
+
+/**
+ * This class contains methods that allow to decrypt data using public and private keys.
+ */
+export class RSAKeyDecryption {
+    static privateDecrypt(privateKey: any, decryptData: any): Buffer {
+        const rsaPrivateKey = { key: privateKey };
+
+        return crypto.privateDecrypt(rsaPrivateKey, decryptData);
+    }
+
+    static publicDecrypt(publicKey: any, decryptData: any): Buffer {
+        const rsaPublicKey = { key: publicKey };
+
+        return crypto.publicDecrypt(rsaPublicKey, decryptData);
+    }
+}

package/src/utils/cryptography/encryption/rsaKey.encryption.ts

@@ -0,0 +1,25 @@
+import crypto from "crypto";
+import { CSignRSAKeyComponent } from "@webAppCore/core/constants/signRSAKeyComponent.constant";
+
+
+/**
+ * This class contains methods which allow encrypting data by passing as arguments
+ * the public/private keys and the data to be encrypted.
+ */
+export class RSAKeyEncryption {
+    static privateEncrypt(privateKey: any, encryptData: any): Buffer {
+        const rsaPrivateKey = {
+            key: privateKey
+        };
+        const bufferData: Buffer = Buffer.from(encryptData, CSignRSAKeyComponent.encodingFormat.utf8 as BufferEncoding);
+
+        return crypto.privateEncrypt(rsaPrivateKey, bufferData);
+    }
+
+    static publicEncrypt(publicKey: any, encryptData: any): Buffer {
+        const rsaPublicKey = { key: publicKey };
+        const bufferData: Buffer = Buffer.from(encryptData, CSignRSAKeyComponent.encodingFormat.utf8 as BufferEncoding);
+
+        return crypto.publicEncrypt(rsaPublicKey, bufferData);
+    }
+}

package/src/utils/dateTimeFormatted.utils.ts

@@ -0,0 +1,6 @@
+/**
+ * Give time like: 6-8-2024 4:30:29
+ */
+
+
+export const dateTimeFormatted: string = `${(new Date().getMonth())}-${(new Date().getDate())}-${(new Date().getFullYear())} ${(new Date().getHours())}:${(new Date().getMinutes())}:${(new Date().getSeconds())}`;

package/src/utils/environment.utils.ts

@@ -0,0 +1,11 @@
+export class Environment<T> {
+    private readonly config: T;
+
+    constructor(config: T) {
+        this.config = config;
+    }
+
+    get<K extends keyof T>(key: K): T[K] {
+        return this.config[key];
+    }
+}

package/src/utils/logMessage.utils.ts

@@ -0,0 +1,20 @@
+import colors from "ansi-colors";
+import { dateTimeFormatted as dateTime } from "@webAppCore/utils/dateTimeFormatted.utils";
+
+export class LogMessage {
+    static success(title: string, action: string, contentAction: string): void {
+        console.log(`${colors.green(`✔`)} ${colors.bgGreen(` ${colors.bold(`${colors.white(`${title}`)}`)} `)}  ${dateTime} | ${colors.bgGreen(`${colors.white(` Success `)}`)} [ ${action} ] ${contentAction} - [ Status ] ${colors.bgGreen(`${colors.white(` 200 `)}`)}`);
+    }
+    static warning(title: string, action: string, contentAction: string): void {
+        console.warn(`${colors.yellow(`⚠️`)} ${colors.bgYellow(` ${colors.bold(`${colors.white(`${title}`)}`)} `)}  ${dateTime} | ${colors.bgYellow(`${colors.white(` Warning `)}`)} ${contentAction}`);
+    }
+    static info(title: string, action: string, contentAction: string): void {
+        console.info(`${colors.cyan(`ⓘ`)} ${colors.bgCyan(` ${colors.bold(`${colors.white(`${title}`)}`)} `)}  ${dateTime} | ${colors.bgCyan(`${colors.white(` Info `)}`)} ${contentAction}`);
+    }
+    static error(title: string, errorType: any, stackTrace: any, messageContent: any, httpCodeValue: number): void {
+        console.error(`${colors.red(`✘`)} ${colors.bgRed(` ${colors.bold(`${colors.white(`${title}`)}`)} `)} | ${dateTime} | [ ${colors.red(`${colors.bold(` ${errorType} `)}`)} ] | [ ${colors.bold(`stack trace`)} ] ${colors.red(`${stackTrace}`)} - ${colors.red(`${messageContent}`)} - [ ${colors.red(`${colors.bold(` HttpCode `)}`)} ] ${colors.red(`${colors.bold(` ${httpCodeValue} `)}`)} `);
+    }
+    static requestError(title: string, errorName: string, errorMessage: string, errorCode: number): void {
+        console.error(`[ ${colors.red(`${title}`)} ] ${dateTime} | ${colors.bgRed(`${colors.white(` ERROR `)}`)} ${colors.red(`[ ${errorName} ]`)} ${colors.red(`${errorMessage}`)} - [ Status ] ${colors.bgRed(`${colors.white(` ${errorCode} `)}`)}`);
+    }
+}

package/src/utils/parseUrlencoded.utils.ts

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param rawBody
+ *
+ * URL-encoded body parse function
+ */
+export function UParseUrlencoded(rawBody: string): any {
+    const pairs: string[] = rawBody.split('&');
+    const result: { [key: string]: string } = {};
+    for (const pair of pairs) {
+        const [key, value] = pair.split('=');
+        if (key && value) {
+            result[decodeURIComponent(key)] = decodeURIComponent(value);
+        }
+    }
+    return result;
+}

package/src/utils/parsing/parsingYaml.utils.ts

@@ -0,0 +1,81 @@
+import { readFile } from "fs/promises";
+import { HttpStatusCode } from "opticore-http-response";
+import { ILoggerConfig, LoggerCore } from "opticore-logger";
+import { TranslationLoader } from "opticore-translator";
+import { loggerConfig } from "@webAppCore/core/config/logger/logger.config";
+import { translateWebAppCoreLanguageLoader } from "@webAppCore/core/config/loaders/translateLanguage.loader";
+import path from "path";
+
+
+export class YamlParsing {
+    private readonly logger: LoggerCore;
+    private readonly localeLanguage: string;
+    
+    constructor(localeLanguage: string, environmentPath: any) {
+        translateWebAppCoreLanguageLoader(environmentPath, localeLanguage);
+
+        this.localeLanguage = localeLanguage;
+        this.logger = new LoggerCore(loggerConfig(environmentPath) as ILoggerConfig);
+    }
+
+    public absolutPath(): string {
+        return path.join(process.cwd(), "src", "utils", "translations");
+    }
+
+    public async readFile(filePath: string): Promise<void> {
+        try {
+            const yamlContent: string = await readFile(filePath, "utf-8");
+            await this.parsing(yamlContent);
+        } catch (error: any) {
+            this.logger.error({
+                message: error.message,
+                title: TranslationLoader.t("parsingFailed", this.localeLanguage, this.logger),
+                errorType: TranslationLoader.t("readingError", this.localeLanguage, this.logger),
+                stackTrace: error.stack,
+                httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+            });
+        }
+    }
+    
+    /**
+     *
+     * @param content
+     * @private
+     */
+    private async parsing(content: string): Promise<Record<any, any>> {
+        const result: Record<string, any> = {};
+        const lines: string[] = content.split("\n");
+        let currentKey: string | null = null;
+
+        for (const line of lines) {
+            // Ignore empty lines or comments
+            if (!line.trim() || line.trim().startsWith("#")) {
+                continue;
+            }
+
+            const keyValueMatch: RegExpMatchArray | null = line.match(/^(\s*)([a-zA-Z0-9_]+):(?:\s*(.*))?$/);
+            if (keyValueMatch) {
+                const [, indent, key, value] = keyValueMatch;
+                // Handle nested objects (simple one-level nesting)
+                if (indent.length > 0 && currentKey) {
+                    result[currentKey] = result[currentKey] || {};
+                    result[currentKey][key] = value?.trim() || null;
+                } else {
+                    currentKey = key;
+                    result[key] = value?.trim() || null;
+                }
+
+            } else {
+                this.logger.error({
+                    message: TranslationLoader.t("badFormat", this.localeLanguage, {line: line}),
+                    title: TranslationLoader.t("parsingFailed", this.localeLanguage, this.logger),
+                    errorType: TranslationLoader.t("unsupportedFormat", this.localeLanguage, this.logger),
+                    stackTrace: content,
+                    httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+                });
+            }
+        }
+
+        return result;
+    }
+}

package/src/utils/translations/message.translation.en.json

@@ -0,0 +1,130 @@
+{
+    "erBadDbError": "ER_BAD_DB_ERROR",
+    "erAccessDeniedError": "ER_ACCESS_DENIED_ERROR",
+    "erNotSupportedAuthMode": "ER_NOT_SUPPORTED_AUTH_MODE",
+    "eAiAgain": "EAI_AGAIN",
+    "dbConnection": "Database connection",
+    "dbConnectionClosed": "MySQL connection is closed",
+    "mysqlErrorCon": "MysqlError connection",
+    "mySQLError": "MysqlError",
+    "mySqlCloseConnection": "MySql close connection",
+    "dbConnexionSuccess": "The database connection was successful  🚀",
+    "mongoConnectionSuccess": "Connection to database is successfully.",
+    "connSuccess": "success connection",
+    "mongoDBConnectionChecker": "MongoDB Connection Checker",
+    "mongoConnection": "connection",
+    "mongoDBAuthentication": "authentication",
+    "mongoDBConnection": "MongoDB connection : {err}",
+    "mongoDBAuthenticationFailed": "failed",
+    "mongoDBUnableParsingUrl": "unable to parse",
+    "mongoDBConnectionUrl": "url",
+    "mongoDBServerSelection": "MongoServer selection error",
+    "mongoDBServer": "MongoServer",
+    "mongoDBConnectionError": "connection error",
+    "mongoDBError": "error",
+    "mongoDBAuthenticationError": "Authentication failed, be sure the credentials is correct.",
+    "postgresDBConnectionChecker": "PostgresDB Connection Checker",
+    "postgresConnection": "connection",
+    "postgresConnectionSuccess": "Connection to database is successfully.",
+    "postgresSuccessConn": "Postgres client Connection",
+    "postgresClosingConnSuccess": "Postgres client is close connection.",
+    "postgresEndClientRejection": "Postgres client end rejected",
+    "postgresClientError": "Postgres client error",
+    "postgresEndRejection": "End rejected",
+    "postgresConnError": "Postgres connection error",
+    "postgresException": "Exception",
+    "rsaKeyNotFound": "RSA key provided is not found.",
+    "encryptionWithPrivateKeyFailed": "Encryption With PrivateKey",
+    "encryptionFailed": "Encryption failed",
+    "verifyExistingKey": "Verify Existing Key",
+    "signatureRSAKeyFailed": "Signature verification failed.",
+    "signatureRSAKeysError": "Signature RSA Keys Error",
+    "errorDecryption": "Error decryption with private key",
+    "errorNameNotVerifyingRSAKey": "Error Verify RSA Key",
+    "decryptionWithPublicKeyFailed": "Decryption With PublicKey",
+    "decryptionFailed": "Decryption failed",
+    "verifyRSAKey": "Verify RSA Keys",
+    "verifyRSAKeyFailed": "Verify RSA Keys Failed",
+    "notVerifying": "Verification failed",
+    "mongoServerError": "MongoServerSelectionError: getaddrinfo EAI_AGAIN ({dbHost} is not allow to database connection)",
+    "dbUrlParsingError": "Unable to parse {dbHost}:{dbPort} with URL",
+    "errorDBHost": "A database host {host} does not allow connection. Please either set the host like this: {localhost} in your .env file",
+    "unknownDB": "Database {database} is unknown. Please try to use Database CLI to create your database, or do it manually in your Database Management System",
+    "accessDeniedToDBCon": "Access denied for user {user}. Database credentials in .env file are User: {user} and Password: {password}.  '{user}''{password}'@'localhost'. Try to set user and password in .env file",
+    "badFormat": "Unsupported YAML line format",
+    "parsingFailed": "YAML Parsing failed",
+    "unsupportedFormat": "Unsupported YAML format",
+    "readingError": "Error reading YAML file",
+    "invalidRequest": "Invalid request",
+    "moduleNotLoaded": "The following module paths are not loaded: {notLoadedPaths}",
+    "serverRouteNotExist": "This route : http://{host}:{port} do not exist.",
+    "webServer": "Web server",
+    "listening": "listening",
+    "webHost": "host",
+    "badHost": "bad host",
+    "hostNotFound": "not found",
+    "errorHostUrl": "The host and port are not define, please define them in .env",
+    "badPort": "bad port",
+    "errorPort": "The port is not correct. Please define a right port with number port.",
+    "errorHost": "The host can't be empty or blank. Please define a string host in .env",
+    "serverStart": "Server start",
+    "serverStartError": "Server start error",
+    "processExitCode": "Process will exit with code: {code}",
+    "beforeExit": "BeforeExit",
+    "processBeforeExit": "process before exit",
+    "childProcessDiscon": "Child process disconnected",
+    "processDiscon": "process disconnected",
+    "disconnected": "Disconnected",
+    "completed": "completed",
+    "finishingProcessWell": "The process finished as expected and everything is ok",
+    "serverStopped": "[OK] The server shutting down",
+    "somethingWentWrong": "Something went wrong",
+    "genErrors": "General Errors",
+    "exited": "Exited",
+    "incorrectCmd": "Incorrect using of shell commands",
+    "misuseShell": "Misuse of shell builtins",
+    "cmdNotExecutable": "The command is found but is not executable (e.g., trying to execute a directory)",
+    "cmdNotFound": "Command not found",
+    "cmdNotFoundInSystemPath": "The command was not found in the system's PATH or is misspelled",
+    "argInvalid": "Invalid argument",
+    "scriptEndedManuallyByCtrlC": "Indicates that the script was manually terminated by the user using the Control-C (SIGINT) signal",
+    "processEndedBySIGKILL": "Indicates that the process was terminated by a SIGKILL signal, possibly due to an out-of-memory situation",
+    "scriptEnded": "Script terminated",
+    "accessProcessIllegally": "Indicates that the process accessed an illegal memory address (segfault)",
+    "defaultSegment": "Segmentation fault",
+    "processReceivedSigtermSignal": "Indicates that the process received a SIGTERM signal to terminate",
+    "processReceived": "process received a SIGTERM",
+    "exitCode": "An exit code that is outside the allowable range (0-255 for Unix-like systems)",
+    "outRange": "out of range",
+    "errorOccurring": "Error is occurring",
+    "errors": "errors",
+    "promiseRejectionHandled": "Promise rejection is handled at : {promise}",
+    "rejectionPromise": "rejection promise",
+    "uncaughtExceptionHandled": "uncaught exception handled",
+    "unhandledRejectionAtPromise": "Unhandled Rejection at: Promise {promise} -- reason {reason}",
+    "unhandledRejection": "Unhandled rejection",
+    "processGotMsg": "process got message {message}",
+    "msgException": "message exception",
+    "promiseReason": "{promise} -- {reason}",
+    "multipleResolvesDetected": "Multiple resolves detected : {type}",
+    "serverWebStopped": "The Web server has been stopped !",
+    "okSuccess": "[ OK ] Success",
+    "processPIDReceivedSignal": "Process ${process.pid} received a SIGTERM signal : {signal}",
+    "serverClosed": "Server is closed",
+    "allProcessStopped": "All processes are stopped",
+    "serverDroppedCon": "The server dropped new connections",
+    "serverMaxCon": "Server maxConnection",
+    "internalServerError": "Internal Server Error",
+    "resStatusNotFunc": "res.status is not a function",
+    "respndNotFunc": "response not Function",
+    "expressErrorHandlingMiddleware": "Express error-handling middleware",
+    "expressError": "Express error",
+    "serverRunning": "The server is running in",
+    "okServerListening": "[OK] Web server listening",
+    "webServerUseNodeVersion": "The Web server is using Node.js version",
+    "startupTime": "Startup time:",
+    "totalMemory": "Resident Set Size - total memory allocated for the process execution :",
+    "memoryUsedDuringExecution": "Actual memory used during the execution :",
+    "memoryUsedByUser": "Memory usage by user :",
+    "memoryUsedBySystem": "Memory usage by system :"
+}

package/src/utils/translations/message.translation.fr.json

@@ -0,0 +1,49 @@
+{
+  "erBadDbError": "ER_BAD_DB_ERROR",
+  "erAccessDeniedError": "ER_ACCESS_DENIED_ERROR",
+  "erNotSupportedAuthMode": "ER_NOT_SUPPORTED_AUTH_MODE",
+  "eAiAgain": "EAI_AGAIN",
+  "dbConnection": "DataBase connection",
+  "dbConnectionClosed": "MySQL connection is closed",
+  "mysqlErrorCon": "MysqlError connection",
+  "mySQLError": "MysqlError",
+  "mySqlCloseConnection": "MySql close connection",
+  "mongoConnectionSuccess": "Connection to database is successfully.",
+  "mongoDBConnectionChecker": "MongoDB Connection Checker",
+  "mongoConnection": "connection",
+  "mongoDBAuthentication": "authentication",
+  "mongoDBConnection": "MongoDB connection",
+  "mongoDBAuthenticationFailed": "failed",
+  "mongoDBUnableParsingUrl": "unable to parse",
+  "mongoDBConnectionUrl": "url",
+  "mongoDBServerSelection": "MongoServer selection error",
+  "mongoDBServer": "MongoServer",
+  "mongoDBConnectionError": "connection error",
+  "mongoDBError": "error",
+  "mongoDBAuthenticationError": "Authentication failed, be sure the credentials is correct.",
+  "postgresDBConnectionChecker": "PostgresDB Connection Checker",
+  "postgresConnection": "connection",
+  "postgresConnectionSuccess": "Connection to database is successfully.",
+  "postgresSuccessConn": "Postgres client Connection",
+  "postgresClosingConnSuccess": "Postgres client is close connection.",
+  "postgresEndClientRejection": "Postgres client end rejected",
+  "postgresClientError": "Postgres client error",
+  "postgresEndRejection": "End rejected",
+  "postgresConnError": "Postgres connection error",
+  "postgresException": "Exception",
+  "rsaKeyNotFound": "RSA key provided is not found.",
+  "encryptionWithPrivateKeyFailed": "Encryption With PrivateKey",
+  "encryptionFailed": "Encryption failed",
+  "verifyExistingKey": "Verify Existing Key",
+  "signatureRSAKeyFailed": "Signature verification failed.",
+  "signatureRSAKeysError": "Signature RSA Keys Error",
+  "errorDecryption": "Error decryption with private key",
+  "errorNameNotVerifyingRSAKey": "Error Verify RSA Key",
+  "decryptionWithPublicKeyFailed": "Decryption With PublicKey",
+  "decryptionFailed": "Decryption failed",
+  "verifyRSAKey": "Verify RSA Keys",
+  "verifyRSAKeyFailed": "Verify RSA Keys Failed",
+  "notVerifying": "Verification failed",
+  "mongoServerError": "MongoServerSelectionError: getaddrinfo EAI_AGAIN ({dbHost} is not allow to database connection)",
+  "dbUrlParsingError": "Unable to parse ${dbHost}:${dbPort} with URL"
+}