@noxfly/noxus 1.0.4 → 1.1.0

package/src/bootstrap.ts

@@ -1,128 +1,29 @@
-import { ipcMain } from "electron";
-import { app, BrowserWindow, MessageChannelMain } from "electron/main";
-import { IApp } from "src/app";
-import { getInjectableMetadata } from "src/decorators/injectable.decorator";
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
+import { app } from "electron/main";
+import { NoxApp } from "src/app";
 import { getModuleMetadata } from "src/decorators/module.decorator";
-import { RootInjector } from "src/DI/app-injector";
-import { IRequest, IResponse, Request } from "src/request";
-import { Router } from "src/router";
+import { inject } from "src/DI/app-injector";
 import { Type } from "src/utils/types";
 
 /**
  * 
  */
-export async function bootstrapApplication(root: Type<IApp>, rootModule: Type<any>): Promise<IApp> {
+export async function bootstrapApplication(rootModule: Type<any>): Promise<NoxApp> {
     if(!getModuleMetadata(rootModule)) {
         throw new Error(`Root module must be decorated with @Module`);
     }
 
-    if(!getInjectableMetadata(root)) {
-        throw new Error(`Root application must be decorated with @Injectable`);
-    }
-
     await app.whenReady();
 
-    RootInjector.resolve(Router);
-
-    const noxEngine = new Nox(root, rootModule);
-
-    const application = await noxEngine.init();
-
-    return application;
-}
+    const noxApp = inject(NoxApp);
 
+    await noxApp.init();
 
-class Nox {
-    private messagePort: Electron.MessageChannelMain | undefined;
-
-    constructor(
-        public readonly root: Type<IApp>,
-        public readonly rootModule: Type<any>
-    ) {}
-
-    /**
-     * 
-     */
-    public async init(): Promise<IApp> {
-        const application = RootInjector.resolve(this.root);
-
-        ipcMain.on('gimme-my-port', this.giveTheClientAPort.bind(this, application));
-
-        app.once('activate', this.onAppActivated.bind(this, application));
-        app.once('window-all-closed', this.onAllWindowsClosed.bind(this, application));
-
-        await application.onReady();
-
-        console.log(''); // create a new line in the console to separate setup logs from the future logs
-
-        return application;
-    }
-
-    /**
-     * 
-     */
-    private giveTheClientAPort(application: IApp, event: Electron.IpcMainInvokeEvent): void {
-        if(this.messagePort) {
-            this.messagePort.port1.close();
-            this.messagePort.port2.close();
-            this.messagePort = undefined;
-        }
-
-        this.messagePort = new MessageChannelMain();
-
-        this.messagePort.port1.on('message', event => this.onClientMessage(application, event));
-        this.messagePort.port1.start();
-
-        event.sender.postMessage('port', null, [this.messagePort.port2]);
-    }
-
-    /**
-     * Electron specific message handling.
-     * Replaces HTTP calls by using Electron's IPC mechanism.
-     */
-    private async onClientMessage(application: IApp, event: Electron.MessageEvent): Promise<void> {
-        const { requestId, path, method, body }: IRequest = event.data;
-
-        try {
-            
-            const request = new Request(application, event, requestId, method, path, body);
-            const router = RootInjector.resolve(Router);
-
-            const response = await router.handle(request);
-
-            this.messagePort?.port1.postMessage(response);
-        }
-        catch(err: any) {
-            const response: IResponse = {
-                requestId,
-                status: 500,
-                body: null,
-                error: err.message || 'Internal Server Error',
-            };
-
-            this.messagePort?.port1.postMessage(response);
-        }
-    }
-
-    /**
-     * 
-     */
-    private onAppActivated(application: IApp): void {
-        if(BrowserWindow.getAllWindows().length === 0) {
-            application.onReady();
-        }
-    }
-
-    /**
-     * 
-     */
-    private async onAllWindowsClosed(application: IApp): Promise<void> {
-        this.messagePort?.port1.close();
-        await application.dispose();
-
-        if(process.platform !== 'darwin') {
-            app.quit();
-        }
-    }
+    return noxApp;
 }
 

package/src/decorators/controller.decorator.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 import { getGuardForController, IGuard } from "src/decorators/guards.decorator";
 import { Injectable } from "src/decorators/injectable.decorator";
 import { Type } from "src/utils/types";

package/src/decorators/guards.decorator.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 import { Request } from 'src/request';
 import { Logger } from 'src/utils/logger';
 import { MaybeAsync, Type } from 'src/utils/types';
@@ -13,7 +19,7 @@ const authorizations = new Map<string, Type<IGuard>[]>();
  * Peut être utilisé sur une classe controleur, ou sur une méthode de contrôleur.
  */
 export function Authorize(...guardClasses: Type<IGuard>[]): MethodDecorator & ClassDecorator {
-    return (target: any, propertyKey?: string | symbol) => {
+    return (target: Function | object, propertyKey?: string | symbol) => {
         let key: string;
 
         // Method decorator
@@ -32,7 +38,7 @@ export function Authorize(...guardClasses: Type<IGuard>[]): MethodDecorator & Cl
             throw new Error(`Guard(s) already registered for ${key}`);
         }
 
-        Logger.debug(`Registering guards for ${key}: ${guardClasses.map(c => c.name).join(', ')}`);
+        Logger.debug(`Registering guard(s) for ${key}: ${guardClasses.map(c => c.name).join(', ')}`);
 
         authorizations.set(key, guardClasses);
     };

package/src/decorators/injectable.decorator.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 import { Lifetime } from "src/DI/app-injector";
 import { InjectorExplorer } from "src/DI/injector-explorer";
 import { Type } from "src/utils/types";

package/src/decorators/method.decorator.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 import { getGuardForControllerAction, IGuard } from "src/decorators/guards.decorator";
 import { Type } from "src/utils/types";
 

package/src/decorators/middleware.decorator.ts

@@ -0,0 +1,54 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
+import { IResponse, Request } from "src/request";
+import { Logger } from "src/utils/logger";
+import { MaybeAsync, Type } from "src/utils/types";
+
+
+export type NextFunction = () => Promise<void>;
+
+export interface IMiddleware {
+    invoke(request: Request, response: IResponse, next: NextFunction): MaybeAsync<void>;
+}
+
+const middlewares = new Map<string, Type<IMiddleware>[]>();
+
+export function UseMiddlewares(mdlw: Type<IMiddleware>[]): ClassDecorator & MethodDecorator {
+    return (target: Function | object, propertyKey?: string | symbol) => {
+        let key: string;
+
+        // Method decorator
+        if(propertyKey) {
+            const ctrlName = target.constructor.name;
+            const actionName = propertyKey as string;
+            key = `${ctrlName}.${actionName}`;
+        }
+        // Class decorator
+        else {
+            const ctrlName = (target as Type<unknown>).name;
+            key = `${ctrlName}`;
+        }
+
+        if(middlewares.has(key)) {
+            throw new Error(`Middlewares(s) already registered for ${key}`);
+        }
+
+        Logger.debug(`Registering middleware(s) for ${key}: ${mdlw.map(c => c.name).join(', ')}`);
+
+        middlewares.set(key, mdlw);
+    };
+}
+
+export function getMiddlewaresForController(controllerName: string): Type<IMiddleware>[] {
+    const key = `${controllerName}`;
+    return middlewares.get(key) ?? [];
+}
+
+export function getMiddlewaresForControllerAction(controllerName: string, actionName: string): Type<IMiddleware>[] {
+    const key = `${controllerName}.${actionName}`;
+    return middlewares.get(key) ?? [];
+}

package/src/decorators/module.decorator.ts

@@ -1,4 +1,8 @@
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
 
 import { CONTROLLER_METADATA_KEY } from "src/decorators/controller.decorator";
 import { Injectable, INJECTABLE_METADATA_KEY } from "src/decorators/injectable.decorator";

package/src/exceptions.ts

@@ -1,8 +1,29 @@
-export abstract class ResponseException extends Error {
-    public abstract readonly status: number;
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
 
-    constructor(message: string = "") {
-        super(message);
+export class ResponseException extends Error {
+    public readonly status: number = 0;
+
+    constructor(message?: string);
+    constructor(statusCode?: number, message?: string);
+    constructor(statusOrMessage?: number | string, message?: string) {
+        let statusCode: number | undefined;
+        
+        if(typeof statusOrMessage === 'number') {
+            statusCode = statusOrMessage;
+        }
+        else if(typeof statusOrMessage === 'string') {
+            message = statusOrMessage;
+        }
+
+        super(message ?? "");
+
+        if(statusCode !== undefined) {
+            this.status = statusCode;
+        }
         
         this.name = this.constructor.name
             .replace(/([A-Z])/g, ' $1');
@@ -10,26 +31,27 @@ export abstract class ResponseException extends Error {
 }
 
 // 4XX
-export class BadRequestException extends ResponseException { public readonly status = 400; }
-export class UnauthorizedException extends ResponseException { public readonly status = 401; }
-export class ForbiddenException extends ResponseException { public readonly status = 403; }
-export class NotFoundException extends ResponseException { public readonly status = 404; }
-export class MethodNotAllowedException extends ResponseException { public readonly status = 405; }
-export class NotAcceptableException extends ResponseException { public readonly status = 406; }
-export class RequestTimeoutException extends ResponseException { public readonly status = 408; }
-export class ConflictException extends ResponseException { public readonly status = 409; }
-export class UpgradeRequiredException extends ResponseException { public readonly status = 426; }
-export class TooManyRequestsException extends ResponseException { public readonly status = 429; }
+export class BadRequestException extends ResponseException { public override readonly status = 400; }
+export class UnauthorizedException extends ResponseException { public override readonly status = 401; }
+export class PaymentRequiredException extends ResponseException { public override readonly status = 402; }
+export class ForbiddenException extends ResponseException { public override readonly status = 403; }
+export class NotFoundException extends ResponseException { public override readonly status = 404; }
+export class MethodNotAllowedException extends ResponseException { public override readonly status = 405; }
+export class NotAcceptableException extends ResponseException { public override readonly status = 406; }
+export class RequestTimeoutException extends ResponseException { public override readonly status = 408; }
+export class ConflictException extends ResponseException { public override readonly status = 409; }
+export class UpgradeRequiredException extends ResponseException { public override readonly status = 426; }
+export class TooManyRequestsException extends ResponseException { public override readonly status = 429; }
 // 5XX
-export class InternalServerException extends ResponseException { public readonly status = 500; }
-export class NotImplementedException extends ResponseException { public readonly status = 501; }
-export class BadGatewayException extends ResponseException { public readonly status = 502; }
-export class ServiceUnavailableException extends ResponseException { public readonly status = 503; }
-export class GatewayTimeoutException extends ResponseException { public readonly status = 504; }
-export class HttpVersionNotSupportedException extends ResponseException { public readonly status = 505; }
-export class VariantAlsoNegotiatesException extends ResponseException { public readonly status = 506; }
-export class InsufficientStorageException extends ResponseException { public readonly status = 507; }
-export class LoopDetectedException extends ResponseException { public readonly status = 508; }
-export class NotExtendedException extends ResponseException { public readonly status = 510; }
-export class NetworkAuthenticationRequiredException extends ResponseException { public readonly status = 511; }
-export class NetworkConnectTimeoutException extends ResponseException { public readonly status = 599; }
+export class InternalServerException extends ResponseException { public override readonly status = 500; }
+export class NotImplementedException extends ResponseException { public override readonly status = 501; }
+export class BadGatewayException extends ResponseException { public override readonly status = 502; }
+export class ServiceUnavailableException extends ResponseException { public override readonly status = 503; }
+export class GatewayTimeoutException extends ResponseException { public override readonly status = 504; }
+export class HttpVersionNotSupportedException extends ResponseException { public override readonly status = 505; }
+export class VariantAlsoNegotiatesException extends ResponseException { public override readonly status = 506; }
+export class InsufficientStorageException extends ResponseException { public override readonly status = 507; }
+export class LoopDetectedException extends ResponseException { public override readonly status = 508; }
+export class NotExtendedException extends ResponseException { public override readonly status = 510; }
+export class NetworkAuthenticationRequiredException extends ResponseException { public override readonly status = 511; }
+export class NetworkConnectTimeoutException extends ResponseException { public override readonly status = 599; }

package/src/index.ts

@@ -1,8 +1,15 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 export * from './DI/app-injector';
 export * from './router';
 export * from './app';
 export * from './bootstrap';
 export * from './exceptions';
+export * from './decorators/middleware.decorator';
 export * from './decorators/guards.decorator';
 export * from './decorators/controller.decorator';
 export * from './decorators/injectable.decorator';

package/src/request.ts

@@ -1,18 +1,19 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 import 'reflect-metadata';
-import { IApp } from 'src/app';
 import { HttpMethod } from 'src/decorators/method.decorator';
-import { RootInjector } from 'src/DI/app-injector';
-
-
-//
+import { AppInjector, RootInjector } from 'src/DI/app-injector';
 
 export class Request {
-    public readonly context: any = RootInjector.createScope();
+    public readonly context: AppInjector = RootInjector.createScope();
 
     public readonly params: Record<string, string> = {};
 
     constructor(
-        public readonly app: IApp,
         public readonly event: Electron.MessageEvent,
         public readonly id: string,
         public readonly method: HttpMethod,
@@ -24,6 +25,7 @@ export class Request {
 }
 
 export interface IRequest<T = any> {
+    senderId: number;
     requestId: string;
     path: string;
     method: HttpMethod;

package/src/router.ts

@@ -1,8 +1,15 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 import 'reflect-metadata';
 import { getControllerMetadata } from 'src/decorators/controller.decorator';
 import { getGuardForController, getGuardForControllerAction, IGuard } from 'src/decorators/guards.decorator';
 import { Injectable } from 'src/decorators/injectable.decorator';
 import { getRouteMetadata } from 'src/decorators/method.decorator';
+import { getMiddlewaresForController, getMiddlewaresForControllerAction, IMiddleware, NextFunction } from 'src/decorators/middleware.decorator';
 import { MethodNotAllowedException, NotFoundException, ResponseException, UnauthorizedException } from 'src/exceptions';
 import { IResponse, Request } from 'src/request';
 import { Logger } from 'src/utils/logger';
@@ -17,6 +24,7 @@ export interface IRouteDefinition {
     controller: Type<any>;
     handler: string;
     guards: Type<IGuard>[];
+    middlewares: Type<IMiddleware>[];
 }
 
 export type ControllerAction = (request: Request, response: IResponse) => any;
@@ -25,11 +33,16 @@ export type ControllerAction = (request: Request, response: IResponse) => any;
 @Injectable('singleton')
 export class Router {
     private readonly routes = new RadixTree<IRouteDefinition>();
+    private readonly rootMiddlewares: Type<IMiddleware>[] = [];
 
+    /**
+     * 
+     */
     public registerController(controllerClass: Type<unknown>): Router {
         const controllerMeta = getControllerMetadata(controllerClass);
 
         const controllerGuards = getGuardForController(controllerClass.name);
+        const controllerMiddlewares = getMiddlewaresForController(controllerClass.name);
         
         if(!controllerMeta)
             throw new Error(`Missing @Controller decorator on ${controllerClass.name}`);
@@ -40,8 +53,10 @@ export class Router {
             const fullPath = `${controllerMeta.path}/${def.path}`.replace(/\/+/g, '/');
 
             const routeGuards = getGuardForControllerAction(controllerClass.name, def.handler);
+            const routeMiddlewares = getMiddlewaresForControllerAction(controllerClass.name, def.handler);
 
             const guards = new Set([...controllerGuards, ...routeGuards]);
+            const middlewares = new Set([...controllerMiddlewares, ...routeMiddlewares]);
 
             const routeDef: IRouteDefinition = {
                 method: def.method,
@@ -49,6 +64,7 @@ export class Router {
                 controller: controllerClass,
                 handler: def.handler,
                 guards: [...guards],
+                middlewares: [...middlewares],
             };
             
             this.routes.insert(fullPath + '/' + def.method, routeDef);
@@ -73,6 +89,18 @@ export class Router {
         return this;
     }
 
+    /**
+     * 
+     */
+    public defineRootMiddleware(middleware: Type<IMiddleware>): Router {
+        Logger.debug(`Registering root middleware: ${middleware.name}`);
+        this.rootMiddlewares.push(middleware);
+        return this;
+    }
+
+    /**
+     * 
+     */
     public async handle(request: Request): Promise<IResponse> {
         Logger.log(`> Received request: {${request.method} /${request.path}}`);
 
@@ -87,13 +115,11 @@ export class Router {
 
         try {
             const routeDef = this.findRoute(request);
-            const controllerInstance = await this.resolveController(request, routeDef);
-
-            const action = controllerInstance[routeDef.handler] as ControllerAction;
-
-            this.verifyRequestBody(request, action);
+            await this.resolveController(request, response, routeDef);
 
-            response.body = await action.call(controllerInstance, request, response);
+            if(response.status > 400) {
+                throw new ResponseException(response.status, response.error);
+            }
         }
         catch(error: unknown) {
             if(error instanceof ResponseException) {
@@ -129,6 +155,9 @@ export class Router {
         }
     }
 
+    /**
+     * 
+     */
     private findRoute(request: Request): IRouteDefinition {
         const matchedRoutes = this.routes.search(request.path);
 
@@ -145,30 +174,85 @@ export class Router {
         return routeDef.value;
     }
 
-    private async resolveController(request: Request, routeDef: IRouteDefinition): Promise<any> {
+    /**
+     * 
+     */
+    private async resolveController(request: Request, response: IResponse, routeDef: IRouteDefinition): Promise<void> {
         const controllerInstance = request.context.resolve(routeDef.controller);
 
         Object.assign(request.params, this.extractParams(request.path, routeDef.path));
 
-        if(routeDef.guards.length > 0) {
-            for(const guardType of routeDef.guards) {
-                const guard = request.context.resolve(guardType);
-                const allowed = await guard.canActivate(request);
+        await this.runRequestPipeline(request, response, routeDef, controllerInstance);
+    }
+
+    /**
+     * 
+     */
+    private async runRequestPipeline(request: Request, response: IResponse, routeDef: IRouteDefinition, controllerInstance: any): Promise<void> {
+        const middlewares = [...new Set([...this.rootMiddlewares, ...routeDef.middlewares])];
 
-                if(!allowed)
-                    throw new UnauthorizedException(`Unauthorized for ${request.method} ${request.path}`);
+        const middlewareMaxIndex = middlewares.length - 1;
+        const guardsMaxIndex = middlewareMaxIndex + routeDef.guards.length;
+
+        let index = -1;
+
+        const dispatch = async (i: number): Promise<void> => {
+            if(i <= index)
+                throw new Error("next() called multiple times");
+            
+            index = i;
+
+            // middlewares
+            if(i <= middlewareMaxIndex) {
+                const nextFn = dispatch.bind(null, i + 1);
+                await this.runMiddleware(request, response, nextFn, middlewares[i]!);
+
+                if(response.status >= 400) {
+                    throw new ResponseException(response.status, response.error);
+                }
+
+                return;
+            }
+            
+            // guards
+            if(i <= guardsMaxIndex) {
+                const guardIndex = i - middlewares.length;
+                const guardType = routeDef.guards[guardIndex]!;
+                await this.runGuard(request, guardType);
+                dispatch(i + 1);
+                return;
             }
-        }
 
-        return controllerInstance;
+            // endpoint action
+            const action = controllerInstance[routeDef.handler] as ControllerAction;
+            response.body = await action.call(controllerInstance, request, response);
+        };
+
+        await dispatch(0);
     }
 
-    private verifyRequestBody(request: Request, action: ControllerAction): void {
-        const requiredParams = Reflect.getMetadata('design:paramtypes', action) || [];
-        // peut être à faire plus tard. problème du TS, c'est qu'en JS pas de typage.
-        // donc il faudrait passer par des décorateurs mais pas sûr que ce soit bien.
+    /**
+     * 
+     */
+    private async runMiddleware(request: Request, response: IResponse, next: NextFunction, middlewareType: Type<IMiddleware>): Promise<void> {
+        const middleware = request.context.resolve(middlewareType);
+        await middleware.invoke(request, response, next);
+    }
+
+    /**
+     * 
+     */
+    private async runGuard(request: Request, guardType: Type<IGuard>): Promise<void> {
+        const guard = request.context.resolve(guardType);
+        const allowed = await guard.canActivate(request);
+
+        if(!allowed)
+            throw new UnauthorizedException(`Unauthorized for ${request.method} ${request.path}`);
     }
 
+    /**
+     * 
+     */
     private extractParams(actual: string, template: string): Record<string, string> {
         const aParts = actual.split('/');
         const tParts = template.split('/');

package/src/utils/logger.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 function getPrettyTimestamp(): string {
     const now = new Date();
     return `${now.getDate().toString().padStart(2, '0')}/${(now.getMonth() + 1).toString().padStart(2, '0')}/${now.getFullYear()}`

package/src/utils/radix-tree.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 type Params = Record<string, string>;
 
 interface ISearchResult<T> {

package/src/utils/types.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
 
 

package/tsup.config.ts

@@ -1,5 +1,13 @@
 import { defineConfig } from "tsup";
 
+const copyrights = `
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+`.trim()
+
 export default defineConfig({
     entry: {
         noxus: "src/index.ts"
@@ -17,4 +25,7 @@ export default defineConfig({
     splitting: false,
     shims: false,
     treeshake: false,
+    banner: {
+        js: copyrights,
+    }
 });