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

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;
-}

package/src/internal/exceptions.ts

@@ -1,57 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-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');
-    }
-}
-
-// 4XX
-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 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/internal/preload-bridge.ts

@@ -1,75 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { contextBridge, ipcRenderer } from 'electron/renderer';
-import type { IPortRequester } from './renderer-client';
-
-export interface NoxusPreloadAPI extends IPortRequester {}
-
-export interface NoxusPreloadOptions {
-    exposeAs?: string;
-    initMessageType?: string;
-    requestChannel?: string;
-    responseChannel?: string;
-    targetWindow?: Window;
-}
-
-const DEFAULT_EXPOSE_NAME = 'noxus';
-const DEFAULT_INIT_EVENT = 'init-port';
-const DEFAULT_REQUEST_CHANNEL = 'gimme-my-port';
-const DEFAULT_RESPONSE_CHANNEL = 'port';
-
-/**
- * Exposes a minimal bridge in the isolated preload context so renderer processes
- * can request the two MessagePorts required by Noxus. The bridge forwards both
- * request/response and socket ports to the renderer via window.postMessage.
- */
-export function exposeNoxusBridge(options: NoxusPreloadOptions = {}): NoxusPreloadAPI {
-    const {
-        exposeAs = DEFAULT_EXPOSE_NAME,
-        initMessageType = DEFAULT_INIT_EVENT,
-        requestChannel = DEFAULT_REQUEST_CHANNEL,
-        responseChannel = DEFAULT_RESPONSE_CHANNEL,
-        targetWindow = window,
-    } = options;
-
-    const api: NoxusPreloadAPI = {
-        requestPort: () => {
-            ipcRenderer.send(requestChannel);
-
-            ipcRenderer.once(responseChannel, (event, message: { senderId: number }) => {
-                const ports = (event.ports ?? []).filter((port): port is MessagePort => port !== undefined);
-
-                if(ports.length === 0) {
-                    console.error('[Noxus] No MessagePort received from main process.');
-                    return;
-                }
-
-                for(const port of ports) {
-                    try {
-                        port.start();
-                    }
-                    catch(error) {
-                        console.error('[Noxus] Failed to start MessagePort.', error);
-                    }
-                }
-
-                targetWindow.postMessage(
-                    {
-                        type: initMessageType,
-                        senderId: message?.senderId,
-                    },
-                    '*',
-                    ports,
-                );
-            });
-        },
-    };
-
-    contextBridge.exposeInMainWorld(exposeAs, api);
-
-    return api;
-}