@ozdao/martyrs 0.2.564 → 0.2.566

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

@@ -2,48 +2,62 @@
 export default class ABACCore {
   constructor(abac) {
     this.abac = abac;
-    this.runningPolicies = new Map(); // Для контроля параллельности
+    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,
-      // Добавляем флаг для пропуска field policies (например, для админов)
       skipFieldPolicies: input.skipFieldPolicies || false,
     };
 
     if (input.req) {
-      // Express context
+      // Express context - НЕ смешиваем body и query!
       context.user = input.user || input.req.userId;
       context.data = {
-        ...input.req.body,
-        ...input.req.query,
-        params: input.req.params,
+        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 остальные поля
-    return Object.assign(context, input);
+    // Merge остальные поля (но не перезаписываем data)
+    return Object.assign(context, {
+      ...input,
+      data: context.data // Сохраняем структурированную data
+    });
   }
 
-  // Выполнение политики с кэшированием
+  /**
+   * Выполнение политики с кэшированием
+   */
   async executePolicyWithCache(policyName, policyFn, context) {
     // Проверяем контекстный кэш
     const contextCacheKey = `${policyName}_${context.action}`;
@@ -51,8 +65,9 @@ export default class ABACCore {
       return context._cache.get(contextCacheKey);
     }
 
-    // Проверяем глобальный кэш
-    const globalCacheKey = `policy_${policyName}_${context.user}_${context.resource}_${context.action}`;
+    // Улучшенный глобальный кэш-ключ с ID ресурса
+    const globalCacheKey = this._buildCacheKey(policyName, context);
+    
     if (this.abac.options.cacheEnabled) {
       const cached = await this.abac.cache.get(globalCacheKey);
       if (cached !== undefined) {
@@ -67,17 +82,45 @@ export default class ABACCore {
     // Сохраняем в кэш
     context._cache.set(contextCacheKey, result);
     if (this.abac.options.cacheEnabled) {
-      await this.abac.cache.setWithTags(globalCacheKey, result, [
+      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;
@@ -95,7 +138,12 @@ export default class ABACCore {
           const result = await this.executePolicyWithCache(name, policyFn, context);
           return { name, result: this.normalizeResult(result, name) };
         } catch (error) {
-          console.error(`Error in policy ${name}:`, error);
+          this.abac.logger?.error('Policy execution error', { 
+            policy: name, 
+            error: error.message,
+            stack: error.stack 
+          });
+          
           return { 
             name, 
             result: { 
@@ -120,10 +168,16 @@ export default class ABACCore {
     return results;
   }
 
-  // Нормализация результата политики
+  /**
+   * Нормализация результата политики
+   */
   normalizeResult(result, policyName) {
     if (this.abac.options.strictMode && result === undefined) {
-      return { allow: false, force: false, reason: `UNDEFINED_IN_STRICT_MODE_${policyName.toUpperCase()}` };
+      return { 
+        allow: false, 
+        force: false, 
+        reason: `UNDEFINED_IN_STRICT_MODE_${policyName.toUpperCase()}` 
+      };
     }
     
     if (result && typeof result === 'object' && ('allow' in result || 'force' in result)) {
@@ -135,16 +189,30 @@ export default class ABACCore {
     }
     
     if (result === true) {
-      return { allow: true, force: false, reason: `ALLOWED_BY_${policyName.toUpperCase()}` };
+      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: false, 
+        force: false, 
+        reason: `DENIED_BY_${policyName.toUpperCase()}` 
+      };
     }
     
-    return { allow: !this.abac.options.strictMode, force: false, reason: `NEUTRAL_${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);
@@ -160,7 +228,7 @@ export default class ABACCore {
     }
 
     // Предзагрузка ресурса
-    if (!context.currentResource && (context.data?._id || context.data?.params?._id || context.data?.url)) {
+    if (!context.currentResource) {
       await this.loadResource(context);
     }
 
@@ -171,52 +239,75 @@ export default class ABACCore {
     if (this.abac.options.enableAudit) {
       await this.audit(context, result, Date.now() - startTime);
     }
-    console.error('result logging:', result);
+    
     return result;
   }
 
-  // Загрузка ресурса
+  /**
+   * Загрузка ресурса
+   */
   async loadResource(context) {
     const resourceModel = this.abac.getResourceModel(context.resource);
     if (!resourceModel) return;
 
     try {
       let currentResource;
-      const id = context.data._id || context.data.params?._id;
+      // Ищем 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.url) {
-        currentResource = await resourceModel.findOne({ url: context.data.url });
+      } 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) {
-      console.error('Resource loading error:', error);
+      this.abac.logger?.error('Resource loading error', { 
+        resource: context.resource,
+        error: error.message 
+      });
     }
   }
 
-  // Аудит
+  /**
+   * Структурированный аудит
+   */
   async audit(context, result, duration) {
     try {
-      let info = JSON.stringify({
+      const auditEntry = {
         type: 'ACCESS_CHECK',
-        timestamp: new Date(),
+        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.log('info', info);
-      console.error('Audit logging:', info);
+      };
+      
+      // Используем структурированное логирование
+      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) {
-      console.error('Audit logging error:', error);
+      this.abac.logger?.error('Audit logging error', { 
+        error: error.message 
+      });
     }
   }
 }