opticore-webapp-core 1.0.20 → 1.0.21

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/utility.utils.ts

@@ -0,0 +1,154 @@
+import process from "node:process";
+import chalk from 'chalk';
+import colors from "ansi-colors";
+import path from "path";
+import fs from "fs";
+import { TranslationLoader } from "opticore-translator";
+
+
+export class Utility {
+    private readonly localLang: string;
+    
+    constructor(localLanguage: string) {
+        this.localLang = localLanguage;
+    }
+
+    /**
+     *
+     * @param data
+     * @private
+     * Return a string converted in MegaBytes
+     */
+    private formatMemoryUsage(data: any): string {
+        return `${Math.round(data / 1024 / 1024 * 100) / 100} MB`;
+    }
+
+    /**
+     * Returns an Object containing a node version, openssl, and v0
+     */
+    public getVersions() {
+        const processVers: NodeJS.ProcessVersions = process.versions;
+        const data = {
+            "node version" : processVers.node,
+            "openssl": processVers.openssl,
+            "v8": processVers.v8
+        };
+
+        return {
+          "nodeVersion" : data["node version"],
+          "openssl": data.openssl,
+          "v8": data.v8
+        };
+    }
+
+    /**
+     * Return an Object containing a Resident Set Size - total memory allocated for the process execution
+     * Total size of the allocated heap
+     * Actual memory used during the execution
+     * Memory usage user
+     * and Memory usage system
+     */
+    public getUsageMemory() {
+        const memoryData: NodeJS.MemoryUsage = process.memoryUsage();
+        const data = {
+            "Resident Set Size - total memory allocated for the process execution": this.formatMemoryUsage(memoryData.rss),
+            "Total size of the allocated heap": this.formatMemoryUsage(memoryData.heapTotal),
+            "Actual memory used during the execution": this.formatMemoryUsage(memoryData.heapUsed),
+            "V8 external memory": this.formatMemoryUsage(memoryData.external),
+            "Memory usage user": this.formatMemoryUsage(process.cpuUsage().user),
+            "Memory usage system": this.formatMemoryUsage(process.cpuUsage().system),
+        }
+
+        return {
+            "rss": data["Resident Set Size - total memory allocated for the process execution"],
+            "heapTotal": data["Total size of the allocated heap"],
+            "heapUsed": data["Actual memory used during the execution"],
+            "external": data["V8 external memory"],
+            "user": data["Memory usage user"],
+            "system": data["Memory usage system"]
+        }
+    }
+
+    /**
+     * Return an Object containing a project path and running server time
+     */
+    public getProjectInfo() {
+        const startTime:[number, number] = process.hrtime();
+        const endTime:[number, number] = process.hrtime(startTime);
+        const executionTime: number = (endTime[0] * 1e9 + endTime[1]) / 1e6; // Convert to milliseconds
+        return {
+            "projectPath": path.join(process.cwd()),
+            "startingTime": `${executionTime.toFixed(5)} ms`
+        }
+    }
+
+    /**
+     *
+     * @param filePath
+     * @private
+     */
+    private getEnvFileLoading(filePath: string): void {
+        const fullPath: string = path.resolve(process.cwd(), filePath);
+        if (fs.existsSync(fullPath)) {
+            const env: string = fs.readFileSync(fullPath, 'utf-8');
+            const lines: string[] = env.split('\n');
+
+            lines.forEach((line: string): void => {
+                const match: RegExpMatchArray | null = line.match(/^([^#=]+)=([^#]+)$/);
+                if (match) {
+                    const key: string = match[1].trim();
+                    process.env[key]  = match[2].trim();
+                }
+            });
+        }
+    }
+
+    /**
+     *
+     * @param development
+     * @param production
+     */
+    public getServerRunningMode(development: string, production: string): string {
+        /**
+         *  Load environment variables from the .env file
+         */
+        this.getEnvFileLoading('.env');
+
+        const isDevelopment: boolean = process.env.NODE_ENV === 'development';
+        if (isDevelopment) {
+            return `${TranslationLoader.t("serverRunning", this.localLang)} ${colors.bgBlue(`${colors.bold(`${development}`)}`)} mode`;
+        } else {
+            return `${TranslationLoader.t("serverRunning", this.localLang)} ${colors.bgBlue(`${colors.bold(`${production}`)}`)} mode`;
+        }
+    }
+
+    public infoServer(nodeVersion: string, startingTime: any, host: string, port: number, rss: string, heapUsed: string, user: string, system: string): void {
+        // Padding length
+        const paddingLength = 52;
+
+        // Creating padded messages
+        const msg0: string = ' '.padEnd(paddingLength, ' ');
+        const msg1: string = ` ${TranslationLoader.t("okServerListening", this.localLang)}`;
+        const msg2Value: string = `${colors.bgBlue(`${colors.bold(`${nodeVersion}`)}`)}`;
+        const msg2: string = ` ${TranslationLoader.t("webServerUseNodeVersion", this.localLang)}`;
+        const msg3Value: string = `${colors.bgBlue(`${colors.bold(`${startingTime}`)}`)}`;
+        const msg3: string = ` ${TranslationLoader.t("startupTime", this.localLang)}`;
+        const msg4: string = ` ${this.getServerRunningMode('development', 'production')}`;
+        const msg5: string = ` ${colors.underline(`http://${host}:${port}`)}`;
+
+        // display the message
+        console.log(chalk.bgGreen.white(msg0.padEnd(paddingLength, ' ')));
+        console.log(chalk.bgGreen.white(msg1.padEnd(paddingLength, ' ')));
+        console.log(chalk.bgGreen.white(msg2, msg2Value.padEnd(30.5, ' ')));
+        console.log(chalk.bgGreen.white(msg3, msg3Value.padEnd(56, ' ')));
+        console.log(chalk.bgGreen.white(msg4.padEnd(71, ' ')));
+        console.log(chalk.bgGreen.white(msg5.padEnd(61, ' ')));
+        console.log(chalk.bgGreen.white(msg0.padEnd(paddingLength, ' ')));
+        console.log(``);
+        console.log(`${(`${TranslationLoader.t("totalMemory", this.localLang)}`)} ${colors.cyan(`${colors.bold(`${rss}`)}`)}`);
+        console.log(`${(`${TranslationLoader.t("memoryUsedDuringExecution", this.localLang)}`)} ${colors.cyan(`${colors.bold(`${heapUsed}`)}`)}`);
+        console.log(`${(`${TranslationLoader.t("memoryUsedByUser", this.localLang)}`)} ${colors.cyan(`${colors.bold(`${user}`)}`)}`);
+        console.log(`${(`${TranslationLoader.t("memoryUsedBySystem", this.localLang)}`)} ${colors.cyan(`${colors.bold(`${system}`)}`)}`);
+        console.log(``);
+    }
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+    name: "webApp-core",
+    format: ["cjs", "esm"],
+    entry: ['src/index.ts'] ,
+    dts: true,
+    shims: true,
+    skipNodeModulesBundle: true,
+    clean: true
+});