@ozdao/martyrs 0.2.475 → 0.2.476

package/src/modules/community/components/layouts/Community.vue

@@ -3,7 +3,7 @@
 		<section class="w-100 h-100 o-hidden flex-nowrap flex gap-thin mobile:pd-zero pd-thin pos-relative">
 
 			<div style="flex: 1 1 auto" class="w-100 o-y-scroll h-100 pos-relative">
-				<header v-if="!route.params.url && route.name !== 'Create BlogPost'" class="bg-light pd-medium radius-medium mobile:radius-zero o-x-scroll scroll-hide o-y-visible t-black pos-relative  mn-b-thin flex-v-center t-left flex-nowrap flex">
+				<header v-if="!route.params.url && route.name !== 'Create BlogPost'" class="bg-light pd-medium radius-medium mobile:radius-zero scroll-hide o-y-visible t-black pos-relative  mn-b-thin flex-v-center t-left flex-nowrap flex">
 		    	<h2 class="pos-relative t-nowrap flex-v-center flex-nowrap flex">
 		    		<span class="mn-r-thin">Posts for </span>
 
@@ -20,6 +20,7 @@
 			        	radius-medium
 			          h2
 			         	t-center
+			         	flex-column flex gap-medium 
 			        "
 			      />
 		    	</h2>
@@ -81,7 +82,7 @@
 				</router-view>
 			</div>
 
-			<div style="flex: 1 1 auto" class="desktop-only o-y-scroll h-100  w-40 h-100 pos-relative ">
+			<div style="flex: 1 1 auto" class="desktop-only scroll-hide o-y-scroll h-100  w-40 h-100 pos-relative ">
 				<div class="radius-medium bg-light mn-b-thin pd-small">
 					<div class="gap-thin flex-nowrap flex">
 						<p class="t-medium mn-b-small">Latest Comments</p>
@@ -103,8 +104,8 @@
 		    </div>
 
 	      <div class="radius-medium bg-light pd-small">
-					<div class="gap-thin flex-nowrap flex">
-						<p class="t-medium mn-b-small">Popular Communities</p>
+					<div class="gap-thin flex-nowrap flex  mn-b-small">
+						<p class="text-box-trim-end t-medium">Popular Communities</p>
 						
 						<router-link 
 							v-if="auth.state.user._id"

package/src/modules/community/components/pages/CreateBlogPost.vue

@@ -51,14 +51,14 @@
         class="mn-b-small"
       />
 
-      <h5 class="mn-b-thin">Add source:</h5>
+      <h5 class="mn-b-small">Add source:</h5>
       <Field 
         v-model:field="post.source"    
         placeholder="Add full link to the source" 
         class="mn-b-medium bg-light radius-medium pd-small" 
       />
 
-      <h5 class="mn-b-thin">Add to public</h5>
+      <h5 class="mn-b-small">Add to public</h5>
       <Card
         v-if="selectedOrganization"
         :photo="selectedOrganization.profile?.photo"

package/src/modules/events/components/pages/EditEvent.vue

@@ -98,7 +98,7 @@
         class="mn-b-small"
       />
 
-      <h5 class="mn-b-thin">Add to public</h5>
+      <h5 class="mn-b-small">Add to public</h5>
       <Card
         v-if="selectedOrganization"
         :photo="selectedOrganization.profile?.photo"

package/src/modules/globals/controllers/classes/globals.websocket.js

@@ -1,68 +1,165 @@
-const { WebSocketServer } = require('ws');
+const uWS = require('uWebSockets.js');
 const jwt = require('jsonwebtoken');
+const cookie = require('cookie');
 
 class WebSocketManager {
-  constructor(server) {
-    this.wss = new WebSocketServer({
-      server,
-      verifyClient: this.verifyClient.bind(this)
-    });
-
+  constructor() {
+    // Создаем uWebSockets.js приложение внутри класса
+    this.app = uWS.App();
     this.modules = new Map();
     this.userConnections = new Map();
-
-    this.wss.on('connection', (ws, req) => {
-      ws.userId = req.userId || null;
-      ws.subscriptions = new Set();
-
-      if (ws.userId) {
-        this._trackUserConnection(ws.userId, ws);
-      }
-
-      ws.on('message', async (rawMessage) => {
+    
+    // Добавляем контейнер для RPC методов
+    this.rpcMethods = new Map();
+    
+    // Настраиваем WebSocket обработчик
+    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;
+        
+        // Получаем cookies и все необходимые заголовки из HTTP-запроса
+        const headers = {};
+        req.forEach((key, value) => {
+          headers[key.toLowerCase()] = value;
+        });
+        
+        // Собираем заголовки для WebSocket-протокола один раз
+        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);
+        
+        // Если авторизация требуется, но 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 = new Set();
+        
+        // Отслеживаем соединение, если есть userId
+        if (ws.userId) {
+          this._trackUserConnection(ws.userId, ws);
+        }
+      },
+      
+      // Обработчик входящих сообщений
+      message: async (ws, message, isBinary) => {
+        if (!isBinary) {
+          try {
+            // Более эффективная обработка ArrayBuffer
+            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;
+            }
+            
+            // Обработка RPC вызова
+            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) {
@@ -76,49 +173,217 @@ class WebSocketManager {
     this.modules.set(moduleName, handler);
   }
 
+  // Добавляем методы для регистрации RPC
+  registerRpcMethod(moduleName, methodName, handler, options = {}) {
+    const fullMethodName = `${moduleName}.${methodName}`;
+    
+    if (!this.rpcMethods.has(moduleName)) {
+      this.rpcMethods.set(moduleName, 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: -32000,
+        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: (result) => this._sendRpcResponse(ws, id, result),
+        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);
-
+    
     if (!sockets) {
       console.log(`No sockets found for user ${userIdStr}`);
       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); // false = not binary
+          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) {
-     const sockets = 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;
   }
 }
 
-module.exports = WebSocketManager;
+module.exports = WebSocketManager;

package/src/modules/globals/controllers/classes/globals.websocket.ws.js

@@ -0,0 +1,124 @@
+const { WebSocketServer } = require('ws');
+const jwt = require('jsonwebtoken');
+
+class WebSocketManager {
+  constructor(server) {
+    this.wss = new WebSocketServer({
+      server,
+      verifyClient: this.verifyClient.bind(this)
+    });
+
+    this.modules = new Map();
+    this.userConnections = new Map();
+
+    this.wss.on('connection', (ws, req) => {
+      ws.userId = req.userId || null;
+      ws.subscriptions = new Set();
+
+      if (ws.userId) {
+        this._trackUserConnection(ws.userId, ws);
+      }
+
+      ws.on('message', async (rawMessage) => {
+        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);
+          }
+        } catch (err) {
+          console.error('Invalid message or handler error:', 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);
+          }
+        }
+      });
+    });
+  }
+
+  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);
+  }
+
+  _trackUserConnection(userId, ws) {
+    if (!this.userConnections.has(userId)) {
+      this.userConnections.set(userId, new Set());
+    }
+    this.userConnections.get(userId).add(ws);
+  }
+
+  registerModule(moduleName, handler) {
+    this.modules.set(moduleName, handler);
+  }
+
+  sendToUserInModule(moduleName, userId, data) {
+    const userIdStr = userId.toString();
+
+    const sockets = this.userConnections.get(userIdStr);
+
+    if (!sockets) {
+      console.log(`No sockets found for user ${userIdStr}`);
+      return false;
+    }
+
+    let sent = false;
+    for (const ws of sockets) {
+
+      if (ws.readyState === 1 && ws.subscriptions.has(moduleName)) {
+        ws.send(JSON.stringify(data));
+        sent = true;
+      }
+    }
+    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));
+      }
+    }
+  }
+
+  broadcastToModuleWithFilter(moduleName, filterFn, data) {
+     const sockets = 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));
+    }
+  }
+
+  getServer() {
+    return this.wss;
+  }
+}
+
+module.exports = WebSocketManager;