@ozdao/martyrs 0.2.550 → 0.2.552

package/dist/core.verifier-Bi-XLEi9.cjs

@@ -1,651 +0,0 @@
-"use strict";
-class Validator {
-  /**
-   * @param {ValidationOptions} [options] - Опции валидации
-   */
-  constructor(options = {}) {
-    this.rules = [];
-    this.errors = [];
-    this.options = {
-      messages: {},
-      context: "",
-      ...options
-    };
-  }
-  /**
-   * Создает новый экземпляр валидатора
-   * @param {ValidationOptions} [options] - Опции валидации
-   * @returns {Validator}
-   */
-  static schema(options) {
-    return new Validator(options);
-  }
-  /**
-   * Проверяет, что значение является строкой
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  string(message) {
-    this.rules.push({
-      type: "string",
-      check: (value) => typeof value === "string",
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет, что значение является числом
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  number(message) {
-    this.rules.push({
-      type: "number",
-      check: (value) => {
-        if (typeof value === "string" && value.trim() !== "") {
-          if (!/^-?\d+$/.test(value.trim())) return false;
-          value = Number(value);
-        }
-        return Number.isInteger(value);
-      },
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет, что значение является целым числом (integer)
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  integer(message) {
-    this.rules.push({
-      type: "integer",
-      check: (value) => {
-        if (typeof value === "string" && value.trim() !== "" && /^-?\d+$/.test(value.trim())) {
-          value = Number(value);
-        }
-        return Number.isInteger(value);
-      },
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет, что значение является булевым
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  boolean(message) {
-    this.rules.push({
-      type: "boolean",
-      check: (value) => {
-        if (typeof value === "boolean") return true;
-        if (typeof value === "string") {
-          const lowered = value.toLowerCase();
-          return lowered === "true" || lowered === "false";
-        }
-        return false;
-      },
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет, что значение является массивом
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  array(message) {
-    this.rules.push({
-      type: "array",
-      check: (value) => Array.isArray(value),
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет, что значение является объектом Date или строкой в ISO-формате
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  date(message) {
-    this.rules.push({
-      type: "date",
-      check: (value) => {
-        const dateObj = value instanceof Date ? value : new Date(value);
-        return dateObj instanceof Date && !isNaN(dateObj.getTime());
-      },
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет, что значение не пустое
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  required(message) {
-    this.rules.push({
-      type: "required",
-      check: (value) => {
-        if (value === void 0 || value === null || value === "") return false;
-        if (Array.isArray(value) && value.length === 0) return false;
-        if (typeof value === "object" && Object.keys(value).length === 0) return false;
-        return true;
-      },
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет минимальное значение или длину
-   * @param {number|Date} limit - Минимальное значение
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  min(limit, message) {
-    this.rules.push({
-      type: "min",
-      check: (value) => {
-        if (value === void 0 || value === null) return true;
-        if (typeof value === "string" && value.trim() !== "" && /^-?\d+$/.test(value.trim())) {
-          value = Number(value);
-        }
-        if (typeof value === "number") return value >= limit;
-        if (value?.length !== void 0) return value.length >= limit;
-        if (value instanceof Date && limit instanceof Date) {
-          return value.getTime() >= limit.getTime();
-        }
-        return true;
-      },
-      param: limit,
-      message
-    });
-    return this;
-  }
-  max(limit, message) {
-    this.rules.push({
-      type: "max",
-      check: (value) => {
-        if (value === void 0 || value === null) return true;
-        if (typeof value === "string" && value.trim() !== "" && /^-?\d+$/.test(value.trim())) {
-          value = Number(value);
-        }
-        if (typeof value === "number") return value <= limit;
-        if (value?.length !== void 0) return value.length <= limit;
-        if (value instanceof Date && limit instanceof Date) {
-          return value.getTime() <= limit.getTime();
-        }
-        return true;
-      },
-      param: limit,
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет длину строки
-   * @param {{ min?: number, max?: number }} options - Минимальная и максимальная длина
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  length(options, message) {
-    this.rules.push({
-      type: "length",
-      check: (value) => {
-        if (value === void 0 || value === null) return true;
-        const str = String(value);
-        if (options.min !== void 0 && str.length < options.min) return false;
-        if (options.max !== void 0 && str.length > options.max) return false;
-        return true;
-      },
-      param: options,
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет соответствие регулярному выражению
-   * @param {RegExp} regex - Регулярное выражение
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  pattern(regex, message) {
-    if (regex.toString().length > 1e3) {
-      throw new Error("Regular expression is too complex");
-    }
-    this.rules.push({
-      type: "pattern",
-      check: (value) => typeof value === "string" && regex.test(value),
-      param: regex,
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет, что значение является email-адресом
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  email(message) {
-    const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
-    this.rules.push({
-      type: "email",
-      check: (value) => typeof value === "string" && emailRegex.test(value),
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет, что значение входит в список допустимых
-   * @param {any[]} values - Массив допустимых значений
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  oneOf(values, message) {
-    this.rules.push({
-      type: "oneOf",
-      check: (value) => values.some(
-        (item) => (
-          // Использование глубокого сравнения для объектов
-          JSON.stringify(item) === JSON.stringify(value)
-        )
-      ),
-      param: values,
-      message
-    });
-    return this;
-  }
-  /**
-   * Проверяет, что значение соответствует одному из указанных типов через уже существующие правила валидатора
-   * @param {string[]} types - Массив допустимых типов (например: ['string', 'number', 'null', 'array'])
-   * @param {string} [message] - Сообщение об ошибке
-   * @returns {Validator}
-   */
-  oneOfTypes(types, message) {
-    const validators = types.map((type) => {
-      const schema = Validator.schema();
-      if (type === "string") return schema.string();
-      if (type === "number") return schema.number();
-      if (type === "integer") return schema.integer();
-      if (type === "boolean") return schema.boolean();
-      if (type === "array") return schema.array();
-      if (type === "object") return schema.object({});
-      if (type === "date") return schema.date();
-      if (type === "null") {
-        return Validator.schema().custom((val) => val === null, "Значение должно быть null");
-      }
-      throw new Error(`Unsupported type in oneOfTypes: ${type}`);
-    });
-    this.rules.push({
-      type: "oneOfTypes",
-      check: (value) => {
-        return validators.some((validator) => validator.validate(value).isValid);
-      },
-      param: types,
-      message
-    });
-    return this;
-  }
-  /**
-   * Добавляет пользовательскую проверку
-   * @param {function} fn - Функция проверки
-   * @param {string} [errorMessage='Custom validation failed'] - Сообщение об ошибке
-   * @returns {Validator}
-   */
-  custom(fn, errorMessage = "Custom validation failed") {
-    this.rules.push({
-      type: "custom",
-      check: fn,
-      param: errorMessage
-    });
-    return this;
-  }
-  /**
-   * Добавляет валидацию для элементов массива
-   * @param {Validator} validator - Валидатор для элементов массива
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  items(validator, message) {
-    if (!(validator instanceof Validator)) {
-      throw new TypeError("items() expects a Validator instance");
-    }
-    this.rules.push({
-      type: "items",
-      check: (value) => {
-        if (!Array.isArray(value)) return true;
-        for (let i = 0; i < value.length; i++) {
-          const result = validator.validate(value[i]);
-          if (!result.isValid) {
-            const fieldName = message ? `${message}[${i}]` : `Item ${i}`;
-            this.errors.push(`${fieldName}: ${result.errors.join(", ")}`);
-            return false;
-          }
-        }
-        return true;
-      },
-      message
-    });
-    return this;
-  }
-  object(schema, message) {
-    if (typeof schema !== "object" || Array.isArray(schema)) {
-      throw new TypeError("object() expects a schema object");
-    }
-    this.rules.push({
-      type: "object",
-      check: (value) => {
-        if (typeof value !== "object" || value === null || Array.isArray(value)) {
-          return false;
-        }
-        for (const [key, validator] of Object.entries(schema)) {
-          if (!(validator instanceof Validator)) {
-            throw new TypeError(`Property "${key}" must be a Validator instance`);
-          }
-          const result = validator.validate(value[key]);
-          if (!result.isValid) {
-            this.errors.push(`"${key}" ${result.errors.join(", ")}`);
-            return false;
-          }
-        }
-        return true;
-      },
-      message
-    });
-    return this;
-  }
-  /**
-   * Добавляет валидацию для свойств объекта
-   * @param {Object<string, Validator>} schema - Схема объекта
-   * @param {string} [message] - Пользовательское сообщение об ошибке
-   * @returns {Validator}
-   */
-  shape(schema, message) {
-    this.rules.push({
-      type: "shape",
-      check: (value) => {
-        if (typeof value !== "object" || value === null) return true;
-        for (const [key, validator] of Object.entries(schema)) {
-          if (!(validator instanceof Validator)) {
-            throw new TypeError(`Property "${key}" must have a Validator instance`);
-          }
-          const result = validator.validate(value[key]);
-          if (!result.isValid) {
-            this.errors.push(`"${key}" ${result.errors.join(", ")}`);
-            return false;
-          }
-        }
-        return true;
-      },
-      message
-    });
-    return this;
-  }
-  /**
-   * Получает сообщение об ошибке для правила
-   * @param {Rule} rule - Правило
-   * @returns {string} - Сообщение об ошибке
-   * @private
-   */
-  _getErrorMessage(rule) {
-    if (rule.message) return rule.message;
-    if (this.options.messages[rule.type]) {
-      const message = this.options.messages[rule.type];
-      if (typeof message === "function") {
-        return message(rule.param);
-      }
-      return message;
-    }
-    const context = this.options.context ? `${this.options.context} ` : "";
-    switch (rule.type) {
-      case "string":
-        return `${context}must be a string`;
-      case "number":
-        return `${context}must be a number`;
-      case "integer":
-        return `${context}must be an integer`;
-      case "boolean":
-        return `${context}must be a boolean`;
-      case "array":
-        return `${context}must be an array`;
-      case "date":
-        return `${context}must be a valid date`;
-      case "required":
-        return `${context}is required`;
-      case "min":
-        if (rule.param instanceof Date) return `${context}must be no earlier than ${rule.param.toLocaleDateString()}`;
-        return `${context}must be at least ${rule.param}`;
-      case "max":
-        if (rule.param instanceof Date) return `${context}must be no later than ${rule.param.toLocaleDateString()}`;
-        return `${context}must be at most ${rule.param}`;
-      case "length":
-        if (rule.param.min !== void 0 && rule.param.max !== void 0) {
-          return `${context}length must be between ${rule.param.min} and ${rule.param.max} characters`;
-        } else if (rule.param.min !== void 0) {
-          return `${context}length must be at least ${rule.param.min} characters`;
-        } else if (rule.param.max !== void 0) {
-          return `${context}length must be at most ${rule.param.max} characters`;
-        }
-        return `${context}does not meet length requirements`;
-      case "pattern":
-        return `${context}does not match required format`;
-      case "email":
-        return `${context}must be a valid email address`;
-      case "oneOf":
-        return `${context}must be one of: ${rule.param.join(", ")}`;
-      case "oneOfTypes":
-        return `${context}must be one of types: ${rule.param.join(", ")}`;
-      case "custom":
-        return rule.param;
-      case "items":
-        return `${context}contains invalid items`;
-      case "object":
-        return `${context}не соответствует типу объекта`;
-      case "shape":
-        return `${context}содержит невалидные свойства`;
-      default:
-        return "Ошибка валидации";
-    }
-  }
-  /**
-   * Выполняет валидацию значения
-   * @param {any} value - Значение для валидации
-   * @returns {ValidationResult} - Результат валидации
-   */
-  validate(value) {
-    this.errors = [];
-    for (const rule of this.rules) {
-      if (!rule.check(value)) {
-        if (rule.type !== "items" && rule.type !== "shape" && rule.type !== "object") {
-          this.errors.push(this._getErrorMessage(rule));
-        }
-        if (["string", "number", "object", "integer", "boolean", "array", "date"].includes(rule.type)) {
-          break;
-        }
-      }
-    }
-    return {
-      isValid: this.errors.length === 0,
-      errors: [...this.errors]
-    };
-  }
-}
-class Verifier {
-  /**
-   * @param {Object<string, ParamConfig>} config - Конфигурация параметров
-   */
-  constructor(config = {}) {
-    this.config = config;
-  }
-  /**
-   * Получает правило доступа для параметра
-   * @param {string} paramName - Имя параметра
-   * @param {Object} context - Контекст для функции rule
-   * @returns {string|Promise<string>} - Правило доступа
-   */
-  getRule(paramName, context = {}) {
-    if (!this.config.hasOwnProperty(paramName)) {
-      return "optional";
-    }
-    const paramConfig = this.config[paramName];
-    if (typeof paramConfig.rule === "function") {
-      return paramConfig.rule(context);
-    }
-    return paramConfig.rule;
-  }
-  /**
-   * Проверяет отдельный параметр на соответствие конфигурации
-   * @param {string} paramName - Имя параметра
-   * @param {any} value - Значение для проверки
-   * @param {Object} context - Контекст для функции rule
-   * @returns {Object|Promise<Object>} - Результат проверки
-   */
-  verifyParam(paramName, value, context = {}) {
-    const ruleResult = this.getRule(paramName, context);
-    const processRule = (rule) => {
-      if (rule === "forbidden") {
-        return { isValid: false, errors: [`Parameter '${paramName}' is forbidden`] };
-      }
-      if (rule === "required" && value === void 0) {
-        return { isValid: false, errors: [`Parameter '${paramName}' is required`] };
-      }
-      if (value === void 0) {
-        return { isValid: true, errors: [] };
-      }
-      const paramConfig = this.config[paramName];
-      if (paramConfig && paramConfig.validator) {
-        return paramConfig.validator.validate(value);
-      }
-      return { isValid: true, errors: [] };
-    };
-    if (ruleResult instanceof Promise) {
-      return ruleResult.then(processRule);
-    }
-    return processRule(ruleResult);
-  }
-  /**
-   * Метод валидации входящего объекта
-   * @param {Object} query - Объект параметров
-   * @param {VerifyOptions} options - Опции проверки
-   * @param {Object} context - Контекст для функции rule
-   * @returns {VerifyResult|Promise<VerifyResult>} - Результат проверки
-   */
-  verify(query, options = {}, context = {}) {
-    const { applyDefaults = true, removeInvalid = true, only = null, except = null } = options;
-    const result = {
-      verifiedData: {},
-      appliedDefaults: {},
-      removedParams: {},
-      untouchedParams: {},
-      isValid: true,
-      verificationErrors: {}
-    };
-    const shouldVerifyParam = (paramName) => {
-      if (only && Array.isArray(only)) return only.includes(paramName);
-      if (except && Array.isArray(except)) return !except.includes(paramName);
-      return true;
-    };
-    const paramPromises = [];
-    const paramResults = {};
-    for (const [paramName, paramConfig] of Object.entries(this.config)) {
-      if (!shouldVerifyParam(paramName)) continue;
-      const hasParam = query.hasOwnProperty(paramName);
-      const value = hasParam ? query[paramName] : void 0;
-      const verifyPromiseOrResult = this.verifyParam(paramName, value, context);
-      if (verifyPromiseOrResult instanceof Promise) {
-        paramPromises.push(
-          verifyPromiseOrResult.then((validationResult) => {
-            paramResults[paramName] = {
-              paramName,
-              validationResult,
-              hasParam,
-              value,
-              paramConfig
-            };
-          })
-        );
-      } else {
-        paramResults[paramName] = {
-          paramName,
-          validationResult: verifyPromiseOrResult,
-          hasParam,
-          value,
-          paramConfig
-        };
-      }
-    }
-    const processResults = () => {
-      for (const { paramName, validationResult, hasParam, value, paramConfig } of Object.values(paramResults)) {
-        if (!validationResult.isValid) {
-          result.isValid = false;
-          result.verificationErrors[paramName] = validationResult.errors;
-          if (hasParam) {
-            if (applyDefaults && paramConfig.default !== void 0) {
-              result.verifiedData[paramName] = paramConfig.default;
-              result.appliedDefaults[paramName] = paramConfig.default;
-            } else if (removeInvalid) {
-              result.removedParams[paramName] = value;
-            } else {
-              result.verifiedData[paramName] = value;
-            }
-          } else if (applyDefaults && paramConfig.default !== void 0) {
-            result.verifiedData[paramName] = paramConfig.default;
-            result.appliedDefaults[paramName] = paramConfig.default;
-          }
-        } else {
-          if (hasParam) {
-            result.verifiedData[paramName] = value;
-          } else if (applyDefaults && paramConfig.default !== void 0) {
-            result.verifiedData[paramName] = paramConfig.default;
-            result.appliedDefaults[paramName] = paramConfig.default;
-          }
-        }
-      }
-      for (const [paramName, paramValue] of Object.entries(query)) {
-        if (!this.config.hasOwnProperty(paramName)) {
-          result.untouchedParams[paramName] = paramValue;
-          result.verifiedData[paramName] = paramValue;
-        }
-      }
-      if (Object.keys(result.verificationErrors).length === 0) {
-        result.verificationErrors = null;
-      }
-      console.log("Verification result:", result);
-      return result;
-    };
-    if (paramPromises.length > 0) {
-      return Promise.all(paramPromises).then(() => processResults());
-    }
-    return processResults();
-  }
-  /**
-   * Middleware для Express
-   * @param {VerifyOptions} options - Опции проверки
-   * @param {Function} [contextResolver] - Функция для получения контекста
-   * @returns {function} - Middleware функция
-   */
-  middleware(options = {}, contextResolver = null) {
-    return (req, res, next) => {
-      try {
-        const context = contextResolver ? contextResolver(req) : {};
-        const result = this.verify(req.query, options, context);
-        const processResult = (validationResult) => {
-          req.queryValidation = validationResult;
-          req.query = validationResult.verifiedData;
-          next();
-        };
-        console.log("verifier result is", processResult);
-        if (result instanceof Promise) {
-          result.then(processResult).catch(next);
-        } else {
-          processResult(result);
-        }
-      } catch (error) {
-        next(error);
-      }
-    };
-  }
-}
-exports.Validator = Validator;
-exports.Verifier = Verifier;