@ozdao/martyrs 0.2.481 → 0.2.483

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

@@ -0,0 +1,295 @@
+// @martyrs/src/modules/globals/controllers/classes/globals.abac.js
+import Cache from '@martyrs/src/modules/globals/controllers/classes/globals.cache.js';
+import Logger from '@martyrs/src/modules/globals/controllers/classes/globals.logger.js';
+
+import ABACCore from './abac/abac.core.js';
+import ABACPolicies from './abac/abac.policies.js';
+import ABACFields from './abac/abac.fields.js';
+
+import ABACExpressAdapter from './abac/abac.adapter.express.js';
+import ABACWebSocketAdapter from './abac/abac.adapter.ws.js';
+
+/**
+ * @typedef {Object} ABACOptions
+ * @property {boolean} [strictMode=false] - Строгий режим (undefined = deny)
+ * @property {boolean} [defaultDeny=false] - Запрет по умолчанию
+ * @property {string} [serviceKey] - Ключ для сервисных запросов
+ * @property {boolean} [enableAudit=true] - Включить аудит
+ * @property {boolean} [cacheEnabled=true] - Включить кэширование
+ * @property {number} [cacheTTL=300] - TTL кэша в секундах
+ * @property {number} [concurrencyLimit=10] - Лимит параллельных политик
+ * @property {Object} [logger] - Кастомный логгер
+ */
+
+/**
+ * @typedef {Object} ABACContext
+ * @property {string|null} user - ID пользователя
+ * @property {string} action - Действие (read, create, update, delete, etc)
+ * @property {string} resource - Тип ресурса
+ * @property {Object} [currentResource] - Загруженный ресурс
+ * @property {string} [resourceId] - ID ресурса
+ * @property {Object} data - Данные запроса
+ * @property {Object} [data.body] - Body запроса (Express)
+ * @property {Object} [data.query] - Query параметры (Express)
+ * @property {Object} [data.params] - Route параметры (Express)
+ * @property {Object} [req] - Express request
+ * @property {Object} [socket] - WebSocket соединение
+ * @property {Object} [params] - Route параметры
+ * @property {boolean} [skipFieldPolicies=false] - Пропустить проверку полей
+ * @property {Object} [options] - Дополнительные опции
+ */
+
+/**
+ * @typedef {Object} ABACResult
+ * @property {boolean} allow - Разрешен ли доступ
+ * @property {string} reason - Причина решения
+ * @property {Array} [policies] - Примененные политики
+ */
+
+/**
+ * @typedef {Object} FieldsResult
+ * @property {Object} allowed - Разрешенные данные
+ * @property {Array} denied - Запрещенные поля
+ * @property {Array} errors - Ошибки валидации
+ * @property {Object} transformed - Трансформированные данные
+ */
+
+class GlobalABAC {
+  constructor(db, options = {}) {
+    this.db = db;
+    
+    /** @type {ABACOptions} */
+    this.options = {
+      strictMode: false,
+      defaultDeny: false,
+      serviceKey: process.env.SERVICE_KEY,
+      enableAudit: true,
+      cacheEnabled: true,
+      cacheTTL: 300,
+      concurrencyLimit: 10,
+      ...options,
+    };
+    
+    // Инициализация компонентов
+    this.cache = new Cache({ ttlSeconds: this.options.cacheTTL });
+    this.logger = this.options.logger || new Logger(db);
+    
+    // Инициализация модулей
+    this.core = new ABACCore(this);
+    this.policies = new ABACPolicies(this);
+    this.fields = new ABACFields(this);
+    this.express = new ABACExpressAdapter(this);
+    this.websocket = new ABACWebSocketAdapter(this);
+  }
+
+  /**
+   * Регистрация глобальной политики
+   * @param {string} name - Имя политики
+   * @param {Function} policyFn - Функция политики (context) => boolean|{allow, force, reason}
+   * @param {Object} [metadata] - Метаданные политики
+   * @param {string} [metadata.type='dynamic'] - Тип (static|dynamic)
+   * @param {number} [metadata.priority=0] - Приоритет
+   * @returns {GlobalABAC}
+   */
+  registerGlobalPolicy(name, policyFn, metadata = {}) {
+    return this.policies.registerGlobalPolicy(name, policyFn, metadata);
+  }
+
+  /**
+   * Регистрация политики для ресурса
+   * @param {string} resourceName - Имя ресурса
+   * @param {Function} policyFn - Функция политики
+   * @param {Object} [options] - Опции
+   * @param {string} [options.modelName] - Имя модели в БД
+   * @returns {GlobalABAC}
+   */
+  registerResourcePolicy(resourceName, policyFn, options = {}) {
+    return this.policies.registerResourcePolicy(resourceName, policyFn, options);
+  }
+
+  /**
+   * Регистрация политики полей
+   * @param {string} resourceName - Имя ресурса
+   * @param {Object} config - Конфигурация полей
+   * @returns {GlobalABAC}
+   * 
+   * @example
+   * abac.registerFieldsPolicy('user', {
+   *   'email': { access: 'deny', actions: ['update'] },
+   *   'password': { access: 'deny', actions: '*', rule: 'remove' },
+   *   'profile.*': { 
+   *     access: async (ctx) => ctx.user === ctx.currentResource?.id,
+   *     transform: (value) => sanitize(value)
+   *   }
+   * });
+   */
+  registerFieldsPolicy(resourceName, config) {
+    return this.fields.registerFieldsPolicy(resourceName, config);
+  }
+
+  /**
+   * Регистрация расширения контекста
+   * @param {string} moduleName - Имя модуля
+   * @param {Function} extensionFn - Функция расширения (context) => void
+   * @returns {GlobalABAC}
+   */
+  registerExtension(moduleName, extensionFn) {
+    return this.policies.registerExtension(moduleName, extensionFn);
+  }
+
+  /**
+   * Проверка доступа
+   * @param {ABACContext|Object} context - Контекст проверки
+   * @param {Object} [customPolicies] - Дополнительные политики
+   * @returns {Promise<ABACResult>}
+   */
+  async checkAccess(context, customPolicies = {}) {
+    return this.core.checkAccess(context, customPolicies);
+  }
+
+  /**
+   * Проверка доступа к полям
+   * @param {ABACContext|Object} context - Контекст
+   * @param {Object} data - Данные для проверки
+   * @param {string} [action] - Действие
+   * @returns {Promise<FieldsResult>}
+   */
+  async checkFields(context, data, action = null) {
+    return this.fields.checkFields(context, data, action);
+  }
+
+  /**
+   * Проверка конкретных политик
+   * @param {ABACContext|Object} context - Контекст
+   * @param {string[]} policyNames - Имена политик
+   * @param {Object} [customPolicies] - Дополнительные политики
+   * @returns {Promise<ABACResult>}
+   */
+  async checkPolicies(context, policyNames = [], customPolicies = {}) {
+    return this.policies.checkPolicies(context, policyNames, customPolicies);
+  }
+
+  /**
+   * Express middleware для проверки доступа
+   * @param {string} resource - Ресурс
+   * @param {string} action - Действие
+   * @param {Object} [options] - Опции
+   * @returns {Function|Function[]} Middleware функция(и)
+   */
+  middleware(resource, action, options = {}) {
+    return this.express.middleware(resource, action, options);
+  }
+
+  /**
+   * Express middleware для проверки политик
+   * @param {string[]} policyNames - Имена политик
+   * @param {Object} [customPolicies] - Дополнительные политики
+   * @param {Object} [options] - Опции
+   * @returns {Function} Middleware функция
+   */
+  policyMiddleware(policyNames = [], customPolicies = {}, options = {}) {
+    return this.express.policyMiddleware(policyNames, customPolicies, options);
+  }
+
+  /**
+   * Express middleware для проверки полей
+   * @param {string} resource - Ресурс
+   * @param {Object} [options] - Опции
+   * @returns {Function} Middleware функция
+   */
+  fieldsMiddleware(resource, options = {}) {
+    return this.express.fieldsMiddleware(resource, options);
+  }
+
+  /**
+   * WebSocket handler
+   * @param {string} moduleName - Имя модуля
+   * @param {Object} [options] - Опции
+   * @returns {Function} Handler функция
+   */
+  wsHandler(moduleName, options = {}) {
+    return this.websocket.handler(moduleName, options);
+  }
+  
+  /**
+   * Получение модели ресурса из БД
+   * @param {string} resourceName - Имя ресурса
+   * @returns {Object|null} Mongoose модель или null
+   */
+  getResourceModel(resourceName) {
+    const resourcePolicy = this.policies.resources.get(resourceName);
+    if (!resourcePolicy) return null;
+    
+    const modelName = resourcePolicy.modelName || resourceName;
+    return this.db[modelName] || null;
+  }
+
+  /**
+   * Очистка кэша
+   * @param {Object} [options] - Опции очистки
+   * @param {string} [options.user] - Очистить для пользователя
+   * @param {string} [options.resource] - Очистить для ресурса
+   * @param {string} [options.policy] - Очистить для политики
+   */
+  async clearCache(options = {}) {
+    if (options.user) {
+      await this.cache.invalidateTag(`user_${options.user}`);
+    }
+    if (options.resource) {
+      await this.cache.invalidateTag(`resource_${options.resource}`);
+    }
+    if (options.policy) {
+      await this.cache.invalidateTag(`policy_${options.policy}`);
+    }
+    if (!options.user && !options.resource && !options.policy) {
+      await this.cache.clear();
+    }
+  }
+
+  /**
+   * Получение статистики
+   * @returns {Object} Статистика системы
+   */
+  getStats() {
+    return {
+      policies: {
+        global: this.policies.global.size,
+        resources: this.policies.resources.size,
+        extensions: this.policies.extensions.size
+      },
+      fields: {
+        configs: this.fields.configs.size
+      },
+      cache: {
+        size: this.cache.size,
+        hits: this.cache.hits,
+        misses: this.cache.misses
+      }
+    };
+  }
+}
+
+// Экспорт синглтона
+let instance = null;
+
+/**
+ * Получение экземпляра ABAC
+ * @param {Object} db - База данных
+ * @param {ABACOptions} [options] - Опции
+ * @returns {GlobalABAC}
+ */
+export const getInstance = (db, options) => {
+  if (!instance) {
+    instance = new GlobalABAC(db, options);
+  }
+  return instance;
+};
+
+/**
+ * Сброс экземпляра (для тестов)
+ */
+export const resetInstance = () => {
+  instance = null;
+};
+
+export default { getInstance, resetInstance };

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

@@ -0,0 +1,316 @@
+// @martyrs/src/modules/globals/controllers/classes/abac/abac.policies.js
+export default class ABACPolicies {
+  constructor(abac) {
+    this.abac = abac;
+    this.global = new Map();
+    this.resources = new Map();
+    this.extensions = new Map();
+    this.priorities = {
+      static: [],
+      dynamic: [],
+      extensions: []
+    };
+  }
+
+  /**
+   * Регистрация глобальной политики
+   */
+  registerGlobalPolicy(name, policyFn, metadata = {}) {
+    if (typeof policyFn !== 'function') {
+      throw new Error(`Global policy "${name}" must be a function`);
+    }
+    
+    const policy = {
+      fn: policyFn,
+      type: metadata.type || 'dynamic',
+      priority: metadata.priority || 0,
+      ...metadata
+    };
+    
+    this.global.set(name, policy);
+    this.updatePriorities();
+    return this.abac;
+  }
+
+  /**
+   * Регистрация политики ресурса
+   */
+  registerResourcePolicy(resourceName, policyFn, options = {}) {
+    if (typeof policyFn !== 'function') {
+      throw new Error(`Resource policy for "${resourceName}" must be a function`);
+    }
+    
+    this.resources.set(resourceName, {
+      fn: policyFn,
+      modelName: options.modelName || options.model || resourceName,
+      ...options
+    });
+    return this.abac;
+  }
+
+  /**
+   * Регистрация расширения
+   */
+  registerExtension(moduleName, extensionFn) {
+    if (typeof extensionFn !== 'function') {
+      throw new Error(`Extension "${moduleName}" must be a function`);
+    }
+    
+    this.extensions.set(moduleName, extensionFn);
+    this.updatePriorities();
+    return this.abac;
+  }
+
+  /**
+   * Обновление приоритетов с сортировкой
+   */
+  updatePriorities() {
+    this.priorities = {
+      static: [],
+      dynamic: [],
+      extensions: []
+    };
+
+    // Группируем и сортируем по приоритету
+    for (const [name, policy] of this.global) {
+      const type = policy.type || 'dynamic';
+      this.priorities[type].push([name, policy]);
+    }
+
+    // Сортировка по приоритету (выше = раньше)
+    this.priorities.static.sort((a, b) => (b[1].priority || 0) - (a[1].priority || 0));
+    this.priorities.dynamic.sort((a, b) => (b[1].priority || 0) - (a[1].priority || 0));
+
+    // Добавляем расширения
+    this.priorities.extensions = Array.from(this.extensions.entries());
+  }
+
+  /**
+   * Основная логика оценки политик
+   */
+  async evaluate(context, customPolicies = {}) {
+    const core = this.abac.core;
+    
+    // Структура для отслеживания результатов
+    const evaluation = {
+      hasForceAllow: false,
+      hasForceDisallow: false,
+      hasDeny: false,
+      denyReason: '',
+      allowReason: '',
+      appliedPolicies: []
+    };
+    
+    // Функция для обработки результата политики
+    const processResult = (name, result) => {
+      evaluation.appliedPolicies.push({ name, result });
+      
+      if (result.force) {
+        if (result.allow) {
+          evaluation.hasForceAllow = true;
+          evaluation.allowReason = result.reason;
+        } else {
+          evaluation.hasForceDisallow = true;
+          evaluation.denyReason = result.reason;
+        }
+      } else if (!result.allow) {
+        evaluation.hasDeny = true;
+        if (!evaluation.denyReason) {
+          evaluation.denyReason = result.reason;
+        }
+      }
+    };
+    
+    // Функция для проверки force флагов
+    const checkForceFlags = () => {
+      if (evaluation.hasForceDisallow) {
+        return {
+          allow: false,
+          reason: evaluation.denyReason || 'FORCE_DENIED_BY_POLICY',
+          policies: evaluation.appliedPolicies
+        };
+      }
+      
+      if (evaluation.hasForceAllow) {
+        return {
+          allow: true,
+          reason: evaluation.allowReason || 'FORCE_ALLOWED_BY_POLICY',
+          policies: evaluation.appliedPolicies
+        };
+      }
+      
+      return null;
+    };
+    
+    // 1. Static политики (с early exit)
+    const staticResults = await core.executePoliciesLimited(
+      this.priorities.static, 
+      context,
+      true // останавливаемся на deny
+    );
+
+    for (const { name, result, error } of staticResults) {
+      if (!error) {
+        processResult(name, result);
+      }
+    }
+    
+    let forceResult = checkForceFlags();
+    if (forceResult) return forceResult;
+
+    // 2. Dynamic политики + custom
+    const dynamicPolicies = [...this.priorities.dynamic];
+    
+    // Добавляем кастомные политики
+    for (const [name, fn] of Object.entries(customPolicies)) {
+      dynamicPolicies.push([name, { fn, type: 'dynamic' }]);
+    }
+
+    const dynamicResults = await core.executePoliciesLimited(
+      dynamicPolicies, 
+      context,
+      false
+    );
+
+    for (const { name, result, error } of dynamicResults) {
+      if (!error) {
+        processResult(name, result);
+      }
+    }
+    
+    forceResult = checkForceFlags();
+    if (forceResult) return forceResult;
+
+    // 3. Resource-specific политика
+    const resourcePolicy = this.resources.get(context.resource);
+    
+    if (resourcePolicy) {
+      const results = await core.executePoliciesLimited(
+        [[`RESOURCE_${context.resource}`, resourcePolicy]], 
+        context
+      );
+      
+      if (!results[0].error) {
+        processResult(`RESOURCE_${context.resource}`, results[0].result);
+      }
+      
+      forceResult = checkForceFlags();
+      if (forceResult) return forceResult;
+    }
+    
+    // Проверяем накопленный deny
+    if (evaluation.hasDeny) {
+      return {
+        allow: false,
+        reason: evaluation.denyReason || 'DENIED_BY_POLICY',
+        policies: evaluation.appliedPolicies
+      };
+    }
+
+    // 4. Extensions (последний шанс разрешить)
+    const extensionResults = await core.executePoliciesLimited(
+      this.priorities.extensions,
+      context
+    );
+    
+    for (const { name, result } of extensionResults) {
+      processResult(name, result);
+      if (result.allow) {
+        return { 
+          allow: true, 
+          reason: result.reason,
+          policies: evaluation.appliedPolicies
+        };
+      }
+    }
+
+    // Финальное решение
+    const defaultAllow = !this.abac.options.defaultDeny;
+    return {
+      allow: defaultAllow,
+      reason: defaultAllow ? 'DEFAULT_ALLOW' : 'DEFAULT_DENY',
+      policies: evaluation.appliedPolicies
+    };
+  }
+
+  /**
+   * Проверка конкретных политик
+   */
+  async checkPolicies(rawContext, policyNames = [], customPolicies = {}) {
+    const context = this.abac.core.normalizeContext(rawContext);
+    const policies = this.getPoliciesByNames(policyNames, customPolicies);
+    
+    const results = await this.abac.core.executePoliciesLimited(
+      Object.entries(policies), 
+      context,
+      this.abac.options.strictMode
+    );
+
+    // Структурированный анализ результатов
+    const evaluation = {
+      passed: [],
+      failed: [],
+      errors: []
+    };
+
+    for (const { name, result, error } of results) {
+      if (error) {
+        evaluation.errors.push({ name, error: error.message });
+        continue;
+      }
+      
+      if (result.force) {
+        return { 
+          allow: result.allow, 
+          reason: result.reason,
+          evaluation 
+        };
+      }
+      
+      if (result.allow) {
+        evaluation.passed.push(name);
+      } else {
+        evaluation.failed.push({ name, reason: result.reason });
+        
+        if (this.abac.options.strictMode) {
+          return { 
+            allow: false, 
+            reason: result.reason,
+            evaluation
+          };
+        }
+      }
+    }
+
+    const allPassed = evaluation.failed.length === 0 && evaluation.errors.length === 0;
+    
+    return { 
+      allow: allPassed, 
+      reason: allPassed ? 'POLICIES_PASSED' : `FAILED: ${evaluation.failed[0]?.name}`,
+      evaluation
+    };
+  }
+
+  /**
+   * Получение политик по именам
+   */
+  getPoliciesByNames(names, customPolicies = {}) {
+    const policies = {};
+    
+    for (const name of names) {
+      if (this.global.has(name)) {
+        policies[name] = this.global.get(name);
+      } else if (this.extensions.has(name)) {
+        policies[name] = { fn: this.extensions.get(name), type: 'extension' };
+      } else if (this.resources.has(name)) {
+        policies[name] = this.resources.get(name);
+      } else {
+        this.abac.logger?.warn('Policy not found', { name });
+      }
+    }
+    
+    // Добавляем кастомные
+    Object.assign(policies, customPolicies);
+    return policies;
+  }
+}