@ozdao/martyrs 0.2.475 → 0.2.476

package/dist/globals.server.mjs

@@ -1,7 +1,8 @@
 import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
 import { r as requireGlobals_abac } from "./globals.abac-DZpTRxKR.mjs";
-import require$$0 from "ws";
+import require$$0 from "uWebSockets.js";
 import require$$0$1 from "jsonwebtoken";
+import require$$2 from "cookie";
 var globals_policies;
 var hasRequiredGlobals_policies;
 function requireGlobals_policies() {
@@ -112,59 +113,132 @@ var hasRequiredGlobals_websocket;
 function requireGlobals_websocket() {
   if (hasRequiredGlobals_websocket) return globals_websocket;
   hasRequiredGlobals_websocket = 1;
-  const { WebSocketServer } = require$$0;
+  const uWS = require$$0;
   const jwt = require$$0$1;
+  const cookie = require$$2;
   class WebSocketManager {
-    constructor(server) {
-      this.wss = new WebSocketServer({
-        server,
-        verifyClient: this.verifyClient.bind(this)
-      });
+    constructor() {
+      this.app = uWS.App();
       this.modules = /* @__PURE__ */ new Map();
       this.userConnections = /* @__PURE__ */ new Map();
-      this.wss.on("connection", (ws, req) => {
-        ws.userId = req.userId || null;
-        ws.subscriptions = /* @__PURE__ */ new Set();
-        if (ws.userId) {
-          this._trackUserConnection(ws.userId, ws);
-        }
-        ws.on("message", async (rawMessage) => {
+      this.rpcMethods = /* @__PURE__ */ new Map();
+      this.app.ws("/api/ws", {
+        maxPayloadLength: 16 * 1024 * 1024,
+        idleTimeout: 120,
+        compression: uWS.SHARED_COMPRESSOR,
+        maxBackpressure: 1024 * 1024,
+        // Обработчик аутентификации и апгрейда соединения
+        upgrade: (res, req, context) => {
+          let userId = null;
+          const headers = {};
+          req.forEach((key, value) => {
+            headers[key.toLowerCase()] = value;
+          });
+          const secWebSocketKey = headers["sec-websocket-key"] || "";
+          const secWebSocketProtocol = headers["sec-websocket-protocol"] || "";
+          const secWebSocketExtensions = headers["sec-websocket-extensions"] || "";
           try {
-            const msg = JSON.parse(rawMessage);
-            if (msg.type === "subscribe" && msg.module && this.modules.has(msg.module)) {
-              ws.subscriptions.add(msg.module);
-              return;
-            }
-            const moduleName = msg.module;
-            if (moduleName && this.modules.has(moduleName)) {
-              const handler = this.modules.get(moduleName);
-              await handler(ws, msg);
+            if (headers.cookie) {
+              const cookies = cookie.parse(headers.cookie);
+              if (cookies.user) {
+                const token = JSON.parse(decodeURIComponent(cookies.user));
+                const decoded = jwt.verify(token.accessToken, process.env.SECRET_KEY);
+                userId = decoded._id;
+              }
             }
           } catch (err) {
-            console.error("Invalid message or handler error:", err);
+            console.error("Invalid token:", err);
           }
-        });
-        ws.on("close", () => {
-          if (ws.userId && this.userConnections.has(ws.userId)) {
-            this.userConnections.get(ws.userId).delete(ws);
-            if (this.userConnections.get(ws.userId).size === 0) {
-              this.userConnections.delete(ws.userId);
+          if (process.env.REQUIRE_AUTH === "true" && !userId) {
+            res.writeStatus("401 Unauthorized").end("Authentication required");
+            return;
+          }
+          const userData = { userId };
+          res.upgrade(
+            userData,
+            secWebSocketKey,
+            secWebSocketProtocol,
+            secWebSocketExtensions,
+            context
+          );
+        },
+        // Обработчик открытия соединения
+        open: (ws) => {
+          ws.userId = ws.getUserData().userId;
+          ws.subscriptions = /* @__PURE__ */ new Set();
+          if (ws.userId) {
+            this._trackUserConnection(ws.userId, ws);
+          }
+        },
+        // Обработчик входящих сообщений
+        message: async (ws, message, isBinary) => {
+          if (!isBinary) {
+            try {
+              const msgStr = new TextDecoder().decode(message);
+              const msg = JSON.parse(msgStr);
+              if (msg.type === "subscribe" && msg.module && this.modules.has(msg.module)) {
+                ws.subscriptions.add(msg.module);
+                return;
+              } else if (msg.type === "unsubscribe" && msg.module) {
+                ws.subscriptions.delete(msg.module);
+                return;
+              }
+              if (msg.type === "rpc") {
+                await this._handleRpcCall(ws, msg);
+                return;
+              }
+              const moduleName = msg.module;
+              if (moduleName && this.modules.has(moduleName)) {
+                const handler = this.modules.get(moduleName);
+                Promise.resolve(handler(ws, msg)).catch((err) => {
+                  console.error(`Error in handler for module ${moduleName}:`, err);
+                });
+              }
+            } catch (err) {
+              console.error("Invalid message or handler error:", err);
+              if (err instanceof Error) {
+                try {
+                  ws.send(JSON.stringify({
+                    type: "error",
+                    error: {
+                      message: err.message,
+                      code: err.code || "INTERNAL_ERROR"
+                    }
+                  }), false);
+                } catch (sendErr) {
+                  console.error("Error sending error response:", sendErr);
+                }
+              }
             }
           }
-        });
+        },
+        // Обработчик закрытия соединения
+        close: (ws, code, message) => {
+          const userId = ws.userId;
+          if (userId && this.userConnections.has(userId)) {
+            this.userConnections.get(userId).delete(ws);
+            if (this.userConnections.get(userId).size === 0) {
+              this.userConnections.delete(userId);
+            }
+          }
+          if (ws.subscriptions && typeof ws.subscriptions.clear === "function") {
+            ws.subscriptions.clear();
+          }
+        }
       });
+      this.listenSocket = null;
     }
-    verifyClient(info, done) {
-      try {
-        const userCookie = info.req.headers.cookie?.split("; ").find((c) => c.startsWith("user="));
-        if (!userCookie) return done(true);
-        const token = JSON.parse(decodeURIComponent(userCookie.replace("user=", "")));
-        const decoded = jwt.verify(token.accessToken, process.env.SECRET_KEY);
-        info.req.userId = decoded._id;
-      } catch (err) {
-        console.error("Invalid token:", err);
-      }
-      done(true);
+    // Метод для запуска сервера
+    listen(port, callback) {
+      this.app.listen(port, (listenSocket) => {
+        if (listenSocket) {
+          this.listenSocket = listenSocket;
+          if (callback) callback(null, this.app);
+        } else {
+          if (callback) callback(new Error("Failed to listen"), null);
+        }
+      });
+      return this;
     }
     _trackUserConnection(userId, ws) {
       if (!this.userConnections.has(userId)) {
@@ -175,6 +249,101 @@ function requireGlobals_websocket() {
     registerModule(moduleName, handler) {
       this.modules.set(moduleName, handler);
     }
+    // Добавляем методы для регистрации RPC
+    registerRpcMethod(moduleName, methodName, handler, options = {}) {
+      const fullMethodName = `${moduleName}.${methodName}`;
+      if (!this.rpcMethods.has(moduleName)) {
+        this.rpcMethods.set(moduleName, /* @__PURE__ */ new Map());
+      }
+      this.rpcMethods.get(moduleName).set(methodName, {
+        handler,
+        options: {
+          requireAuth: options.requireAuth !== false,
+          // По умолчанию true
+          validateParams: options.validateParams || null,
+          rateLimit: options.rateLimit || null,
+          ...options
+        }
+      });
+      console.log(`RPC method registered: ${fullMethodName}`);
+      return this;
+    }
+    // Метод для регистрации группы RPC методов из модуля
+    registerRpcMethods(moduleName, methodsMap) {
+      for (const [methodName, config] of Object.entries(methodsMap)) {
+        const handler = typeof config === "function" ? config : config.handler;
+        const options = typeof config === "function" ? {} : config.options || {};
+        this.registerRpcMethod(moduleName, methodName, handler, options);
+      }
+      return this;
+    }
+    // Обработчик RPC вызовов
+    async _handleRpcCall(ws, message) {
+      const { module, method, params, id } = message;
+      if (!this.rpcMethods.has(module) || !this.rpcMethods.get(module).has(method)) {
+        this._sendRpcResponse(ws, id, null, {
+          code: -32601,
+          message: `Method ${module}.${method} not found`
+        });
+        return;
+      }
+      const { handler, options } = this.rpcMethods.get(module).get(method);
+      if (options.requireAuth && !ws.userId) {
+        this._sendRpcResponse(ws, id, null, {
+          code: -32e3,
+          message: "Authentication required"
+        });
+        return;
+      }
+      if (options.validateParams && !options.validateParams(params)) {
+        this._sendRpcResponse(ws, id, null, {
+          code: -32602,
+          message: "Invalid params"
+        });
+        return;
+      }
+      try {
+        const context = {
+          userId: ws.userId,
+          ws,
+          sendResponse: (result2) => this._sendRpcResponse(ws, id, result2),
+          sendError: (error) => this._sendRpcResponse(ws, id, null, error)
+        };
+        const result = await handler.call(context, params, context);
+        if (!context.responseSent) {
+          this._sendRpcResponse(ws, id, result);
+        }
+      } catch (error) {
+        console.error(`Error executing RPC method ${module}.${method}:`, error);
+        this._sendRpcResponse(ws, id, null, {
+          code: -32603,
+          message: error.message || "Internal error"
+        });
+      }
+    }
+    // Отправка ответа на RPC запрос
+    _sendRpcResponse(ws, id, result, error = null) {
+      if (ws.context?.responseSent) return;
+      if (ws.context) ws.context.responseSent = true;
+      const response = {
+        type: "rpc_response",
+        id
+      };
+      if (error) {
+        response.error = {
+          code: error.code || -32603,
+          message: error.message || "Internal error",
+          data: error.data
+        };
+      } else {
+        response.result = result;
+      }
+      try {
+        ws.send(JSON.stringify(response), false);
+      } catch (err) {
+        console.error("Error sending RPC response:", err);
+      }
+    }
     sendToUserInModule(moduleName, userId, data) {
       const userIdStr = userId.toString();
       const sockets = this.userConnections.get(userIdStr);
@@ -183,32 +352,71 @@ function requireGlobals_websocket() {
         return false;
       }
       let sent = false;
+      const message = JSON.stringify(data);
       for (const ws of sockets) {
-        if (ws.readyState === 1 && ws.subscriptions.has(moduleName)) {
-          ws.send(JSON.stringify(data));
-          sent = true;
+        if (ws.subscriptions.has(moduleName)) {
+          try {
+            const ok = ws.send(message, false);
+            if (!ok) {
+              console.warn("WebSocket backpressure exceeded for user:", userIdStr);
+            } else {
+              sent = true;
+            }
+          } catch (err) {
+            console.warn("Failed to send message to user:", userIdStr, err);
+          }
         }
       }
       return sent;
     }
     broadcastToModule(moduleName, data) {
-      for (const ws of this.wss.clients) {
-        if (ws.readyState === 1 && ws.subscriptions.has(moduleName)) {
-          ws.send(JSON.stringify(data));
+      const message = JSON.stringify(data);
+      let failedSends = 0;
+      for (const sockets of this.userConnections.values()) {
+        for (const ws of sockets) {
+          if (ws.subscriptions.has(moduleName)) {
+            try {
+              const ok = ws.send(message, false);
+              if (!ok) {
+                failedSends++;
+              }
+            } catch (err) {
+              failedSends++;
+              console.warn("Failed to broadcast message:", err);
+            }
+          }
         }
       }
+      if (failedSends > 0) {
+        console.warn(`Failed to send broadcast to ${failedSends} connections due to backpressure or closed sockets`);
+      }
+      return true;
     }
     broadcastToModuleWithFilter(moduleName, filterFn, data) {
-      this.userConnections;
-      for (const ws of this.wss.clients) {
-        if (ws.readyState !== 1) continue;
-        if (!ws.subscriptions.has(moduleName)) continue;
-        if (!filterFn(ws)) continue;
-        ws.send(JSON.stringify(data));
+      const message = JSON.stringify(data);
+      let failedSends = 0;
+      for (const sockets of this.userConnections.values()) {
+        for (const ws of sockets) {
+          if (!ws.subscriptions.has(moduleName)) continue;
+          if (!filterFn(ws)) continue;
+          try {
+            const ok = ws.send(message, false);
+            if (!ok) {
+              failedSends++;
+            }
+          } catch (err) {
+            failedSends++;
+            console.warn("Failed to send filtered broadcast:", err);
+          }
+        }
+      }
+      if (failedSends > 0) {
+        console.warn(`Failed to send filtered broadcast to ${failedSends} connections due to backpressure or closed sockets`);
       }
+      return true;
     }
     getServer() {
-      return this.wss;
+      return this.app;
     }
   }
   globals_websocket = WebSocketManager;