@noxfly/noxus 1.1.9 → 1.2.0

package/dist/{noxus.mjs → main.mjs}

@@ -622,6 +622,45 @@ 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;
+var RENDERER_EVENT_TYPE = "noxus:event";
+function createRendererEventMessage(event, payload) {
+  return {
+    type: RENDERER_EVENT_TYPE,
+    event,
+    payload
+  };
+}
+__name(createRendererEventMessage, "createRendererEventMessage");
+function isRendererEventMessage(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const possibleMessage = value;
+  return possibleMessage.type === RENDERER_EVENT_TYPE && typeof possibleMessage.event === "string";
+}
+__name(isRendererEventMessage, "isRendererEventMessage");
+
 // src/utils/radix-tree.ts
 var _a;
 var RadixNode = (_a = class {
@@ -787,6 +826,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 +905,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 +954,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.
@@ -1035,46 +1179,106 @@ 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, "");
+// src/socket.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(_ts_decorate2, "_ts_decorate");
+var _NoxSocket = class _NoxSocket {
+  constructor() {
+    __publicField(this, "messagePorts", /* @__PURE__ */ new Map());
+  }
+  register(senderId, channel) {
+    this.messagePorts.set(senderId, channel);
+  }
+  get(senderId) {
+    return this.messagePorts.get(senderId);
+  }
+  unregister(senderId) {
+    this.messagePorts.delete(senderId);
+  }
+  getSenderIds() {
+    return [
+      ...this.messagePorts.keys()
+    ];
+  }
+  emit(eventName, payload, targetSenderIds) {
+    const normalizedEvent = eventName.trim();
+    if (normalizedEvent.length === 0) {
+      throw new Error("Renderer event name must be a non-empty string.");
+    }
+    const recipients = targetSenderIds ?? this.getSenderIds();
+    let delivered = 0;
+    for (const senderId of recipients) {
+      const channel = this.messagePorts.get(senderId);
+      if (!channel) {
+        Logger.warn(`No message channel found for sender ID: ${senderId} while emitting "${normalizedEvent}".`);
+        continue;
+      }
+      try {
+        channel.port1.postMessage(createRendererEventMessage(normalizedEvent, payload));
+        delivered++;
+      } catch (error) {
+        Logger.error(`[Noxus] Failed to emit "${normalizedEvent}" to sender ${senderId}.`, error);
+      }
+    }
+    return delivered;
+  }
+  emitToRenderer(senderId, eventName, payload) {
+    return this.emit(eventName, payload, [
+      senderId
+    ]) > 0;
   }
 };
-__name(_Request, "Request");
-var Request = _Request;
+__name(_NoxSocket, "NoxSocket");
+var NoxSocket = _NoxSocket;
+NoxSocket = _ts_decorate2([
+  Injectable("singleton")
+], NoxSocket);
 
 // src/app.ts
-function _ts_decorate2(decorators, target, key, desc) {
+function _ts_decorate3(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(_ts_decorate2, "_ts_decorate");
+__name(_ts_decorate3, "_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) {
+  constructor(router, socket) {
     __publicField(this, "router");
-    __publicField(this, "messagePorts", /* @__PURE__ */ new Map());
+    __publicField(this, "socket");
     __publicField(this, "app");
+    __publicField(this, "onRendererMessage", /* @__PURE__ */ __name(async (event) => {
+      const { senderId, requestId, path, method, body } = event.data;
+      const channel = this.socket.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) {
+        const response = {
+          requestId,
+          status: 500,
+          body: null,
+          error: err.message || "Internal Server Error"
+        };
+        channel.port1.postMessage(response);
+      }
+    }, "onRendererMessage"));
     this.router = router;
+    this.socket = socket;
   }
   /**
    * Initializes the NoxApp instance.
@@ -1096,44 +1300,19 @@ var _NoxApp = class _NoxApp {
    */
   giveTheRendererAPort(event) {
     const senderId = event.sender.id;
-    if (this.messagePorts.has(senderId)) {
+    if (this.socket.get(senderId)) {
       this.shutdownChannel(senderId);
     }
     const channel = new MessageChannelMain();
-    this.messagePorts.set(senderId, channel);
-    channel.port1.on("message", this.onRendererMessage.bind(this));
+    channel.port1.on("message", this.onRendererMessage);
     channel.port1.start();
+    this.socket.register(senderId, channel);
     event.sender.postMessage("port", {
       senderId
     }, [
       channel.port2
     ]);
   }
-  /**
-   * Electron specific message handling.
-   * Replaces HTTP calls by using Electron's IPC mechanism.
-   */
-  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(event, requestId, method, path, body);
-      const response = await this.router.handle(request);
-      channel.port1.postMessage(response);
-    } catch (err) {
-      const response = {
-        requestId,
-        status: 500,
-        body: null,
-        error: err.message || "Internal Server Error"
-      };
-      channel.port1.postMessage(response);
-    }
-  }
   /**
    * MacOS specific behavior.
    */
@@ -1150,25 +1329,24 @@ var _NoxApp = class _NoxApp {
    * @param remove - Whether to remove the channel from the messagePorts map.
    */
   shutdownChannel(channelSenderId) {
-    const channel = this.messagePorts.get(channelSenderId);
+    const channel = this.socket.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.off("message", this.onRendererMessage);
     channel.port1.close();
     channel.port2.close();
-    this.messagePorts.delete(channelSenderId);
+    this.socket.unregister(channelSenderId);
   }
   /**
    * Handles the application shutdown process.
    * This method is called when all windows are closed, and it cleans up the message channels
    */
   async onAllWindowsClosed() {
-    this.messagePorts.forEach((channel, senderId) => {
+    for (const senderId of this.socket.getSenderIds()) {
       this.shutdownChannel(senderId);
-    });
-    this.messagePorts.clear();
+    }
     Logger.info("All windows closed, shutting down application...");
     await this.app?.dispose();
     if (process.platform !== "darwin") {
@@ -1207,11 +1385,12 @@ var _NoxApp = class _NoxApp {
 };
 __name(_NoxApp, "NoxApp");
 var NoxApp = _NoxApp;
-NoxApp = _ts_decorate2([
+NoxApp = _ts_decorate3([
   Injectable("singleton"),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof Router === "undefined" ? Object : Router
+    typeof Router === "undefined" ? Object : Router,
+    typeof NoxSocket === "undefined" ? Object : NoxSocket
   ])
 ], NoxApp);
 
@@ -1227,6 +1406,86 @@ async function bootstrapApplication(rootModule) {
   return noxApp;
 }
 __name(bootstrapApplication, "bootstrapApplication");
+
+// src/renderer-events.ts
+var _RendererEventRegistry = class _RendererEventRegistry {
+  constructor() {
+    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  /**
+   *
+   */
+  subscribe(eventName, handler) {
+    const normalizedEventName = eventName.trim();
+    if (normalizedEventName.length === 0) {
+      throw new Error("Renderer event name must be a non-empty string.");
+    }
+    const handlers = this.listeners.get(normalizedEventName) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.listeners.set(normalizedEventName, handlers);
+    return {
+      unsubscribe: /* @__PURE__ */ __name(() => this.unsubscribe(normalizedEventName, handler), "unsubscribe")
+    };
+  }
+  /**
+   *
+   */
+  unsubscribe(eventName, handler) {
+    const handlers = this.listeners.get(eventName);
+    if (!handlers) {
+      return;
+    }
+    handlers.delete(handler);
+    if (handlers.size === 0) {
+      this.listeners.delete(eventName);
+    }
+  }
+  /**
+   *
+   */
+  clear(eventName) {
+    if (eventName) {
+      this.listeners.delete(eventName);
+      return;
+    }
+    this.listeners.clear();
+  }
+  /**
+   *
+   */
+  dispatch(message) {
+    const handlers = this.listeners.get(message.event);
+    if (!handlers || handlers.size === 0) {
+      return;
+    }
+    handlers.forEach((handler) => {
+      try {
+        handler(message.payload);
+      } catch (error) {
+        console.error(`[Noxus] Renderer event handler for "${message.event}" threw an error.`, error);
+      }
+    });
+  }
+  /**
+   *
+   */
+  tryDispatchFromMessageEvent(event) {
+    if (!isRendererEventMessage(event.data)) {
+      return false;
+    }
+    this.dispatch(event.data);
+    return true;
+  }
+  /**
+   *
+   */
+  hasHandlers(eventName) {
+    const handlers = this.listeners.get(eventName);
+    return !!handlers && handlers.size > 0;
+  }
+};
+__name(_RendererEventRegistry, "RendererEventRegistry");
+var RendererEventRegistry = _RendererEventRegistry;
 export {
   AppInjector,
   Authorize,
@@ -1256,11 +1515,14 @@ export {
   NotFoundException,
   NotImplementedException,
   NoxApp,
+  NoxSocket,
   Patch,
   PaymentRequiredException,
   Post,
   Put,
+  RENDERER_EVENT_TYPE,
   ROUTE_METADATA_KEY,
+  RendererEventRegistry,
   Request,
   RequestTimeoutException,
   ResponseException,
@@ -1273,6 +1535,7 @@ export {
   UseMiddlewares,
   VariantAlsoNegotiatesException,
   bootstrapApplication,
+  createRendererEventMessage,
   getControllerMetadata,
   getGuardForController,
   getGuardForControllerAction,
@@ -1281,11 +1544,12 @@ export {
   getMiddlewaresForControllerAction,
   getModuleMetadata,
   getRouteMetadata,
-  inject
+  inject,
+  isRendererEventMessage
 };
 /**
  * @copyright 2025 NoxFly
  * @license MIT
  * @author NoxFly
  */
-//# sourceMappingURL=noxus.mjs.map
+//# sourceMappingURL=main.mjs.map

package/dist/renderer.d.mts

@@ -0,0 +1 @@
+export { o as IBatchRequestItem, p as IBatchRequestPayload, q as IBatchResponsePayload, s as IRendererEventMessage, n as IRequest, I as IResponse, r as RENDERER_EVENT_TYPE, v as RendererEventHandler, x as RendererEventRegistry, w as RendererEventSubscription, R as Request, t as createRendererEventMessage, u as isRendererEventMessage } from './index-5OkVPHfI.mjs';

package/dist/renderer.d.ts

@@ -0,0 +1 @@
+export { o as IBatchRequestItem, p as IBatchRequestPayload, q as IBatchResponsePayload, s as IRendererEventMessage, n as IRequest, I as IResponse, r as RENDERER_EVENT_TYPE, v as RendererEventHandler, x as RendererEventRegistry, w as RendererEventSubscription, R as Request, t as createRendererEventMessage, u as isRendererEventMessage } from './index-5OkVPHfI.js';