@ozdao/martyrs 0.2.481 → 0.2.483

package/src/modules/globals/controllers/classes/abac/v2/abac-express-fixed.js

@@ -0,0 +1,276 @@
+// @martyrs/src/modules/globals/controllers/classes/abac/abac.adapter.express.js
+export default class ABACExpressAdapter {
+  constructor(abac) {
+    this.abac = abac;
+  }
+
+  /**
+   * Основной middleware - разделен на составные части
+   */
+  middleware(resource, action, options = {}) {
+    const middlewares = [];
+    
+    // 1. Access control
+    middlewares.push(this._accessMiddleware(resource, action, options));
+    
+    // 2. Field validation (если включена)
+    if (options.checkFields) {
+      middlewares.push(this._fieldsValidationMiddleware(resource, action, options));
+    }
+    
+    return middlewares;
+  }
+
+  /**
+   * Middleware проверки доступа
+   * @private
+   */
+  _accessMiddleware(resource, action, options = {}) {
+    return async (req, res, next) => {
+      try {
+        const context = this._buildContext(req, resource, action, options);
+        const accessResult = await this.abac.checkAccess(context, context.customPolicies);
+
+        if (!accessResult.allow) {
+          return this._sendAccessDenied(res, accessResult.reason);
+        }
+
+        // Сохраняем результат для последующих middleware
+        req.abacContext = context;
+        req.abacAccessResult = accessResult;
+        next();
+      } catch (error) {
+        this.abac.logger?.error('ABAC middleware error', {
+          resource,
+          action,
+          error: error.message,
+          stack: error.stack
+        });
+        return this._sendError(res);
+      }
+    };
+  }
+
+  /**
+   * Middleware проверки полей
+   * @private
+   */
+  _fieldsValidationMiddleware(resource, action, options = {}) {
+    return async (req, res, next) => {
+      try {
+        const context = req.abacContext || this._buildContext(req, resource, action, options);
+        const fieldsResult = await this.abac.checkFields(context, req.body, action);
+        
+        if (fieldsResult.errors.length > 0 && options.strictFieldsMode) {
+          return this._sendFieldError(res, fieldsResult.errors);
+        }
+        
+        // Заменяем body отфильтрованными данными
+        req.body = fieldsResult.allowed;
+        req.abacFieldsResult = fieldsResult;
+        
+        next();
+      } catch (error) {
+        this.abac.logger?.error('Fields middleware error', {
+          resource,
+          action,
+          error: error.message
+        });
+        
+        if (options.passErrors) {
+          next(error);
+        } else {
+          return this._sendError(res);
+        }
+      }
+    };
+  }
+
+  /**
+   * Построение контекста
+   * @private
+   */
+  _buildContext(req, resource, action, options = {}) {
+    return {
+      user: req.userId,
+      resource,
+      action,
+      req,
+      // НЕ смешиваем body и query - передаем структурированно
+      data: {
+        body: req.body || {},
+        query: req.query || {},
+        params: req.params || {}
+      },
+      params: req.params,
+      customPolicies: options.policies || {},
+      options
+    };
+  }
+
+  /**
+   * Policy middleware
+   */
+  policyMiddleware(policyNames = [], customPolicies = {}, options = {}) {
+    return async (req, res, next) => {
+      try {
+        const context = this._buildContext(
+          req, 
+          options.resource || 'custom',
+          options.action || 'access',
+          options
+        );
+
+        const result = await this.abac.checkPolicies(context, policyNames, customPolicies);
+        
+        if (!result.allow) {
+          return this._sendPolicyDenied(res, result.reason);
+        }
+
+        req.abacPolicyResult = result;
+        next();
+      } catch (error) {
+        this.abac.logger?.error('Policy middleware error', {
+          policies: policyNames,
+          error: error.message
+        });
+        return this._sendError(res);
+      }
+    };
+  }
+
+  /**
+   * Fields middleware для проверки/трансформации полей
+   */
+  fieldsMiddleware(resource, options = {}) {
+    return async (req, res, next) => {
+      try {
+        // Определяем action из метода запроса
+        const action = options.action || this._getActionFromMethod(req.method);
+        const context = this._buildContext(req, resource, action, options);
+
+        // Определяем какие данные проверять
+        let dataToCheck = this._getDataToCheck(req, res, options);
+
+        const fieldsResult = await this.abac.checkFields(context, dataToCheck, action);
+        
+        // Обработка ошибок
+        if (fieldsResult.errors.length > 0) {
+          if (options.strictMode) {
+            return this._sendFieldError(res, fieldsResult.errors);
+          }
+          // В нестрогом режиме логируем ошибки
+          this.abac.logger?.warn('Field validation errors', {
+            resource,
+            action,
+            errors: fieldsResult.errors
+          });
+        }
+        
+        // Применяем результаты
+        this._applyFieldsResult(req, res, options, fieldsResult);
+        
+        // Сохраняем результат
+        req.abacFieldsResult = fieldsResult;
+        
+        next();
+      } catch (error) {
+        this.abac.logger?.error('Fields middleware error', {
+          resource,
+          error: error.message
+        });
+        
+        if (options.passErrors) {
+          next(error);
+        } else {
+          return this._sendError(res);
+        }
+      }
+    };
+  }
+
+  /**
+   * Получение action из HTTP метода
+   * @private
+   */
+  _getActionFromMethod(method) {
+    const methodActionMap = {
+      'GET': 'read',
+      'POST': 'create',
+      'PUT': 'update',
+      'PATCH': 'update',
+      'DELETE': 'delete'
+    };
+    return methodActionMap[method] || 'access';
+  }
+
+  /**
+   * Определение данных для проверки
+   * @private
+   */
+  _getDataToCheck(req, res, options) {
+    if (req.method === 'GET' && options.checkQuery) {
+      return req.query;
+    }
+    
+    if (options.checkResponse && res.locals.data) {
+      return res.locals.data;
+    }
+    
+    return req.body;
+  }
+
+  /**
+   * Применение результатов проверки полей
+   * @private
+   */
+  _applyFieldsResult(req, res, options, fieldsResult) {
+    if (req.method === 'GET' && options.checkQuery) {
+      req.query = fieldsResult.allowed;
+    } else if (options.checkResponse && res.locals.data) {
+      res.locals.data = fieldsResult.transformed || fieldsResult.allowed;
+    } else {
+      req.body = fieldsResult.allowed;
+    }
+  }
+
+  /**
+   * Отправка ошибок - унифицированные методы
+   * @private
+   */
+  _sendAccessDenied(res, reason) {
+    return res.status(403).json({
+      error: {
+        code: 'ACCESS_DENIED',
+        message: reason
+      }
+    });
+  }
+
+  _sendPolicyDenied(res, reason) {
+    return res.status(403).json({
+      error: {
+        code: 'POLICY_DENIED',
+        message: reason
+      }
+    });
+  }
+
+  _sendFieldError(res, errors) {
+    return res.status(400).json({
+      error: {
+        code: 'FIELD_VALIDATION_ERROR',
+        fields: errors
+      }
+    });
+  }
+
+  _sendError(res) {
+    return res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Access control error'
+      }
+    });
+  }
+}

package/src/modules/globals/controllers/classes/abac/v2/abac-fields-fixed.js

@@ -0,0 +1,422 @@
+// @martyrs/src/modules/globals/controllers/classes/abac/abac.fields.js
+import _ from 'lodash';
+
+export default class ABACFields {
+  constructor(abac) {
+    this.abac = abac;
+    this.configs = new Map();
+    this.compiledPatterns = new Map(); // Кэш скомпилированных паттернов
+  }
+
+  /**
+   * Регистрация field policies
+   */
+  registerFieldsPolicy(resourceName, config) {
+    const normalized = {};
+    
+    for (const [pattern, conf] of Object.entries(config)) {
+      const { actions, ...baseSettings } = conf;
+      
+      const base = {
+        actions: baseSettings.actions || '*',
+        access: baseSettings.access || 'allow',
+        validator: baseSettings.validator || null,
+        transform: baseSettings.transform || null,
+        rule: baseSettings.rule || 'remove',
+        force: baseSettings.force || false,
+        pattern
+      };
+      
+      if (actions && typeof actions === 'object') {
+        normalized[pattern] = {
+          base,
+          actions: Object.entries(actions).reduce((acc, [action, override]) => {
+            acc[action] = { ...base, ...override };
+            return acc;
+          }, {})
+        };
+      } else {
+        normalized[pattern] = { base };
+      }
+    }
+    
+    this.configs.set(resourceName, normalized);
+    // Очищаем кэш паттернов при изменении конфига
+    this.compiledPatterns.delete(resourceName);
+    return this;
+  }
+
+  /**
+   * Проверка доступа к полям
+   */
+  async checkFields(context, data, action = null) {
+    const normalizedContext = this.abac.core.normalizeContext(context);
+    
+    if (normalizedContext.skipFieldPolicies) {
+      return { 
+        allowed: data, 
+        denied: [], 
+        errors: [], 
+        transformed: data 
+      };
+    }
+
+    const { resource } = normalizedContext;
+    const fieldAction = action || normalizedContext.action;
+    const config = normalizedContext.options?.fieldsConfig || this.configs.get(resource);
+    
+    if (!config) {
+      return { allowed: data, denied: [], errors: [], transformed: data };
+    }
+
+    // Применяем расширения
+    await this._applyExtensions(normalizedContext);
+
+    // Используем structuredClone или lodash для безопасного клонирования
+    const result = {
+      allowed: this._deepClone(data),
+      denied: [],
+      errors: [],
+      transformed: null
+    };
+
+    // Собираем правила с учетом force
+    const rules = this._collectRulesOptimized(data, config, fieldAction, resource);
+    const forced = rules.filter(r => r.rule.force);
+    const regular = rules.filter(r => !r.rule.force);
+    
+    // Set для отслеживания обработанных путей (БЫЛ БАГ!)
+    const processed = new Set();
+
+    // Применяем правила (сначала forced, потом обычные)
+    for (const { path, value, rule } of [...forced, ...regular]) {
+      // Пропускаем уже обработанные пути
+      if (processed.has(path)) continue;
+      processed.add(path);
+
+      // Проверка доступа
+      const hasAccess = await this._checkFieldAccess(
+        rule.access, 
+        normalizedContext, 
+        path, 
+        value
+      );
+      
+      if (!hasAccess) {
+        await this._handleDenied(result, path, rule.rule);
+        continue;
+      }
+
+      // Валидация
+      if (rule.validator && rule.access !== 'optional') {
+        const validation = await this._validateField(
+          rule.validator, 
+          value, 
+          normalizedContext,
+          path
+        );
+        
+        if (!validation.isValid) {
+          result.errors.push({ path, errors: validation.errors });
+          
+          if (rule.rule === 'error') {
+            throw new Error(`Validation failed: ${path}`);
+          }
+          await this._handleDenied(result, path, rule.rule);
+        }
+      }
+    }
+
+    // Трансформация
+    result.transformed = this._deepClone(result.allowed);
+    
+    for (const { path, value, rule } of [...forced, ...regular]) {
+      if (!rule.transform) continue;
+      
+      const isDenied = result.denied.some(d => d.path === path);
+      if (isDenied) continue;
+
+      const transformed = await this._transformField(
+        rule.transform,
+        value,
+        normalizedContext,
+        path,
+        result.transformed
+      );
+      _.set(result.transformed, path, transformed);
+    }
+
+    return result;
+  }
+
+  /**
+   * Применение расширений
+   * @private
+   */
+  async _applyExtensions(context) {
+    if (!this.abac.policies || !this.abac.policies.priorities.extensions.length) {
+      return;
+    }
+
+    for (const [name, extensionFn] of this.abac.policies.priorities.extensions) {
+      try {
+        await extensionFn(context);
+      } catch (error) {
+        this.abac.logger?.error('Extension error', { name, error });
+      }
+    }
+  }
+
+  /**
+   * Безопасное клонирование
+   * @private
+   */
+  _deepClone(obj) {
+    // Используем structuredClone если доступен (Node 17+)
+    if (typeof structuredClone === 'function') {
+      try {
+        return structuredClone(obj);
+      } catch (e) {
+        // Fallback для циклических ссылок
+      }
+    }
+    // Fallback на lodash
+    return _.cloneDeep(obj);
+  }
+
+  /**
+   * Оптимизированный сбор правил
+   * @private
+   */
+  _collectRulesOptimized(data, config, action, resource) {
+    const rules = [];
+    
+    // Компилируем паттерны если нужно
+    const compiledPatterns = this._getCompiledPatterns(resource, config);
+    
+    // Проверяем есть ли паттерн "*" - если да, применяем его ко всем полям
+    const hasWildcard = compiledPatterns.has('*');
+    
+    // Оптимизация: сначала собираем все пути
+    const dataPaths = this._extractPathsOptimized(data);
+    
+    // Если есть wildcard, сразу добавляем правило для всех путей
+    if (hasWildcard) {
+      const wildcardConfig = config['*'];
+      const rule = this._getRuleForAction(wildcardConfig, action);
+      
+      if (this._matchesAction(rule.actions, action)) {
+        for (const path of dataPaths) {
+          rules.push({
+            path,
+            value: _.get(data, path),
+            rule
+          });
+        }
+        // Если применили wildcard, можем не проверять другие паттерны
+        return rules;
+      }
+    }
+    
+    // Проверяем остальные паттерны
+    for (const path of dataPaths) {
+      for (const [pattern, matcher] of compiledPatterns) {
+        if (pattern === '*') continue; // Уже обработали
+        
+        if (matcher(path)) {
+          const fieldConfig = config[pattern];
+          const rule = this._getRuleForAction(fieldConfig, action);
+          
+          if (this._matchesAction(rule.actions, action)) {
+            rules.push({
+              path,
+              value: _.get(data, path),
+              rule
+            });
+            break; // Берем первое совпадение
+          }
+        }
+      }
+    }
+    
+    return rules;
+  }
+
+  /**
+   * Получение скомпилированных паттернов
+   * @private
+   */
+  _getCompiledPatterns(resource, config) {
+    if (!this.compiledPatterns.has(resource)) {
+      const compiled = new Map();
+      
+      for (const pattern of Object.keys(config)) {
+        compiled.set(pattern, this._compilePattern(pattern));
+      }
+      
+      this.compiledPatterns.set(resource, compiled);
+    }
+    
+    return this.compiledPatterns.get(resource);
+  }
+
+  /**
+   * Компиляция паттерна в функцию проверки
+   * @private
+   */
+  _compilePattern(pattern) {
+    if (pattern === '*') return () => true;
+    
+    // Преобразуем паттерн в регулярку
+    const escaped = pattern
+      .replace(/\./g, '\\.')
+      .replace(/\*\*/g, '.*')
+      .replace(/\*/g, '[^.]+')
+      .replace(/\[\*\]/g, '\\[\\d+\\]');
+    
+    const regex = new RegExp(`^${escaped}$`);
+    
+    return (path) => regex.test(path);
+  }
+
+  /**
+   * Оптимизированное извлечение путей
+   * @private
+   */
+  _extractPathsOptimized(obj, prefix = '', paths = []) {
+    if (!obj || typeof obj !== 'object') return paths;
+    
+    if (Array.isArray(obj)) {
+      obj.forEach((item, i) => {
+        const path = prefix ? `${prefix}[${i}]` : `[${i}]`;
+        paths.push(path);
+        this._extractPathsOptimized(item, path, paths);
+      });
+    } else {
+      for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+          const path = prefix ? `${prefix}.${key}` : key;
+          paths.push(path);
+          
+          if (obj[key] && typeof obj[key] === 'object') {
+            this._extractPathsOptimized(obj[key], path, paths);
+          }
+        }
+      }
+    }
+    
+    return paths;
+  }
+
+  /**
+   * Получение правила для действия
+   * @private
+   */
+  _getRuleForAction(fieldConfig, action) {
+    if (fieldConfig.actions && fieldConfig.actions[action]) {
+      return fieldConfig.actions[action];
+    }
+    return fieldConfig.base;
+  }
+
+  /**
+   * Проверка доступа к полю
+   * @private
+   */
+  async _checkFieldAccess(access, context, fieldPath, fieldValue) {
+    if (access === 'allow') return true;
+    if (access === 'deny') return false;
+    if (access === 'optional') return true;
+    
+    if (typeof access === 'function') {
+      try {
+        return !!(await access(context, fieldPath, fieldValue));
+      } catch (e) {
+        this.abac.logger?.error('Field access check error', { 
+          field: fieldPath, 
+          error: e.message 
+        });
+        return false;
+      }
+    }
+    
+    return true;
+  }
+
+  /**
+   * Валидация поля
+   * @private
+   */
+  async _validateField(validator, value, context, fieldPath) {
+    if (typeof validator === 'function') {
+      try {
+        const result = await validator(value, context, fieldPath);
+        if (typeof result === 'boolean') {
+          return { isValid: result, errors: result ? [] : ['Validation failed'] };
+        }
+        return result;
+      } catch (e) {
+        return { isValid: false, errors: [e.message] };
+      }
+    }
+    
+    if (validator && validator.validate) {
+      return validator.validate(value);
+    }
+    
+    return { isValid: true, errors: [] };
+  }
+
+  /**
+   * Трансформация поля
+   * @private
+   */
+  async _transformField(transform, value, context, fieldPath, currentData) {
+    try {
+      return await transform(value, context, fieldPath, currentData);
+    } catch (error) {
+      this.abac.logger?.error('Field transform error', { 
+        field: fieldPath, 
+        error: error.message 
+      });
+      return value;
+    }
+  }
+
+  /**
+   * Обработка отказа
+   * @private
+   */
+  async _handleDenied(result, path, rule) {
+    result.denied.push({ path, reason: rule });
+    
+    if (rule === 'remove') {
+      _.unset(result.allowed, path);
+    } else if (rule === 'error') {
+      throw new Error(`Access denied: ${path}`);
+    }
+  }
+
+  /**
+   * Проверка действия
+   * @private
+   */
+  _matchesAction(actions, action) {
+    if (actions === '*') return true;
+    return Array.isArray(actions) ? actions.includes(action) : actions === action;
+  }
+
+  // Публичные методы для управления конфигами
+  getConfig(resourceName) {
+    return this.configs.get(resourceName);
+  }
+
+  hasConfig(resourceName) {
+    return this.configs.has(resourceName);
+  }
+
+  removeConfig(resourceName) {
+    this.compiledPatterns.delete(resourceName);
+    return this.configs.delete(resourceName);
+  }
+}