@ozdao/martyrs 0.2.564 → 0.2.565

package/src/modules/core/controllers/classes/abac/abac.fields.js

@@ -1,9 +1,14 @@
 // @martyrs/src/modules/core/controllers/classes/abac/abac.fields.js
+import set from 'lodash/set.js';
+import get from 'lodash/get.js';
+import unset from 'lodash/unset.js';
+import cloneDeep from 'lodash/cloneDeep.js';
 
 export default class ABACFields {
   constructor(abac) {
     this.abac = abac;
     this.configs = new Map();
+    this.compiledPatterns = new Map(); // Кэш скомпилированных паттернов
   }
 
   /**
@@ -13,10 +18,8 @@ export default class ABACFields {
     const normalized = {};
     
     for (const [pattern, conf] of Object.entries(config)) {
-      // Извлекаем базовые настройки (все кроме actions)
       const { actions, ...baseSettings } = conf;
       
-      // Нормализуем базовые настройки
       const base = {
         actions: baseSettings.actions || '*',
         access: baseSettings.access || 'allow',
@@ -27,7 +30,6 @@ export default class ABACFields {
         pattern
       };
       
-      // Если есть переопределения для действий
       if (actions && typeof actions === 'object') {
         normalized[pattern] = {
           base,
@@ -42,6 +44,8 @@ export default class ABACFields {
     }
     
     this.configs.set(resourceName, normalized);
+    // Очищаем кэш паттернов при изменении конфига
+    this.compiledPatterns.delete(resourceName);
     return this;
   }
 
@@ -49,7 +53,6 @@ export default class ABACFields {
    * Проверка доступа к полям
    */
   async checkFields(context, data, action = null) {
-    // Используем нормализованный контекст из core
     const normalizedContext = this.abac.core.normalizeContext(context);
     
     if (normalizedContext.skipFieldPolicies) {
@@ -69,38 +72,32 @@ export default class ABACFields {
       return { allowed: data, denied: [], errors: [], transformed: data };
     }
 
-    // Применяем расширения к контексту (если есть)
-    if (this.abac.policies && this.abac.policies.priorities.extensions.length > 0) {
-      for (const [name, extensionFn] of this.abac.policies.priorities.extensions) {
-        try {
-          await extensionFn(normalizedContext);
-        } catch (error) {
-          console.error(`Extension ${name} error:`, error);
-        }
-      }
-    }
+    // Применяем расширения
+    await this._applyExtensions(normalizedContext);
 
+    // Используем structuredClone или lodash для безопасного клонирования
     const result = {
-      allowed: JSON.parse(JSON.stringify(data)),
+      allowed: this._deepClone(data),
       denied: [],
       errors: [],
       transformed: null
     };
 
     // Собираем правила с учетом force
-    const rules = this._collectRules(data, config, fieldAction);
+    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]) {
-      const processed = new Set();
-      
-      // Пропускаем уже обработанные пути (для force)
+      // Пропускаем уже обработанные пути
       if (processed.has(path)) continue;
       processed.add(path);
 
-      // Проверка доступа - передаем поле и значение как параметры
+      // Проверка доступа
       const hasAccess = await this._checkFieldAccess(
         rule.access, 
         normalizedContext, 
@@ -134,7 +131,7 @@ export default class ABACFields {
     }
 
     // Трансформация
-    result.transformed = JSON.parse(JSON.stringify(result.allowed));
+    result.transformed = this._deepClone(result.allowed);
     
     for (const { path, value, rule } of [...forced, ...regular]) {
       if (!rule.transform) continue;
@@ -149,102 +146,94 @@ export default class ABACFields {
         path,
         result.transformed
       );
-      this._setValue(result.transformed, path, transformed);
+      set(result.transformed, path, transformed);
     }
 
     return result;
   }
 
   /**
-   * Проверка доступа к полю
+   * Применение расширений
    * @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') {
+  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 {
-        // Передаем поле и значение как параметры функции
-        return !!(await access(context, fieldPath, fieldValue));
-      } catch (e) {
-        console.error('Field access check error:', e);
-        return false;
+        await extensionFn(context);
+      } catch (error) {
+        this.abac.logger?.error('Extension error', { name, error });
       }
     }
-    
-    return true;
   }
 
   /**
-   * Валидация поля
+   * Безопасное клонирование
    * @private
    */
-  async _validateField(validator, value, context, fieldPath) {
-    if (typeof validator === 'function') {
+  _deepClone(obj) {
+    // Используем structuredClone если доступен (Node 17+)
+    if (typeof structuredClone === 'function') {
       try {
-        // Передаем контекст и путь как параметры
-        const result = await validator(value, context, fieldPath);
-        if (typeof result === 'boolean') {
-          return { isValid: result, errors: result ? [] : ['Validation failed'] };
-        }
-        return result;
+        return structuredClone(obj);
       } catch (e) {
-        return { isValid: false, errors: [e.message] };
+        // Fallback для циклических ссылок
       }
     }
-    
-    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) {
-      console.error('Field transform error:', error);
-      return value;
-    }
+    // Fallback на lodash
+    return cloneDeep(obj);
   }
 
   /**
-   * Сбор применимых правил
+   * Оптимизированный сбор правил
    * @private
    */
-  _collectRules(data, config, action) {
+  _collectRulesOptimized(data, config, action, resource) {
     const rules = [];
-    const patterns = Object.keys(config);
+    
+    // Компилируем паттерны если нужно
+    const compiledPatterns = this._getCompiledPatterns(resource, config);
+    
+    // Проверяем есть ли паттерн "*" - если да, применяем его ко всем полям
+    const hasWildcard = compiledPatterns.has('*');
     
     // Оптимизация: сначала собираем все пути
-    const dataPaths = this._extractPaths(data);
+    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 of patterns) {
-        if (this._matchesPattern(path, pattern)) {
+      for (const [pattern, matcher] of compiledPatterns) {
+        if (pattern === '*') continue; // Уже обработали
+        
+        if (matcher(path)) {
           const fieldConfig = config[pattern];
+          const rule = this._getRuleForAction(fieldConfig, action);
           
-          // Получаем правило для конкретного действия
-          let rule;
-          if (fieldConfig.actions && fieldConfig.actions[action]) {
-            rule = fieldConfig.actions[action];
-          } else {
-            rule = fieldConfig.base;
-          }
-          
-          // Проверяем, подходит ли правило для действия
           if (this._matchesAction(rule.actions, action)) {
             rules.push({
               path,
-              value: this._getValue(data, path),
+              value: get(data, path),
               rule
             });
             break; // Берем первое совпадение
@@ -257,43 +246,54 @@ export default class ABACFields {
   }
 
   /**
-   * Проверка паттерна
+   * Получение скомпилированных паттернов
    * @private
    */
-  _matchesPattern(path, pattern) {
-    if (pattern === path) return true;
-    if (pattern === '*') return true;
-    
-    const pathParts = path.split('.');
-    const patternParts = pattern.split('.');
-    
-    for (let i = 0; i < patternParts.length; i++) {
-      const pp = patternParts[i];
-      const pathPart = pathParts[i];
+  _getCompiledPatterns(resource, config) {
+    if (!this.compiledPatterns.has(resource)) {
+      const compiled = new Map();
       
-      if (pp === '**') return true;
-      if (pp === '*' && pathPart !== undefined) continue;
-      if (pp === '[*]' && /^\[\d+\]$/.test(pathPart)) continue;
-      if (pp !== pathPart) return false;
+      for (const pattern of Object.keys(config)) {
+        compiled.set(pattern, this._compilePattern(pattern));
+      }
+      
+      this.compiledPatterns.set(resource, compiled);
     }
     
-    return pathParts.length === patternParts.length;
+    return this.compiledPatterns.get(resource);
   }
 
   /**
-   * Извлечение путей
+   * Компиляция паттерна в функцию проверки
    * @private
    */
-  _extractPaths(obj, prefix = '') {
-    const paths = [];
+  _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);
-        paths.push(...this._extractPaths(item, path));
+        this._extractPathsOptimized(item, path, paths);
       });
     } else {
       for (const key in obj) {
@@ -302,7 +302,7 @@ export default class ABACFields {
           paths.push(path);
           
           if (obj[key] && typeof obj[key] === 'object') {
-            paths.push(...this._extractPaths(obj[key], path));
+            this._extractPathsOptimized(obj[key], path, paths);
           }
         }
       }
@@ -312,19 +312,33 @@ export default class ABACFields {
   }
 
   /**
-   * Проверка доступа
+   * Получение правила для действия
+   * @private
+   */
+  _getRuleForAction(fieldConfig, action) {
+    if (fieldConfig.actions && fieldConfig.actions[action]) {
+      return fieldConfig.actions[action];
+    }
+    return fieldConfig.base;
+  }
+
+  /**
+   * Проверка доступа к полю
    * @private
    */
-  async _checkAccess(access, ctx) {
+  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(ctx));
+        return !!(await access(context, fieldPath, fieldValue));
       } catch (e) {
-        console.error('Access check error:', e);
+        this.abac.logger?.error('Field access check error', { 
+          field: fieldPath, 
+          error: e.message 
+        });
         return false;
       }
     }
@@ -333,13 +347,13 @@ export default class ABACFields {
   }
 
   /**
-   * Валидация
+   * Валидация поля
    * @private
    */
-  async _validate(validator, value, ctx) {
+  async _validateField(validator, value, context, fieldPath) {
     if (typeof validator === 'function') {
       try {
-        const result = await validator(value, ctx);
+        const result = await validator(value, context, fieldPath);
         if (typeof result === 'boolean') {
           return { isValid: result, errors: result ? [] : ['Validation failed'] };
         }
@@ -356,15 +370,31 @@ export default class ABACFields {
     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, ctx) {
+  async _handleDenied(result, path, rule) {
     result.denied.push({ path, reason: rule });
     
     if (rule === 'remove') {
-      this._removePath(result.allowed, path);
+      unset(result.allowed, path);
     } else if (rule === 'error') {
       throw new Error(`Access denied: ${path}`);
     }
@@ -379,73 +409,7 @@ export default class ABACFields {
     return Array.isArray(actions) ? actions.includes(action) : actions === action;
   }
 
-  /**
-   * Получение значения
-   * @private
-   */
-  _getValue(obj, path) {
-    const parts = path.split(/\.|\[|\]/).filter(Boolean);
-    let current = obj;
-    
-    for (const part of parts) {
-      if (!current) return undefined;
-      current = /^\d+$/.test(part) ? current[parseInt(part)] : current[part];
-    }
-    
-    return current;
-  }
-
-  /**
-   * Установка значения
-   * @private
-   */
-  _setValue(obj, path, value) {
-    const parts = path.split(/\.|\[|\]/).filter(Boolean);
-    let current = obj;
-    
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i];
-      const next = parts[i + 1];
-      const isArray = /^\d+$/.test(next);
-      
-      if (!current[part]) {
-        current[part] = isArray ? [] : {};
-      }
-      current = current[part];
-    }
-    
-    const last = parts[parts.length - 1];
-    if (/^\d+$/.test(last)) {
-      current[parseInt(last)] = value;
-    } else {
-      current[last] = value;
-    }
-  }
-
-  /**
-   * Удаление пути
-   * @private
-   */
-  _removePath(obj, path) {
-    const parts = path.split(/\.|\[|\]/).filter(Boolean);
-    let current = obj;
-    
-    // Доходим до родителя
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = /^\d+$/.test(parts[i]) ? parseInt(parts[i]) : parts[i];
-      if (!current[part]) return;
-      current = current[part];
-    }
-    
-    // Удаляем элемент
-    const last = parts[parts.length - 1];
-    if (/^\d+$/.test(last)) {
-      current.splice(parseInt(last), 1);
-    } else {
-      delete current[last];
-    }
-  }
-
+  // Публичные методы для управления конфигами
   getConfig(resourceName) {
     return this.configs.get(resourceName);
   }
@@ -455,6 +419,7 @@ export default class ABACFields {
   }
 
   removeConfig(resourceName) {
+    this.compiledPatterns.delete(resourceName);
     return this.configs.delete(resourceName);
   }
 }