@noxfly/noxus 1.1.9 → 1.1.10

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "typescript.tsdk": "node_modules\\typescript\\lib"
+}

package/dist/noxus.d.mts

@@ -86,7 +86,11 @@ interface IRouteMetadata {
 /**
  * The different HTTP methods that can be used in the application.
  */
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'BATCH';
+/**
+ * Atomic HTTP verbs supported by controllers. BATCH is handled at the router level only.
+ */
+type AtomicHttpMethod = Exclude<HttpMethod, 'BATCH'>;
 /**
  * Gets the route metadata for a given target class.
  * This metadata includes the HTTP method, path, handler, and guards defined by the route decorators.
@@ -152,24 +156,36 @@ declare class Request {
  * It includes properties for the sender ID, request ID, path, method, and an optional body.
  * This interface is used to standardize the request data across the application.
  */
-interface IRequest<T = any> {
+interface IRequest<TBody = unknown> {
     senderId: number;
     requestId: string;
     path: string;
     method: HttpMethod;
-    body?: T;
+    body?: TBody;
+}
+interface IBatchRequestItem<TBody = unknown> {
+    requestId?: string;
+    path: string;
+    method: AtomicHttpMethod;
+    body?: TBody;
+}
+interface IBatchRequestPayload {
+    requests: IBatchRequestItem[];
 }
 /**
  * Creates a Request object from the IPC event data.
  * This function extracts the necessary information from the IPC event and constructs a Request instance.
  */
-interface IResponse<T = any> {
+interface IResponse<TBody = unknown> {
     requestId: string;
     status: number;
-    body?: T;
+    body?: TBody;
     error?: string;
     stack?: string;
 }
+interface IBatchResponsePayload {
+    responses: IResponse[];
+}
 
 
 /**
@@ -291,6 +307,10 @@ declare class Router {
      * @param channelSenderId - The ID of the sender channel to shut down.
      */
     handle(request: Request): Promise<IResponse>;
+    private handleAtomic;
+    private handleBatch;
+    private normalizeBatchPayload;
+    private normalizeBatchItem;
     /**
      * Finds the route definition for a given request.
      * This method searches the routing tree for a matching route based on the request's path and method.
@@ -650,4 +670,4 @@ declare namespace Logger {
     };
 }
 
-export { AppInjector, Authorize, BadGatewayException, BadRequestException, CONTROLLER_METADATA_KEY, ConflictException, Controller, type ControllerAction, Delete, ForbiddenException, GatewayTimeoutException, Get, type HttpMethod, HttpVersionNotSupportedException, type IApp, type IBinding, type IControllerMetadata, type IGuard, type IMiddleware, type IModuleMetadata, INJECTABLE_METADATA_KEY, type IRequest, type IResponse, type IRouteDefinition, type IRouteMetadata, Injectable, InsufficientStorageException, InternalServerException, type Lifetime, type LogLevel, Logger, LoopDetectedException, MODULE_METADATA_KEY, type MaybeAsync, MethodNotAllowedException, Module, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, type NextFunction, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, NoxApp, Patch, PaymentRequiredException, Post, Put, ROUTE_METADATA_KEY, Request, RequestTimeoutException, ResponseException, RootInjector, Router, ServiceUnavailableException, TooManyRequestsException, type Type, UnauthorizedException, UpgradeRequiredException, UseMiddlewares, VariantAlsoNegotiatesException, bootstrapApplication, getControllerMetadata, getGuardForController, getGuardForControllerAction, getInjectableMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata, getRouteMetadata, inject };
+export { AppInjector, type AtomicHttpMethod, Authorize, BadGatewayException, BadRequestException, CONTROLLER_METADATA_KEY, ConflictException, Controller, type ControllerAction, Delete, ForbiddenException, GatewayTimeoutException, Get, type HttpMethod, HttpVersionNotSupportedException, type IApp, type IBatchRequestItem, type IBatchRequestPayload, type IBatchResponsePayload, type IBinding, type IControllerMetadata, type IGuard, type IMiddleware, type IModuleMetadata, INJECTABLE_METADATA_KEY, type IRequest, type IResponse, type IRouteDefinition, type IRouteMetadata, Injectable, InsufficientStorageException, InternalServerException, type Lifetime, type LogLevel, Logger, LoopDetectedException, MODULE_METADATA_KEY, type MaybeAsync, MethodNotAllowedException, Module, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, type NextFunction, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, NoxApp, Patch, PaymentRequiredException, Post, Put, ROUTE_METADATA_KEY, Request, RequestTimeoutException, ResponseException, RootInjector, Router, ServiceUnavailableException, TooManyRequestsException, type Type, UnauthorizedException, UpgradeRequiredException, UseMiddlewares, VariantAlsoNegotiatesException, bootstrapApplication, getControllerMetadata, getGuardForController, getGuardForControllerAction, getInjectableMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata, getRouteMetadata, inject };

package/dist/noxus.d.ts

@@ -86,7 +86,11 @@ interface IRouteMetadata {
 /**
  * The different HTTP methods that can be used in the application.
  */
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'BATCH';
+/**
+ * Atomic HTTP verbs supported by controllers. BATCH is handled at the router level only.
+ */
+type AtomicHttpMethod = Exclude<HttpMethod, 'BATCH'>;
 /**
  * Gets the route metadata for a given target class.
  * This metadata includes the HTTP method, path, handler, and guards defined by the route decorators.
@@ -152,24 +156,36 @@ declare class Request {
  * It includes properties for the sender ID, request ID, path, method, and an optional body.
  * This interface is used to standardize the request data across the application.
  */
-interface IRequest<T = any> {
+interface IRequest<TBody = unknown> {
     senderId: number;
     requestId: string;
     path: string;
     method: HttpMethod;
-    body?: T;
+    body?: TBody;
+}
+interface IBatchRequestItem<TBody = unknown> {
+    requestId?: string;
+    path: string;
+    method: AtomicHttpMethod;
+    body?: TBody;
+}
+interface IBatchRequestPayload {
+    requests: IBatchRequestItem[];
 }
 /**
  * Creates a Request object from the IPC event data.
  * This function extracts the necessary information from the IPC event and constructs a Request instance.
  */
-interface IResponse<T = any> {
+interface IResponse<TBody = unknown> {
     requestId: string;
     status: number;
-    body?: T;
+    body?: TBody;
     error?: string;
     stack?: string;
 }
+interface IBatchResponsePayload {
+    responses: IResponse[];
+}
 
 
 /**
@@ -291,6 +307,10 @@ declare class Router {
      * @param channelSenderId - The ID of the sender channel to shut down.
      */
     handle(request: Request): Promise<IResponse>;
+    private handleAtomic;
+    private handleBatch;
+    private normalizeBatchPayload;
+    private normalizeBatchItem;
     /**
      * Finds the route definition for a given request.
      * This method searches the routing tree for a matching route based on the request's path and method.
@@ -650,4 +670,4 @@ declare namespace Logger {
     };
 }
 
-export { AppInjector, Authorize, BadGatewayException, BadRequestException, CONTROLLER_METADATA_KEY, ConflictException, Controller, type ControllerAction, Delete, ForbiddenException, GatewayTimeoutException, Get, type HttpMethod, HttpVersionNotSupportedException, type IApp, type IBinding, type IControllerMetadata, type IGuard, type IMiddleware, type IModuleMetadata, INJECTABLE_METADATA_KEY, type IRequest, type IResponse, type IRouteDefinition, type IRouteMetadata, Injectable, InsufficientStorageException, InternalServerException, type Lifetime, type LogLevel, Logger, LoopDetectedException, MODULE_METADATA_KEY, type MaybeAsync, MethodNotAllowedException, Module, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, type NextFunction, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, NoxApp, Patch, PaymentRequiredException, Post, Put, ROUTE_METADATA_KEY, Request, RequestTimeoutException, ResponseException, RootInjector, Router, ServiceUnavailableException, TooManyRequestsException, type Type, UnauthorizedException, UpgradeRequiredException, UseMiddlewares, VariantAlsoNegotiatesException, bootstrapApplication, getControllerMetadata, getGuardForController, getGuardForControllerAction, getInjectableMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata, getRouteMetadata, inject };
+export { AppInjector, type AtomicHttpMethod, Authorize, BadGatewayException, BadRequestException, CONTROLLER_METADATA_KEY, ConflictException, Controller, type ControllerAction, Delete, ForbiddenException, GatewayTimeoutException, Get, type HttpMethod, HttpVersionNotSupportedException, type IApp, type IBatchRequestItem, type IBatchRequestPayload, type IBatchResponsePayload, type IBinding, type IControllerMetadata, type IGuard, type IMiddleware, type IModuleMetadata, INJECTABLE_METADATA_KEY, type IRequest, type IResponse, type IRouteDefinition, type IRouteMetadata, Injectable, InsufficientStorageException, InternalServerException, type Lifetime, type LogLevel, Logger, LoopDetectedException, MODULE_METADATA_KEY, type MaybeAsync, MethodNotAllowedException, Module, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, type NextFunction, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, NoxApp, Patch, PaymentRequiredException, Post, Put, ROUTE_METADATA_KEY, Request, RequestTimeoutException, ResponseException, RootInjector, Router, ServiceUnavailableException, TooManyRequestsException, type Type, UnauthorizedException, UpgradeRequiredException, UseMiddlewares, VariantAlsoNegotiatesException, bootstrapApplication, getControllerMetadata, getGuardForController, getGuardForControllerAction, getInjectableMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata, getRouteMetadata, inject };

package/dist/noxus.js

@@ -359,7 +359,7 @@ __name(inject, "inject");
 var RootInjector = new AppInjector("root");
 
 // src/router.ts
-var import_reflect_metadata2 = require("reflect-metadata");
+var import_reflect_metadata3 = require("reflect-metadata");
 
 // src/decorators/guards.decorator.ts
 function Authorize(...guardClasses) {
@@ -699,6 +699,28 @@ function getMiddlewaresForControllerAction(controllerName, actionName) {
 __name(getMiddlewaresForControllerAction, "getMiddlewaresForControllerAction");
 var middlewares = /* @__PURE__ */ new Map();
 
+// src/request.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+var _Request = class _Request {
+  constructor(event, id, method, path, body) {
+    __publicField(this, "event");
+    __publicField(this, "id");
+    __publicField(this, "method");
+    __publicField(this, "path");
+    __publicField(this, "body");
+    __publicField(this, "context", RootInjector.createScope());
+    __publicField(this, "params", {});
+    this.event = event;
+    this.id = id;
+    this.method = method;
+    this.path = path;
+    this.body = body;
+    this.path = path.replace(/^\/|\/$/g, "");
+  }
+};
+__name(_Request, "Request");
+var Request = _Request;
+
 // src/utils/radix-tree.ts
 var _a;
 var RadixNode = (_a = class {
@@ -864,6 +886,17 @@ function _ts_decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate, "_ts_decorate");
+var ATOMIC_HTTP_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE"
+]);
+function isAtomicHttpMethod(method) {
+  return typeof method === "string" && ATOMIC_HTTP_METHODS.has(method);
+}
+__name(isAtomicHttpMethod, "isAtomicHttpMethod");
 var _Router = class _Router {
   constructor() {
     __publicField(this, "routes", new RadixTree());
@@ -932,6 +965,12 @@ var _Router = class _Router {
    * @param channelSenderId - The ID of the sender channel to shut down.
    */
   async handle(request) {
+    if (request.method === "BATCH") {
+      return this.handleBatch(request);
+    }
+    return this.handleAtomic(request);
+  }
+  async handleAtomic(request) {
     Logger.comment(`>     ${request.method} /${request.path}`);
     const t0 = performance.now();
     const response = {
@@ -975,6 +1014,94 @@ var _Router = class _Router {
       return response;
     }
   }
+  async handleBatch(request) {
+    Logger.comment(`>     ${request.method} /${request.path}`);
+    const t0 = performance.now();
+    const response = {
+      requestId: request.id,
+      status: 200,
+      body: {
+        responses: []
+      }
+    };
+    try {
+      const payload = this.normalizeBatchPayload(request.body);
+      const batchResponses = [];
+      for (const [index, item] of payload.requests.entries()) {
+        const subRequestId = item.requestId ?? `${request.id}:${index}`;
+        const atomicRequest = new Request(request.event, subRequestId, item.method, item.path, item.body);
+        batchResponses.push(await this.handleAtomic(atomicRequest));
+      }
+      response.body.responses = batchResponses;
+    } catch (error) {
+      response.body = void 0;
+      if (error instanceof ResponseException) {
+        response.status = error.status;
+        response.error = error.message;
+        response.stack = error.stack;
+      } else if (error instanceof Error) {
+        response.status = 500;
+        response.error = error.message || "Internal Server Error";
+        response.stack = error.stack || "No stack trace available";
+      } else {
+        response.status = 500;
+        response.error = "Unknown error occurred";
+        response.stack = "No stack trace available";
+      }
+    } finally {
+      const t1 = performance.now();
+      const message = `< ${response.status} ${request.method} /${request.path} ${Logger.colors.yellow}${Math.round(t1 - t0)}ms${Logger.colors.initial}`;
+      if (response.status < 400) Logger.log(message);
+      else if (response.status < 500) Logger.warn(message);
+      else Logger.error(message);
+      if (response.error !== void 0) {
+        Logger.error(response.error);
+        if (response.stack !== void 0) {
+          Logger.errorStack(response.stack);
+        }
+      }
+      return response;
+    }
+  }
+  normalizeBatchPayload(body) {
+    if (body === null || typeof body !== "object") {
+      throw new BadRequestException("Batch payload must be an object containing a requests array.");
+    }
+    const possiblePayload = body;
+    const { requests } = possiblePayload;
+    if (!Array.isArray(requests)) {
+      throw new BadRequestException("Batch payload must define a requests array.");
+    }
+    const normalizedRequests = requests.map((entry, index) => this.normalizeBatchItem(entry, index));
+    return {
+      requests: normalizedRequests
+    };
+  }
+  normalizeBatchItem(entry, index) {
+    if (entry === null || typeof entry !== "object") {
+      throw new BadRequestException(`Batch request at index ${index} must be an object.`);
+    }
+    const { requestId, path, method, body } = entry;
+    if (requestId !== void 0 && typeof requestId !== "string") {
+      throw new BadRequestException(`Batch request at index ${index} has an invalid requestId.`);
+    }
+    if (typeof path !== "string" || path.length === 0) {
+      throw new BadRequestException(`Batch request at index ${index} must define a non-empty path.`);
+    }
+    if (typeof method !== "string") {
+      throw new BadRequestException(`Batch request at index ${index} must define an HTTP method.`);
+    }
+    const normalizedMethod = method.toUpperCase();
+    if (!isAtomicHttpMethod(normalizedMethod)) {
+      throw new BadRequestException(`Batch request at index ${index} uses the unsupported method ${method}.`);
+    }
+    return {
+      requestId,
+      path,
+      method: normalizedMethod,
+      body
+    };
+  }
   /**
    * Finds the route definition for a given request.
    * This method searches the routing tree for a matching route based on the request's path and method.
@@ -1111,30 +1238,6 @@ Router = _ts_decorate([
 
 // src/app.ts
 var import_main = require("electron/main");
-
-// src/request.ts
-var import_reflect_metadata3 = require("reflect-metadata");
-var _Request = class _Request {
-  constructor(event, id, method, path, body) {
-    __publicField(this, "event");
-    __publicField(this, "id");
-    __publicField(this, "method");
-    __publicField(this, "path");
-    __publicField(this, "body");
-    __publicField(this, "context", RootInjector.createScope());
-    __publicField(this, "params", {});
-    this.event = event;
-    this.id = id;
-    this.method = method;
-    this.path = path;
-    this.body = body;
-    this.path = path.replace(/^\/|\/$/g, "");
-  }
-};
-__name(_Request, "Request");
-var Request = _Request;
-
-// 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);

package/dist/noxus.mjs

@@ -622,6 +622,28 @@ function getMiddlewaresForControllerAction(controllerName, actionName) {
 __name(getMiddlewaresForControllerAction, "getMiddlewaresForControllerAction");
 var middlewares = /* @__PURE__ */ new Map();
 
+// src/request.ts
+import "reflect-metadata";
+var _Request = class _Request {
+  constructor(event, id, method, path, body) {
+    __publicField(this, "event");
+    __publicField(this, "id");
+    __publicField(this, "method");
+    __publicField(this, "path");
+    __publicField(this, "body");
+    __publicField(this, "context", RootInjector.createScope());
+    __publicField(this, "params", {});
+    this.event = event;
+    this.id = id;
+    this.method = method;
+    this.path = path;
+    this.body = body;
+    this.path = path.replace(/^\/|\/$/g, "");
+  }
+};
+__name(_Request, "Request");
+var Request = _Request;
+
 // src/utils/radix-tree.ts
 var _a;
 var RadixNode = (_a = class {
@@ -787,6 +809,17 @@ function _ts_decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate, "_ts_decorate");
+var ATOMIC_HTTP_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE"
+]);
+function isAtomicHttpMethod(method) {
+  return typeof method === "string" && ATOMIC_HTTP_METHODS.has(method);
+}
+__name(isAtomicHttpMethod, "isAtomicHttpMethod");
 var _Router = class _Router {
   constructor() {
     __publicField(this, "routes", new RadixTree());
@@ -855,6 +888,12 @@ var _Router = class _Router {
    * @param channelSenderId - The ID of the sender channel to shut down.
    */
   async handle(request) {
+    if (request.method === "BATCH") {
+      return this.handleBatch(request);
+    }
+    return this.handleAtomic(request);
+  }
+  async handleAtomic(request) {
     Logger.comment(`>     ${request.method} /${request.path}`);
     const t0 = performance.now();
     const response = {
@@ -898,6 +937,94 @@ var _Router = class _Router {
       return response;
     }
   }
+  async handleBatch(request) {
+    Logger.comment(`>     ${request.method} /${request.path}`);
+    const t0 = performance.now();
+    const response = {
+      requestId: request.id,
+      status: 200,
+      body: {
+        responses: []
+      }
+    };
+    try {
+      const payload = this.normalizeBatchPayload(request.body);
+      const batchResponses = [];
+      for (const [index, item] of payload.requests.entries()) {
+        const subRequestId = item.requestId ?? `${request.id}:${index}`;
+        const atomicRequest = new Request(request.event, subRequestId, item.method, item.path, item.body);
+        batchResponses.push(await this.handleAtomic(atomicRequest));
+      }
+      response.body.responses = batchResponses;
+    } catch (error) {
+      response.body = void 0;
+      if (error instanceof ResponseException) {
+        response.status = error.status;
+        response.error = error.message;
+        response.stack = error.stack;
+      } else if (error instanceof Error) {
+        response.status = 500;
+        response.error = error.message || "Internal Server Error";
+        response.stack = error.stack || "No stack trace available";
+      } else {
+        response.status = 500;
+        response.error = "Unknown error occurred";
+        response.stack = "No stack trace available";
+      }
+    } finally {
+      const t1 = performance.now();
+      const message = `< ${response.status} ${request.method} /${request.path} ${Logger.colors.yellow}${Math.round(t1 - t0)}ms${Logger.colors.initial}`;
+      if (response.status < 400) Logger.log(message);
+      else if (response.status < 500) Logger.warn(message);
+      else Logger.error(message);
+      if (response.error !== void 0) {
+        Logger.error(response.error);
+        if (response.stack !== void 0) {
+          Logger.errorStack(response.stack);
+        }
+      }
+      return response;
+    }
+  }
+  normalizeBatchPayload(body) {
+    if (body === null || typeof body !== "object") {
+      throw new BadRequestException("Batch payload must be an object containing a requests array.");
+    }
+    const possiblePayload = body;
+    const { requests } = possiblePayload;
+    if (!Array.isArray(requests)) {
+      throw new BadRequestException("Batch payload must define a requests array.");
+    }
+    const normalizedRequests = requests.map((entry, index) => this.normalizeBatchItem(entry, index));
+    return {
+      requests: normalizedRequests
+    };
+  }
+  normalizeBatchItem(entry, index) {
+    if (entry === null || typeof entry !== "object") {
+      throw new BadRequestException(`Batch request at index ${index} must be an object.`);
+    }
+    const { requestId, path, method, body } = entry;
+    if (requestId !== void 0 && typeof requestId !== "string") {
+      throw new BadRequestException(`Batch request at index ${index} has an invalid requestId.`);
+    }
+    if (typeof path !== "string" || path.length === 0) {
+      throw new BadRequestException(`Batch request at index ${index} must define a non-empty path.`);
+    }
+    if (typeof method !== "string") {
+      throw new BadRequestException(`Batch request at index ${index} must define an HTTP method.`);
+    }
+    const normalizedMethod = method.toUpperCase();
+    if (!isAtomicHttpMethod(normalizedMethod)) {
+      throw new BadRequestException(`Batch request at index ${index} uses the unsupported method ${method}.`);
+    }
+    return {
+      requestId,
+      path,
+      method: normalizedMethod,
+      body
+    };
+  }
   /**
    * Finds the route definition for a given request.
    * This method searches the routing tree for a matching route based on the request's path and method.
@@ -1034,30 +1161,6 @@ Router = _ts_decorate([
 
 // src/app.ts
 import { app, BrowserWindow, ipcMain, MessageChannelMain } from "electron/main";
-
-// src/request.ts
-import "reflect-metadata";
-var _Request = class _Request {
-  constructor(event, id, method, path, body) {
-    __publicField(this, "event");
-    __publicField(this, "id");
-    __publicField(this, "method");
-    __publicField(this, "path");
-    __publicField(this, "body");
-    __publicField(this, "context", RootInjector.createScope());
-    __publicField(this, "params", {});
-    this.event = event;
-    this.id = id;
-    this.method = method;
-    this.path = path;
-    this.body = body;
-    this.path = path.replace(/^\/|\/$/g, "");
-  }
-};
-__name(_Request, "Request");
-var Request = _Request;
-
-// 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noxfly/noxus",
-  "version": "1.1.9",
+  "version": "1.1.10",
   "main": "dist/noxus.js",
   "types": "dist/noxus.d.ts",
   "scripts": {

package/src/decorators/method.decorator.ts

@@ -23,7 +23,12 @@ export interface IRouteMetadata {
 /**
  * The different HTTP methods that can be used in the application.
  */
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'BATCH';
+
+/**
+ * Atomic HTTP verbs supported by controllers. BATCH is handled at the router level only.
+ */
+export type AtomicHttpMethod = Exclude<HttpMethod, 'BATCH'>;
 
 /**
  * The configuration that waits a route's decorator.

package/src/request.ts

@@ -5,7 +5,7 @@
  */
 
 import 'reflect-metadata';
-import { HttpMethod } from 'src/decorators/method.decorator';
+import { AtomicHttpMethod, HttpMethod } from 'src/decorators/method.decorator';
 import { AppInjector, RootInjector } from 'src/DI/app-injector';
 
 /**
@@ -34,22 +34,37 @@ export class Request {
  * It includes properties for the sender ID, request ID, path, method, and an optional body.
  * This interface is used to standardize the request data across the application.
  */
-export interface IRequest<T = any> {
+export interface IRequest<TBody = unknown> {
     senderId: number;
     requestId: string;
     path: string;
     method: HttpMethod;
-    body?: T;
+    body?: TBody;
+}
+
+export interface IBatchRequestItem<TBody = unknown> {
+    requestId?: string;
+    path: string;
+    method: AtomicHttpMethod;
+    body?: TBody;
+}
+
+export interface IBatchRequestPayload {
+    requests: IBatchRequestItem[];
 }
 
 /**
  * Creates a Request object from the IPC event data.
  * This function extracts the necessary information from the IPC event and constructs a Request instance.
  */
-export interface IResponse<T = any> {
+export interface IResponse<TBody = unknown> {
     requestId: string;
     status: number;
-    body?: T;
+    body?: TBody;
     error?: string;
     stack?: string;
 }
+
+export interface IBatchResponsePayload {
+    responses: IResponse[];
+}

package/src/router.ts

@@ -8,14 +8,20 @@ import 'reflect-metadata';
 import { getControllerMetadata } from 'src/decorators/controller.decorator';
 import { getGuardForController, getGuardForControllerAction, IGuard } from 'src/decorators/guards.decorator';
 import { Injectable } from 'src/decorators/injectable.decorator';
-import { getRouteMetadata } from 'src/decorators/method.decorator';
+import { AtomicHttpMethod, getRouteMetadata } from 'src/decorators/method.decorator';
 import { getMiddlewaresForController, getMiddlewaresForControllerAction, IMiddleware, NextFunction } from 'src/decorators/middleware.decorator';
-import { MethodNotAllowedException, NotFoundException, ResponseException, UnauthorizedException } from 'src/exceptions';
-import { IResponse, Request } from 'src/request';
+import { BadRequestException, MethodNotAllowedException, NotFoundException, ResponseException, UnauthorizedException } from 'src/exceptions';
+import { IBatchRequestItem, IBatchRequestPayload, IBatchResponsePayload, IResponse, Request } from 'src/request';
 import { Logger } from 'src/utils/logger';
 import { RadixTree } from 'src/utils/radix-tree';
 import { Type } from 'src/utils/types';
 
+const ATOMIC_HTTP_METHODS: ReadonlySet<AtomicHttpMethod> = new Set<AtomicHttpMethod>(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']);
+
+function isAtomicHttpMethod(method: unknown): method is AtomicHttpMethod {
+    return typeof method === 'string' && ATOMIC_HTTP_METHODS.has(method as AtomicHttpMethod);
+}
+
 /**
  * IRouteDefinition interface defines the structure of a route in the application.
  * It includes the HTTP method, path, controller class, handler method name,
@@ -121,6 +127,14 @@ export class Router {
      * @param channelSenderId - The ID of the sender channel to shut down.
      */
     public async handle(request: Request): Promise<IResponse> {
+        if(request.method === 'BATCH') {
+            return this.handleBatch(request);
+        }
+
+        return this.handleAtomic(request);
+    }
+
+    private async handleAtomic(request: Request): Promise<IResponse> {
         Logger.comment(`>     ${request.method} /${request.path}`);
 
         const t0 = performance.now();
@@ -182,6 +196,122 @@ export class Router {
         }
     }
 
+    private async handleBatch(request: Request): Promise<IResponse> {
+        Logger.comment(`>     ${request.method} /${request.path}`);
+
+        const t0 = performance.now();
+
+        const response: IResponse<IBatchResponsePayload> = {
+            requestId: request.id,
+            status: 200,
+            body: { responses: [] },
+        };
+
+        try {
+            const payload = this.normalizeBatchPayload(request.body);
+            const batchResponses: IResponse[] = [];
+
+            for(const [index, item] of payload.requests.entries()) {
+                const subRequestId = item.requestId ?? `${request.id}:${index}`;
+                const atomicRequest = new Request(request.event, subRequestId, item.method, item.path, item.body);
+                batchResponses.push(await this.handleAtomic(atomicRequest));
+            }
+
+            response.body!.responses = batchResponses;
+        }
+        catch(error: unknown) {
+            response.body = undefined;
+
+            if(error instanceof ResponseException) {
+                response.status = error.status;
+                response.error = error.message;
+                response.stack = error.stack;
+            }
+            else if(error instanceof Error) {
+                response.status = 500;
+                response.error = error.message || 'Internal Server Error';
+                response.stack = error.stack || 'No stack trace available';
+            }
+            else {
+                response.status = 500;
+                response.error = 'Unknown error occurred';
+                response.stack = 'No stack trace available';
+            }
+        }
+        finally {
+            const t1 = performance.now();
+
+            const message = `< ${response.status} ${request.method} /${request.path} ${Logger.colors.yellow}${Math.round(t1 - t0)}ms${Logger.colors.initial}`;
+
+            if(response.status < 400)
+                Logger.log(message);
+            else if(response.status < 500)
+                Logger.warn(message);
+            else
+                Logger.error(message);
+
+            if(response.error !== undefined) {
+                Logger.error(response.error);
+
+                if(response.stack !== undefined) {
+                    Logger.errorStack(response.stack);
+                }
+            }
+
+            return response;
+        }
+    }
+
+    private normalizeBatchPayload(body: unknown): IBatchRequestPayload {
+        if(body === null || typeof body !== 'object') {
+            throw new BadRequestException('Batch payload must be an object containing a requests array.');
+        }
+
+        const possiblePayload = body as Partial<IBatchRequestPayload>;
+        const { requests } = possiblePayload;
+
+        if(!Array.isArray(requests)) {
+            throw new BadRequestException('Batch payload must define a requests array.');
+        }
+
+        const normalizedRequests = requests.map((entry, index) => this.normalizeBatchItem(entry, index));
+
+        return { requests: normalizedRequests };
+    }
+
+    private normalizeBatchItem(entry: unknown, index: number): IBatchRequestItem {
+        if(entry === null || typeof entry !== 'object') {
+            throw new BadRequestException(`Batch request at index ${index} must be an object.`);
+        }
+
+        const { requestId, path, method, body } = entry as Partial<IBatchRequestItem> & { method?: unknown };
+
+        if(requestId !== undefined && typeof requestId !== 'string') {
+            throw new BadRequestException(`Batch request at index ${index} has an invalid requestId.`);
+        }
+
+        if(typeof path !== 'string' || path.length === 0) {
+            throw new BadRequestException(`Batch request at index ${index} must define a non-empty path.`);
+        }
+
+        if(typeof method !== 'string') {
+            throw new BadRequestException(`Batch request at index ${index} must define an HTTP method.`);
+        }
+
+        const normalizedMethod = method.toUpperCase();
+
+        if(!isAtomicHttpMethod(normalizedMethod)) {
+            throw new BadRequestException(`Batch request at index ${index} uses the unsupported method ${method}.`);
+        }
+
+        return {
+            requestId,
+            path,
+            method: normalizedMethod as AtomicHttpMethod,
+            body,
+        };
+    }
+
     /**
      * Finds the route definition for a given request.
      * This method searches the routing tree for a matching route based on the request's path and method.