opticore-webapp 1.0.0

package/src/core/handlers/errors/stackTraceURIError.ts

@@ -0,0 +1,13 @@
+import StackTraceError from "./base/stackTraceError";
+import {errorNameConstant} from "../../utils/constants/errorName.constant";
+import {HttpStatusCodesConstant as status} from "../../../domain/constants/httpStatusCodes.constant";
+
+
+/**
+ * Handling and catch a Node.js error.
+ */
+export default class StackTraceURIError extends StackTraceError {
+    constructor(message: string) {
+        super(message, errorNameConstant.evalError, status.BAD_REQUEST, true);
+    }
+}

package/src/core/handlers/eventProcess.handler.ts

@@ -0,0 +1,106 @@
+import express, {Express} from "express";
+import process from 'node:process';
+import EventEmitter from "node:events";
+import {eventName, event} from "../../index";
+import {ServerListenEventError} from "@/errors/serverListen.event.error";
+
+/**
+ *
+ */
+export function eventProcessHandler(): void {
+    const errorEmitter = new EventEmitter();
+    const app: Express = express();
+
+    /**
+     * Listener for error events
+     */
+    errorEmitter.on(eventName.error, (error: Error): void => {
+        ServerListenEventError.listenerError(error);
+    });
+
+    /**
+     * Catch uncaught exceptions
+     * Process event listeners
+     */
+    process.on(event.beforeExit, (code: number): void => {
+        setTimeout((): void => {
+            ServerListenEventError.processBeforeExit(code);
+        }, 100);
+    });
+
+    /**
+     *
+     */
+    process.on(event.disconnect, (): void => {
+        ServerListenEventError.processDisconnected();
+    });
+
+    /**
+     *
+     */
+    process.on(event.exit, (code: number): void => {
+        ServerListenEventError.exited(code);
+    });
+
+    /**
+     *
+     */
+    process.on(event.rejectionHandled, (promise: Promise<any>): void => {
+        ServerListenEventError.promiseRejectionHandled(promise);
+    });
+
+    /**
+     *
+     */
+    process.on(event.uncaughtException, (error: any): void => {
+        ServerListenEventError.uncaughtException(error);
+    });
+
+    /**
+     *
+     */
+    process.on(event.uncaughtExceptionMonitor, (error: any): void => {
+        ServerListenEventError.uncaughtExceptionMonitor(error);
+    });
+
+    /**
+     *
+     */
+    process.on(event.unhandledRejection, (reason: any, promise: Promise<any>): void => {
+        ServerListenEventError.unhandledRejection(reason, promise);
+    });
+
+    /**
+     *
+     */
+    process.on(event.warning, (warning: any): void => {
+        ServerListenEventError.warning(warning);
+    });
+    process.on(event.message, (message: any): void => {
+        ServerListenEventError.message(message);
+    });
+
+    /**
+     *
+     */
+    process.on(event.multipleResolves, (type: string, promise: Promise<any>, reason: any): void => {
+        ServerListenEventError.multipleResolves(type, promise, reason);
+    });
+
+    /**
+     * Handle specific signals
+     */
+    process.on(event.sigint, (): void => {
+        ServerListenEventError.processInterrupted();
+    });
+    process.on(event.sigterm, (signal: any): void => {
+        ServerListenEventError.sigtermSignalReceived(signal);
+    });
+
+    /**
+     * Express error-handling middleware
+     */
+    app.use((err: Error, req: express.Request, res: express.Response, next: express.NextFunction): void => {
+        ServerListenEventError.expressErrorHandlingMiddleware(errorEmitter, err, req, res, next);
+    });
+}

package/src/core/utils/dateTimeFormatted.utils.ts

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

package/src/core/utils/logMessage.utils.ts

@@ -0,0 +1,20 @@
+    import colors from "ansi-colors";
+import {dateTimeFormattedUtils} from "./dateTimeFormatted.utils";
+
+export class LogMessageUtils {
+    static success(title: string, action: string, contentAction: string): void {
+        console.log(`${colors.green(`✔`)} ${colors.bgGreen(` ${colors.bold(`${colors.white(`${title}`)}`)} `)}  ${dateTimeFormattedUtils} | ${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}`)}`)} `)}  ${dateTimeFormattedUtils} | ${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}`)}`)} `)}  ${dateTimeFormattedUtils} | ${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}`)}`)} `)} | ${dateTimeFormattedUtils} | [ ${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}`)} ] ${dateTimeFormattedUtils} | ${colors.bgRed(`${colors.white(` ERROR `)}`)} ${colors.red(`[ ${errorName} ]`)} ${colors.red(`${errorMessage}`)} - [ Status ] ${colors.bgRed(`${colors.white(` ${errorCode} `)}`)}`);
+    }
+}

package/src/core/utils/modulesLoaded.utils.ts

@@ -0,0 +1,16 @@
+import colors from "ansi-colors";
+import express from "express";
+import {dateTimeFormattedUtils} from "./dateTimeFormatted.utils";
+import {LogMessageUtils} from "@webApp/core/utils/logMessage.utils";
+
+
+export function modulesLoadedUtils(allAppRoutes: express.Router[], dbConChecker: () => void): void {
+    LogMessageUtils.success("Kernel", "load kernel", "Modules app have been successfully loaded");
+    console.log(`${colors.whiteBright(`  content`)} ${colors.green('Kernel :')} ${colors.cyan(`${colors.bold(`server side`)}`)} has been loaded successfully ${colors.green(`✔`)}`);
+    allAppRoutes
+        ? console.log(`${colors.whiteBright(`  content`)} ${colors.green('Kernel :')} ${colors.cyan(`${colors.bold(`Routers service`)} `)} has been loaded successfully ${colors.green(`✔`)}`)
+        : console.log(`${colors.red(`✘`)} ${colors.bgRed(` ${colors.bold(`${colors.white(` Register routes `)}`)} `)} | ${dateTimeFormattedUtils} | [ ${colors.red(`${colors.bold(` fail `)}`)} ] | [ ${colors.bold(` loading `)} ] - ${colors.red(` routers `)} - The route register failed to load `);
+    typeof dbConChecker == "function"
+        ? console.log(`${colors.whiteBright(`  content`)} ${colors.green('Kernel :')} ${colors.cyan(`${colors.bold(`database checker connection`)}`)} has been loaded successfully ${colors.green(`✔`)}`)
+        : "";
+}

package/src/core/webServer.core.ts

@@ -0,0 +1,110 @@
+import {Server as serverWebApp} from "http";
+import {IncomingMessage, ServerResponse} from "node:http";
+import express, {Express} from "express";
+import corsOrigin, {CorsOptions} from "cors";
+import {IRouteDefinition} from "@webApp/domains/interfaces/routeDefinition.interface";
+import {KernelModuleType} from "@webApp/domains/types/kernelModule.type";
+import {getEnvVariable} from "@webApp/domains/env/access.env";
+import {HttpStatusCodesConstant as status} from "@webApp/domains/constants/httpStatusCodes.constant";
+import StackTraceError from "@webApp/core/handlers/errors/base/stackTraceError";
+import {eventProcessHandler} from "@webApp/core/handlers/eventProcess.handler";
+import {requestCallsEvent} from "@webApp/core/events/requestCalls.event";
+import {CEventNameError as eventName} from "@webApp/domains/constants/eventNameError.constant";
+import {ServerListenEventError as eventErrorOnListeningServer} from "@webApp/core/events/errors/serverListen.event.error";
+import {CoreService} from "@webApp/application/service/core.service";
+import {dateTimeFormattedUtils as currentDate} from "@webApp/core/utils/dateTimeFormatted.utils";
+
+
+export class WebServerCore {
+    private serverUtility: CoreService = new CoreService();
+    private expressApp: Express = express();
+    private readonly routerExpressApp: express.Application;
+    private readonly port: number;
+    private readonly host: string;
+
+    constructor(app: express.Application, corsOriginOptions?: Partial<CorsOptions>) {
+        this.port = Number(getEnvVariable.appPort);
+        this.host = getEnvVariable.appHost;
+        this.routerExpressApp = app;
+
+        this.expressApp.use(express.json());
+        this.expressApp.use(express.raw());
+        this.expressApp.use(express.text());
+        this.expressApp.use(express.urlencoded({ extended: true }));
+        this.expressApp.use(corsOrigin(corsOriginOptions));
+
+        this.stackTraceErrorHandling();
+    }
+
+    public onStartServer(routers: { featureRoute: IRouteDefinition[] }[]) {
+        return this.expressApp.listen(
+            this.port,
+            this.host,
+            (): void => {
+                try {
+                    if (this.host === "" && this.port === 0) {
+                        eventErrorOnListeningServer.hostPortUndefined();
+                    } else if (this.host === "") {
+                        eventErrorOnListeningServer.hostUndefined();
+                    } else if (this.port === 0) {
+                        eventErrorOnListeningServer.portUndefined();
+                    } else {
+                        this.registerRoutes(routers);
+                    }
+                } catch (err: any) {
+                    this.traceError(err.message, "Error", status.NOT_ACCEPTABLE);
+                }
+            }
+        );
+    }
+
+    public onListeningOnServerEvent(serverWeb: serverWebApp, kernelModule: KernelModuleType): void {
+        serverWeb.on(eventName.error, (err: Error): void => {
+            eventErrorOnListeningServer.onEventError(err);
+        }).on(eventName.close, (): void => {
+            eventErrorOnListeningServer.serverClosing();
+        }).on(eventName.drop, (): void => {
+            eventErrorOnListeningServer.dropNewConnection();
+        }).on(eventName.listening, (): void => {
+            this.infoWebApp();
+            this.serverUtility.coreListenerEventLoaderModuleService(kernelModule);
+        });
+    }
+
+    public onRequestOnServerEvent(serverWeb: serverWebApp): void {
+        serverWeb.on(eventName.request, (req: IncomingMessage, res: ServerResponse): void => {
+            requestCallsEvent(req, res, this.host, this.port, currentDate);
+        });
+    }
+
+    public kernelModules(registerRouter: { featureRoute: IRouteDefinition[] }[],
+                         dbConnection: () => void): KernelModuleType {
+        return [registerRouter, dbConnection] as KernelModuleType
+    }
+
+    private registerRoutes(allFeatureRoutes: { featureRoute: IRouteDefinition[] }[]): void {
+        allFeatureRoutes.map((router: {featureRoute: IRouteDefinition[]} ): void => {
+            router.featureRoute.map((route: IRouteDefinition): void => {
+                this.expressApp.use(route.path, route.handler);
+            });
+        });
+    }
+    private stackTraceErrorHandling(): void {
+        eventProcessHandler();
+    }
+    private infoWebApp(): void {
+        this.serverUtility.infoServer(
+            this.serverUtility.getVersions().nodeVersion,
+            this.serverUtility.getProjectInfo().startingTime,
+            getEnvVariable.appHost,
+            Number(getEnvVariable.appPort),
+            this.serverUtility.getUsageMemory().rss,
+            this.serverUtility.getUsageMemory().heapUsed,
+            this.serverUtility.getUsageMemory().user,
+            this.serverUtility.getUsageMemory().system
+        );
+    }
+    private traceError(props: string, name: string, status: number): StackTraceError {
+        return new StackTraceError(props, name, status, true);
+    }
+}

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

@@ -0,0 +1,12 @@
+export const CErrorName = {
+    evalError: "EvalError",
+    syntaxError: "SyntaxError",
+    rangeError: "RangeError",
+    referenceError: "ReferenceError",
+    typeError: "TypeError",
+    uriError: "URIError",
+    systemError: "SystemError",
+    assertionError: "AssertionError",
+    openSSLError: "OpenSSLError",
+    generalError: "GeneralError"
+}

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

@@ -0,0 +1,15 @@
+export const CEvent = {
+    beforeExit: "beforeExit",
+    disconnect: "disconnect",
+    exit: "exit",
+    rejectionHandled: "rejectionHandled",
+    uncaughtException: "uncaughtException",
+    uncaughtExceptionMonitor: "uncaughtExceptionMonitor",
+    unhandledRejection: "unhandledRejection",
+    warning: "warning",
+    message: "message",
+    multipleResolves: "multipleResolves",
+    worker: "worker",
+    sigint: "SIGINT",
+    sigterm: "SIGTERM"
+}

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

@@ -0,0 +1,8 @@
+export const CEventNameError = {
+    error: "error",
+    listening: "listening",
+    close: "close",
+    connection: "connection",
+    drop: "drop",
+    request: "request"
+}