@ozdao/martyrs 0.2.585 → 0.2.586

package/src/modules/auth/CLAUDE.md

@@ -0,0 +1,381 @@
+# Auth Module
+
+Аутентификация пользователей: JWT + Sessions, OTP-верификация для критичных операций.
+
+## Quick Start
+
+### Клиент
+
+```javascript
+import auth from '@ozdao/martyrs/modules/auth/client'
+auth.initialize(app, store, router)
+```
+
+Запрос с OTP-верификацией:
+
+```javascript
+import { withOtp } from '@ozdao/martyrs/modules/auth/client'
+
+const result = await withOtp(
+  (data) => axios.post('/api/auth/signup', data),
+  { email: 'user@example.com', password: '...' }
+)
+```
+
+### Сервер
+
+```javascript
+import auth from '@ozdao/martyrs/modules/auth/server'
+auth.initialize(app, db, origins, publicPath)
+```
+
+Защита роута OTP-верификацией:
+
+```javascript
+import otpMiddleware from '@ozdao/martyrs/modules/auth/server'
+const { stepUp } = otpMiddleware(db)
+
+app.post('/api/sensitive',
+  stepUp('action-name', req => ({ identifier: req.body.email, type: 'email' })),
+  controller
+)
+```
+
+## Architecture
+
+### Структура модуля
+
+```
+auth/
+├── auth.server.js              # Server entry point
+├── auth.client.js              # Client entry point
+├── models/
+│   ├── user.model.js           # User schema
+│   ├── otp.model.js            # OTP challenges
+│   └── role.model.js           # Roles (user/admin/moderator)
+├── controllers/
+│   ├── routes/
+│   │   ├── auth.routes.js      # /api/auth/* (signin, signup, reset-password)
+│   │   └── users.routes.js     # /api/users/* (profile, email, phone)
+│   ├── services/
+│   │   ├── auth.service.js     # signin, signup, updatePassword
+│   │   ├── users.service.js    # CRUD пользователей
+│   │   └── otp.service.js      # OTP отправка/верификация (Singleton)
+│   └── middlewares/
+│       ├── authJwt.js          # JWT verification, role checks
+│       ├── otp.middleware.js   # stepUp(), dualVerify()
+│       ├── verifySignUp.js     # Проверка дублей при регистрации
+│       └── verifyUser.js       # Ownership, duplicate checks
+└── views/
+    ├── store/
+    │   ├── auth.js             # Auth state (login, logout, initialize)
+    │   └── users.js            # Users CRUD
+    ├── plugins/
+    │   └── otp.plugin.js       # withOtp() + OtpDialog
+    ├── router/
+    │   ├── auth.router.js      # /auth/signin, /auth/signup
+    │   └── users.router.js     # /users/:_id/*
+    └── middlewares/
+        └── auth.validation.js  # requiresAuth, requiresNoAuth guards
+```
+
+### JWT + Session Flow
+
+```
+┌─────────────────┐                         ┌─────────────────┐
+│     Client      │                         │     Server      │
+├─────────────────┤                         ├─────────────────┤
+│                 │   POST /api/auth/signin │                 │
+│  login() ───────┼────────────────────────►│  bcrypt.compare │
+│                 │                         │       │         │
+│                 │                         │       ▼         │
+│                 │                         │  createSession  │
+│                 │                         │       │         │
+│                 │◄─ { accessToken, ... } ─│       ▼         │
+│                 │                         │  jwt.sign()     │
+│  setCookie() ◄──┤                         │                 │
+│  setAuthToken() │                         │                 │
+│                 │                         │                 │
+│                 │   GET /api/protected    │                 │
+│  request ───────┼─ X-Access-Token: jwt ──►│  verifyToken()  │
+│                 │                         │       │         │
+│                 │                         │       ▼         │
+│                 │                         │  validateSession│
+│                 │◄────── response ────────│       │         │
+│                 │                         │       ▼         │
+│                 │                         │  controller     │
+└─────────────────┘                         └─────────────────┘
+```
+
+**Ключевые моменты:**
+- Каждый login создаёт новую сессию в базе
+- JWT содержит `{ _id, session_id }`
+- `verifyToken()` валидирует и JWT, и сессию
+- При смене пароля все сессии деактивируются
+
+### OTP Challenge Flow
+
+```
+┌─────────────────┐                    ┌─────────────────┐
+│     Клиент      │                    │     Сервер      │
+├─────────────────┤                    ├─────────────────┤
+│                 │  1. POST /signup   │                 │
+│  withOtp()  ────┼───────────────────►│  stepUp()       │
+│                 │                    │       │         │
+│                 │◄─ requires_otp ────│       ▼         │
+│                 │   + challengeId    │  sendOtp()      │
+│  OtpDialog  ◄───┤                    │                 │
+│       │         │                    │                 │
+│       ▼         │  2. POST + otp     │                 │
+│  [код] ─────────┼───────────────────►│  verifyOtp()    │
+│                 │                    │       │         │
+│                 │◄─── success ───────│       ▼         │
+│                 │                    │  controller     │
+└─────────────────┘                    └─────────────────┘
+```
+
+**Почему challenge-based:** OTP привязан к `challengeId`, а не к сессии. Это верифицирует операцию, а не пользователя — защита от CSRF и replay-атак.
+
+## API Reference
+
+### Server Middleware
+
+#### stepUp(purpose, getCredentials)
+
+Одиночная OTP-верификация. Используйте для: регистрации, сброса пароля, опасных действий.
+
+```javascript
+stepUp('signup', req => ({
+  identifier: req.body.email,  // куда слать код
+  type: 'email',               // 'email' | 'phone'
+  target: req.userId           // опционально, привязка к пользователю
+}))
+```
+
+#### dualVerify(field)
+
+Двойная верификация при смене контакта. Код отправляется и на старый, и на новый контакт.
+
+```javascript
+app.put('/api/users/:_id/email',
+  authJwt.verifyToken(),
+  dualVerify('email'),
+  controller
+)
+```
+
+#### authJwt.verifyToken(options?)
+
+Проверяет JWT из header `X-Access-Token` или cookie.
+
+```javascript
+// Обязательная авторизация
+app.get('/api/protected', authJwt.verifyToken(), controller)
+
+// Опциональная (не выбрасывает ошибку)
+app.get('/api/public', authJwt.verifyToken({ continueOnFail: true }), controller)
+```
+
+После проверки устанавливает `req.userId` и `req.sessionId`.
+
+#### authJwt.loadUser
+
+Загружает полный объект пользователя в `req.user`.
+
+```javascript
+app.put('/api/users/:_id',
+  authJwt.verifyToken(),
+  authJwt.loadUser,  // req.user теперь доступен
+  controller
+)
+```
+
+#### authJwt.isAdmin / isModerator
+
+Проверяет роль пользователя.
+
+```javascript
+app.delete('/api/users/:_id',
+  authJwt.verifyToken(),
+  authJwt.isAdmin,  // 403 если не admin
+  controller
+)
+```
+
+### Client API
+
+#### withOtp(makeRequest, data)
+
+Wrapper для запросов с OTP. Автоматически показывает диалог при `requires_otp`.
+
+```javascript
+import { withOtp } from '@ozdao/martyrs/modules/auth/client'
+
+// Single OTP
+const result = await withOtp(
+  (data) => axios.post('/api/auth/signup', data),
+  { email, password }
+)
+
+// Dual OTP (смена контакта) — обрабатывается автоматически
+const result = await withOtp(
+  (data) => axios.put(`/api/users/${_id}/email`, data),
+  { email: newEmail }
+)
+```
+
+#### store.auth
+
+```javascript
+import { auth } from '@ozdao/martyrs/modules/auth/client'
+
+// State
+auth.state.user        // { _id, email, phone, avatar, ... }
+auth.state.access      // { roles, token, status }
+
+// Actions
+await auth.initialize()                    // Загрузка из cookie при старте
+await auth.login(credentials, 'email')     // POST /api/auth/signin
+await auth.signup(data, 'email', invite?)  // POST /api/auth/signup с OTP
+auth.logout()                              // Очистка + disconnect WebSocket
+```
+
+#### store.users
+
+```javascript
+import { users } from '@ozdao/martyrs/modules/auth/client'
+
+// State
+users.state.current    // Текущий просматриваемый профиль
+users.state.all        // Список пользователей
+
+// Actions
+await users.read({ _id })              // GET /api/users?_id=...
+await users.read({ search: 'query' })  // Поиск
+await users.update(userData)           // PUT /api/users/:_id (с OTP для email/phone)
+await users.create(userData)           // POST /api/users (admin)
+```
+
+#### Route Guards
+
+```javascript
+import { requiresAuth, requiresNoAuth } from '@ozdao/martyrs/modules/auth/client'
+
+// Защищённый роут
+{
+  path: '/dashboard',
+  component: Dashboard,
+  beforeEnter: requiresAuth  // Редирект на /auth/signin если не авторизован
+}
+
+// Только для неавторизованных
+{
+  path: '/auth/signin',
+  component: SignIn,
+  beforeEnter: requiresNoAuth  // Редирект на /users/:_id если уже авторизован
+}
+```
+
+## Integration
+
+### Зависимости от других модулей
+
+```
+auth ──► core
+         ├── sessions.service    # Создание/валидация сессий
+         ├── mailing             # Отправка email/sms для OTP
+         └── ws.manager          # Переподключение WebSocket при login
+
+auth ──► organizations
+         └── check-accesses      # Загрузка прав пользователя
+```
+
+### Использование auth в других модулях
+
+```javascript
+// Защита роута с JWT
+import { authJwt } from '@ozdao/martyrs/modules/auth/server'
+app.post('/api/orders', authJwt.verifyToken(), createOrder)
+
+// Защита с OTP
+import { otp } from '@ozdao/martyrs/modules/auth/server'
+app.post('/api/wallet/withdraw',
+  authJwt.verifyToken(),
+  otp.stepUp('withdraw', req => ({ identifier: req.user.email, type: 'email' })),
+  withdraw
+)
+
+// Клиент: проверка авторизации
+import { auth } from '@ozdao/martyrs/modules/auth/client'
+if (auth.state.access.status) {
+  // Пользователь авторизован
+}
+```
+
+## Error Handling
+
+| Код | Значение | Действие |
+|-----|----------|----------|
+| `RATE_LIMITED` | Слишком частые запросы | Показать таймер `retryAfter` сек |
+| `INVALID_CODE` | Неверный код | Показать "Осталось попыток: `attemptsLeft`" |
+| `CODE_NOT_FOUND` | OTP истёк или не найден | Запросить новый код |
+| `ALREADY_USED` | Код уже использован | Запросить новый код |
+
+```javascript
+try {
+  await withOtp(request, data)
+} catch (error) {
+  if (error.response?.data?.errorCode === 'RATE_LIMITED') {
+    const seconds = error.response.data.retryAfter
+    showMessage(`Подождите ${seconds} секунд`)
+  }
+}
+```
+
+## Security
+
+| Параметр | Значение |
+|----------|----------|
+| Rate limit | 30 сек между запросами на один identifier |
+| Попытки | Максимум 3 на один код |
+| TTL | Код живёт 10 минут |
+| Атомарность | `findOneAndUpdate` исключает race conditions |
+
+## Troubleshooting
+
+### JWT invalid или сессия не найдена
+
+**Симптом:** 401 Unauthorized на защищённых роутах
+
+**Причины:**
+1. Токен истёк (24 часа по умолчанию)
+2. Сессия деактивирована (например, после смены пароля)
+3. Cookie не передаётся (проблемы с CORS/credentials)
+
+**Решение:**
+```javascript
+// Клиент должен обрабатывать 401 и делать logout
+axios.interceptors.response.use(
+  response => response,
+  error => {
+    if (error.response?.status === 401) {
+      auth.logout()
+      router.push('/auth/signin')
+    }
+    return Promise.reject(error)
+  }
+)
+```
+
+### OTP не приходит
+
+**Проверьте:**
+1. Rate limit — подождите 30 секунд
+2. Конфигурация mailing в core модуле
+3. Логи сервера на ошибки отправки
+
+### Dual OTP показывает только одно поле
+
+**Причина:** У пользователя нет старого контакта (первое добавление email/phone)
+
+**Это нормально:** При первом добавлении контакта верифицируется только новый.

package/src/modules/auth/FIXES.md

@@ -1,41 +1,3 @@
-### 1. **Нет OTP-сервиса — дублирование логики**
-- Сейчас генерация и отправка кодов реализована **в разных частях**: часть в `auth.service.js`, часть в `twofa.service.js`.
-- В будущем при добавлении новых каналов (WhatsApp, push и т.д.) это вызовет **хаос и дублирование**.
-  
-📌 **Решение:**  
-Выделить `otp.service.js`, который:
-- генерирует код (общая логика),
-- сохраняет код (в временную коллекцию),
-- проверяет код,
-- можно вызывать для любого действия и вставлять мидллвар в ручки с проверкой на ввод кода иначе отказ
-- поддерживает каналы доставки (email, SMS и т.д.).
-
----
-
-### 2. **Отсутствие полноценной сессии — только JWT**
-- Используются только JWT и куки, но нет **отвязки токенов от состояния на сервере**.
-- Нет поддержки:
-  - logout с **ревокацией токена**,
-  - множественных сессий (разные устройства),
-  - деактивации токенов при смене пароля.
-
-📌 **Решение:**  
-Добавить:
-- Модель `Session` в базе,
-- Привязку JWT к `sessionId`,
-- Проверку `session.isActive === true` при валидации токена,
-- Хендлер `logout` — деактивация сессии,
-- Использовать вебсокеты для отображения онлайн, был в сети 15 секунд назад и так далее.
-- Очистку всех сессий при сбросе пароля.
-
----
-
-### 3. **Логгер посетителей — лишний в auth**
-- `visitor.logger` — это **технический middleware**, но подключается прямо в `auth.server.js`. Модуль auth отвечает не только за аутентификацию и авторизацию, но и за учёт посетителей — ведь до входа в систему пользователь тоже считается «субъектом». Поэтому модели Visitor и Request логично оставлять внутри auth. Однако вместо простого подключения middleware логирования, нужно выделить отдельный сервис visitors.service, который будет управлять логикой работы с визитами и запросами: записью, обновлением, анализом. Модуль auth должен не только учитывать посетителей и их запросы через модели Visitor и Request, но и связывать эти данные с сессиями пользователей и их навигацией по приложению. Для этого сервис visitors.service обязан отслеживать пользовательские сессии, фиксировать последовательность посещённых страниц и действий (пользовательский путь), связывая это с конкретным посетителем или авторизованным пользователем. Такая связь позволит не просто собирать сырые логи, а анализировать поведение пользователей и состояние сессий в единой модели, что существенно расширит возможности аутентификации и безопасности без усложнения архитектуры.
-
----
-
-
 ### 5. **Непрозрачная интеграция с внешними провайдерами**
 - В `auth.service.js` логика Apple/Google логина встроена в `if`-блоки,
 - Нет абстракции: невозможно быстро подключить нового провайдера (напр. Discord, Telegram).

package/src/modules/auth/auth.client.js

@@ -4,8 +4,8 @@ console.log('[LOADING 36] Auth module import started...');
 
 // Functional imports (needed for initialize function)
 import * as storeAuth from './views/store/auth.js';
-import * as storeTwofa from './views/store/twofa.js';
 import * as storeUsers from './views/store/users.js';
+import otpPlugin from './views/plugins/otp.plugin.js';
 
 performance.mark('loading-36-stores-end');
 const storesTime = performance.measure('loading-36-stores', 'loading-36-start', 'loading-36-stores-end');
@@ -29,8 +29,6 @@ console.log(`[LOADING 36] Router/middleware/locales imports completed in ${impor
 
 // Component re-exports (enables tree shaking)
 export { default as Auth } from './views/components/layouts/Auth.vue';
-export { default as EnterCode } from './views/components/pages/EnterCode.vue';
-export { default as EnterPassword } from './views/components/pages/EnterPassword.vue';
 export { default as Invite } from './views/components/pages/Invite.vue';
 export { default as Profile } from './views/components/pages/Profile.vue';
 export { default as ProfileEdit } from './views/components/pages/ProfileEdit.vue';
@@ -51,9 +49,11 @@ function initializeAuth(app, store, router, options = {}) {
   addRoutes(router, { ...usersRoute.config, parentName: usersRoute.parentName });
 
   store.addStore('auth', storeAuth);
-  store.addStore('twofa', storeTwofa);
   store.addStore('users', storeUsers);
 
+  // OTP plugin для challenge-response
+  app.use(otpPlugin);
+
   app.provide('store', store);
 }
 
@@ -62,7 +62,6 @@ const ModuleAuth = {
   views: {
     store: {
       storeAuth,
-      storeTwofa,
       storeUsers,
     },
     router: {
@@ -78,7 +77,6 @@ const ModuleAuth = {
 // Functional exports
 export {
   storeAuth,
-  storeTwofa,
   storeUsers,
   getAuthRoutes,
   getUsersRoutes,

package/src/modules/auth/auth.server.js

@@ -1,43 +1,32 @@
-import visitors from '@martyrs/src/modules/auth/controllers/middlewares/visitor.logger.js';
 import authRoutes from './controllers/routes/auth.routes.js';
-import twofaRoutes from './controllers/routes/twofa.routes.js';
 import usersRoutes from './controllers/routes/users.routes.js';
 import AuthController from './controllers/services/auth.service.js';
-import TwoFaController from './controllers/services/twofa.service.js';
+import { initOtpService } from './controllers/services/otp.service.js';
 import UsersController from './controllers/services/users.service.js';
-import RequestModel from './models/request.model.js';
 import RoleModel from './models/role.model.js';
 import UserModel from './models/user.model.js';
-import VisitorModel from './models/visitor.model.js';
+import OtpModel from './models/otp.model.js';
 
 function initializeAuth(app, db, origins, publicPath) {
-  // Настраиваем модели в объекте базы данных
   db.role = RoleModel(db);
   db.user = UserModel(db);
-  db.visitor = VisitorModel(db);
-  db.request = RequestModel(db);
-  // Настраиваем маршруты, если объект приложения передан
+  db.otp = OtpModel(db);
+  initOtpService(db);
   if (app) {
     authRoutes(app, db, origins, publicPath);
-    twofaRoutes(app, db, origins, publicPath);
     usersRoutes(app, db, origins, publicPath);
-    const visitorModule = visitors(db);
-    app.use(visitorModule.visitorLogger);
   }
 }
 export const models = {
   RoleModel,
   UserModel,
-  VisitorModel,
 };
 export const routes = {
   authRoutes,
-  twofaRoutes,
   usersRoutes,
 };
 export const controllers = {
   AuthController,
-  TwoFaController,
   UsersController,
 };
 export { initializeAuth as initialize };

package/src/modules/auth/controllers/middlewares/authJwt.js

@@ -1,55 +1,77 @@
 import jwt from 'jsonwebtoken';
+import { getSessionsService } from '@martyrs/src/modules/core/controllers/services/sessions.service.js';
 
 const middlewareFactory = db => {
-  
+
   const User = db.user;
   const Role = db.role;
-  
+
   const verifyToken = (continueOnFail = false) => {
-    
+
     return async (req, res, next) => {
-      
+
       try {
         let token = req.headers['x-access-token'];
-        
+
         if (!token && req.cookies && req.cookies.user) {
           let user = JSON.parse(req.cookies.user);
           token = user.accessToken;
         }
-        
+
         if (req.headers['x-service-key']) {
           const serviceKey = req.headers['x-service-key'];
           const validServiceKey = process.env.SERVICE_KEY;
-          
+
           if (serviceKey !== validServiceKey) {
             return res.status(403).send({ message: 'Unauthorized: Invalid service key' });
           }
-          
+
           req.isServiceRequest = true;
           return next();
         }
-        
+
         if (!token) {
           req.userId = null;
-          
+
           if (continueOnFail) {
             return next();
           } else {
             return res.status(401).send({ message: 'Unauthorized: No token provided' });
           }
         }
-        
+
         const decoded = jwt.verify(token, process.env.SECRET_KEY);
-        
+
+        // Validate session
+        if (decoded.session_id) {
+          const sessionsService = getSessionsService();
+          const session = await sessionsService.validateSession({
+            sessionId: decoded.session_id,
+            userId: decoded._id,
+          });
+
+          if (!session) {
+            req.userId = null;
+            if (continueOnFail) {
+              return next();
+            } else {
+              return res.status(401).send({ message: 'Unauthorized: Session expired or revoked' });
+            }
+          }
+
+          req.sessionId = decoded.session_id;
+        }
+
         req.userId = decoded._id;
+
         req.user = {
           _id: decoded._id,
         };
-        
+
         next();
       } catch (err) {
         req.userId = null;
-        
+
         if (continueOnFail) {
           next();
         } else {
@@ -58,11 +80,29 @@ const middlewareFactory = db => {
       }
     };
   };
+
+  const loadUser = async (req, res, next) => {
+    try {
+      if (!req.userId) {
+        return res.status(401).json({ errorCode: 'AUTH_REQUIRED' });
+      }
+      const user = await User.findById(req.userId).exec();
+      if (!user) {
+        return res.status(404).json({ errorCode: 'USER_NOT_FOUND' });
+      }
+      req.user = user;
+      next();
+    } catch (err) {
+      res.status(500).send({ message: err.message });
+    }
+  };
+
   
   const checkRole = roleToCheck => async (req, res, next) => {
     
     try {
       const user = await User.findById(req.userId).exec();
+      
       if (!user) {
         console.log('[CheckRole] User not found');
         return res.status(404).send({ message: 'User Not found.' });
@@ -84,13 +124,15 @@ const middlewareFactory = db => {
   
   const isAdmin = checkRole('admin');
   const isModerator = checkRole('moderator');
-  
+
+
   const authJwt = {
     verifyToken,
+    loadUser,
     isAdmin,
-    isModerator,
+    isModerator
   };
-  
+
   return authJwt;
 };
 

package/src/modules/auth/controllers/middlewares/index.js

@@ -4,6 +4,7 @@ import authSecretModule from './authSecret.js';
 import verifySignUpModule from './verifySignUp.js';
 import verifyUserModule from './verifyUser.js';
 import verifyInvitesModule from './verifyInvites.js';
+import otpModule from './otp.middleware.js';
 
 const middlewareIndexFactory = db => {
   const authJwt = authJwtModule(db);
@@ -11,13 +12,15 @@ const middlewareIndexFactory = db => {
   const verifySignUp = verifySignUpModule(db);
   const verifyUser = verifyUserModule(db);
   const verifyInvites = verifyInvitesModule(db);
-  
+  const otp = otpModule();
+
   return {
     authJwt,
     authSecret,
     verifySignUp,
     verifyUser,
     verifyInvites,
+    otp,
   };
 };