@ozdao/prometheus-framework 0.2.330 → 0.2.331

package/dist/globals.abac-dtpS1dd-.mjs

@@ -0,0 +1,189 @@
+var globals_abac;
+var hasRequiredGlobals_abac;
+function requireGlobals_abac() {
+  if (hasRequiredGlobals_abac) return globals_abac;
+  hasRequiredGlobals_abac = 1;
+  class GlobalABAC {
+    constructor(db, options = {}) {
+      this.policies = {
+        global: {},
+        // Глобальные политики
+        resources: {},
+        // Политики для ресурсов
+        extensions: {}
+        // Расширения от внешних модулей
+      };
+      this.options = {
+        strictMode: false,
+        defaultDeny: false,
+        ...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";
+      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;
+    }
+    // Базовый метод проверки доступа
+    async checkAccess(context) {
+      const {
+        user,
+        // Пользователь
+        resource,
+        // Тип ресурса
+        action,
+        // Действие
+        data,
+        // Данные ресурса
+        options = {}
+        // Добавляем опции
+      } = context;
+      if (!user && !options.allowUnauthenticated) {
+        return {
+          allowed: false,
+          reason: "UNAUTHENTICATED_ALLOWED"
+        };
+      }
+      if (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 {
+              allowed: false,
+              reason: "RESOURCE_NOT_FOUND"
+            };
+          }
+          context.currentResource = currentResource;
+          context.resourceModel = resourceModel;
+        } catch (error) {
+          console.error("Resource loading error:", error);
+          return {
+            allowed: false,
+            reason: "RESOURCE_LOAD_ERROR"
+          };
+        }
+      }
+      for (const [policyName, policyFn] of Object.entries(this.policies.global)) {
+        const result = await policyFn(context);
+        if (result === false) {
+          return {
+            allowed: false,
+            reason: `DENIED_BY_GLOBAL_POLICY_${policyName.toUpperCase()}`
+          };
+        }
+      }
+      if (this.policies.resources[resource]) {
+        const resourceResult = await this.policies.resources[resource](context);
+        if (resourceResult === true) {
+          return {
+            allowed: true,
+            reason: "RESOURCE_POLICY_ALLOWED"
+          };
+        }
+      }
+      for (const [moduleName, extensionFn] of Object.entries(this.policies.extensions)) {
+        const extensionResult = await extensionFn(context);
+        if (extensionResult && extensionResult.allowed) {
+          return {
+            allowed: true,
+            reason: `ALLOWED_BY_${moduleName.toUpperCase()}_EXTENSION`
+          };
+        }
+      }
+      return {
+        allowed: !this.options.defaultDeny,
+        reason: "ACCESS_DENIED"
+      };
+    }
+    // Middleware для Express
+    middleware(resource, action, options = {}) {
+      return async (req, res, next) => {
+        try {
+          const context = {
+            user: req.userId,
+            resource,
+            action,
+            data: {
+              ...req.body,
+              ...req.query,
+              params: req.params
+            },
+            options,
+            // Передаем опции в контекст
+            req,
+            // Передаем весь объект запроса для максимальной гибкости
+            res
+            // И объект ответа
+          };
+          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.paramas = context.data.params;
+          if (accessResult.allowed) {
+            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;
+  globals_abac = {
+    getInstance: (db, options) => {
+      if (!instance) {
+        instance = new GlobalABAC(db, options);
+      }
+      return instance;
+    }
+  };
+  return globals_abac;
+}
+export {
+  requireGlobals_abac as r
+};

package/dist/globals.abac-laM7hZZV.js

@@ -0,0 +1,188 @@
+"use strict";
+var globals_abac;
+var hasRequiredGlobals_abac;
+function requireGlobals_abac() {
+  if (hasRequiredGlobals_abac) return globals_abac;
+  hasRequiredGlobals_abac = 1;
+  class GlobalABAC {
+    constructor(db, options = {}) {
+      this.policies = {
+        global: {},
+        // Глобальные политики
+        resources: {},
+        // Политики для ресурсов
+        extensions: {}
+        // Расширения от внешних модулей
+      };
+      this.options = {
+        strictMode: false,
+        defaultDeny: false,
+        ...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";
+      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;
+    }
+    // Базовый метод проверки доступа
+    async checkAccess(context) {
+      const {
+        user,
+        // Пользователь
+        resource,
+        // Тип ресурса
+        action,
+        // Действие
+        data,
+        // Данные ресурса
+        options = {}
+        // Добавляем опции
+      } = context;
+      if (!user && !options.allowUnauthenticated) {
+        return {
+          allowed: false,
+          reason: "UNAUTHENTICATED_ALLOWED"
+        };
+      }
+      if (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 {
+              allowed: false,
+              reason: "RESOURCE_NOT_FOUND"
+            };
+          }
+          context.currentResource = currentResource;
+          context.resourceModel = resourceModel;
+        } catch (error) {
+          console.error("Resource loading error:", error);
+          return {
+            allowed: false,
+            reason: "RESOURCE_LOAD_ERROR"
+          };
+        }
+      }
+      for (const [policyName, policyFn] of Object.entries(this.policies.global)) {
+        const result = await policyFn(context);
+        if (result === false) {
+          return {
+            allowed: false,
+            reason: `DENIED_BY_GLOBAL_POLICY_${policyName.toUpperCase()}`
+          };
+        }
+      }
+      if (this.policies.resources[resource]) {
+        const resourceResult = await this.policies.resources[resource](context);
+        if (resourceResult === true) {
+          return {
+            allowed: true,
+            reason: "RESOURCE_POLICY_ALLOWED"
+          };
+        }
+      }
+      for (const [moduleName, extensionFn] of Object.entries(this.policies.extensions)) {
+        const extensionResult = await extensionFn(context);
+        if (extensionResult && extensionResult.allowed) {
+          return {
+            allowed: true,
+            reason: `ALLOWED_BY_${moduleName.toUpperCase()}_EXTENSION`
+          };
+        }
+      }
+      return {
+        allowed: !this.options.defaultDeny,
+        reason: "ACCESS_DENIED"
+      };
+    }
+    // Middleware для Express
+    middleware(resource, action, options = {}) {
+      return async (req, res, next) => {
+        try {
+          const context = {
+            user: req.userId,
+            resource,
+            action,
+            data: {
+              ...req.body,
+              ...req.query,
+              params: req.params
+            },
+            options,
+            // Передаем опции в контекст
+            req,
+            // Передаем весь объект запроса для максимальной гибкости
+            res
+            // И объект ответа
+          };
+          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.paramas = context.data.params;
+          if (accessResult.allowed) {
+            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;
+  globals_abac = {
+    getInstance: (db, options) => {
+      if (!instance) {
+        instance = new GlobalABAC(db, options);
+      }
+      return instance;
+    }
+  };
+  return globals_abac;
+}
+exports.requireGlobals_abac = requireGlobals_abac;

package/dist/globals.crud-BYsWLRqB.js

@@ -0,0 +1,177 @@
+"use strict";
+const queryProcessor = require("./queryProcessor-B3PZEzSW.js");
+const require$$0 = require("node-cache");
+var globals_cache;
+var hasRequiredGlobals_cache;
+function requireGlobals_cache() {
+  if (hasRequiredGlobals_cache) return globals_cache;
+  hasRequiredGlobals_cache = 1;
+  const NodeCache = require$$0;
+  const stdTTL = 60 * 5;
+  class Cache {
+    constructor(ttlSeconds = stdTTL) {
+      this.cache = new NodeCache({ stdTTL: ttlSeconds });
+    }
+    async get(key) {
+      return this.cache.get(key);
+    }
+    async set(key, value) {
+      return this.cache.set(key, value);
+    }
+    async del(keys) {
+      return this.cache.del(keys);
+    }
+    async flush() {
+      this.cache.flushAll();
+    }
+  }
+  globals_cache = Cache;
+  return globals_cache;
+}
+var globals_logger;
+var hasRequiredGlobals_logger;
+function requireGlobals_logger() {
+  if (hasRequiredGlobals_logger) return globals_logger;
+  hasRequiredGlobals_logger = 1;
+  class Logger {
+    static logModel = null;
+    constructor(db) {
+      if (!Logger.logModel) {
+        const logSchema = new db.mongoose.Schema({
+          timestamp: { type: Date, default: Date.now },
+          level: String,
+          message: String
+        }, { versionKey: false });
+        Logger.logModel = db.mongoose.model("Log", logSchema);
+      }
+      this.LogModel = Logger.logModel;
+    }
+    async log(level, message) {
+      const logEntry = new Logger.logModel({
+        level,
+        message
+      });
+      try {
+        await logEntry.save();
+        console.info(`Logged: ${level} - ${message}`);
+      } catch (err) {
+        console.error("Logging error:", err);
+      }
+    }
+    // Удобные методы для различных уровней логирования
+    async info(message) {
+      await this.log("info", message);
+    }
+    async error(message) {
+      await this.log("error", message);
+    }
+  }
+  globals_logger = Logger;
+  return globals_logger;
+}
+var globals_crud;
+var hasRequiredGlobals_crud;
+function requireGlobals_crud() {
+  if (hasRequiredGlobals_crud) return globals_crud;
+  hasRequiredGlobals_crud = 1;
+  const globalsQuery = queryProcessor.requireQueryProcessor();
+  const Cache = requireGlobals_cache();
+  const Logger = requireGlobals_logger();
+  class CRUD {
+    constructor(basePath, app, db, model) {
+      this.model = model;
+      this.cache = new Cache();
+      this.logger = new Logger(db);
+      this.app = app;
+      this.basePath = basePath;
+      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 = [
+          ...globalsQuery.getBasicOptions(
+            req.query
+          ),
+          // For creator
+          globalsQuery.getCreatorUserLookupStage(),
+          globalsQuery.getCreatorOrganizationLookupStage(),
+          // For owner
+          globalsQuery.getOwnerUserLookupStage(),
+          globalsQuery.getOwnerOrganizationLookupStage(),
+          globalsQuery.getAddFieldsCreatorOwnerStage(),
+          // Pagination
+          ...globalsQuery.getSortingOptions(
+            req.query.sortParam,
+            req.query.sortOrder
+          ),
+          ...globalsQuery.getPaginationOptions(
+            req.query.skip,
+            req.query.limit
+          ),
+          globalsQuery.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 });
+      }
+    }
+  }
+  globals_crud = CRUD;
+  return globals_crud;
+}
+exports.requireGlobals_crud = requireGlobals_crud;