@ozdao/martyrs 0.2.486 → 0.2.487

package/dist/crud-DJvpe0aZ.js

@@ -0,0 +1,1097 @@
+import { m as middlewareFactory } from "./authJwt-DqxhUym0.js";
+import { q as queryProcessorGlobals } from "./queryProcessor-CVcLPEnv.js";
+import { O as Observer } from "./globals.observer-CDqUjVU5.js";
+import { L as Logger, C as Cache } from "./globals.logger-Bf6rRU7j.js";
+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 = 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;
+    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"].includes(actionName)) {
+      return "body";
+    }
+    if (["read", "delete"].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(...queryProcessorGlobals.getBasicOptions(query));
+    if (extensions.middle) {
+      stages.push(...await extensions.middle(query, context));
+    }
+    stages.push(
+      queryProcessorGlobals.getCreatorUserLookupStage(),
+      queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+      queryProcessorGlobals.getOwnerUserLookupStage(),
+      queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+      queryProcessorGlobals.getAddFieldsCreatorOwnerStage()
+    );
+    if (extensions.beforePagination) {
+      stages.push(...await extensions.beforePagination(query, context));
+    }
+    stages.push(
+      ...queryProcessorGlobals.getSortingOptions(query.sortParam, query.sortOrder),
+      ...queryProcessorGlobals.getPaginationOptions(query.skip, query.limit),
+      queryProcessorGlobals.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
+        }
+      );
+    }
+    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 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 Observer();
+      this.logger = options.logger || new Logger(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 Cache ? cache : new Cache() : null;
+    this.logger = logger || new Logger(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("delete", "/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;
+  }
+}
+export {
+  CRUD as C
+};