@decaf-ts/decorator-validation
Version:
simple decorator based validation engine
104 lines • 4.38 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 Validator for checking if a value is present and not empty
* @summary The RequiredValidator ensures that a value is provided and not empty.
* It handles different types of values appropriately: for booleans and numbers,
* it checks if they're undefined; for other types (strings, arrays, objects),
* it checks if they're falsy. This validator is typically used with the @required decorator
* and is often the first validation applied to important fields.
*
* @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}
*
* @class RequiredValidator
* @extends Validator
*
* @example
* ```typescript
* // Create a required validator with default error message
* const requiredValidator = new RequiredValidator();
*
* // Create a required validator with custom error message
* const customRequiredValidator = new RequiredValidator("This field is mandatory");
*
* // Validate different types of values
* requiredValidator.hasErrors("Hello"); // undefined (valid)
* requiredValidator.hasErrors(""); // Returns error message (invalid)
* requiredValidator.hasErrors(0); // undefined (valid - 0 is a valid number)
* requiredValidator.hasErrors(null); // Returns error message (invalid)
* requiredValidator.hasErrors([]); // undefined (valid - empty array is still an array)
* ```
*
* @mermaid
* sequenceDiagram
* participant C as Client
* participant V as RequiredValidator
*
* C->>V: new RequiredValidator(message)
* C->>V: hasErrors(value, options)
* alt typeof value is boolean or number
* alt value is undefined
* V-->>C: Error message
* else value is defined
* V-->>C: undefined (valid)
* end
* else other types
* alt value is falsy (null, undefined, empty string)
* V-->>C: Error message
* else value is truthy
* V-->>C: undefined (valid)
* end
* end
*
* @category Validators
*/
let RequiredValidator = class RequiredValidator extends Validator {
constructor(message = DEFAULT_ERROR_MESSAGES.REQUIRED) {
super(message);
}
/**
* @description Checks if a value is present and not empty
* @summary Validates that the provided value exists and is not empty.
* The validation logic varies by type:
* - For booleans and numbers: checks if the value is undefined
* - For other types (strings, arrays, objects): checks if the value is falsy
*
* @param {any} value - The value to validate
* @param {ValidatorOptions} [options={}] - Optional configuration options
*
* @return {string | undefined} Error message if validation fails, undefined if validation passes
*
* @override
*
* @see Validator#hasErrors
*/
hasErrors(value, options = {}) {
switch (typeof value) {
case "boolean":
case "number":
return typeof value === "undefined"
? this.getMessage(options.message || this.message)
: undefined;
default:
return !value
? this.getMessage(options.message || this.message)
: undefined;
}
}
};
RequiredValidator = __decorate([
validator(ValidationKeys.REQUIRED),
__metadata("design:paramtypes", [String])
], RequiredValidator);
export { RequiredValidator };
//# sourceMappingURL=RequiredValidator.js.map