@noxfly/noxus 3.0.0-dev.4 → 3.0.0-dev.5

package/src/DI/token.ts

@@ -1,53 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { Type } from '../utils/types';
-
-/**
- * A DI token uniquely identifies a dependency.
- * It can wrap a class (Type<T>) or be a named symbol token.
- *
- * Using tokens instead of reflect-metadata means dependencies are
- * declared explicitly — no magic type inference, no emitDecoratorMetadata.
- *
- * @example
- * // Class token (most common)
- * const MY_SERVICE = token(MyService);
- *
- * // Named symbol token (for interfaces or non-class values)
- * const DB_URL = token<string>('DB_URL');
- */
-export class Token<T> {
-    public readonly description: string;
-
-    constructor(
-        public readonly target: Type<T> | string,
-    ) {
-        this.description = typeof target === 'string' ? target : target.name;
-    }
-
-    public toString(): string {
-        return `Token(${this.description})`;
-    }
-}
-
-/**
- * Creates a DI token for a class type or a named value.
- *
- * @example
- * export const MY_SERVICE = token(MyService);
- * export const DB_URL = token<string>('DB_URL');
- */
-export function token<T>(target: Type<T> | string): Token<T> {
-    return new Token<T>(target);
-}
-
-/**
- * The key used to look up a class token in the registry.
- * For class tokens, the key is the class constructor itself.
- * For named tokens, the key is the Token instance.
- */
-export type TokenKey<T = unknown> = Type<T> | Token<T>;

package/src/decorators/controller.decorator.ts

@@ -1,58 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { InjectorExplorer } from '../DI/injector-explorer';
-import { TokenKey } from '../DI/token';
-import { Type } from '../utils/types';
-
-export interface ControllerOptions {
-    /**
-     * Explicit constructor dependencies.
-     */
-    deps?: ReadonlyArray<TokenKey>;
-}
-
-export interface IControllerMetadata {
-    deps: ReadonlyArray<TokenKey>;
-}
-
-const controllerMetaMap = new WeakMap<object, IControllerMetadata>();
-
-/**
- * Marks a class as a Noxus controller.
- * Controllers are always scope-scoped injectables.
- * The route prefix and guards/middlewares are declared in defineRoutes(), not here.
- *
- * @example
- * @Controller({ deps: [UserService] })
- * export class UserController {
- *   constructor(private svc: UserService) {}
- *
- *   @Get('byId/:userId')
- *   getUserById(req: Request) { ... }
- * }
- */
-export function Controller(options: ControllerOptions = {}): ClassDecorator {
-    return (target) => {
-        const meta: IControllerMetadata = {
-            deps: options.deps ?? [],
-        };
-
-        controllerMetaMap.set(target, meta);
-
-        InjectorExplorer.enqueue({
-            key: target as unknown as Type<unknown>,
-            implementation: target as unknown as Type<unknown>,
-            lifetime: 'scope',
-            deps: options.deps ?? [],
-            isController: true,
-        });
-    };
-}
-
-export function getControllerMetadata(target: object): IControllerMetadata | undefined {
-    return controllerMetaMap.get(target);
-}

package/src/decorators/guards.decorator.ts

@@ -1,15 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { Request } from '../internal/request';
-import { MaybeAsync } from '../utils/types';
-
-/**
- * A guard decides whether an incoming request should reach the handler.
- * Implement this interface and pass the class to @Controller({ guards }) or @Get('path', { guards }).
- */
-
-export type Guard = (request: Request) => MaybeAsync<boolean>;

package/src/decorators/injectable.decorator.ts

@@ -1,81 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { Lifetime } from '../DI/app-injector';
-import { InjectorExplorer } from '../DI/injector-explorer';
-import { Token, TokenKey } from '../DI/token';
-import { Type } from '../utils/types';
-
-export interface InjectableOptions {
-    /**
-     * Lifetime of this injectable.
-     * @default 'scope'
-     */
-    lifetime?: Lifetime;
-
-    /**
-     * Explicit list of constructor dependencies, in the same order as the constructor parameters.
-     * Each entry is either a class constructor or a Token created with token().
-     *
-     * This replaces reflect-metadata / emitDecoratorMetadata entirely.
-     *
-     * @example
-     * @Injectable({ lifetime: 'singleton', deps: [MyRepo, DB_URL] })
-     * class MyService {
-     *   constructor(private repo: MyRepo, private dbUrl: string) {}
-     * }
-     */
-    deps?: ReadonlyArray<TokenKey>;
-}
-
-/**
- * Marks a class as injectable into the Noxus DI container.
- *
- * Unlike the v2 @Injectable, this decorator:
- * - Does NOT require reflect-metadata or emitDecoratorMetadata.
- * - Requires you to declare deps explicitly when the class has constructor parameters.
- * - Supports standalone usage — no module declaration needed.
- *
- * @example
- * // No dependencies
- * @Injectable()
- * class Logger {}
- *
- * // With dependencies
- * @Injectable({ lifetime: 'singleton', deps: [Logger, MyRepo] })
- * class MyService {
- *   constructor(private logger: Logger, private repo: MyRepo) {}
- * }
- *
- * // With a named token
- * const DB_URL = token<string>('DB_URL');
- *
- * @Injectable({ deps: [DB_URL] })
- * class DbService {
- *   constructor(private url: string) {}
- * }
- */
-export function Injectable(options: InjectableOptions = {}): ClassDecorator {
-    const { lifetime = 'scope', deps = [] } = options;
-
-    return (target) => {
-        if (typeof target !== 'function' || !target.prototype) {
-            throw new Error(`@Injectable can only be applied to classes, not ${typeof target}`);
-        }
-
-        const key = target as unknown as Type<unknown>;
-
-        InjectorExplorer.enqueue({
-            key,
-            implementation: key,
-            lifetime,
-            deps,
-            isController: false,
-        });
-    };
-}
-
-export { Token, TokenKey };

package/src/decorators/method.decorator.ts

@@ -1,66 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { Guard } from './guards.decorator';
-import { Middleware } from './middleware.decorator';
-
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'BATCH';
-export type AtomicHttpMethod = Exclude<HttpMethod, 'BATCH'>;
-
-const ATOMIC_METHODS = new Set<AtomicHttpMethod>(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']);
-export function isAtomicHttpMethod(m: unknown): m is AtomicHttpMethod {
-    return typeof m === 'string' && ATOMIC_METHODS.has(m as AtomicHttpMethod);
-}
-
-export interface IRouteOptions {
-    /**
-     * Guards specific to this route (merged with controller guards).
-     */
-    guards?: Guard[];
-    /**
-     * Middlewares specific to this route (merged with controller middlewares).
-     */
-    middlewares?: Middleware[];
-}
-
-export interface IRouteMetadata {
-    method: HttpMethod;
-    path: string;
-    handler: string;
-    guards: Guard[];
-    middlewares: Middleware[];
-}
-
-const routeMetaMap = new WeakMap<object, IRouteMetadata[]>();
-
-function createRouteDecorator(verb: HttpMethod) {
-    return (path: string, options: IRouteOptions = {}): MethodDecorator => {
-        return (target, propertyKey) => {
-            const ctor = target.constructor;
-            const existing: IRouteMetadata[] = routeMetaMap.get(ctor) ?? [];
-
-            existing.push({
-                method: verb,
-                path: (path ?? '').trim().replace(/^\/|\/$/g, ''),
-                handler: propertyKey as string,
-                guards: options.guards ?? [],
-                middlewares: options.middlewares ?? [],
-            });
-
-            routeMetaMap.set(ctor, existing);
-        };
-    };
-}
-
-export function getRouteMetadata(target: object): IRouteMetadata[] {
-    return routeMetaMap.get(target) ?? [];
-}
-
-export const Get    = createRouteDecorator('GET');
-export const Post   = createRouteDecorator('POST');
-export const Put    = createRouteDecorator('PUT');
-export const Patch  = createRouteDecorator('PATCH');
-export const Delete = createRouteDecorator('DELETE');

package/src/decorators/middleware.decorator.ts

@@ -1,15 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { IResponse, Request } from '../internal/request';
-import { MaybeAsync } from '../utils/types';
-
-/**
- * A middleware intercepts requests before they reach guards and the handler.
- * Implement this interface and pass the class to @Controller({ middlewares }) or per-route options.
- */
-export type Middleware = (request: Request, response: IResponse, next: NextFunction) => MaybeAsync<void>;
-export type NextFunction = () => Promise<void>;

package/src/index.ts

@@ -1,10 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- *
- * Entry point for renderer process and preload consumers.
- */
-
-// src/index.ts — redirige vers renderer
-export * from './renderer';

package/src/internal/app.ts

@@ -1,219 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { app, BrowserWindow, ipcMain, MessageChannelMain } from 'electron/main';
-import { Guard } from "../decorators/guards.decorator";
-import { Injectable } from '../decorators/injectable.decorator';
-import { Middleware } from '../decorators/middleware.decorator';
-import { inject } from '../DI/app-injector';
-import { InjectorExplorer } from '../DI/injector-explorer';
-import { Logger } from '../utils/logger';
-import { Type } from '../utils/types';
-import { WindowManager } from '../window/window-manager';
-import { IResponse, Request } from './request';
-import { Router } from './router';
-import { NoxSocket } from './socket';
-
-/**
- * Your application service should implement IApp.
- * Noxus calls these lifecycle methods at the appropriate time.
- *
- * Unlike v2, IApp no longer receives a BrowserWindow in onReady.
- * Use the injected WindowManager instead — it is more flexible and
- * does not couple the lifecycle to a single pre-created window.
- *
- * @example
- * @Injectable({ lifetime: 'singleton', deps: [WindowManager, MyService] })
- * class AppService implements IApp {
- *   constructor(private wm: WindowManager, private svc: MyService) {}
- *
- *   async onReady() {
- *     const win = await this.wm.createSplash({ webPreferences: { preload: ... } });
- *     win.loadFile('index.html');
- *   }
- *
- *   async onActivated() { ... }
- *   async dispose() { ... }
- * }
- */
-export interface IApp {
-    dispose(): Promise<void>;
-    onReady(): Promise<void>;
-    onActivated(): Promise<void>;
-}
-
-@Injectable({ lifetime: 'singleton', deps: [Router, NoxSocket, WindowManager] })
-export class NoxApp {
-    private appService: IApp | undefined;
-
-    constructor(
-        private readonly router: Router,
-        private readonly socket: NoxSocket,
-        public readonly windowManager: WindowManager,
-    ) {}
-
-    // -------------------------------------------------------------------------
-    // Initialisation
-    // -------------------------------------------------------------------------
-
-    public async init(): Promise<this> {
-        ipcMain.on('gimme-my-port', this.giveTheRendererAPort.bind(this));
-        app.once('activate', this.onAppActivated.bind(this));
-        app.once('window-all-closed', this.onAllWindowsClosed.bind(this));
-        console.log('');
-        return this;
-    }
-
-    // -------------------------------------------------------------------------
-    // Public API
-    // -------------------------------------------------------------------------
-
-    /**
-     * Registers a lazy route. The file behind this prefix is dynamically
-     * imported on the first IPC request that targets it.
-     *
-     * The import function should NOT statically reference heavy modules —
-     * the whole point is to defer their loading.
-     *
-     * @example
-     * noxApp.lazy('auth', () => import('./modules/auth/auth.controller.js'));
-     * noxApp.lazy('reporting', () => import('./modules/reporting/index.js'));
-     */
-    public lazy(
-        pathPrefix: string,
-        load: () => Promise<unknown>,
-        guards: Guard[] = [],
-        middlewares: Middleware[] = [],
-    ): this {
-        this.router.registerLazyRoute(pathPrefix, load, guards, middlewares);
-        return this;
-    }
-
-    /**
-     * Eagerly loads a set of modules (controllers + services) before start().
-     * Use this for modules that provide services needed by your IApp.onReady().
-     *
-     * All imports run in parallel; DI is flushed with the two-phase guarantee.
-     */
-    public async load(importFns: Array<() => Promise<unknown>>): Promise<this> {
-        InjectorExplorer.beginAccumulate();
-        await Promise.all(importFns.map((fn) => fn()));
-        await InjectorExplorer.flushAccumulated();
-        return this;
-    }
-
-    /**
-     * Registers a global middleware applied to every route.
-     */
-    public use(middleware: Middleware): this {
-        this.router.defineRootMiddleware(middleware);
-        return this;
-    }
-
-    /**
-     * Sets the application service (implements IApp) that receives lifecycle events.
-     * @param appClass - Class decorated with @Injectable that implements IApp.
-     */
-    public configure(appClass: Type<IApp>): this {
-        this.appService = inject(appClass);
-        return this;
-    }
-
-    /**
-     * Calls IApp.onReady(). Should be called after configure() and any lazy()
-     * registrations are set up.
-     */
-    public start(): this {
-        this.appService?.onReady();
-        return this;
-    }
-
-    // -------------------------------------------------------------------------
-    // IPC
-    // -------------------------------------------------------------------------
-
-    private readonly onRendererMessage = async (event: Electron.MessageEvent): Promise<void> => {
-        const { senderId, requestId, path, method, body, query }: import('./request').IRequest = event.data;
-        const channels = this.socket.get(senderId);
-
-        if (!channels) {
-            Logger.error(`No message channel found for sender ID: ${senderId}`);
-            return;
-        }
-
-        try {
-            const request = new Request(event, senderId, requestId, method, path, body, query);
-            const response = await this.router.handle(request);
-            channels.request.port1.postMessage(response);
-        }
-        catch (err: unknown) {
-            const response: IResponse = {
-                requestId,
-                status: 500,
-                body: null,
-                error: err instanceof Error ? err.message : 'Internal Server Error',
-            };
-            channels.request.port1.postMessage(response);
-        }
-    };
-
-    private giveTheRendererAPort(event: Electron.IpcMainInvokeEvent): void {
-        const senderId = event.sender.id;
-
-        if (this.socket.get(senderId)) {
-            this.shutdownChannel(senderId);
-        }
-
-        const requestChannel = new MessageChannelMain();
-        const socketChannel = new MessageChannelMain();
-
-        requestChannel.port1.on('message', this.onRendererMessage);
-        requestChannel.port1.start();
-        socketChannel.port1.start();
-
-        event.sender.once('destroyed', () => this.shutdownChannel(senderId));
-
-        this.socket.register(senderId, requestChannel, socketChannel);
-        event.sender.postMessage('port', { senderId }, [requestChannel.port2, socketChannel.port2]);
-    }
-
-    // -------------------------------------------------------------------------
-    // Lifecycle
-    // -------------------------------------------------------------------------
-
-    private onAppActivated(): void {
-        if (process.platform === 'darwin' && BrowserWindow.getAllWindows().length === 0) {
-            this.appService?.onActivated();
-        }
-    }
-
-    private async onAllWindowsClosed(): Promise<void> {
-        for (const senderId of this.socket.getSenderIds()) {
-            this.shutdownChannel(senderId);
-        }
-
-        Logger.info('All windows closed, shutting down application...');
-        await this.appService?.dispose();
-
-        if (process.platform !== 'darwin') app.quit();
-    }
-
-    private shutdownChannel(channelSenderId: number): void {
-        const channels = this.socket.get(channelSenderId);
-
-        if (!channels) {
-            return;
-        }
-
-        channels.request.port1.off('message', this.onRendererMessage);
-        channels.request.port1.close();
-        channels.request.port2.close();
-        channels.socket.port1.close();
-        channels.socket.port2.close();
-
-        this.socket.unregister(channelSenderId);
-    }
-}

package/src/internal/bootstrap.ts

@@ -1,141 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { app } from 'electron/main';
-import { inject, RootInjector } from '../DI/app-injector';
-import { InjectorExplorer } from '../DI/injector-explorer';
-import { TokenKey } from '../DI/token';
-import { Logger } from '../utils/logger';
-import { NoxApp } from './app';
-import { RouteDefinition } from "./routes";
-import { Router } from './router';
-
-/**
- * A singleton value override: provides an already-constructed instance
- * for a given token, bypassing the DI factory.
- *
- * Useful for injecting external singletons (e.g. a database connection,
- * a logger already configured, a third-party SDK wrapper) that cannot
- * or should not be constructed by the DI container.
- *
- * @example
- * { token: MikroORM, useValue: await MikroORM.init(config) }
- * { token: DB_URL,   useValue: process.env.DATABASE_URL }
- */
-export interface SingletonOverride<T = unknown> {
-    token: TokenKey<T>;
-    useValue: T;
-}
-
-/**
- * Configuration object for bootstrapApplication.
- */
-export interface BootstrapConfig {
-    /**
-     * Application routing table, produced by defineRoutes().
-     * All lazy routes are registered before the app starts.
-     */
-    routes?: RouteDefinition[];
-
-    /**
-     * Pre-built singleton instances to inject into the DI container
-     * before the application starts.
-     *
-     * This replaces the v2 module/provider declaration pattern for
-     * external singletons.
-     *
-     * @example
-     * singletons: [
-     *   { token: MikroORM, useValue: await MikroORM.init(ormConfig) },
-     *   { token: DB_URL,   useValue: process.env.DATABASE_URL! },
-     * ]
-     */
-    singletons?: SingletonOverride[];
-
-    /**
-     * Controllers and services to eagerly load before NoxApp.start() is called.
-     * Each entry is a dynamic import function — files are imported in parallel.
-     *
-     * Use this only for things needed at startup (e.g. if your IApp service
-     * depends on a service in an otherwise lazy module).
-     *
-     * Everything else should be registered via noxApp.lazy().
-     *
-     * @example
-     * eagerLoad: [
-     *   () => import('./modules/auth/auth.controller.js'),
-     * ]
-     */
-    eagerLoad?: Array<() => Promise<unknown>>;
-
-    /**
-     * Controls framework log verbosity.
-     * - `'debug'`: all messages (default during development).
-     * - `'info'`: info, warn, error, critical only.
-     * - `'none'`: completely silent — no framework logs.
-     *
-     * You can also pass an array of specific log levels to enable.
-     */
-    logLevel?: 'debug' | 'info' | 'none' | import('../utils/logger').LogLevel[];
-}
-
-/**
- * Bootstraps the Noxus application.
- */
-export async function bootstrapApplication(config: BootstrapConfig = {}): Promise<NoxApp> {
-    await app.whenReady();
-
-    // Apply log level configuration
-    if (config.logLevel !== undefined) {
-        if (config.logLevel === 'none') {
-            Logger.setLogLevel([]);
-        } else if (Array.isArray(config.logLevel)) {
-            Logger.setLogLevel(config.logLevel);
-        } else {
-            Logger.setLogLevel(config.logLevel);
-        }
-    }
-
-    // Build override map for the DI flush phase
-    const overrides = new Map<TokenKey, unknown>();
-
-    for (const { token, useValue } of config.singletons ?? []) {
-        overrides.set(token, useValue);
-        // Pre-register the binding so the injector knows the token exists
-        RootInjector.singletons.set(token as any, useValue);
-    }
-
-    // Flush all classes enqueued by decorators at import time (two-phase)
-    // Wire the controller registrar so InjectorExplorer can register controllers
-    // without directly importing Router (avoids circular dependency).
-    InjectorExplorer.setControllerRegistrar((controllerClass, pathPrefix, routeGuards, routeMiddlewares) => {
-        const router = inject(Router);
-        router.registerController(controllerClass, pathPrefix, routeGuards, routeMiddlewares);
-    });
-
-    InjectorExplorer.processPending(overrides);
-
-    // Resolve core framework singletons
-    const noxApp = inject(NoxApp);
-
-    // Register routes from the routing table
-    if (config.routes?.length) {
-        for (const route of config.routes) {
-            if (route.load) {
-                noxApp.lazy(route.path, route.load, route.guards, route.middlewares);
-            }
-        }
-    }
-
-    // Eagerly load optional modules
-    if (config.eagerLoad?.length) {
-        await noxApp.load(config.eagerLoad);
-    }
-
-    await noxApp.init();
-
-    return noxApp;
-}