@noxfly/noxus 1.0.4 → 1.1.0

package/dist/noxus.mjs

@@ -1,3 +1,8 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -8,8 +13,18 @@ import "reflect-metadata";
 
 // src/exceptions.ts
 var _ResponseException = class _ResponseException extends Error {
-  constructor(message = "") {
-    super(message);
+  constructor(statusOrMessage, message) {
+    let statusCode;
+    if (typeof statusOrMessage === "number") {
+      statusCode = statusOrMessage;
+    } else if (typeof statusOrMessage === "string") {
+      message = statusOrMessage;
+    }
+    super(message ?? "");
+    __publicField(this, "status", 0);
+    if (statusCode !== void 0) {
+      this.status = statusCode;
+    }
     this.name = this.constructor.name.replace(/([A-Z])/g, " $1");
   }
 };
@@ -31,6 +46,14 @@ var _UnauthorizedException = class _UnauthorizedException extends ResponseExcept
 };
 __name(_UnauthorizedException, "UnauthorizedException");
 var UnauthorizedException = _UnauthorizedException;
+var _PaymentRequiredException = class _PaymentRequiredException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 402);
+  }
+};
+__name(_PaymentRequiredException, "PaymentRequiredException");
+var PaymentRequiredException = _PaymentRequiredException;
 var _ForbiddenException = class _ForbiddenException extends ResponseException {
   constructor() {
     super(...arguments);
@@ -193,8 +216,7 @@ __name(_NetworkConnectTimeoutException, "NetworkConnectTimeoutException");
 var NetworkConnectTimeoutException = _NetworkConnectTimeoutException;
 
 // src/DI/app-injector.ts
-var _a;
-var AppInjector = (_a = class {
+var _AppInjector = class _AppInjector {
   constructor(name = null) {
     __publicField(this, "name");
     __publicField(this, "bindings", /* @__PURE__ */ new Map());
@@ -207,7 +229,7 @@ var AppInjector = (_a = class {
    * au niveau "scope" (donc durée de vie d'une requête)
    */
   createScope() {
-    const scope = new _a();
+    const scope = new _AppInjector();
     scope.bindings = this.bindings;
     scope.singletons = this.singletons;
     return scope;
@@ -218,7 +240,8 @@ var AppInjector = (_a = class {
    */
   resolve(target) {
     const binding = this.bindings.get(target);
-    if (!binding) throw new InternalServerException(`Failed to resolve a dependency injection : No binding for type ${target.name}`);
+    if (!binding) throw new InternalServerException(`Failed to resolve a dependency injection : No binding for type ${target.name}.
+Did you forget to use @Injectable() decorator ?`);
     switch (binding.lifetime) {
       case "transient":
         return this.instantiate(binding.implementation);
@@ -247,8 +270,14 @@ var AppInjector = (_a = class {
     const params = paramTypes.map((p) => this.resolve(p));
     return new target(...params);
   }
-}, __name(_a, "AppInjector"), _a);
+};
+__name(_AppInjector, "AppInjector");
+var AppInjector = _AppInjector;
 var RootInjector = new AppInjector("root");
+function inject(t) {
+  return RootInjector.resolve(t);
+}
+__name(inject, "inject");
 
 // src/router.ts
 import "reflect-metadata";
@@ -383,7 +412,7 @@ function Authorize(...guardClasses) {
     if (authorizations.has(key)) {
       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);
   };
 }
@@ -546,9 +575,41 @@ function getControllerMetadata(target) {
 }
 __name(getControllerMetadata, "getControllerMetadata");
 
+// src/decorators/middleware.decorator.ts
+var middlewares = /* @__PURE__ */ new Map();
+function UseMiddlewares(mdlw) {
+  return (target, propertyKey) => {
+    let key;
+    if (propertyKey) {
+      const ctrlName = target.constructor.name;
+      const actionName = propertyKey;
+      key = `${ctrlName}.${actionName}`;
+    } else {
+      const ctrlName = target.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);
+  };
+}
+__name(UseMiddlewares, "UseMiddlewares");
+function getMiddlewaresForController(controllerName) {
+  const key = `${controllerName}`;
+  return middlewares.get(key) ?? [];
+}
+__name(getMiddlewaresForController, "getMiddlewaresForController");
+function getMiddlewaresForControllerAction(controllerName, actionName) {
+  const key = `${controllerName}.${actionName}`;
+  return middlewares.get(key) ?? [];
+}
+__name(getMiddlewaresForControllerAction, "getMiddlewaresForControllerAction");
+
 // src/utils/radix-tree.ts
-var _a2;
-var RadixNode = (_a2 = class {
+var _a;
+var RadixNode = (_a = class {
   constructor(segment) {
     __publicField(this, "segment");
     __publicField(this, "children", []);
@@ -573,7 +634,7 @@ var RadixNode = (_a2 = class {
   addChild(node) {
     this.children.push(node);
   }
-}, __name(_a2, "RadixNode"), _a2);
+}, __name(_a, "RadixNode"), _a);
 var _RadixTree = class _RadixTree {
   constructor() {
     __publicField(this, "root", new RadixNode(""));
@@ -660,19 +721,29 @@ __name(_ts_decorate, "_ts_decorate");
 var _Router = class _Router {
   constructor() {
     __publicField(this, "routes", new RadixTree());
+    __publicField(this, "rootMiddlewares", []);
   }
+  /**
+   * 
+   */
   registerController(controllerClass) {
     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}`);
     const routeMetadata = getRouteMetadata(controllerClass);
     for (const def of routeMetadata) {
       const fullPath = `${controllerMeta.path}/${def.path}`.replace(/\/+/g, "/");
       const routeGuards = getGuardForControllerAction(controllerClass.name, def.handler);
+      const routeMiddlewares = getMiddlewaresForControllerAction(controllerClass.name, def.handler);
       const guards = /* @__PURE__ */ new Set([
         ...controllerGuards,
         ...routeGuards
       ]);
+      const middlewares2 = /* @__PURE__ */ new Set([
+        ...controllerMiddlewares,
+        ...routeMiddlewares
+      ]);
       const routeDef = {
         method: def.method,
         path: fullPath,
@@ -680,6 +751,9 @@ var _Router = class _Router {
         handler: def.handler,
         guards: [
           ...guards
+        ],
+        middlewares: [
+          ...middlewares2
         ]
       };
       this.routes.insert(fullPath + "/" + def.method, routeDef);
@@ -692,6 +766,17 @@ var _Router = class _Router {
     Logger.log(`Mapped ${controllerClass.name}${controllerGuardsInfo} controller's routes`);
     return this;
   }
+  /**
+   * 
+   */
+  defineRootMiddleware(middleware) {
+    Logger.debug(`Registering root middleware: ${middleware.name}`);
+    this.rootMiddlewares.push(middleware);
+    return this;
+  }
+  /**
+   * 
+   */
   async handle(request) {
     Logger.log(`> Received request: {${request.method} /${request.path}}`);
     const t0 = performance.now();
@@ -703,10 +788,10 @@ var _Router = class _Router {
     };
     try {
       const routeDef = this.findRoute(request);
-      const controllerInstance = await this.resolveController(request, routeDef);
-      const action = controllerInstance[routeDef.handler];
-      this.verifyRequestBody(request, action);
-      response.body = await action.call(controllerInstance, request, response);
+      await this.resolveController(request, response, routeDef);
+      if (response.status > 400) {
+        throw new ResponseException(response.status, response.error);
+      }
     } catch (error) {
       if (error instanceof ResponseException) {
         response.status = error.status;
@@ -730,6 +815,9 @@ var _Router = class _Router {
       return response;
     }
   }
+  /**
+   * 
+   */
   findRoute(request) {
     const matchedRoutes = this.routes.search(request.path);
     if (matchedRoutes?.node === void 0 || matchedRoutes.node.children.length === 0) {
@@ -741,21 +829,68 @@ var _Router = class _Router {
     }
     return routeDef.value;
   }
-  async resolveController(request, routeDef) {
+  /**
+   * 
+   */
+  async resolveController(request, response, routeDef) {
     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);
-        if (!allowed) throw new UnauthorizedException(`Unauthorized for ${request.method} ${request.path}`);
+    await this.runRequestPipeline(request, response, routeDef, controllerInstance);
+  }
+  /**
+   * 
+   */
+  async runRequestPipeline(request, response, routeDef, controllerInstance) {
+    const middlewares2 = [
+      .../* @__PURE__ */ new Set([
+        ...this.rootMiddlewares,
+        ...routeDef.middlewares
+      ])
+    ];
+    const middlewareMaxIndex = middlewares2.length - 1;
+    const guardsMaxIndex = middlewareMaxIndex + routeDef.guards.length;
+    let index = -1;
+    const dispatch = /* @__PURE__ */ __name(async (i) => {
+      if (i <= index) throw new Error("next() called multiple times");
+      index = i;
+      if (i <= middlewareMaxIndex) {
+        const nextFn = dispatch.bind(null, i + 1);
+        await this.runMiddleware(request, response, nextFn, middlewares2[i]);
+        if (response.status >= 400) {
+          throw new ResponseException(response.status, response.error);
+        }
+        return;
       }
-    }
-    return controllerInstance;
+      if (i <= guardsMaxIndex) {
+        const guardIndex = i - middlewares2.length;
+        const guardType = routeDef.guards[guardIndex];
+        await this.runGuard(request, guardType);
+        dispatch(i + 1);
+        return;
+      }
+      const action = controllerInstance[routeDef.handler];
+      response.body = await action.call(controllerInstance, request, response);
+    }, "dispatch");
+    await dispatch(0);
+  }
+  /**
+   * 
+   */
+  async runMiddleware(request, response, next, middlewareType) {
+    const middleware = request.context.resolve(middlewareType);
+    await middleware.invoke(request, response, next);
   }
-  verifyRequestBody(request, action) {
-    const requiredParams = Reflect.getMetadata("design:paramtypes", action) || [];
+  /**
+   * 
+   */
+  async runGuard(request, guardType) {
+    const guard = request.context.resolve(guardType);
+    const allowed = await guard.canActivate(request);
+    if (!allowed) throw new UnauthorizedException(`Unauthorized for ${request.method} ${request.path}`);
   }
+  /**
+   * 
+   */
   extractParams(actual, template) {
     const aParts = actual.split("/");
     const tParts = template.split("/");
@@ -774,15 +909,13 @@ Router = _ts_decorate([
   Injectable("singleton")
 ], Router);
 
-// src/bootstrap.ts
-import { ipcMain } from "electron";
-import { app, BrowserWindow, MessageChannelMain } from "electron/main";
+// src/app.ts
+import { app, BrowserWindow, ipcMain, MessageChannelMain } from "electron/main";
 
 // src/request.ts
 import "reflect-metadata";
 var _Request = class _Request {
-  constructor(app2, event, id, method, path, body) {
-    __publicField(this, "app");
+  constructor(event, id, method, path, body) {
     __publicField(this, "event");
     __publicField(this, "id");
     __publicField(this, "method");
@@ -790,7 +923,6 @@ var _Request = class _Request {
     __publicField(this, "body");
     __publicField(this, "context", RootInjector.createScope());
     __publicField(this, "params", {});
-    this.app = app2;
     this.event = event;
     this.id = id;
     this.method = method;
@@ -802,69 +934,68 @@ var _Request = class _Request {
 __name(_Request, "Request");
 var Request = _Request;
 
-// src/bootstrap.ts
-async function bootstrapApplication(root, rootModule) {
-  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;
+// src/app.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(bootstrapApplication, "bootstrapApplication");
-var _a3;
-var Nox = (_a3 = class {
-  constructor(root, rootModule) {
-    __publicField(this, "root");
-    __publicField(this, "rootModule");
-    __publicField(this, "messagePort");
-    this.root = root;
-    this.rootModule = rootModule;
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var _NoxApp = class _NoxApp {
+  constructor(router) {
+    __publicField(this, "router");
+    __publicField(this, "messagePorts", /* @__PURE__ */ new Map());
+    __publicField(this, "app");
+    this.router = router;
   }
   /**
    * 
    */
   async init() {
-    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();
+    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 application;
+    return this;
   }
   /**
    * 
    */
-  giveTheClientAPort(application, event) {
-    if (this.messagePort) {
-      this.messagePort.port1.close();
-      this.messagePort.port2.close();
-      this.messagePort = void 0;
+  giveTheRendererAPort(event) {
+    const senderId = event.sender.id;
+    if (this.messagePorts.has(senderId)) {
+      this.shutdownChannel(senderId);
     }
-    this.messagePort = new MessageChannelMain();
-    this.messagePort.port1.on("message", (event2) => this.onClientMessage(application, event2));
-    this.messagePort.port1.start();
-    event.sender.postMessage("port", null, [
-      this.messagePort.port2
+    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.
    */
-  async onClientMessage(application, event) {
-    const { requestId, path, method, body } = event.data;
+  async onRendererMessage(event) {
+    const { senderId, requestId, path, method, body } = 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(application, event, requestId, method, path, body);
-      const router = RootInjector.resolve(Router);
-      const response = await router.handle(request);
-      this.messagePort?.port1.postMessage(response);
+      const request = new Request(event, requestId, method, path, body);
+      const response = await this.router.handle(request);
+      channel.port1.postMessage(response);
     } catch (err) {
       const response = {
         requestId,
@@ -872,29 +1003,82 @@ var Nox = (_a3 = class {
         body: null,
         error: err.message || "Internal Server Error"
       };
-      this.messagePort?.port1.postMessage(response);
+      channel.port1.postMessage(response);
     }
   }
   /**
-   * 
+   * MacOS specific behavior.
    */
-  onAppActivated(application) {
-    if (BrowserWindow.getAllWindows().length === 0) {
-      application.onReady();
+  onAppActivated() {
+    if (process.platform === "darwin" && BrowserWindow.getAllWindows().length === 0) {
+      this.app?.onActivated();
     }
   }
+  shutdownChannel(channelSenderId, remove = true) {
+    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);
+  }
   /**
    * 
    */
-  async onAllWindowsClosed(application) {
-    this.messagePort?.port1.close();
-    await application.dispose();
+  async onAllWindowsClosed() {
+    this.messagePorts.forEach((channel, senderId) => {
+      this.shutdownChannel(senderId, false);
+    });
+    this.messagePorts.clear();
+    this.app?.dispose();
     if (process.platform !== "darwin") {
       app.quit();
     }
   }
-}, __name(_a3, "Nox"), _a3);
+  // ---
+  configure(app3) {
+    this.app = inject(app3);
+    return this;
+  }
+  use(middleware) {
+    this.router.defineRootMiddleware(middleware);
+    return this;
+  }
+  /**
+   * Should be called after the bootstrapApplication function is called.
+   */
+  start() {
+    this.app?.onReady();
+    return this;
+  }
+};
+__name(_NoxApp, "NoxApp");
+var NoxApp = _NoxApp;
+NoxApp = _ts_decorate2([
+  Injectable("singleton"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof Router === "undefined" ? Object : Router
+  ])
+], NoxApp);
+
+// src/bootstrap.ts
+import { app as app2 } from "electron/main";
+async function bootstrapApplication(rootModule) {
+  if (!getModuleMetadata(rootModule)) {
+    throw new Error(`Root module must be decorated with @Module`);
+  }
+  await app2.whenReady();
+  const noxApp = inject(NoxApp);
+  await noxApp.init();
+  return noxApp;
+}
+__name(bootstrapApplication, "bootstrapApplication");
 export {
+  AppInjector,
   Authorize,
   BadGatewayException,
   BadRequestException,
@@ -921,7 +1105,9 @@ export {
   NotExtendedException,
   NotFoundException,
   NotImplementedException,
+  NoxApp,
   Patch,
+  PaymentRequiredException,
   Post,
   Put,
   ROUTE_METADATA_KEY,
@@ -934,13 +1120,22 @@ export {
   TooManyRequestsException,
   UnauthorizedException,
   UpgradeRequiredException,
+  UseMiddlewares,
   VariantAlsoNegotiatesException,
   bootstrapApplication,
   getControllerMetadata,
   getGuardForController,
   getGuardForControllerAction,
   getInjectableMetadata,
+  getMiddlewaresForController,
+  getMiddlewaresForControllerAction,
   getModuleMetadata,
-  getRouteMetadata
+  getRouteMetadata,
+  inject
 };
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
 //# sourceMappingURL=noxus.mjs.map