opticore-webapp-core 1.0.20 → 1.0.22

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);
+    }
+}

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
+    );
+}