@noxfly/noxus 1.0.4 → 1.1.0

package/dist/noxus.js

@@ -1,3 +1,8 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -23,6 +28,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AppInjector: () => AppInjector,
   Authorize: () => Authorize,
   BadGatewayException: () => BadGatewayException,
   BadRequestException: () => BadRequestException,
@@ -49,7 +55,9 @@ __export(src_exports, {
   NotExtendedException: () => NotExtendedException,
   NotFoundException: () => NotFoundException,
   NotImplementedException: () => NotImplementedException,
+  NoxApp: () => NoxApp,
   Patch: () => Patch,
+  PaymentRequiredException: () => PaymentRequiredException,
   Post: () => Post,
   Put: () => Put,
   ROUTE_METADATA_KEY: () => ROUTE_METADATA_KEY,
@@ -62,14 +70,18 @@ __export(src_exports, {
   TooManyRequestsException: () => TooManyRequestsException,
   UnauthorizedException: () => UnauthorizedException,
   UpgradeRequiredException: () => UpgradeRequiredException,
+  UseMiddlewares: () => UseMiddlewares,
   VariantAlsoNegotiatesException: () => VariantAlsoNegotiatesException,
   bootstrapApplication: () => bootstrapApplication,
   getControllerMetadata: () => getControllerMetadata,
   getGuardForController: () => getGuardForController,
   getGuardForControllerAction: () => getGuardForControllerAction,
   getInjectableMetadata: () => getInjectableMetadata,
+  getMiddlewaresForController: () => getMiddlewaresForController,
+  getMiddlewaresForControllerAction: () => getMiddlewaresForControllerAction,
   getModuleMetadata: () => getModuleMetadata,
-  getRouteMetadata: () => getRouteMetadata
+  getRouteMetadata: () => getRouteMetadata,
+  inject: () => inject
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -78,8 +90,18 @@ var import_reflect_metadata = require("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");
   }
 };
@@ -101,6 +123,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);
@@ -263,8 +293,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());
@@ -277,7 +306,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;
@@ -288,7 +317,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);
@@ -317,8 +347,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
 var import_reflect_metadata2 = require("reflect-metadata");
@@ -453,7 +489,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);
   };
 }
@@ -616,9 +652,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", []);
@@ -643,7 +711,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(""));
@@ -730,19 +798,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,
@@ -750,6 +828,9 @@ var _Router = class _Router {
         handler: def.handler,
         guards: [
           ...guards
+        ],
+        middlewares: [
+          ...middlewares2
         ]
       };
       this.routes.insert(fullPath + "/" + def.method, routeDef);
@@ -762,6 +843,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();
@@ -773,10 +865,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;
@@ -800,6 +892,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) {
@@ -811,21 +906,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("/");
@@ -844,15 +986,13 @@ Router = _ts_decorate([
   Injectable("singleton")
 ], Router);
 
-// src/bootstrap.ts
-var import_electron = require("electron");
+// src/app.ts
 var import_main = require("electron/main");
 
 // src/request.ts
 var import_reflect_metadata3 = require("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");
@@ -860,7 +1000,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;
@@ -872,69 +1011,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 import_main.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);
-    import_electron.ipcMain.on("gimme-my-port", this.giveTheClientAPort.bind(this, application));
-    import_main.app.once("activate", this.onAppActivated.bind(this, application));
-    import_main.app.once("window-all-closed", this.onAllWindowsClosed.bind(this, application));
-    await application.onReady();
+    import_main.ipcMain.on("gimme-my-port", this.giveTheRendererAPort.bind(this));
+    import_main.app.once("activate", this.onAppActivated.bind(this));
+    import_main.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 import_main.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 import_main.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,
@@ -942,30 +1080,83 @@ 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 (import_main.BrowserWindow.getAllWindows().length === 0) {
-      application.onReady();
+  onAppActivated() {
+    if (process.platform === "darwin" && import_main.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") {
       import_main.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
+var import_main2 = require("electron/main");
+async function bootstrapApplication(rootModule) {
+  if (!getModuleMetadata(rootModule)) {
+    throw new Error(`Root module must be decorated with @Module`);
+  }
+  await import_main2.app.whenReady();
+  const noxApp = inject(NoxApp);
+  await noxApp.init();
+  return noxApp;
+}
+__name(bootstrapApplication, "bootstrapApplication");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AppInjector,
   Authorize,
   BadGatewayException,
   BadRequestException,
@@ -992,7 +1183,9 @@ var Nox = (_a3 = class {
   NotExtendedException,
   NotFoundException,
   NotImplementedException,
+  NoxApp,
   Patch,
+  PaymentRequiredException,
   Post,
   Put,
   ROUTE_METADATA_KEY,
@@ -1005,13 +1198,22 @@ var Nox = (_a3 = class {
   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.js.map