@ozdao/martyrs 0.2.481 → 0.2.483

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

@@ -1,15 +1,5 @@
 // @martyrs/src/modules/globals/controllers/classes/abac/abac.fields.js
 
-/**
- * @typedef {Object} FieldConfig
- * @property {string[]|'*'} [actions=['*']] - Действия
- * @property {'allow'|'deny'|'optional'|Function} [access='allow'] - Правило доступа
- * @property {import('../globals.validator.js').default|Function} [validator] - Валидатор
- * @property {Function} [transform] - Трансформация (value, ctx) => any
- * @property {'remove'|'error'} [rule='remove'] - Действие при отказе в доступе
- * @property {boolean} [force=false] - Принудительное применение (высший приоритет)
- */
-
 export default class ABACFields {
   constructor(abac) {
     this.abac = abac;
@@ -23,15 +13,32 @@ export default class ABACFields {
     const normalized = {};
     
     for (const [pattern, conf] of Object.entries(config)) {
-      normalized[pattern] = {
-        actions: conf.actions || '*',
-        access: conf.access || 'allow',
-        validator: conf.validator || null,
-        transform: conf.transform || null,
-        rule: conf.rule || 'remove',
-        force: conf.force || false,
+      // Извлекаем базовые настройки (все кроме actions)
+      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);
@@ -42,9 +49,10 @@ export default class ABACFields {
    * Проверка доступа к полям
    */
   async checkFields(context, data, action = null) {
-    console.log(context)
-    if (context.skipFieldPolicies) {
-      console.log('Field policies skipped for admin/moderator');
+    // Используем нормализованный контекст из core
+    const normalizedContext = this.abac.core.normalizeContext(context);
+    
+    if (normalizedContext.skipFieldPolicies) {
       return { 
         allowed: data, 
         denied: [], 
@@ -53,23 +61,19 @@ export default class ABACFields {
       };
     }
 
-    const { resource } = context;
-    const fieldAction = action || context.action;
-    const config = context.options?.fieldsConfig || this.configs.get(resource);
+    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 };
     }
 
-    // ВАЖНО: Применяем расширения к контексту перед проверкой полей
-    const enrichedContext = { ...context };
-    
-    // Проверяем, есть ли расширения в ABAC
+    // Применяем расширения к контексту (если есть)
     if (this.abac.policies && this.abac.policies.priorities.extensions.length > 0) {
-      // Применяем расширения к контексту
       for (const [name, extensionFn] of this.abac.policies.priorities.extensions) {
         try {
-          await extensionFn(enrichedContext);
+          await extensionFn(normalizedContext);
         } catch (error) {
           console.error(`Extension ${name} error:`, error);
         }
@@ -83,10 +87,6 @@ export default class ABACFields {
       transformed: null
     };
 
-    // Используем обогащенный контекст
-    const ctx = { ...enrichedContext, fieldAction, cache: new Map(), originalData: data };
-
-
     // Собираем правила с учетом force
     const rules = this._collectRules(data, config, fieldAction);
     const forced = rules.filter(r => r.rule.force);
@@ -94,24 +94,33 @@ export default class ABACFields {
 
     // Применяем правила (сначала forced, потом обычные)
     for (const { path, value, rule } of [...forced, ...regular]) {
-      const fieldCtx = { ...ctx, field: path, value };
       const processed = new Set();
       
       // Пропускаем уже обработанные пути (для force)
       if (processed.has(path)) continue;
       processed.add(path);
 
-      // Проверка доступа
-      const hasAccess = await this._checkAccess(rule.access, fieldCtx);
+      // Проверка доступа - передаем поле и значение как параметры
+      const hasAccess = await this._checkFieldAccess(
+        rule.access, 
+        normalizedContext, 
+        path, 
+        value
+      );
       
       if (!hasAccess) {
-        await this._handleDenied(result, path, rule.rule, fieldCtx);
+        await this._handleDenied(result, path, rule.rule);
         continue;
       }
 
       // Валидация
       if (rule.validator && rule.access !== 'optional') {
-        const validation = await this._validate(rule.validator, value, fieldCtx);
+        const validation = await this._validateField(
+          rule.validator, 
+          value, 
+          normalizedContext,
+          path
+        );
         
         if (!validation.isValid) {
           result.errors.push({ path, errors: validation.errors });
@@ -119,7 +128,7 @@ export default class ABACFields {
           if (rule.rule === 'error') {
             throw new Error(`Validation failed: ${path}`);
           }
-          await this._handleDenied(result, path, rule.rule, fieldCtx);
+          await this._handleDenied(result, path, rule.rule);
         }
       }
     }
@@ -133,14 +142,80 @@ export default class ABACFields {
       const isDenied = result.denied.some(d => d.path === path);
       if (isDenied) continue;
 
-      const fieldCtx = { ...ctx, field: path, value, currentData: result.transformed };
-      const transformed = await rule.transform(value, fieldCtx);
+      const transformed = await this._transformField(
+        rule.transform,
+        value,
+        normalizedContext,
+        path,
+        result.transformed
+      );
       this._setValue(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') {
+      try {
+        // Передаем поле и значение как параметры функции
+        return !!(await access(context, fieldPath, fieldValue));
+      } catch (e) {
+        console.error('Field access check error:', e);
+        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) {
+      console.error('Field transform error:', error);
+      return value;
+    }
+  }
+
   /**
    * Сбор применимых правил
    * @private
@@ -155,8 +230,17 @@ export default class ABACFields {
     for (const path of dataPaths) {
       for (const pattern of patterns) {
         if (this._matchesPattern(path, pattern)) {
-          const rule = config[pattern];
+          const fieldConfig = config[pattern];
+          
+          // Получаем правило для конкретного действия
+          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,

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

@@ -0,0 +1,313 @@
+// @martyrs/src/modules/globals/controllers/classes/abac/abac.core.js
+export default class ABACCore {
+  constructor(abac) {
+    this.abac = abac;
+    this.runningPolicies = new Map();
+  }
+
+  /**
+   * Нормализация контекста
+   */
+  normalizeContext(input) {
+    const context = {
+      user: null,
+      action: null,
+      resource: null,
+      currentResource: null,
+      resourceId: null, // Добавляем ID ресурса для кэша
+      data: {},
+      req: null,
+      socket: null,
+      params: {},
+      _cache: new Map(),
+      _abac: this.abac,
+      skipFieldPolicies: input.skipFieldPolicies || false,
+    };
+
+    if (input.req) {
+      // Express context - НЕ смешиваем body и query!
+      context.user = input.user || input.req.userId;
+      context.data = {
+        body: input.req.body || {},
+        query: input.req.query || {},
+        params: input.req.params || {},
+      };
+      context.params = input.req.params;
+      context.req = input.req;
+      
+      // Извлекаем ID ресурса для кэша
+      context.resourceId = input.req.params?._id || 
+                          input.req.params?.id || 
+                          input.req.body?._id ||
+                          input.req.body?.id;
+    } else if (input.socket) {
+      // WebSocket context
+      context.user = input.user || input.socket.userId;
+      context.socket = input.socket;
+      context.data = input.data || {};
+      context.resourceId = input.data?._id || input.data?.id;
+    }
+
+    // Merge остальные поля (но не перезаписываем data)
+    return Object.assign(context, {
+      ...input,
+      data: context.data // Сохраняем структурированную data
+    });
+  }
+
+  /**
+   * Выполнение политики с кэшированием
+   */
+  async executePolicyWithCache(policyName, policyFn, context) {
+    // Проверяем контекстный кэш
+    const contextCacheKey = `${policyName}_${context.action}`;
+    if (context._cache.has(contextCacheKey)) {
+      return context._cache.get(contextCacheKey);
+    }
+
+    // Улучшенный глобальный кэш-ключ с ID ресурса
+    const globalCacheKey = this._buildCacheKey(policyName, context);
+    
+    if (this.abac.options.cacheEnabled) {
+      const cached = await this.abac.cache.get(globalCacheKey);
+      if (cached !== undefined) {
+        context._cache.set(contextCacheKey, cached);
+        return cached;
+      }
+    }
+
+    // Выполняем политику
+    const result = await policyFn(context);
+    
+    // Сохраняем в кэш
+    context._cache.set(contextCacheKey, result);
+    if (this.abac.options.cacheEnabled) {
+      const tags = [
+        `user_${context.user}`,
+        `resource_${context.resource}`,
+        `policy_${policyName}`
+      ];
+      
+      if (context.resourceId) {
+        tags.push(`resourceId_${context.resourceId}`);
+      }
+      
+      await this.abac.cache.setWithTags(globalCacheKey, result, tags);
+    }
+
+    return result;
+  }
+
+  /**
+   * Построение ключа кэша с учетом ID ресурса
+   * @private
+   */
+  _buildCacheKey(policyName, context) {
+    const parts = [
+      'policy',
+      policyName,
+      context.user,
+      context.resource,
+      context.action
+    ];
+    
+    if (context.resourceId) {
+      parts.push(context.resourceId);
+    }
+    
+    return parts.join('_');
+  }
+
+  /**
+   * Выполнение политик с ограничением параллельности
+   */
+  async executePoliciesLimited(policies, context, stopOnDeny = false) {
+    const results = [];
+    const limit = this.abac.options.concurrencyLimit;
+    
+    // Разбиваем на батчи
+    const batches = [];
+    for (let i = 0; i < policies.length; i += limit) {
+      batches.push(policies.slice(i, i + limit));
+    }
+
+    for (const batch of batches) {
+      const batchPromises = batch.map(async ([name, policy]) => {
+        try {
+          const policyFn = typeof policy === 'function' ? policy : policy.fn;
+          const result = await this.executePolicyWithCache(name, policyFn, context);
+          return { name, result: this.normalizeResult(result, name) };
+        } catch (error) {
+          this.abac.logger?.error('Policy execution error', { 
+            policy: name, 
+            error: error.message,
+            stack: error.stack 
+          });
+          
+          return { 
+            name, 
+            result: { 
+              allow: !this.abac.options.strictMode, 
+              reason: `POLICY_ERROR_${name.toUpperCase()}` 
+            },
+            error
+          };
+        }
+      });
+
+      const batchResults = await Promise.all(batchPromises);
+      results.push(...batchResults);
+
+      // Проверяем нужно ли остановиться
+      if (stopOnDeny) {
+        const shouldStop = batchResults.some(r => !r.result.allow || r.result.force);
+        if (shouldStop) break;
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Нормализация результата политики
+   */
+  normalizeResult(result, policyName) {
+    if (this.abac.options.strictMode && result === undefined) {
+      return { 
+        allow: false, 
+        force: false, 
+        reason: `UNDEFINED_IN_STRICT_MODE_${policyName.toUpperCase()}` 
+      };
+    }
+    
+    if (result && typeof result === 'object' && ('allow' in result || 'force' in result)) {
+      return {
+        allow: result.allow !== undefined ? !!result.allow : true,
+        force: !!result.force,
+        reason: result.reason || `POLICY_${policyName.toUpperCase()}`,
+      };
+    }
+    
+    if (result === true) {
+      return { 
+        allow: true, 
+        force: false, 
+        reason: `ALLOWED_BY_${policyName.toUpperCase()}` 
+      };
+    }
+    if (result === false) {
+      return { 
+        allow: false, 
+        force: false, 
+        reason: `DENIED_BY_${policyName.toUpperCase()}` 
+      };
+    }
+    
+    return { 
+      allow: !this.abac.options.strictMode, 
+      force: false, 
+      reason: `NEUTRAL_${policyName.toUpperCase()}` 
+    };
+  }
+
+  /**
+   * Основной метод проверки доступа
+   */
+  async checkAccess(rawContext, customPolicies = {}) {
+    const startTime = Date.now();
+    const context = this.normalizeContext(rawContext);
+
+    // Проверка сервисного запроса
+    if (context.isServiceRequest) {
+      return { allow: true, reason: 'SERVICE_REQUEST_ALLOWED' };
+    }
+
+    // Проверка аутентификации
+    if (!context.user && !context.options?.allowUnauthenticated) {
+      return { allow: false, reason: 'UNAUTHENTICATED_ACCESS_DENIED' };
+    }
+
+    // Предзагрузка ресурса
+    if (!context.currentResource) {
+      await this.loadResource(context);
+    }
+
+    // Выполнение политик
+    const result = await this.abac.policies.evaluate(context, customPolicies);
+    
+    // Аудит
+    if (this.abac.options.enableAudit) {
+      await this.audit(context, result, Date.now() - startTime);
+    }
+    
+    return result;
+  }
+
+  /**
+   * Загрузка ресурса
+   */
+  async loadResource(context) {
+    const resourceModel = this.abac.getResourceModel(context.resource);
+    if (!resourceModel) return;
+
+    try {
+      let currentResource;
+      // Ищем ID в структурированной data
+      const id = context.resourceId || 
+                 context.data?.body?._id || 
+                 context.data?.params?._id;
+      
+      if (id) {
+        currentResource = await resourceModel.findById(id);
+      } else if (context.data?.body?.url || context.data?.params?.url) {
+        const url = context.data.body?.url || context.data.params?.url;
+        currentResource = await resourceModel.findOne({ url });
+      }
+      
+      if (currentResource) {
+        context.currentResource = currentResource;
+        context.resourceModel = resourceModel;
+        context.resourceId = currentResource._id?.toString();
+      }
+    } catch (error) {
+      this.abac.logger?.error('Resource loading error', { 
+        resource: context.resource,
+        error: error.message 
+      });
+    }
+  }
+
+  /**
+   * Структурированный аудит
+   */
+  async audit(context, result, duration) {
+    try {
+      const auditEntry = {
+        type: 'ACCESS_CHECK',
+        timestamp: new Date().toISOString(),
+        user: context.user,
+        resource: context.resource,
+        resourceId: context.resourceId,
+        action: context.action,
+        result: result.allow,
+        reason: result.reason,
+        duration: duration,
+        ip: context.req?.ip,
+        userAgent: context.req?.get?.('user-agent'),
+        metadata: context.auditMetadata || {}
+      };
+      
+      // Используем структурированное логирование
+      await this.abac.logger.info('Access check', auditEntry);
+      
+      // Если критическое действие - дополнительный алерт
+      if (['delete', 'admin', 'export'].includes(context.action)) {
+        await this.abac.logger.warn('Critical action attempt', auditEntry);
+      }
+    } catch (error) {
+      this.abac.logger?.error('Audit logging error', { 
+        error: error.message 
+      });
+    }
+  }
+}