@ozdao/martyrs 0.2.564 → 0.2.566

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

@@ -1,237 +0,0 @@
-// @martyrs/src/modules/core/controllers/classes/abac/abac.adapter.ws.js
-export default class ABACWebSocketAdapter {
-  constructor(abac) {
-    this.abac = abac;
-  }
-
-  /**
-   * WebSocket handler для проверки доступа
-   * @param {string} moduleName - Имя модуля
-   * @param {Object} [options] - Опции
-   * @returns {Function} Handler функция
-   */
-  handler(moduleName, options = {}) {
-    return async (ws, message) => {
-      try {
-        const { action = 'access', resource = moduleName } = options;
-        
-        const context = this._buildContext(ws, resource, action, message, options);
-        const accessResult = await this.abac.checkAccess(context, context.customPolicies);
-        
-        if (!accessResult.allow) {
-          await this._sendError(ws, 'ACCESS_DENIED', accessResult.reason);
-          return false;
-        }
-
-        // Проверка полей если включена
-        if (options.checkFields && message) {
-          const fieldsResult = await this.abac.checkFields(context, message, action);
-          
-          if (fieldsResult.errors.length > 0 && options.strictFieldsMode) {
-            await this._sendError(ws, 'FIELD_VALIDATION_ERROR', 'Field validation failed', {
-              fields: fieldsResult.errors
-            });
-            return false;
-          }
-          
-          // Возвращаем отфильтрованные данные
-          return {
-            allowed: true,
-            data: fieldsResult.transformed || fieldsResult.allowed,
-            fieldsResult
-          };
-        }
-
-        return true;
-      } catch (error) {
-        this.abac.logger?.error('WebSocket access control error', {
-          module: moduleName,
-          error: error.message,
-          stack: error.stack
-        });
-        
-        await this._sendError(ws, 'INTERNAL_ERROR', 'Access control error');
-        return false;
-      }
-    };
-  }
-
-  /**
-   * RPC handler для вызовов через WebSocket
-   * @param {string} module - Модуль
-   * @param {string} method - Метод
-   * @param {Object} [options] - Опции
-   * @returns {Function} RPC handler
-   */
-  rpcHandler(module, method, options = {}) {
-    return async (params, rpcContext) => {
-      try {
-        const context = this._buildRPCContext(rpcContext, module, method, params, options);
-        const accessResult = await this.abac.checkAccess(context, context.customPolicies);
-        
-        if (!accessResult.allow) {
-          throw new RPCError('ACCESS_DENIED', accessResult.reason);
-        }
-
-        // Проверка полей если нужно
-        if (options.checkFields && params) {
-          const fieldsResult = await this.abac.checkFields(context, params, method);
-          
-          if (fieldsResult.errors.length > 0) {
-            if (options.strictFieldsMode) {
-              throw new RPCError(
-                'FIELD_VALIDATION_ERROR',
-                `Fields validation failed: ${fieldsResult.errors.map(e => e.path).join(', ')}`
-              );
-            }
-            
-            // Логируем ошибки в нестрогом режиме
-            this.abac.logger?.warn('RPC field validation errors', {
-              module,
-              method,
-              errors: fieldsResult.errors
-            });
-          }
-          
-          // Возвращаем трансформированные данные
-          return fieldsResult.transformed || fieldsResult.allowed;
-        }
-
-        return params;
-      } catch (error) {
-        // Пробрасываем RPC ошибки как есть
-        if (error instanceof RPCError) {
-          throw error;
-        }
-        
-        this.abac.logger?.error('RPC access control error', {
-          module,
-          method,
-          error: error.message,
-          stack: error.stack
-        });
-        
-        throw new RPCError('INTERNAL_ERROR', 'Access control error');
-      }
-    };
-  }
-
-  /**
-   * Middleware для обработки WebSocket сообщений
-   * @param {Object} [options] - Опции
-   * @returns {Function} Middleware функция
-   */
-  messageMiddleware(options = {}) {
-    return async (ws, message, next) => {
-      try {
-        const { resource = 'message', action = 'send' } = options;
-        const context = this._buildContext(ws, resource, action, message, options);
-        
-        const accessResult = await this.abac.checkAccess(context, options.policies || {});
-        
-        if (!accessResult.allow) {
-          await this._sendError(ws, 'ACCESS_DENIED', accessResult.reason);
-          return;
-        }
-        
-        // Сохраняем результат в контексте WS
-        ws.abacContext = context;
-        ws.abacAccessResult = accessResult;
-        
-        next();
-      } catch (error) {
-        this.abac.logger?.error('WebSocket middleware error', {
-          error: error.message
-        });
-        
-        await this._sendError(ws, 'INTERNAL_ERROR', 'Access control error');
-      }
-    };
-  }
-
-  /**
-   * Построение контекста для WebSocket
-   * @private
-   */
-  _buildContext(ws, resource, action, data, options) {
-    return {
-      user: ws.userId || ws.user?.id,
-      resource,
-      action,
-      data: data || {},
-      socket: ws,
-      customPolicies: options.policies || {},
-      options,
-      // Дополнительная информация о соединении
-      connectionInfo: {
-        id: ws.id,
-        remoteAddress: ws._socket?.remoteAddress,
-        protocol: ws.protocol,
-        readyState: ws.readyState
-      }
-    };
-  }
-
-  /**
-   * Построение контекста для RPC
-   * @private
-   */
-  _buildRPCContext(rpcContext, module, method, params, options) {
-    return {
-      user: rpcContext.userId || rpcContext.user?.id,
-      resource: module,
-      action: method,
-      data: params || {},
-      socket: rpcContext.ws,
-      customPolicies: options.policies || {},
-      options,
-      rpcInfo: {
-        id: rpcContext.id,
-        module,
-        method,
-        timestamp: new Date().toISOString()
-      }
-    };
-  }
-
-  /**
-   * Отправка ошибки через WebSocket
-   * @private
-   */
-  async _sendError(ws, code, message, details = {}) {
-    if (ws.readyState !== 1) { // WebSocket.OPEN
-      return;
-    }
-    
-    try {
-      const errorMessage = JSON.stringify({
-        type: 'error',
-        error: {
-          code,
-          message,
-          ...details
-        },
-        timestamp: new Date().toISOString()
-      });
-      
-      ws.send(errorMessage);
-    } catch (error) {
-      this.abac.logger?.error('Failed to send WebSocket error', {
-        originalError: { code, message },
-        sendError: error.message
-      });
-    }
-  }
-}
-
-/**
- * Класс для RPC ошибок
- */
-class RPCError extends Error {
-  constructor(code, message, details = {}) {
-    super(message);
-    this.name = 'RPCError';
-    this.code = code;
-    this.details = details;
-  }
-}

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

@@ -1,310 +0,0 @@
-class GlobalABAC {
-  constructor(db, options = {}) {
-    // Основные политики и обработчики
-    this.policies = {
-      global: {}, // Глобальные политики
-      resources: {}, // Политики для ресурсов
-      extensions: {}, // Расширения от внешних модулей
-    };
-    // Настройки по умолчанию
-    this.options = {
-      strictMode: false,
-      defaultDeny: false,
-      serviceKey: process.env.SERVICE_KEY, // Добавляем ключ сервиса из env
-      ...options,
-    };
-    // Сохраняем ссылку на базу данных
-    this.db = db;
-  }
-  // Регистрация глобальной политики
-  registerGlobalPolicy(name, policyFn) {
-    this.policies.global[name] = policyFn;
-    return this;
-  }
-  // Регистрация политики для ресурса
-  registerResourcePolicy(resourceName, policyFn) {
-    this.policies.resources[resourceName] = policyFn;
-    return this;
-  }
-  // Метод для регистрации расширений от внешних модулей
-  registerExtension(moduleName, extensionFn) {
-    // Если расширение уже существует, объединяем функции
-    if (this.policies.extensions[moduleName]) {
-      const existingExtension = this.policies.extensions[moduleName];
-      this.policies.extensions[moduleName] = async context => {
-        const existingResult = await existingExtension(context);
-        if (existingResult) return existingResult;
-        return await extensionFn(context);
-      };
-    } else {
-      this.policies.extensions[moduleName] = extensionFn;
-    }
-    return this;
-  }
-  // Автоматическое определение модели по имени ресурса
-  getResourceModel(resourceName) {
-    if (resourceName === 'posts') resourceName = 'blogposts';
-    // Преобразуем название ресурса в singural форму модели
-    const modelName = resourceName.endsWith('s') ? resourceName.slice(0, -1) : resourceName;
-    // Ищем модель в базе данных
-    const model = this.db[modelName];
-    if (!model) {
-      throw new Error(`Model for resource ${resourceName} not found`);
-    }
-    return model;
-  }
-  /**
-   * Нормализация результата политики для единообразной обработки
-   * @param {any} result - Результат выполнения политики
-   * @param {string} policyName - Имя политики для формирования причины
-   * @returns {Object} Нормализованный результат
-   */
-  _normalizeResult(result, policyName) {
-    // Результат уже в формате объекта с нужными полями
-    if (result && typeof result === 'object' && ('allow' in result || 'force' in result)) {
-      return {
-        allow: !!result.allow,
-        force: !!result.force,
-        reason: result.reason || `POLICY_${policyName.toUpperCase()}`,
-      };
-    }
-    // Boolean результаты
-    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()}` };
-    }
-    // Специальные случаи для adminAccessGranted и подобных
-    if (result === undefined && policyName === 'AdminModeratorAccessPolicy' && this._context && this._context.adminAccessGranted) {
-      return { allow: true, force: true, reason: 'ADMIN_MODERATOR_ACCESS_GRANTED' };
-    }
-    // Нейтральный результат (пропуск политики)
-    return { allow: true, force: false, reason: `NEUTRAL_${policyName.toUpperCase()}` };
-  }
-  // Базовый метод проверки доступа
-  async checkAccess(context) {
-    this._context = context; // Сохраняем контекст для использования в _normalizeResult
-    const {
-      user, // Пользователь
-      resource, // Тип ресурса
-      action, // Действие
-      data, // Данные ресурса
-      options = {}, // Добавляем опции
-      isServiceRequest, // Флаг сервисного запроса
-    } = context;
-    // Если это сервисный запрос, пропускаем проверки
-    if (isServiceRequest) {
-      return {
-        allow: true,
-        reason: 'SERVICE_REQUEST_ALLOWED',
-      };
-    }
-    // Проверка базовой аутентификации
-    if (!user && !options.allowUnauthenticated) {
-      return {
-        allow: false,
-        reason: 'UNAUTHENTICATED_ACCESS_DENIED',
-      };
-    }
-    // Предзагрузка ресурса
-    if ((action !== 'create') && (data._id || data.params?._id || data.url)) {
-      try {
-        const resourceModel = this.getResourceModel(resource);
-        let currentResource;
-        if (data._id || data.params?._id) {
-          currentResource = await resourceModel.findById(data._id || data.params._id);
-        } else if (data.url) {
-          currentResource = await resourceModel.findOne({ url: data.url });
-        }
-        if (!currentResource) {
-          return {
-            allow: false,
-            reason: 'RESOURCE_NOT_FOUND',
-          };
-        }
-        // Добавляем загруженный ресурс в контекст
-        context.currentResource = currentResource;
-        // Добавляем модель ресурса в контекст
-        context.resourceModel = resourceModel;
-      } catch (error) {
-        console.error('Resource loading error:', error);
-        return {
-          allow: false,
-          reason: 'RESOURCE_LOAD_ERROR',
-        };
-      }
-    }
-    // Выполнение всех глобальных политик параллельно
-    const policyEntries = Object.entries(this.policies.global);
-    const policyPromises = policyEntries.map(async ([policyName, policyFn]) => {
-      try {
-        const result = await policyFn(context);
-        return { policyName, result };
-      } catch (error) {
-        console.error(`Error in policy ${policyName}:`, error);
-        // При ошибке возвращаем нейтральный результат
-        return { policyName, result: undefined, error };
-      }
-    });
-    // Ожидаем выполнения всех политик
-    const policyResults = await Promise.all(policyPromises);
-    // Обработка результатов глобальных политик
-    let hasForceAllow = false;
-    let hasForceDisallow = false;
-    let hasDeny = false;
-    let denyReason = '';
-    let allowReason = '';
-    for (const { policyName, result, error } of policyResults) {
-      if (error) continue; // Пропускаем политики с ошибками
-      // Нормализуем результат для унифицированной обработки
-      const normalizedResult = this._normalizeResult(result, policyName);
-      if (normalizedResult.force) {
-        if (normalizedResult.allow) {
-          hasForceAllow = true;
-          allowReason = normalizedResult.reason;
-        } else {
-          hasForceDisallow = true;
-          denyReason = normalizedResult.reason;
-        }
-      } else if (!normalizedResult.allow) {
-        hasDeny = true;
-        if (!denyReason) denyReason = normalizedResult.reason;
-      }
-    }
-    // Принятие решения на основе результатов
-    // 1. Проверка на стопроцентный запрет
-    if (hasForceDisallow) {
-      return {
-        allow: false,
-        reason: denyReason || 'FORCE_DENIED_BY_POLICY',
-      };
-    }
-    // 2. Проверка на стопроцентный доступ
-    if (hasForceAllow) {
-      return {
-        allow: true,
-        reason: allowReason || 'FORCE_ALLOWED_BY_POLICY',
-      };
-    }
-    // 3. Проверка на обычный запрет
-    if (hasDeny) {
-      return {
-        allow: false,
-        reason: denyReason || 'DENIED_BY_POLICY',
-      };
-    }
-    // 4. Проверка политик ресурсов (возможно асинхронное выполнение)
-    if (this.policies.resources[resource]) {
-      try {
-        const resourceResult = await this.policies.resources[resource](context);
-        const normalizedResult = this._normalizeResult(resourceResult, `RESOURCE_${resource}`);
-        if (normalizedResult.force) {
-          return {
-            allow: normalizedResult.allow,
-            reason: normalizedResult.reason,
-          };
-        }
-        if (!normalizedResult.allow) {
-          return {
-            allow: false,
-            reason: normalizedResult.reason,
-          };
-        }
-        if (normalizedResult.allow) {
-          return {
-            allow: true,
-            reason: normalizedResult.reason,
-          };
-        }
-      } catch (error) {
-        console.error(`Error in resource policy for ${resource}:`, error);
-      }
-    }
-    // 5. Выполнение расширений от внешних модулей
-    const extensionPromises = Object.entries(this.policies.extensions).map(async ([moduleName, extensionFn]) => {
-      try {
-        const extensionResult = await extensionFn(context);
-        return { moduleName, result: extensionResult };
-      } catch (error) {
-        console.error(`Error in extension ${moduleName}:`, error);
-        return { moduleName, result: null, error };
-      }
-    });
-    const extensionResults = await Promise.all(extensionPromises);
-    for (const { moduleName, result, error } of extensionResults) {
-      if (error) continue;
-      if (result && result.allow) {
-        return {
-          allow: true,
-          reason: `ALLOWED_BY_${moduleName.toUpperCase()}_EXTENSION`,
-        };
-      }
-    }
-    // 6. Финальное решение на основе настроек
-    return {
-      allow: !this.options.defaultDeny,
-      reason: this.options.defaultDeny ? 'ACCESS_DENIED' : 'ACCESS_ALLOWED',
-    };
-  }
-  // Проверка сервисного ключа
-  validateServiceKey(providedKey) {
-    return providedKey && providedKey === this.options.serviceKey;
-  }
-  // Middleware для Express
-  middleware(resource, action, options = {}) {
-    return async (req, res, next) => {
-      try {
-        // Проверка сервисного ключа
-        const serviceKey = req.headers['x-service-key'];
-        if (serviceKey && this.validateServiceKey(serviceKey)) {
-          req.isServiceRequest = true; // Помечаем, что это запрос от другого сервиса
-          return next();
-        }
-        const context = {
-          user: req.userId,
-          resource,
-          action,
-          data: {
-            ...req.body,
-            ...req.query,
-            params: req.params,
-          },
-          options, // Передаем опции в контекст
-          req, // Передаем весь объект запроса для максимальной гибкости
-          res, // И объект ответа
-          isServiceRequest: req.isServiceRequest, // Передаем флаг сервисного запроса
-        };
-        const accessResult = await this.checkAccess(context);
-        if (context.req?.body) req.body = context.req.body;
-        if (context.req?.query) req.query = context.req.query;
-        if (context.data?.params) req.params = context.data.params;
-        if (accessResult.allow) {
-          req.accessResult = accessResult;
-          return next();
-        }
-        return res.status(403).json({
-          errorCode: accessResult.reason,
-          message: 'Access Denied',
-        });
-      } catch (error) {
-        console.error('Access control error:', error);
-        return res.status(500).json({
-          errorCode: 'INTERNAL_ACCESS_CONTROL_ERROR',
-          message: 'Internal Server Error',
-        });
-      }
-    };
-  }
-}
-// Экспорт синглтона
-let instance = null;
-export const getInstance = (db, options) => {
-  if (!instance) {
-    instance = new GlobalABAC(db, options);
-  }
-  return instance;
-};
-export default {
-  getInstance,
-};

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

@@ -1,89 +0,0 @@
-import Cache from '@martyrs/src/modules/core/controllers/classes/core.cache.js';
-import Logger from '@martyrs/src/modules/core/controllers/classes/core.logger.js';
-import coreQuery from '@martyrs/src/modules/core/controllers/utils/queryProcessor.js';
-class CRUD {
-  constructor(basePath, app, db, model, options) {
-    this.model = model;
-    this.cache = new Cache();
-    this.logger = new Logger(db);
-    this.app = app;
-    this.basePath = basePath;
-    if (!options || (options && !options.disableDefaultRoutes)) this.registerRoutes();
-  }
-  registerRoutes() {
-    this.app.post(`${this.basePath}/create`, this.create.bind(this));
-    this.app.get(`${this.basePath}/read`, this.read.bind(this));
-    this.app.put(`${this.basePath}/update`, this.update.bind(this));
-    this.app.delete(`${this.basePath}/delete`, this.delete.bind(this));
-  }
-  async create(req, res) {
-    try {
-      const createdData = await this.model.create(req.body);
-      await this.cache.flush();
-      res.status(201).json(createdData);
-    } catch (error) {
-      console.log(error);
-      this.logger.error('Ошибка создания данных', error);
-      res.status(500).json({ error: error.message });
-    }
-  }
-  async read(req, res) {
-    try {
-      let stages = [];
-      stages = [
-        ...coreQuery.getBasicOptions(req.query),
-        // For creator
-        coreQuery.getCreatorUserLookupStage(),
-        coreQuery.getCreatorOrganizationLookupStage(),
-        // For owner
-        coreQuery.getOwnerUserLookupStage(),
-        coreQuery.getOwnerOrganizationLookupStage(),
-        coreQuery.getAddFieldsCreatorOwnerStage(),
-        // Pagination
-        ...coreQuery.getSortingOptions(req.query.sortParam, req.query.sortOrder),
-        ...coreQuery.getPaginationOptions(req.query.skip, req.query.limit),
-        coreQuery.removeTempPropeties(),
-      ];
-      const cacheKey = JSON.stringify({ stages });
-      let data = await this.cache.get(cacheKey);
-      if (!data) {
-        data = await this.model.aggregate(stages).exec();
-        await this.cache.set(cacheKey, data);
-      }
-      res.json(data);
-    } catch (error) {
-      this.logger.error(error);
-      res.status(500).json({ error: error.message });
-    }
-  }
-  async update(req, res) {
-    try {
-      const updatedData = await this.model.findOneAndUpdate({ _id: req.body._id }, req.body, {
-        new: true,
-        runValidators: true,
-      });
-      if (!updatedData) {
-        throw new Error('Документ не найден.');
-      }
-      await this.cache.flush();
-      res.json(updatedData);
-    } catch (error) {
-      this.logger.error('Ошибка обновления данных', error);
-      res.status(404).json({ error: error.message });
-    }
-  }
-  async delete(req, res) {
-    try {
-      const deletedData = await this.model.findOneAndDelete({ _id: req.body._id });
-      if (!deletedData) {
-        throw new Error('Документ не найден.');
-      }
-      await this.cache.flush();
-      res.status(204).send();
-    } catch (error) {
-      this.logger.error('Ошибка удаления данных', error);
-      res.status(404).json({ error: error.message });
-    }
-  }
-}
-export default CRUD;

package/src/modules/governance/reactcode/eslint.config.js

@@ -1,28 +0,0 @@
-import js from '@eslint/js';
-import globals from 'globals';
-import reactHooks from 'eslint-plugin-react-hooks';
-import reactRefresh from 'eslint-plugin-react-refresh';
-import tseslint from 'typescript-eslint';
-
-export default tseslint.config(
-  { ignores: ['dist'] },
-  {
-    extends: [js.configs.recommended, ...tseslint.configs.recommended],
-    files: ['**/*.{ts,tsx}'],
-    languageOptions: {
-      ecmaVersion: 2020,
-      globals: core.browser,
-    },
-    plugins: {
-      'react-hooks': reactHooks,
-      'react-refresh': reactRefresh,
-    },
-    rules: {
-      ...reactHooks.configs.recommended.rules,
-      'react-refresh/only-export-components': [
-        'warn',
-        { allowConstantExport: true },
-      ],
-    },
-  }
-);