@ozdao/martyrs 0.2.551 → 0.2.552

package/dist/crud-CQ3ICbm7.cjs

@@ -1,1176 +0,0 @@
-"use strict";
-const authJwt = require("./authJwt-BIZ2GIfT.cjs");
-const queryProcessor = require("./queryProcessor-DJUTwCLN.cjs");
-const core_logger = require("./core.logger-BuW7JHMY.cjs");
-class CRUDCore {
-  constructor(crud) {
-    this.crud = crud;
-    this.verifiers = {};
-    this.hooks = {};
-    this.aggregateExtensions = {};
-    this.cacheOptions = {
-      ttl: 300,
-      // 5 минут по умолчанию
-      tags: [crud.modelName],
-      enabled: true
-    };
-    this.auth = {
-      read: false,
-      // Публичный доступ к чтению
-      create: true,
-      // Требует авторизацию
-      update: true,
-      // Требует авторизацию
-      delete: true
-      // Требует авторизацию
-    };
-    this.options = {
-      enableEvents: true,
-      enableAudit: false,
-      enableMetrics: false,
-      strictMode: false,
-      serviceKey: process.env.SERVICE_KEY
-    };
-  }
-  // Инициализация с опциями
-  init(options = {}) {
-    if (options.auth !== void 0) {
-      if (options.auth === false) {
-        this.auth = false;
-      } else if (options.auth === true) {
-        this.auth = {
-          read: false,
-          create: true,
-          update: true,
-          delete: true
-        };
-      } else if (typeof options.auth === "object") {
-        this.auth = {
-          read: false,
-          create: true,
-          update: true,
-          delete: true,
-          ...options.auth
-        };
-      }
-    }
-    if (options.cache !== void 0) {
-      if (options.cache === false) {
-        this.cacheOptions.enabled = false;
-      } else if (typeof options.cache === "object") {
-        this.setCacheOptions(options.cache);
-      }
-    }
-    if (options.events !== void 0) {
-      if (options.events === false) {
-        this.options.enableEvents = false;
-      } else if (typeof options.events === "object") {
-        Object.assign(this.options, options.events);
-      }
-    }
-    if (options.verifiers) this.initVerifiers(options.verifiers);
-    if (options.hooks) this.initHooks(options.hooks);
-    if (options.middlewares) this.initMiddlewares(options.middlewares);
-    if (options.aggregateExtensions) this.initAggregateExtensions(options.aggregateExtensions);
-    if (options.abac) this.initABAC(options.abac, options.policies, options.fieldsPolicies);
-    if (options.serviceKey !== void 0) {
-      this.options.serviceKey = options.serviceKey;
-    }
-    this.crud.events.init(this.options);
-    if (options.abac) {
-      this.crud.policies.init(options.abac, options.policies, options.fieldsPolicies);
-    }
-  }
-  // Управление auth
-  setAuth(action, required) {
-    if (this.auth === false) {
-      this.auth = {};
-    }
-    this.auth[action] = required;
-  }
-  getAuth(action) {
-    if (this.auth === false) return false;
-    return this.auth[action] ?? true;
-  }
-  isAuthEnabled() {
-    return this.auth !== false;
-  }
-  // Управление верификаторами
-  setVerifier(action, verifier) {
-    this.verifiers[action] = verifier;
-  }
-  getVerifier(action) {
-    return this.verifiers[action];
-  }
-  initVerifiers(verifiers) {
-    Object.entries(verifiers).forEach(([action, verifier]) => {
-      this.setVerifier(action, verifier);
-    });
-  }
-  // Управление хуками
-  addHook(name, handler) {
-    this.hooks[name] = handler;
-  }
-  getHook(name) {
-    return this.hooks[name];
-  }
-  async executeHook(name, ...args) {
-    const hook = this.getHook(name);
-    if (hook) {
-      return await hook(...args);
-    }
-  }
-  initHooks(hooks) {
-    Object.entries(hooks).forEach(([name, handler]) => {
-      this.addHook(name, handler);
-    });
-  }
-  // Управление расширениями агрегации
-  addAggregateExtension(phase, extension) {
-    this.aggregateExtensions[phase] = extension;
-  }
-  getAggregateExtensions() {
-    return this.aggregateExtensions;
-  }
-  initAggregateExtensions(extensions) {
-    Object.entries(extensions).forEach(([phase, extension]) => {
-      this.addAggregateExtension(phase, extension);
-    });
-  }
-  // Управление middleware (делегирует в controller)
-  initMiddlewares(middlewares) {
-    Object.entries(middlewares).forEach(([phase, actions]) => {
-      if (typeof actions === "object") {
-        Object.entries(actions).forEach(([action, mws]) => {
-          const middlewareArray = Array.isArray(mws) ? mws : [mws];
-          middlewareArray.forEach((mw) => {
-            this.crud.controller.addMiddleware(phase, action, mw);
-          });
-        });
-      }
-    });
-  }
-  // Управление ABAC (делегирует в policies)
-  initABAC(abac, policies = {}, fieldsPolicies = null) {
-    if (fieldsPolicies && typeof fieldsPolicies === "function" && abac) {
-      abac.registerFieldsPolicy(this.crud.modelName, fieldsPolicies);
-    }
-  }
-  // Управление кешем
-  getCacheOptions() {
-    return { ...this.cacheOptions };
-  }
-  setCacheOptions(options) {
-    Object.assign(this.cacheOptions, options);
-    if (!this.cacheOptions.tags.includes(this.crud.modelName)) {
-      this.cacheOptions.tags.unshift(this.crud.modelName);
-    }
-  }
-  // Получение опций
-  getOptions() {
-    return { ...this.options };
-  }
-  setOption(key, value) {
-    this.options[key] = value;
-  }
-  // Проверка включенности функций
-  isEventsEnabled() {
-    return this.options.enableEvents;
-  }
-  isCacheEnabled() {
-    return this.cacheOptions.enabled && this.crud.cache !== null;
-  }
-  isAuditEnabled() {
-    return this.options.enableAudit;
-  }
-  isMetricsEnabled() {
-    return this.options.enableMetrics;
-  }
-}
-class CRUDController {
-  constructor(crud) {
-    this.crud = crud;
-    this.routes = /* @__PURE__ */ new Map();
-    this.middlewares = {
-      before: {},
-      after: {}
-    };
-    this.jwt = authJwt.middlewareFactory(crud.db);
-  }
-  // Добавление middleware
-  addMiddleware(phase, action, middleware) {
-    if (!["before", "after"].includes(phase)) {
-      throw new Error(`Invalid middleware phase: ${phase}`);
-    }
-    if (!this.middlewares[phase][action]) {
-      this.middlewares[phase][action] = [];
-    }
-    this.middlewares[phase][action].push(middleware);
-  }
-  // Получение middleware для действия
-  getMiddlewares(phase, action) {
-    return this.middlewares[phase][action] || [];
-  }
-  // Регистрация роута
-  registerRoute(method, path, actionName) {
-    const fullPath = `${this.crud.basePath}${path}`;
-    const middlewareStack = [];
-    if (this.crud.core.isAuthEnabled()) {
-      const authRequired = this.crud.core.getAuth(actionName);
-      middlewareStack.push(this.jwt.verifyToken(!authRequired));
-    }
-    const verifierMiddleware = this._createVerifierMiddleware(method, actionName);
-    if (verifierMiddleware) {
-      middlewareStack.push(verifierMiddleware);
-    }
-    middlewareStack.push(...this.getMiddlewares("before", actionName));
-    const abacMiddleware = this.crud.policies.getPoliciesMiddleware(actionName);
-    if (abacMiddleware) {
-      middlewareStack.push(abacMiddleware);
-    }
-    if (["create", "update"].includes(actionName)) {
-      const fieldsMiddleware = this.crud.policies.getFieldsMiddleware(actionName);
-      if (fieldsMiddleware) {
-        middlewareStack.push(fieldsMiddleware);
-      }
-    }
-    const handler = this._createHandler(actionName);
-    const wrappedHandler = this._wrapHandler(handler, actionName);
-    this.crud.app[method](fullPath, ...middlewareStack, wrappedHandler);
-    this.routes.set(`${method.toUpperCase()} ${fullPath}`, {
-      method,
-      path: fullPath,
-      actionName,
-      middlewareStack
-    });
-    return this;
-  }
-  // Регистрация кастомного роута
-  registerCustomRoute(method, path, actionName, handler) {
-    this.crud.service.registerCustomHandler(actionName, handler);
-    return this.registerRoute(method, path, actionName);
-  }
-  // Создание handler для стандартных CRUD операций
-  _createHandler(actionName) {
-    switch (actionName) {
-      case "create":
-        return async (req, res) => {
-          try {
-            const data = req.verified || req.body;
-            const context = this._buildContext(req);
-            const created = await this.crud.service.create(data, context);
-            res.status(201).json(created);
-          } catch (error) {
-            this._handleError(error, res);
-          }
-        };
-      case "read":
-        return async (req, res) => {
-          try {
-            const query = req.verified || req.query;
-            const context = this._buildContext(req);
-            let data = await this.crud.service.read(query, context);
-            if (this.crud.policies.hasAbac()) {
-              data = await this.crud.policies.filterFieldsForRead(req, data);
-            }
-            res.json(data);
-          } catch (error) {
-            this._handleError(error, res);
-          }
-        };
-      case "update":
-        return async (req, res) => {
-          try {
-            const data = req.verified || req.body;
-            const { _id, ...updateData } = data;
-            if (!_id) {
-              return res.status(400).json({ error: "ID_REQUIRED" });
-            }
-            const context = this._buildContext(req);
-            const updated = await this.crud.service.update(_id, updateData, context);
-            res.json(updated);
-          } catch (error) {
-            this._handleError(error, res);
-          }
-        };
-      case "delete":
-        return async (req, res) => {
-          try {
-            const data = req.verified || req.query || req.body;
-            const { _id } = data;
-            if (!_id) {
-              return res.status(400).json({ error: "ID_REQUIRED" });
-            }
-            const context = this._buildContext(req);
-            await this.crud.service.delete(_id, context);
-            res.status(204).send();
-          } catch (error) {
-            this._handleError(error, res);
-          }
-        };
-      default:
-        return async (req, res) => {
-          try {
-            const customHandler = this.crud.service.getCustomHandler(actionName);
-            if (!customHandler) {
-              return res.status(404).json({ error: "ACTION_NOT_FOUND" });
-            }
-            await customHandler.call(this.crud, req, res);
-          } catch (error) {
-            this._handleError(error, res);
-          }
-        };
-    }
-  }
-  // Создание контекста из request
-  _buildContext(req) {
-    return {
-      userId: req.userId,
-      user: req.user,
-      organizationId: req.organizationId,
-      roles: req.roles || [],
-      permissions: req.permissions || [],
-      abacContext: req.abacContext || {},
-      ip: req.ip,
-      userAgent: req.get("user-agent"),
-      isServiceRequest: req.isServiceRequest || false,
-      ...req.context
-      // Дополнительный контекст
-    };
-  }
-  // Обработка ошибок
-  _handleError(error, res) {
-    if (res.headersSent) return;
-    console.log(error);
-    const statusCode = error.statusCode || error.code === "NOT_FOUND" ? 404 : 500;
-    const message = error.message || "Internal Server Error";
-    res.status(statusCode).json({
-      error: message,
-      code: error.code
-    });
-  }
-  // Создание middleware для верификации
-  _createVerifierMiddleware(method, actionName) {
-    const verifier = this.crud.core.getVerifier(actionName);
-    if (!verifier) return null;
-    const verifyTarget = this._getVerificationTarget(method, actionName);
-    if (!verifyTarget) return null;
-    return (req, res, next) => {
-      const data = verifyTarget === "query" ? req.query : req.body;
-      const result = verifier.verify ? verifier.verify(data) : verifier.validate(data);
-      if (!result.isValid) {
-        return res.status(400).json({
-          error: "VALIDATION_ERROR",
-          field: verifyTarget,
-          errors: result.verificationErrors || result.errors
-        });
-      }
-      console.log("verified result", result);
-      req.verified = result.verifiedData || data;
-      next();
-    };
-  }
-  // Определение цели верификации
-  _getVerificationTarget(method, actionName) {
-    if (["create", "update", "delete"].includes(actionName)) {
-      return "body";
-    }
-    if (["read"].includes(actionName)) {
-      return "query";
-    }
-    if (["post", "put", "patch"].includes(method)) {
-      return "body";
-    }
-    if (["get", "delete"].includes(method)) {
-      return "query";
-    }
-    return null;
-  }
-  // Обертка handler для after middleware
-  _wrapHandler(handler, actionName) {
-    return async (req, res, next) => {
-      try {
-        await handler(req, res, next);
-        if (!res.headersSent) {
-          const afterMiddlewares = this.getMiddlewares("after", actionName);
-          for (const mw of afterMiddlewares) {
-            await new Promise((resolve, reject) => {
-              mw(req, res, (err) => err ? reject(err) : resolve());
-            });
-          }
-        }
-      } catch (error) {
-        next(error);
-      }
-    };
-  }
-  // Получение информации о роутах
-  getRoutes() {
-    return Array.from(this.routes.entries()).map(([key, value]) => ({
-      key,
-      ...value
-    }));
-  }
-  // Удаление роута
-  removeRoute(method, path) {
-    const key = `${method.toUpperCase()} ${this.crud.basePath}${path}`;
-    return this.routes.delete(key);
-  }
-  // Проверка существования роута
-  hasRoute(method, path) {
-    const key = `${method.toUpperCase()} ${this.crud.basePath}${path}`;
-    return this.routes.has(key);
-  }
-}
-class CRUDService {
-  constructor(crud) {
-    this.crud = crud;
-    this.customHandlers = /* @__PURE__ */ new Map();
-  }
-  // Регистрация кастомного handler
-  registerCustomHandler(name, handler) {
-    this.customHandlers.set(name, handler);
-  }
-  // CREATE операция
-  async create(data, context = {}) {
-    try {
-      const hookData = await this.crud.core.executeHook("beforeCreate", data, context);
-      const finalData = hookData || data;
-      const created = await this.crud.model.create(finalData);
-      if (this.crud.core.isCacheEnabled()) {
-        await this.invalidateCache("create", created);
-      }
-      if (this.crud.core.isEventsEnabled()) {
-        await this.crud.events.emit("created", {
-          document: created,
-          user: context.userId
-        });
-      }
-      await this.crud.core.executeHook("afterCreate", created, context);
-      return created;
-    } catch (error) {
-      console.log(error);
-      await this.crud.events.logError("create", error);
-      throw error;
-    }
-  }
-  // READ операция
-  async read(query = {}, context = {}) {
-    try {
-      await this.crud.core.executeHook("beforeRead", query, context);
-      let data = null;
-      let cacheKey = null;
-      if (this.crud.core.isCacheEnabled()) {
-        cacheKey = this.generateCacheKey("read", query);
-        data = await this.crud.cache.get(cacheKey);
-      }
-      if (!data) {
-        const pipeline = await this.buildAggregationPipeline(query, context);
-        data = await this.crud.model.aggregate(pipeline).exec();
-        if (this.crud.core.isCacheEnabled() && cacheKey) {
-          const cacheOptions = this.crud.core.getCacheOptions();
-          await this.crud.cache.setWithTags(
-            cacheKey,
-            data,
-            [...cacheOptions.tags, `${this.crud.modelName}_list`],
-            cacheOptions.ttl
-          );
-        }
-      }
-      if (this.crud.core.isEventsEnabled()) {
-        await this.crud.events.emitRead(query, data, context.userId);
-      }
-      const hookResult = await this.crud.core.executeHook("afterRead", data, context);
-      return hookResult || data;
-    } catch (error) {
-      console.log(error);
-      await this.crud.events.logError("read", error);
-      throw error;
-    }
-  }
-  // UPDATE операция
-  async update(id, updateData, context = {}) {
-    try {
-      const current = await this.crud.model.findById(id);
-      if (!current) {
-        const error = new Error("NOT_FOUND");
-        error.code = "NOT_FOUND";
-        error.statusCode = 404;
-        throw error;
-      }
-      const hookData = await this.crud.core.executeHook("beforeUpdate", updateData, context, current);
-      const finalData = hookData || updateData;
-      const updated = await this.crud.model.findByIdAndUpdate(
-        id,
-        finalData,
-        { new: true, runValidators: true }
-      );
-      if (this.crud.core.isCacheEnabled()) {
-        await this.invalidateCache("update", updated);
-      }
-      if (this.crud.core.isEventsEnabled()) {
-        await this.crud.events.emit("updated", {
-          document: updated,
-          previousDocument: current,
-          user: context.userId
-        });
-      }
-      await this.crud.core.executeHook("afterUpdate", updated, context, current);
-      return updated;
-    } catch (error) {
-      await this.crud.events.logError("update", error);
-      throw error;
-    }
-  }
-  // DELETE операция
-  async delete(id, context = {}) {
-    try {
-      const document = await this.crud.model.findById(id);
-      if (!document) {
-        const error = new Error("NOT_FOUND");
-        error.code = "NOT_FOUND";
-        error.statusCode = 404;
-        throw error;
-      }
-      await this.crud.core.executeHook("beforeDelete", document, context);
-      await this.crud.model.findByIdAndDelete(id);
-      if (this.crud.core.isCacheEnabled()) {
-        await this.invalidateCache("delete", document);
-      }
-      if (this.crud.core.isEventsEnabled()) {
-        await this.crud.events.emit("deleted", {
-          document,
-          user: context.userId
-        });
-      }
-      await this.crud.core.executeHook("afterDelete", document, context);
-      return document;
-    } catch (error) {
-      await this.crud.events.logError("delete", error);
-      throw error;
-    }
-  }
-  // Получение кастомного handler
-  getCustomHandler(name) {
-    return this.customHandlers.get(name);
-  }
-  // Построение aggregation pipeline
-  async buildAggregationPipeline(query, context) {
-    const stages = [];
-    const extensions = this.crud.core.getAggregateExtensions();
-    if (extensions.before) {
-      stages.push(...await extensions.before(query, context));
-    }
-    stages.push(...queryProcessor.queryProcessorCore.getBasicOptions(query));
-    if (extensions.middle) {
-      stages.push(...await extensions.middle(query, context));
-    }
-    stages.push(
-      queryProcessor.queryProcessorCore.getCreatorUserLookupStage(),
-      queryProcessor.queryProcessorCore.getCreatorOrganizationLookupStage(),
-      queryProcessor.queryProcessorCore.getOwnerUserLookupStage(),
-      queryProcessor.queryProcessorCore.getOwnerOrganizationLookupStage(),
-      queryProcessor.queryProcessorCore.getAddFieldsCreatorOwnerStage()
-    );
-    if (extensions.beforePagination) {
-      stages.push(...await extensions.beforePagination(query, context));
-    }
-    stages.push(
-      ...queryProcessor.queryProcessorCore.getSortingOptions(query.sortParam, query.sortOrder),
-      ...queryProcessor.queryProcessorCore.getPaginationOptions(query.skip, query.limit),
-      queryProcessor.queryProcessorCore.removeTempPropeties()
-    );
-    if (extensions.after) {
-      stages.push(...await extensions.after(query, context));
-    }
-    return stages;
-  }
-  // Управление кешем
-  generateCacheKey(operation, data) {
-    const prefix = `${this.crud.modelName}:${operation}`;
-    if (operation === "read") {
-      return `${prefix}:${JSON.stringify(this._normalizeQuery(data))}`;
-    }
-    return `${prefix}:${Date.now()}`;
-  }
-  _normalizeQuery(query) {
-    const normalized = {};
-    const keys = Object.keys(query).sort();
-    for (const key of keys) {
-      if (query[key] !== void 0 && query[key] !== null && query[key] !== "") {
-        normalized[key] = query[key];
-      }
-    }
-    return normalized;
-  }
-  async invalidateCache(operation, document) {
-    const cacheOptions = this.crud.core.getCacheOptions();
-    const tags = [...cacheOptions.tags];
-    if (["create", "update", "delete"].includes(operation)) {
-      tags.push(`${this.crud.modelName}_list`);
-      if (document && document._id) {
-        tags.push(`${this.crud.modelName}_${document._id}`);
-      }
-    }
-    for (const tag of tags) {
-      await this.crud.cache.delByTags([tag]);
-    }
-  }
-}
-class CRUDPolicies {
-  constructor(crud) {
-    this.crud = crud;
-    this.abac = null;
-    this.policyOptions = {};
-    this.defaultPolicies = {};
-  }
-  // Инициализация с ABAC
-  init(abac, policies = {}, fieldPolicies = null) {
-    this.abac = abac;
-    this.defaultPolicies = policies;
-  }
-  // Установка опций для конкретного действия
-  setOptions(action, options) {
-    this.policyOptions[action] = {
-      enabled: options.enabled !== false,
-      policies: options.policies || [],
-      customPolicies: options.customPolicies || {},
-      skipDefaultPolicies: options.skipDefaultPolicies || false,
-      ...options
-    };
-  }
-  // Получение опций для действия
-  getOptions(action) {
-    return this.policyOptions[action] || this.defaultPolicies[action] || {};
-  }
-  // Получение ABAC middleware для действия
-  getPoliciesMiddleware(action) {
-    if (!this.abac) return null;
-    const options = this.getOptions(action);
-    if (options.enabled === false) {
-      return null;
-    }
-    if (options.policies && options.policies.length > 0) {
-      return this.abac.policyMiddleware(
-        options.policies,
-        options.customPolicies || {},
-        {
-          resource: this.crud.modelName,
-          action,
-          skipDefaultPolicies: options.skipDefaultPolicies
-        }
-      );
-    }
-    if (options.enabled === false) {
-      return null;
-    }
-    return this.abac.middleware(this.crud.modelName, action, options);
-  }
-  // Получение middleware для проверки доступа к полям
-  getFieldsMiddleware(action) {
-    if (!this.abac) return null;
-    return async (req, res, next) => {
-      try {
-        const data = req.verified || req.body;
-        const context = {
-          user: req.userId,
-          resource: this.crud.modelName,
-          action,
-          req,
-          data: {
-            ...req.body,
-            ...req.query,
-            params: req.params
-          },
-          params: req.params
-        };
-        if (req.skipFieldPolicies) {
-          console.log("Skipping field policies for admin/moderator");
-          req.verified = data;
-          return next();
-        }
-        if (action === "update" && data._id) {
-          try {
-            const current = await this.crud.model.findById(data._id);
-            if (current) {
-              context.currentResource = current;
-            }
-          } catch (err) {
-          }
-        }
-        const fieldsResult = await this.abac.checkFields(
-          context,
-          data,
-          action
-        );
-        if (fieldsResult.denied && fieldsResult.denied.length > 0) {
-          return res.status(403).json({
-            error: "FIELD_ACCESS_DENIED",
-            deniedFields: fieldsResult.denied.map((d) => d.path)
-          });
-        }
-        if (fieldsResult.errors && fieldsResult.errors.length > 0) {
-          return res.status(400).json({
-            error: "FIELD_VALIDATION_ERROR",
-            fields: fieldsResult.errors
-          });
-        }
-        req.verified = fieldsResult.transformed || fieldsResult.allowed;
-        next();
-      } catch (error) {
-        next(error);
-      }
-    };
-  }
-  // Фильтрация полей для чтения (вызывается из controller после получения данных)
-  async filterFieldsForRead(req, data) {
-    if (!this.abac) {
-      return data;
-    }
-    const context = {
-      user: req.userId,
-      resource: this.crud.modelName,
-      action: "read",
-      req,
-      data: {
-        ...req.query,
-        params: req.params
-      },
-      params: req.params
-    };
-    if (Array.isArray(data)) {
-      const results = [];
-      for (const doc of data) {
-        const fieldsResult2 = await this.abac.checkFields(
-          { ...context, currentResource: doc },
-          doc,
-          "read"
-        );
-        results.push(fieldsResult2.transformed || fieldsResult2.allowed);
-      }
-      return results;
-    }
-    const fieldsResult = await this.abac.checkFields(
-      { ...context, currentResource: data },
-      data,
-      "read"
-    );
-    return fieldsResult.transformed || fieldsResult.allowed;
-  }
-  // Добавление кастомной политики
-  addPolicy(action, policyName, policyFn = null) {
-    if (!this.policyOptions[action]) {
-      this.policyOptions[action] = {
-        enabled: true,
-        policies: [],
-        customPolicies: {}
-      };
-    }
-    if (policyFn) {
-      this.policyOptions[action].customPolicies[policyName] = policyFn;
-    }
-    if (!this.policyOptions[action].policies.includes(policyName)) {
-      this.policyOptions[action].policies.push(policyName);
-    }
-  }
-  // Удаление политики
-  removePolicy(action, policyName) {
-    if (!this.policyOptions[action]) return;
-    const policies = this.policyOptions[action].policies;
-    const index = policies.indexOf(policyName);
-    if (index > -1) {
-      policies.splice(index, 1);
-    }
-    delete this.policyOptions[action].customPolicies[policyName];
-  }
-  // Проверка наличия ABAC
-  hasAbac() {
-    return !!this.abac;
-  }
-  // Получение всех политик для действия
-  getPolicies(action) {
-    const options = this.getOptions(action);
-    return {
-      enabled: options.enabled !== false,
-      policies: options.policies || [],
-      customPolicies: options.customPolicies || {},
-      defaultPolicies: this.defaultPolicies[action] || {}
-    };
-  }
-  // Временное отключение ABAC для действия
-  disableForAction(action) {
-    if (!this.policyOptions[action]) {
-      this.policyOptions[action] = {};
-    }
-    this.policyOptions[action].enabled = false;
-  }
-  // Включение ABAC для действия
-  enableForAction(action) {
-    if (!this.policyOptions[action]) {
-      this.policyOptions[action] = {};
-    }
-    this.policyOptions[action].enabled = true;
-  }
-  // Установка политик по умолчанию для всех действий
-  setDefaultPolicies(policies) {
-    ["create", "read", "update", "delete"].forEach((action) => {
-      if (!this.policyOptions[action]) {
-        this.policyOptions[action] = {};
-      }
-      this.policyOptions[action].policies = [...policies];
-    });
-  }
-}
-class Observer {
-  constructor() {
-    this.listeners = {};
-  }
-  subscribe(eventType, callback, once = false) {
-    if (!this.listeners[eventType]) {
-      this.listeners[eventType] = /* @__PURE__ */ new Map();
-    }
-    this.listeners[eventType].set(callback, { once });
-  }
-  async notify(eventType, data) {
-    if (this.listeners[eventType]) {
-      const promises = [];
-      const callbacksToRemove = [];
-      for (const [callback, { once }] of this.listeners[eventType]) {
-        const promise = Promise.resolve().then(() => callback(data)).catch((error) => {
-          console.error("Error executing callback:", error);
-        });
-        promises.push(promise);
-        if (once) {
-          callbacksToRemove.push(callback);
-        }
-      }
-      await Promise.all(promises);
-      for (const callback of callbacksToRemove) {
-        this.listeners[eventType].delete(callback);
-        if (this.listeners[eventType].size === 0) {
-          delete this.listeners[eventType];
-        }
-      }
-    }
-  }
-  remove(eventType, callback) {
-    if (this.listeners[eventType]?.has(callback)) {
-      this.listeners[eventType].delete(callback);
-      if (this.listeners[eventType].size === 0) {
-        delete this.listeners[eventType];
-      }
-    }
-  }
-  removeAll(eventType) {
-    if (eventType) {
-      delete this.listeners[eventType];
-    } else {
-      this.listeners = {};
-    }
-  }
-}
-const instances = /* @__PURE__ */ new Map();
-class ObserverNamespaced {
-  constructor(namespace = "global") {
-    if (instances.has(namespace)) {
-      return instances.get(namespace);
-    }
-    const instance = new Observer();
-    instances.set(namespace, instance);
-    return instance;
-  }
-  // Статический метод для получения всех namespace'ов
-  static getNamespaces() {
-    return Array.from(instances.keys());
-  }
-  // Статический метод для очистки подписок в namespace
-  static clearNamespace(namespace) {
-    if (instances.has(namespace)) {
-      instances.get(namespace).removeAll();
-    }
-  }
-  // Статический метод для удаления namespace (полностью)
-  static removeNamespace(namespace) {
-    if (instances.has(namespace)) {
-      instances.get(namespace).removeAll();
-      instances.delete(namespace);
-    }
-  }
-}
-class CRUDEvents {
-  constructor(crud) {
-    this.crud = crud;
-    this.observer = null;
-    this.logger = null;
-    this.enabled = false;
-    this.options = {};
-  }
-  init(options = {}) {
-    this.enabled = options.enabled !== false;
-    this.options = options;
-    if (this.enabled) {
-      this.observer = options.observer || new ObserverNamespaced();
-      this.logger = options.logger || new core_logger.LoggerNamespaced(this.crud.db);
-    }
-  }
-  // Отправка события
-  async emit(eventName, data) {
-    if (!this.enabled || !this.observer) return;
-    const fullEventName = `${this.crud.modelName}:${eventName}`;
-    try {
-      await this.observer.notify(fullEventName, {
-        ...data,
-        timestamp: /* @__PURE__ */ new Date(),
-        model: this.crud.modelName
-      });
-      await this.log("info", `Event emitted: ${fullEventName}`, data);
-    } catch (error) {
-      console.error(`Error emitting event ${fullEventName}:`, error);
-    }
-  }
-  // Подписка на событие
-  subscribe(eventName, handler) {
-    if (!this.observer) return null;
-    const fullEventName = `${this.crud.modelName}:${eventName}`;
-    return this.observer.subscribe(fullEventName, handler);
-  }
-  // Отписка от события
-  unsubscribe(eventName, handler) {
-    if (!this.observer) return;
-    const fullEventName = `${this.crud.modelName}:${eventName}`;
-    this.observer.unsubscribe(fullEventName, handler);
-  }
-  // Логирование
-  async log(level, message, data = {}) {
-    if (!this.enabled || !this.logger) return;
-    try {
-      const logData = {
-        model: this.crud.modelName,
-        ...data
-      };
-      switch (level) {
-        case "info":
-          await this.logger.info(message, logData);
-          break;
-        case "warning":
-          await this.logger.warning(message, logData);
-          break;
-        case "error":
-          await this.logger.error(message, logData);
-          break;
-        default:
-          await this.logger.info(message, logData);
-      }
-    } catch (error) {
-      console.error("Logging error:", error);
-    }
-  }
-  // Логирование ошибок
-  async logError(operation, error) {
-    await this.log("error", `Error in ${operation} operation`, {
-      operation,
-      error: error.message,
-      stack: error.stack
-    });
-  }
-  // Специализированные методы событий
-  async emitCreate(document, userId) {
-    await this.emit("created", {
-      document,
-      user: userId,
-      action: "create"
-    });
-  }
-  async emitUpdate(document, previousDocument, userId) {
-    await this.emit("updated", {
-      document,
-      previousDocument,
-      user: userId,
-      action: "update",
-      changes: this._getChanges(previousDocument, document)
-    });
-  }
-  async emitDelete(document, userId) {
-    await this.emit("deleted", {
-      document,
-      user: userId,
-      action: "delete"
-    });
-  }
-  async emitRead(query, results, userId) {
-    if (this.options.logReads !== false) {
-      await this.emit("read", {
-        query,
-        resultCount: Array.isArray(results) ? results.length : 1,
-        user: userId,
-        action: "read"
-      });
-    }
-  }
-  // Вспомогательные методы
-  _getChanges(oldDoc, newDoc) {
-    const changes = {};
-    if (!oldDoc || !newDoc) return changes;
-    for (const key in newDoc) {
-      if (newDoc.hasOwnProperty(key)) {
-        const oldVal = oldDoc[key];
-        const newVal = newDoc[key];
-        if (["_id", "__v", "updatedAt"].includes(key)) continue;
-        if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
-          changes[key] = {
-            old: oldVal,
-            new: newVal
-          };
-        }
-      }
-    }
-    return changes;
-  }
-  // Аудит действий
-  async audit(action, data) {
-    if (!this.options.enableAudit) return;
-    const auditData = {
-      action,
-      model: this.crud.modelName,
-      timestamp: /* @__PURE__ */ new Date(),
-      ...data
-    };
-    await this.emit("audit", auditData);
-    await this.log("info", `Audit: ${action}`, auditData);
-  }
-  // Метрики
-  async recordMetric(metric, value = 1) {
-    if (!this.options.enableMetrics) return;
-    await this.emit("metric", {
-      metric,
-      value,
-      model: this.crud.modelName,
-      timestamp: /* @__PURE__ */ new Date()
-    });
-  }
-  // Проверка включены ли события
-  isEnabled() {
-    return this.enabled;
-  }
-  // Временное отключение событий
-  disable() {
-    this.enabled = false;
-  }
-  // Включение событий
-  enable() {
-    if (this.observer && this.logger) {
-      this.enabled = true;
-    }
-  }
-}
-class CRUD {
-  constructor(options = {}) {
-    const {
-      app,
-      db,
-      model,
-      basePath,
-      modelName = model?.modelName || "resource",
-      cache,
-      logger,
-      ...otherOptions
-    } = options;
-    this.app = app;
-    this.db = db;
-    this.model = model;
-    this.basePath = basePath;
-    this.modelName = modelName;
-    this.cache = cache !== false ? cache instanceof core_logger.CacheNamespaced ? cache : new core_logger.CacheNamespaced() : null;
-    this.logger = logger || new core_logger.LoggerNamespaced(db);
-    this.initModules(otherOptions);
-    this.core.init(otherOptions);
-    if (!otherOptions.disableDefaultRoutes) {
-      this.registerDefaultRoutes();
-    }
-  }
-  initModules(options) {
-    this.core = new CRUDCore(this);
-    this.service = new CRUDService(this);
-    this.controller = new CRUDController(this);
-    this.policies = new CRUDPolicies(this);
-    this.events = new CRUDEvents(this);
-  }
-  // Регистрация дефолтных CRUD роутов
-  registerDefaultRoutes() {
-    this.controller.registerRoute("post", "/create", "create");
-    this.controller.registerRoute("get", "/read", "read");
-    this.controller.registerRoute("put", "/update", "update");
-    this.controller.registerRoute("post", "/delete", "delete");
-  }
-  // API методы для конфигурации
-  setVerifier(action, verifier) {
-    this.core.setVerifier(action, verifier);
-    return this;
-  }
-  addHook(name, handler) {
-    this.core.addHook(name, handler);
-    return this;
-  }
-  addMiddleware(phase, action, middleware) {
-    this.controller.addMiddleware(phase, action, middleware);
-    return this;
-  }
-  addAbac(action, options = {}) {
-    this.policies.setOptions(action, options);
-    return this;
-  }
-  addAggregateExtension(phase, extension) {
-    this.core.addAggregateExtension(phase, extension);
-    return this;
-  }
-  // Управление авторизацией
-  setAuth(action, required) {
-    this.core.setAuth(action, required);
-    return this;
-  }
-  // Добавление кастомного действия
-  addAction(name, config) {
-    const {
-      method = "post",
-      path = `/${name}`,
-      handler,
-      verifier,
-      middlewares = { before: [], after: [] },
-      abac = {},
-      hooks = {},
-      auth = true
-      // По умолчанию требует авторизацию
-    } = config;
-    if (verifier) this.setVerifier(name, verifier);
-    if (abac) this.addAbac(name, abac);
-    if (auth !== void 0) this.setAuth(name, auth);
-    if (middlewares.before) {
-      const beforeMiddlewares = Array.isArray(middlewares.before) ? middlewares.before : [middlewares.before];
-      beforeMiddlewares.forEach((mw) => this.addMiddleware("before", name, mw));
-    }
-    if (middlewares.after) {
-      const afterMiddlewares = Array.isArray(middlewares.after) ? middlewares.after : [middlewares.after];
-      afterMiddlewares.forEach((mw) => this.addMiddleware("after", name, mw));
-    }
-    Object.entries(hooks).forEach(([hookName, hookFn]) => {
-      this.addHook(hookName, hookFn);
-    });
-    if (handler) {
-      this.controller.registerCustomRoute(method, path, name, handler);
-    } else {
-      this.controller.registerRoute(method, path, name);
-    }
-    return this;
-  }
-  // Получение конфигурации кеша
-  getCacheOptions() {
-    return this.core.getCacheOptions();
-  }
-  // Установка опций кеша
-  setCacheOptions(options) {
-    this.core.setCacheOptions(options);
-    return this;
-  }
-}
-exports.CRUD = CRUD;
-exports.ObserverNamespaced = ObserverNamespaced;