@ozdao/martyrs 0.2.488 → 0.2.491

package/dist/globals.logger-Bf6rRU7j.js

@@ -0,0 +1,156 @@
+import NodeCache from "node-cache";
+class Cache {
+  constructor(options = {}) {
+    const { ttlSeconds = 60 * 5 } = options;
+    this.cache = new NodeCache({ stdTTL: ttlSeconds });
+    this.tagStore = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Получение значения по ключу
+   * @param {string} key - Ключ
+   * @returns {Promise<any>} Значение из кэша
+   */
+  async get(key) {
+    return this.cache.get(key);
+  }
+  /**
+   * Установка значения по ключу
+   * @param {string} key - Ключ
+   * @param {any} value - Значение
+   * @returns {Promise<boolean>} Успешность операции
+   */
+  async set(key, value) {
+    return this.cache.set(key, value);
+  }
+  /**
+   * Установка значения с тегами
+   * @param {string} key - Ключ
+   * @param {any} value - Значение
+   * @param {string[]} tags - Массив тегов
+   * @returns {Promise<boolean>} Успешность операции
+   */
+  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;
+  }
+  /**
+   * Удаление по ключу или ключам
+   * @param {string|string[]} keys - Ключ или массив ключей
+   * @returns {Promise<number>} Количество удаленных элементов
+   */
+  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;
+  }
+  /**
+   * Удаление всех ключей, связанных с тегом
+   * @param {string} tag - Тег
+   * @returns {Promise<number>} Количество удаленных элементов
+   */
+  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;
+  }
+  /**
+   * Удаление всех ключей, связанных с массивом тегов
+   * @param {string[]} tags - Массив тегов
+   * @returns {Promise<number>} Количество удаленных элементов
+   */
+  async delByTags(tags) {
+    let totalDeleted = 0;
+    for (const tag of tags) {
+      totalDeleted += await this.delByTag(tag);
+    }
+    return totalDeleted;
+  }
+  /**
+   * Полная очистка кэша
+   * @returns {Promise<void>}
+   */
+  async flush() {
+    this.cache.flushAll();
+    this.tagStore.clear();
+  }
+  /**
+   * Получение всех ключей в кэше
+   * @returns {Promise<string[]>} Массив ключей
+   */
+  async keys() {
+    return this.cache.keys();
+  }
+  /**
+   * Получение тегов для ключа
+   * @param {string} key - Ключ
+   * @returns {Promise<string[]>} Массив тегов
+   */
+  async getTagsForKey(key) {
+    const tags = [];
+    for (const [tag, keySet] of this.tagStore.entries()) {
+      if (keySet.has(key)) {
+        tags.push(tag);
+      }
+    }
+    return tags;
+  }
+  /**
+   * Получение статистики кэша
+   * @returns {Promise<object>} Статистика
+   */
+  async stats() {
+    return {
+      keys: this.cache.keys().length,
+      tags: this.tagStore.size,
+      ...this.cache.getStats()
+    };
+  }
+}
+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);
+  }
+}
+export {
+  Cache as C,
+  Logger as L
+};

package/dist/globals.logger-CZMgIMlM.cjs

@@ -0,0 +1,155 @@
+"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();
+  }
+  /**
+   * Получение значения по ключу
+   * @param {string} key - Ключ
+   * @returns {Promise<any>} Значение из кэша
+   */
+  async get(key) {
+    return this.cache.get(key);
+  }
+  /**
+   * Установка значения по ключу
+   * @param {string} key - Ключ
+   * @param {any} value - Значение
+   * @returns {Promise<boolean>} Успешность операции
+   */
+  async set(key, value) {
+    return this.cache.set(key, value);
+  }
+  /**
+   * Установка значения с тегами
+   * @param {string} key - Ключ
+   * @param {any} value - Значение
+   * @param {string[]} tags - Массив тегов
+   * @returns {Promise<boolean>} Успешность операции
+   */
+  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;
+  }
+  /**
+   * Удаление по ключу или ключам
+   * @param {string|string[]} keys - Ключ или массив ключей
+   * @returns {Promise<number>} Количество удаленных элементов
+   */
+  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;
+  }
+  /**
+   * Удаление всех ключей, связанных с тегом
+   * @param {string} tag - Тег
+   * @returns {Promise<number>} Количество удаленных элементов
+   */
+  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;
+  }
+  /**
+   * Удаление всех ключей, связанных с массивом тегов
+   * @param {string[]} tags - Массив тегов
+   * @returns {Promise<number>} Количество удаленных элементов
+   */
+  async delByTags(tags) {
+    let totalDeleted = 0;
+    for (const tag of tags) {
+      totalDeleted += await this.delByTag(tag);
+    }
+    return totalDeleted;
+  }
+  /**
+   * Полная очистка кэша
+   * @returns {Promise<void>}
+   */
+  async flush() {
+    this.cache.flushAll();
+    this.tagStore.clear();
+  }
+  /**
+   * Получение всех ключей в кэше
+   * @returns {Promise<string[]>} Массив ключей
+   */
+  async keys() {
+    return this.cache.keys();
+  }
+  /**
+   * Получение тегов для ключа
+   * @param {string} key - Ключ
+   * @returns {Promise<string[]>} Массив тегов
+   */
+  async getTagsForKey(key) {
+    const tags = [];
+    for (const [tag, keySet] of this.tagStore.entries()) {
+      if (keySet.has(key)) {
+        tags.push(tag);
+      }
+    }
+    return tags;
+  }
+  /**
+   * Получение статистики кэша
+   * @returns {Promise<object>} Статистика
+   */
+  async stats() {
+    return {
+      keys: this.cache.keys().length,
+      tags: this.tagStore.size,
+      ...this.cache.getStats()
+    };
+  }
+}
+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);
+  }
+}
+exports.Cache = Cache;
+exports.Logger = Logger;

package/dist/globals.observer-CDqUjVU5.js

@@ -0,0 +1,44 @@
+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];
+      }
+    }
+  }
+}
+export {
+  Observer as O
+};

package/dist/globals.observer-CV2wCzzh.cjs

@@ -0,0 +1,43 @@
+"use strict";
+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];
+      }
+    }
+  }
+}
+exports.Observer = Observer;

package/dist/globals.server.cjs

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const abac = require("./abac-6LjoG9u-.cjs");
+const globals_websocket = require("./globals.websocket-k6_B1T7k.cjs");
+const initGlobalsPolicies = 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;
+function initializeGlobals(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);
+  initGlobalsPolicies(abac2);
+}
+const globals_server = {
+  initialize: initializeGlobals,
+  WebSocketManager: globals_websocket.WebSocketManager
+};
+exports.WebSocketManager = globals_websocket.WebSocketManager;
+exports.default = globals_server;
+exports.initialize = initializeGlobals;

package/dist/globals.server.js

@@ -0,0 +1,127 @@
+import { A as ABAC } from "./abac-Cf_9lCSh.js";
+import { W as WebSocketManager } from "./globals.websocket-DzvdIBf6.js";
+const initGlobalsPolicies = 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;
+function initializeGlobals(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 abac = getInstance(db);
+  initGlobalsPolicies(abac);
+}
+const globals_server = {
+  initialize: initializeGlobals,
+  WebSocketManager
+};
+export {
+  WebSocketManager,
+  globals_server as default,
+  initializeGlobals as initialize
+};