@decaf-ts/decorator-validation
Version:
simple decorator based validation engine
137 lines • 14.8 kB
JavaScript
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { Validator } from "./Validator.js";
import { DEFAULT_ERROR_MESSAGES, ValidationKeys } from "./constants.js";
import { validator } from "./decorators.js";
/**
* @description Regular expression for parsing string patterns with flags
* @summary This regular expression is used to parse string patterns in the format "/pattern/flags".
* It captures the pattern and flags separately, allowing the creation of a RegExp object
* with the appropriate flags.
*
* @const {RegExp}
* @memberOf module:decorator-validation
* @category Validation
*/
export const regexpParser = new RegExp("^/(.+)/([gimus]*)$");
/**
* @description Validator for checking if a string matches a regular expression pattern
* @summary The PatternValidator checks if a string value matches a specified regular expression pattern.
* It supports both RegExp objects and string representations of patterns, including those with flags.
* This validator is the foundation for specialized validators like EmailValidator and URLValidator,
* and is typically used with the @pattern decorator.
*
* @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}
*
* @class PatternValidator
* @extends Validator
*
* @example
* ```typescript
* // Create a pattern validator with default error message
* const patternValidator = new PatternValidator();
*
* // Create a pattern validator with custom error message
* const customPatternValidator = new PatternValidator("Value must match the required format");
*
* // Validate using a RegExp object
* const regexOptions = { pattern: /^[A-Z][a-z]+$/ };
* patternValidator.hasErrors("Hello", regexOptions); // undefined (valid)
* patternValidator.hasErrors("hello", regexOptions); // Returns error message (invalid)
*
* // Validate using a string pattern
* const stringOptions = { pattern: "^\\d{3}-\\d{2}-\\d{4}$" };
* patternValidator.hasErrors("123-45-6789", stringOptions); // undefined (valid)
*
* // Validate using a string pattern with flags
* const flagOptions = { pattern: "/^hello$/i" };
* patternValidator.hasErrors("Hello", flagOptions); // undefined (valid)
* ```
*
* @mermaid
* sequenceDiagram
* participant C as Client
* participant V as PatternValidator
*
* C->>V: new PatternValidator(message)
* C->>V: hasErrors(value, options)
* alt value is empty
* V-->>C: undefined (valid)
* else pattern is missing
* V-->>C: Error: Missing Pattern
* else pattern is string
* V->>V: getPattern(pattern)
* end
* V->>V: Reset pattern.lastIndex
* V->>V: Test value against pattern
* alt pattern test passes
* V-->>C: undefined (valid)
* else pattern test fails
* V-->>C: Error message
* end
*
* @category Validators
*/
let PatternValidator = class PatternValidator extends Validator {
constructor(message = DEFAULT_ERROR_MESSAGES.PATTERN) {
super(message, "string");
}
/**
* @description Converts a string pattern to a RegExp object
* @summary Parses a string representation of a regular expression and converts it to a RegExp object.
* It handles both simple string patterns and patterns with flags in the format "/pattern/flags".
*
* @param {string} pattern - The string pattern to convert
* @return {RegExp} A RegExp object created from the string pattern
* @private
*/
getPattern(pattern) {
if (!regexpParser.test(pattern))
return new RegExp(pattern);
const match = pattern.match(regexpParser);
return new RegExp(match[1], match[2]);
}
/**
* @description Checks if a string matches a regular expression pattern
* @summary Validates that the provided string matches the pattern specified in the options.
* If the pattern is provided as a string, it's converted to a RegExp object using the getPattern method.
* The method resets the pattern's lastIndex property to ensure consistent validation results
* for patterns with the global flag.
*
* @param {string} value - The string to validate against the pattern
* @param {PatternValidatorOptions} options - Configuration options containing the pattern
*
* @return {string | undefined} Error message if validation fails, undefined if validation passes
*
* @throws {Error} If no pattern is provided in the options
*
* @override
*
* @see Validator#hasErrors
*/
hasErrors(value, options) {
if (!value)
return;
let { pattern } = options;
if (!pattern)
throw new Error("Missing Pattern");
pattern = typeof pattern === "string" ? this.getPattern(pattern) : pattern;
pattern.lastIndex = 0; // resets pattern position for repeat validation requests
return !pattern.test(value)
? this.getMessage(options.message || this.message)
: undefined;
}
};
PatternValidator = __decorate([
validator(ValidationKeys.PATTERN),
__metadata("design:paramtypes", [String])
], PatternValidator);
export { PatternValidator };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PatternValidator.js","sourceRoot":"","sources":["../../../../src/validation/Validators/PatternValidator.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,SAAS,EAAE,uBAAoB;AACxC,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,uBAAoB;AACrE,OAAO,EAAE,SAAS,EAAE,wBAAqB;AAGzC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,YAAY,GAAW,IAAI,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEI,IAAM,gBAAgB,GAAtB,MAAM,gBAAiB,SAAQ,SAAkC;IACtE,YAAY,UAAkB,sBAAsB,CAAC,OAAO;QAC1D,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3B,CAAC;IAED;;;;;;;;OAQG;IACK,UAAU,CAAC,OAAe;QAChC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC;YAAE,OAAO,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC;QAC5D,MAAM,KAAK,GAAQ,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAC/C,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACI,SAAS,CACd,KAAa,EACb,OAAgC;QAEhC,IAAI,CAAC,KAAK;YAAE,OAAO;QAEnB,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAC1B,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACjD,OAAO,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;QAC3E,OAAO,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,yDAAyD;QAChF,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC;YACzB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;YAClD,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;CACF,CAAA;AApDY,gBAAgB;IAD5B,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC;;GACrB,gBAAgB,CAoD5B","sourcesContent":["import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { PatternValidatorOptions } from \"../types\";\n\n/**\n * @description Regular expression for parsing string patterns with flags\n * @summary This regular expression is used to parse string patterns in the format \"/pattern/flags\".\n * It captures the pattern and flags separately, allowing the creation of a RegExp object\n * with the appropriate flags.\n *\n * @const {RegExp}\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport const regexpParser: RegExp = new RegExp(\"^/(.+)/([gimus]*)$\");\n\n/**\n * @description Validator for checking if a string matches a regular expression pattern\n * @summary The PatternValidator checks if a string value matches a specified regular expression pattern.\n * It supports both RegExp objects and string representations of patterns, including those with flags.\n * This validator is the foundation for specialized validators like EmailValidator and URLValidator,\n * and is typically used with the @pattern decorator.\n *\n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}\n *\n * @class PatternValidator\n * @extends Validator\n *\n * @example\n * ```typescript\n * // Create a pattern validator with default error message\n * const patternValidator = new PatternValidator();\n *\n * // Create a pattern validator with custom error message\n * const customPatternValidator = new PatternValidator(\"Value must match the required format\");\n *\n * // Validate using a RegExp object\n * const regexOptions = { pattern: /^[A-Z][a-z]+$/ };\n * patternValidator.hasErrors(\"Hello\", regexOptions); // undefined (valid)\n * patternValidator.hasErrors(\"hello\", regexOptions); // Returns error message (invalid)\n *\n * // Validate using a string pattern\n * const stringOptions = { pattern: \"^\\\\d{3}-\\\\d{2}-\\\\d{4}$\" };\n * patternValidator.hasErrors(\"123-45-6789\", stringOptions); // undefined (valid)\n *\n * // Validate using a string pattern with flags\n * const flagOptions = { pattern: \"/^hello$/i\" };\n * patternValidator.hasErrors(\"Hello\", flagOptions); // undefined (valid)\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as PatternValidator\n *\n *   C->>V: new PatternValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is empty\n *     V-->>C: undefined (valid)\n *   else pattern is missing\n *     V-->>C: Error: Missing Pattern\n *   else pattern is string\n *     V->>V: getPattern(pattern)\n *   end\n *   V->>V: Reset pattern.lastIndex\n *   V->>V: Test value against pattern\n *   alt pattern test passes\n *     V-->>C: undefined (valid)\n *   else pattern test fails\n *     V-->>C: Error message\n *   end\n *\n * @category Validators\n */\n@validator(ValidationKeys.PATTERN)\nexport class PatternValidator extends Validator<PatternValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.PATTERN) {\n    super(message, \"string\");\n  }\n\n  /**\n   * @description Converts a string pattern to a RegExp object\n   * @summary Parses a string representation of a regular expression and converts it to a RegExp object.\n   * It handles both simple string patterns and patterns with flags in the format \"/pattern/flags\".\n   *\n   * @param {string} pattern - The string pattern to convert\n   * @return {RegExp} A RegExp object created from the string pattern\n   * @private\n   */\n  private getPattern(pattern: string): RegExp {\n    if (!regexpParser.test(pattern)) return new RegExp(pattern);\n    const match: any = pattern.match(regexpParser);\n    return new RegExp(match[1], match[2]);\n  }\n\n  /**\n   * @description Checks if a string matches a regular expression pattern\n   * @summary Validates that the provided string matches the pattern specified in the options.\n   * If the pattern is provided as a string, it's converted to a RegExp object using the getPattern method.\n   * The method resets the pattern's lastIndex property to ensure consistent validation results\n   * for patterns with the global flag.\n   *\n   * @param {string} value - The string to validate against the pattern\n   * @param {PatternValidatorOptions} options - Configuration options containing the pattern\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @throws {Error} If no pattern is provided in the options\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: string,\n    options: PatternValidatorOptions\n  ): string | undefined {\n    if (!value) return;\n\n    let { pattern } = options;\n    if (!pattern) throw new Error(\"Missing Pattern\");\n    pattern = typeof pattern === \"string\" ? this.getPattern(pattern) : pattern;\n    pattern.lastIndex = 0; // resets pattern position for repeat validation requests\n    return !pattern.test(value)\n      ? this.getMessage(options.message || this.message)\n      : undefined;\n  }\n}\n"]}