@noxfly/noxus 1.0.4 → 1.0.5

package/scripts/postbuild.js

@@ -0,0 +1,26 @@
+const fs = require('fs');
+const path = require('path');
+
+const frameworkName = 'noxus';
+
+function removeDuplicateCopyrights(filename) {
+    const filepath = path.join(__dirname, '../dist/' + filename);
+    const content = fs.readFileSync(filepath, 'utf8');
+
+    const reg = /\/\*\*[\t ]*\n(?: \*.*\n)*? \* *@copyright.*\n(?: \*.*\n)*? \*\/\n?/gm;
+
+    let first = true;
+    const deduped = content.replace(reg, (match) => {
+        if (first) {
+            first = false;
+            return match; // keep the first
+        }
+        return ''; // remove others
+    });
+
+    fs.writeFileSync(filepath, deduped);
+}
+
+
+removeDuplicateCopyrights(`${frameworkName}.d.mts`);
+removeDuplicateCopyrights(`${frameworkName}.d.ts`);

package/src/DI/app-injector.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 import 'reflect-metadata';
 import { InternalServerException } from 'src/exceptions';
 import { Type } from 'src/utils/types';
@@ -78,3 +84,7 @@ class AppInjector {
 }
 
 export const RootInjector = new AppInjector('root');
+
+export function inject<T>(t: Type<T>): T {
+    return RootInjector.resolve(t);
+}

package/src/DI/injector-explorer.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 import { getControllerMetadata } from "src/decorators/controller.decorator";
 import { getInjectableMetadata } from "src/decorators/injectable.decorator";
 import { getRouteMetadata } from "src/decorators/method.decorator";

package/src/app.ts

@@ -1,4 +1,151 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
+import { app, BrowserWindow, ipcMain, MessageChannelMain } from "electron/main";
+import { Injectable } from "src/decorators/injectable.decorator";
+import { inject } from "src/DI/app-injector";
+import { IRequest, IResponse, Request } from "src/request";
+import { Router } from "src/router";
+import { Logger } from "src/utils/logger";
+import { Type } from "src/utils/types";
+
 export interface IApp {
     dispose(): Promise<void>;
     onReady(): Promise<void>;
+    onActivated(): Promise<void>;
 }
+
+@Injectable('singleton')
+export class NoxApp {
+    private readonly messagePorts = new Map<number, Electron.MessageChannelMain>();
+    private app: IApp | undefined;
+
+    constructor(
+        private readonly router: Router,
+    ) {}
+
+    /**
+     * 
+     */
+    public async init(): Promise<NoxApp> {
+        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(''); // create a new line in the console to separate setup logs from the future logs
+
+        return this;
+    }
+
+    /**
+     * 
+     */
+    private giveTheRendererAPort(event: Electron.IpcMainInvokeEvent): void {
+        const senderId = event.sender.id;
+
+        if(this.messagePorts.has(senderId)) {
+            this.shutdownChannel(senderId);
+        }
+
+        const channel = new MessageChannelMain();
+        this.messagePorts.set(senderId, channel);
+
+        channel.port1.on('message', this.onRendererMessage.bind(this));
+        channel.port1.start();
+
+        event.sender.postMessage('port', { senderId }, [channel.port2]);
+    }
+
+    /**
+     * Electron specific message handling.
+     * Replaces HTTP calls by using Electron's IPC mechanism.
+     */
+    private async onRendererMessage(event: Electron.MessageEvent): Promise<void> {
+        const { senderId, requestId, path, method, body }: IRequest = event.data;
+
+        const channel = this.messagePorts.get(senderId);
+
+        if(!channel) {
+            Logger.error(`No message channel found for sender ID: ${senderId}`);
+            return;
+        }
+
+        try {
+            const request = new Request(event, requestId, method, path, body);
+            const response = await this.router.handle(request);
+            channel.port1.postMessage(response);
+        }
+        catch(err: any) {
+            const response: IResponse = {
+                requestId,
+                status: 500,
+                body: null,
+                error: err.message || 'Internal Server Error',
+            };
+
+            channel.port1.postMessage(response);
+        }
+    }
+
+    /**
+     * MacOS specific behavior.
+     */
+    private onAppActivated(): void {
+        if(process.platform === 'darwin' && BrowserWindow.getAllWindows().length === 0) {
+            this.app?.onActivated();
+        }   
+    }
+
+    private shutdownChannel(channelSenderId: number, remove: boolean = true): void {
+        const channel = this.messagePorts.get(channelSenderId);
+
+        if(!channel) {
+            Logger.warn(`No message channel found for sender ID: ${channelSenderId}`);
+            return;
+        }
+
+        channel.port1.off('message', this.onRendererMessage.bind(this));
+        channel.port1.close();
+        channel.port2.close();
+
+        this.messagePorts.delete(channelSenderId);
+    }
+
+    /**
+     * 
+     */
+    private async onAllWindowsClosed(): Promise<void> {
+        this.messagePorts.forEach((channel, senderId) => {
+            this.shutdownChannel(senderId, false);
+        });
+
+        this.messagePorts.clear();
+
+        this.app?.dispose();
+
+        if(process.platform !== 'darwin') {
+            app.quit();
+        }
+    }
+
+
+    // ---
+
+
+    public configure(app: Type<IApp>): NoxApp {
+        this.app = inject(app);
+        return this;
+    }
+
+    /**
+     * Should be called after the bootstrapApplication function is called.
+     */
+    public start(): NoxApp {
+        this.app?.onReady();
+        return this;
+    }
+}

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

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/module.decorator.ts

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

package/src/exceptions.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 export abstract class ResponseException extends Error {
     public abstract readonly status: number;
 
@@ -12,6 +18,7 @@ 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 PaymentRequiredException extends ResponseException { public readonly status = 402; }
 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; }

package/src/index.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
 export * from './DI/app-injector';
 export * from './router';
 export * from './app';

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';
 
-
-//
-
 export class Request {
     public readonly context: any = 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,3 +1,9 @@
+/**
+ * @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';

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,
+    }
 });