@ozdao/martyrs 0.2.550 → 0.2.552

package/dist/core.abac-DqDvtkHR.cjs

@@ -1,297 +0,0 @@
-"use strict";
-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";
-    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()}`
-      };
-    }
-    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()}` };
-    }
-    if (result === void 0 && 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;
-    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: void 0, 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;
-      }
-    }
-    if (hasForceDisallow) {
-      return {
-        allow: false,
-        reason: denyReason || "FORCE_DENIED_BY_POLICY"
-      };
-    }
-    if (hasForceAllow) {
-      return {
-        allow: true,
-        reason: allowReason || "FORCE_ALLOWED_BY_POLICY"
-      };
-    }
-    if (hasDeny) {
-      return {
-        allow: false,
-        reason: denyReason || "DENIED_BY_POLICY"
-      };
-    }
-    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);
-      }
-    }
-    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`
-        };
-      }
-    }
-    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;
-const getInstance = (db, options) => {
-  if (!instance) {
-    instance = new GlobalABAC(db, options);
-  }
-  return instance;
-};
-const coreabac = {
-  getInstance
-};
-exports.coreabac = coreabac;

package/dist/core.logger-BuW7JHMY.cjs

@@ -1,165 +0,0 @@
-"use strict";
-const NodeCache = require("node-cache");
-class Cache {
-  constructor(options = {}) {
-    const { ttlSeconds = 60 * 5 } = options;
-    this.cache = new NodeCache({ stdTTL: ttlSeconds });
-    this.tagStore = /* @__PURE__ */ new Map();
-  }
-  async get(key) {
-    return this.cache.get(key);
-  }
-  async set(key, value) {
-    return this.cache.set(key, value);
-  }
-  async setWithTags(key, value, tags = []) {
-    const success = this.cache.set(key, value);
-    if (success && tags.length > 0) {
-      for (const tag of tags) {
-        if (!this.tagStore.has(tag)) {
-          this.tagStore.set(tag, /* @__PURE__ */ new Set());
-        }
-        this.tagStore.get(tag).add(key);
-      }
-    }
-    return success;
-  }
-  async del(keys) {
-    const keyArray = Array.isArray(keys) ? keys : [keys];
-    const deletedCount = this.cache.del(keyArray);
-    for (const key of keyArray) {
-      for (const [tag, keySet] of this.tagStore.entries()) {
-        if (keySet.has(key)) {
-          keySet.delete(key);
-          if (keySet.size === 0) {
-            this.tagStore.delete(tag);
-          }
-        }
-      }
-    }
-    return deletedCount;
-  }
-  async delByTag(tag) {
-    if (!this.tagStore.has(tag)) return 0;
-    const keys = Array.from(this.tagStore.get(tag));
-    const deletedCount = await this.del(keys);
-    this.tagStore.delete(tag);
-    return deletedCount;
-  }
-  async delByTags(tags) {
-    let totalDeleted = 0;
-    for (const tag of tags) {
-      totalDeleted += await this.delByTag(tag);
-    }
-    return totalDeleted;
-  }
-  async flush() {
-    this.cache.flushAll();
-    this.tagStore.clear();
-  }
-  async keys() {
-    return this.cache.keys();
-  }
-  async getTagsForKey(key) {
-    const tags = [];
-    for (const [tag, keySet] of this.tagStore.entries()) {
-      if (keySet.has(key)) {
-        tags.push(tag);
-      }
-    }
-    return tags;
-  }
-  async stats() {
-    return {
-      keys: this.cache.keys().length,
-      tags: this.tagStore.size,
-      ...this.cache.getStats()
-    };
-  }
-}
-const instances$1 = /* @__PURE__ */ new Map();
-class CacheNamespaced {
-  constructor(namespaceOrOptions, options) {
-    let namespace = "global";
-    let cacheOptions = {};
-    if (typeof namespaceOrOptions === "string") {
-      namespace = namespaceOrOptions;
-      cacheOptions = options || {};
-    } else if (typeof namespaceOrOptions === "object") {
-      cacheOptions = namespaceOrOptions || {};
-    }
-    if (instances$1.has(namespace)) {
-      return instances$1.get(namespace);
-    }
-    const instance = new Cache(cacheOptions);
-    instances$1.set(namespace, instance);
-    return instance;
-  }
-  // Статический метод для получения всех namespace'ов
-  static getNamespaces() {
-    return Array.from(instances$1.keys());
-  }
-  // Статический метод для очистки конкретного namespace
-  static async flushNamespace(namespace) {
-    if (instances$1.has(namespace)) {
-      await instances$1.get(namespace).flush();
-    }
-  }
-  // Статический метод для удаления namespace (полностью)
-  static removeNamespace(namespace) {
-    if (instances$1.has(namespace)) {
-      instances$1.get(namespace).flush();
-      instances$1.delete(namespace);
-    }
-  }
-}
-class Logger {
-  constructor(db) {
-    this.LogModel = db.log;
-  }
-  async log(level, message) {
-    const logEntry = new this.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);
-  }
-}
-const instances = /* @__PURE__ */ new Map();
-class LoggerNamespaced {
-  constructor(namespaceOrDb, db) {
-    if (!db && namespaceOrDb && typeof namespaceOrDb === "object") {
-      const namespace2 = "global";
-      if (instances.has(namespace2)) {
-        return instances.get(namespace2);
-      }
-      const instance2 = new Logger(namespaceOrDb);
-      instances.set(namespace2, instance2);
-      return instance2;
-    }
-    const namespace = namespaceOrDb;
-    if (instances.has(namespace)) {
-      return instances.get(namespace);
-    }
-    const instance = new Logger(db);
-    instances.set(namespace, instance);
-    return instance;
-  }
-  // Статический метод для получения всех namespace'ов
-  static getNamespaces() {
-    return Array.from(instances.keys());
-  }
-}
-exports.CacheNamespaced = CacheNamespaced;
-exports.LoggerNamespaced = LoggerNamespaced;

package/dist/core.server.cjs

@@ -1,135 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const abac = require("./abac-gNSxNkX1.cjs");
-const initCorePolicies = (function initializeDefaultPolicies(abacAccessControl) {
-  abacAccessControl.registerGlobalPolicy("AdminModeratorAccessPolicy", async (context) => {
-    const { user, req } = context;
-    if (!user) {
-      return { allow: true, force: false };
-    }
-    try {
-      const userModel = abacAccessControl.db.user;
-      const userDoc = await userModel.findById(user).populate("roles");
-      let userRoles = [];
-      if (userDoc && userDoc.roles) {
-        context.userDoc = userDoc;
-        userRoles = userDoc.roles.map((role) => typeof role === "string" ? role : role.name || role);
-      }
-      const isAdmin = userRoles.includes("admin");
-      const isModerator = userRoles.includes("moderator");
-      if (isAdmin || isModerator) {
-        if (context.req) {
-          context.req.skipFieldPolicies = true;
-        }
-        return {
-          allow: true,
-          force: true,
-          reason: isAdmin ? "ADMIN_ACCESS_GRANTED" : "MODERATOR_ACCESS_GRANTED"
-        };
-      }
-      return { allow: true, force: false };
-    } catch (error) {
-      console.error("Error in AdminModeratorPolicy:", error);
-      return { allow: true, force: false };
-    }
-  });
-  abacAccessControl.registerGlobalPolicy("PersonalResourceOwnerPolicy", async (context) => {
-    let { user, action, data, currentResource, options } = context;
-    const ObjectId = abacAccessControl.db.mongoose.Types.ObjectId;
-    if (action === "create" && data.owner?.type === "user") {
-      if (data.owner.target === user && data.creator.target === user) {
-        return { allow: true, force: false };
-      } else {
-        return {
-          allow: false,
-          force: false,
-          reason: "UNAUTHORIZED_RESOURCE_CREATION"
-        };
-      }
-    }
-    if (action === "read") {
-      const allowedPublicStatuses = ["published", "active", "featured"];
-      if (!user || currentResource && currentResource.creator && !currentResource.creator.target.equals(new ObjectId(user))) {
-        if (context.req && context.req.query) {
-          if (context.req.query.status) {
-            if (Array.isArray(context.req.query.status)) {
-              for (const queryStatus of context.req.query.status) {
-                if (!allowedPublicStatuses.includes(queryStatus)) {
-                  return {
-                    allow: false,
-                    force: true,
-                    // Стопроцентный запрет для неразрешенных статусов
-                    reason: "UNAUTHORIZED_STATUS_ACCESS"
-                  };
-                }
-              }
-            } else {
-              if (!allowedPublicStatuses.includes(context.req.query.status)) {
-                return {
-                  allow: false,
-                  force: true,
-                  // Стопроцентный запрет для неразрешенных статусов
-                  reason: "UNAUTHORIZED_STATUS_ACCESS"
-                };
-              }
-            }
-          }
-        }
-        if (currentResource && !allowedPublicStatuses.includes(currentResource.status)) {
-          return {
-            allow: false,
-            force: true,
-            // Стопроцентный запрет для неразрешенных статусов
-            reason: "UNAUTHORIZED_RESOURCE_ACCESS"
-          };
-        }
-      }
-      return { allow: true, force: false };
-    }
-    if ((action === "edit" || action === "delete") && currentResource && currentResource.owner?.type === "user") {
-      if (currentResource.creator.target.equals(new ObjectId(user))) {
-        return { allow: true, force: false };
-      } else {
-        return {
-          allow: false,
-          force: false,
-          reason: "NOT_RESOURCE_OWNER"
-        };
-      }
-    }
-    return { allow: true, force: false };
-  });
-  return abacAccessControl;
-});
-const { getInstance } = abac.ABAC;
-let _WebSocketManagerClass = null;
-async function createWebSocketManager(...args) {
-  if (!_WebSocketManagerClass) {
-    const module2 = await Promise.resolve().then(() => require("./core.websocket-Cm72lPCs.cjs"));
-    _WebSocketManagerClass = module2.default;
-  }
-  return new _WebSocketManagerClass(...args);
-}
-const WebSocketManager = createWebSocketManager;
-function initializeCore(app, db, origins, publicPath) {
-  db.log = db.mongoose.models.Log || db.mongoose.model(
-    "Log",
-    new db.mongoose.Schema(
-      {
-        timestamp: { type: Date, default: Date.now },
-        level: String,
-        message: String
-      },
-      { versionKey: false }
-    )
-  );
-  const abac2 = getInstance(db);
-  initCorePolicies(abac2);
-}
-const core_server = {
-  initialize: initializeCore,
-  WebSocketManager
-};
-exports.WebSocketManager = WebSocketManager;
-exports.default = core_server;
-exports.initialize = initializeCore;