opticore-webapp 1.0.0

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "opticore-webapp",
+  "version": "1.0.0",
+  "description": "wep server",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsup"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/guyzoum77/opticore-webApp.git"
+  },
+  "keywords": [
+    "opticore"
+  ],
+  "author": "Guy-serge Kouacou",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/guyzoum77/opticore-webApp/issues"
+  },
+  "homepage": "https://github.com/guyzoum77/opticore-webApp#readme",
+  "dependencies": {
+    "ansi-colors": "^4.1.3",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.0",
+    "express-rate-limit": "^5.5.1",
+    "express-session": "^1.0.0",
+    "express-useragent": "^1.0.15",
+    "gradient-string": "^2.0.2",
+    "opticore-logger": "^1.0.1",
+    "opticore-router": "^1.0.7",
+    "opticore-validator": "^1.0.3",
+    "typescript": "^5.4.5"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/gradient-string": "^1.1.6",
+    "tsup": "^8.3.5"
+  }
+}

package/src/application/exceptions/messages.exception.ts

@@ -0,0 +1,67 @@
+import colors from "ansi-colors";
+
+export const messageException = {
+    dbConnection: "DataBase connection",
+    dbConnectionClosed: "MySQL connection is closed",
+    mysqlErrorCon: "MysqlError connection",
+    mySQLError: "MysqlError",
+    mySqlCloseConnection: "MySql close connection",
+    verifyExistingKey: "Verify Existing Key",
+    invalidRequest: "Invalid request",
+    tokenNotProvided: "No token provided.",
+    ExpiresToken: "Expires Token. You're not authorize",
+    privateKeyNotExist: "A private key doesn't exist.",
+    publicKeyNotExist: "A public key doesn't exist.",
+    errorNamePublicKeyNotExist: "No public key",
+    errorAuthorPublicKeyNotExist: "PublicKey not existing",
+    errorDecryption: "Error decryption with private key",
+    rsaKeyNotFound: "RSA key provided is not found.",
+    notVerifyingRSAKey: "Not verify RSA Key",
+    errorNameNotVerifyingRSAKey: "Error Verify RSA Key",
+    errorEncryptionPublicKey: "Error encryption with public key",
+    errorEncryptionPrivateKey: "Error encryption with private key",
+    errorNameRsaVerifyExistingKey: "Verify existing key",
+    signatureRSAKeyFailed: "Signature verification failed.",
+    encryptionWithPrivateKeyFailed: "Encryption With PrivateKey",
+    encryptionFailed: "Encryption failed",
+    decryptionWithPublicKeyFailed: "Decryption With PublicKey",
+    decryptionFailed: "Decryption failed",
+    verifyRSAKey: "Verify RSA Keys",
+    verifyRSAKeyFailed: "Verify RSA Keys Failed",
+    notVerifying: "Verification failed",
+    signatureRSAKeysError: "Signature RSA Keys Error",
+    encryptionWithPublicKey: "Encryption error",
+    errorDecryptionWithPrivateKey: "Error Decryption With PrivateKey",
+    verifyPublicRSAKey: "Verify Public RSA Key",
+    PostgresDBConnectionChecker: "PostgresDB Connection Checker",
+    PostgresConnection: "connection",
+    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",
+    loadedModules: "Loading core modules",
+    loadedModulesError: "Required core modules are not loaded properly",
+    dbConnexionSuccess: "The database connection was successful  🚀",
+    mongoConnectionSuccess: "Connection to database is successfully.",
+    PostgresConnectionSuccess: "Connection to database is successfully.",
+    verifyExistingKeyError: "The provided key is not found",
+    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",
+    accessDeniedToDBCon: (user: string, password: string): string => `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`,
+    unknownDB: (database: string): string => `Database ${database} is unknown. Please try to use Database CLI to create your database, or do it manually in your Database Management System`,
+    errorDBHost: (host: string): string => `A database host ${host} does not allow connection. Please either set the host like this: ${colors.bgRed(`${colors.white(`localhost`)}`)} in your .env file`
+}

package/src/application/http/response.http.ts

@@ -0,0 +1,67 @@
+import express from "express";
+import {ValidationResultInterface} from "opticore-validator";
+
+export class ResponseHttp {
+    /**
+     *
+     * @param res
+     * @param status
+     * @param message
+     * @param apiVersion
+     */
+    static error(res: express.Response,
+                 status: number,
+                 message: string | ValidationResultInterface,
+                 apiVersion: any): express.Response<any, Record<string, any>> {
+        return res.status(status).json({
+            errorMessage: message,
+            responseStatus: status,
+            version: apiVersion
+        });
+    }
+
+    /**
+     *
+     * @param res
+     * @param status
+     * @param context
+     * @param successMessage
+     * @param apiVersion
+     */
+    static success(res: express.Response,
+                    status: number,
+                    context: string,
+                    successMessage: string,
+                    apiVersion: any): express.Response<any, Record<string, any>> {
+        return res.status(200).json({
+            "@context": context,
+            message: successMessage,
+            responseStatus: status,
+            version: apiVersion
+        });
+    }
+
+    /**
+     *
+     * @param res
+     * @param status
+     * @param context
+     * @param successMessage
+     * @param data
+     * @param apiVersion
+     */
+    static successWithData (res: express.Response,
+                            status: number,
+                            context: string,
+                            successMessage: string,
+                            data: any,
+                            apiVersion: any): express.Response<any, Record<string, any>> {
+        return res.status(200).json({
+            "@context": context,
+            message: successMessage,
+            dataResponse: data,
+            responseStatus: status,
+            version: apiVersion
+        });
+    }
+}

package/src/application/service/core.service.ts

@@ -0,0 +1,180 @@
+import process from "node:process";
+import chalk from 'chalk';
+import * as path from "path";
+import * as fs from "fs";
+import colors from "ansi-colors";
+import {KernelModuleType} from "@webApp/domains/types/kernelModule.type";
+import express from "express";
+import StackTraceError from "@webApp/core/handlers/errors/base/stackTraceError";
+import {modulesLoadedUtils as loadedModules} from "@webApp/core/utils/modulesLoaded.utils";
+import {messageException as msg} from "@webApp/application/exceptions/messages.exception";
+import {HttpStatusCodesConstant as status} from "@webApp/domains/constants/httpStatusCodes.constant";
+
+
+export class CoreService {
+
+    /**
+     *
+     * @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 { node, openssl, v8 }: NodeJS.ProcessVersions = process.versions;
+        const data = {
+            "node version" : node,
+            "openssl": openssl,
+            "v8": 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; // Convertir en millisecondes
+        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 `The server is running in ${colors.bgBlue(`${colors.bold(`${development}`)}`)} mode`;
+        } else {
+            return `The server is running in ${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 = ' [OK] Web server listening';
+        const msg2Value: string = `${colors.bgBlue(`${colors.bold(`${nodeVersion}`)}`)}`;
+        const msg2: string = ` The Web server is using Node.js version`;
+        const msg3Value: string = `${colors.bgBlue(`${colors.bold(`${startingTime}`)}`)}`;
+        const msg3: string = ` Startup time:`;
+        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(`${(`Resident Set Size - total memory allocated for the process execution :`)} ${colors.cyan(`${colors.bold(`${rss}`)}`)}`);
+        console.log(`${(`Actual memory used during the execution :`)} ${colors.cyan(`${colors.bold(`${heapUsed}`)}`)}`);
+        console.log(`${(`Memory usage by user :`)} ${colors.cyan(`${colors.bold(`${user}`)}`)}`);
+        console.log(`${(`Memory usage by system :`)} ${colors.cyan(`${colors.bold(`${system}`)}`)}`);
+        console.log(``);
+    }
+
+    public coreListenerEventLoaderModuleService<T extends KernelModuleType>(kernelModule: T) {
+        let router: express.Router[] = [];
+        let dbCon: (() => void) | undefined;
+
+        kernelModule.forEach((module): void => {
+            if (Array.isArray(module)) {
+                router = module as express.Router[];
+            } else if (typeof module === "function") {
+                dbCon = module as () => void;
+            }
+        });
+
+        if (router && dbCon) {
+            loadedModules(router, dbCon);
+            ((): void => { dbCon(); })();
+        } else {
+            const stackTrace: StackTraceError = new StackTraceError(
+                msg.loadedModulesError,
+                msg.loadedModules,
+                status.NOT_ACCEPTABLE,
+                true
+            );
+            throw new Error(stackTrace.message);
+        }
+    }
+}