@decaf-ts/decorator-validation 1.6.2 → 1.6.4

package/lib/esm/validation/Validators/EqualsValidator.d.ts

@@ -0,0 +1,27 @@
+import { Validator } from "./Validator";
+import type { ComparisonValidatorOptions } from "../types";
+/**
+ * @summary Equals Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#EQUALS}
+ *
+ * @class EqualsValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class EqualsValidator extends Validator<ComparisonValidatorOptions> {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ComparisonValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: any, options: ComparisonValidatorOptions, instance: any): string | undefined;
+}

package/lib/esm/validation/Validators/EqualsValidator.js

@@ -0,0 +1,63 @@
+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";
+import { DEFAULT_ERROR_MESSAGES, ValidationKeys } from "./constants";
+import { validator } from "./decorators";
+import { isEqual } from "@decaf-ts/reflection";
+import { getValueByPath } from "./utils";
+/**
+ * @summary Equals Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#EQUALS}
+ *
+ * @class EqualsValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let EqualsValidator = class EqualsValidator extends Validator {
+    constructor(message = DEFAULT_ERROR_MESSAGES.EQUALS) {
+        super(message);
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ComparisonValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options, instance) {
+        let comparisonPropertyValue;
+        try {
+            comparisonPropertyValue = getValueByPath(instance, options.propertyToCompare);
+        }
+        catch (e) {
+            return this.getMessage(e.message || this.message);
+        }
+        return isEqual(value, comparisonPropertyValue)
+            ? undefined
+            : this.getMessage(options.message || this.message, options.propertyToCompare);
+    }
+};
+EqualsValidator = __decorate([
+    validator(ValidationKeys.EQUALS),
+    __metadata("design:paramtypes", [String])
+], EqualsValidator);
+export { EqualsValidator };
+// Validation.register({
+//   validator: EqualsValidator,
+//   validationKey: ValidationKeys.EQUALS,
+//   save: false,
+// } as ValidatorDefinition);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/validation/Validators/GreaterThanOrEqualValidator.d.ts

@@ -0,0 +1,27 @@
+import { Validator } from "./Validator";
+import type { ComparisonValidatorOptions } from "../types";
+/**
+ * @summary Greater Than or Equal Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#GREATER_THAN_OR_EQUAL}
+ *
+ * @class GreaterThanOrEqualValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class GreaterThanOrEqualValidator extends Validator<ComparisonValidatorOptions> {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ComparisonValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: any, options: ComparisonValidatorOptions, instance: any): string | undefined;
+}

package/lib/esm/validation/Validators/GreaterThanOrEqualValidator.js

@@ -0,0 +1,65 @@
+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";
+import { DEFAULT_ERROR_MESSAGES, ValidationKeys } from "./constants";
+import { validator } from "./decorators";
+import { getValueByPath, isGreaterThan, isValidForGteOrLteComparison, } from "./utils";
+import { isEqual } from "@decaf-ts/reflection";
+/**
+ * @summary Greater Than or Equal Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#GREATER_THAN_OR_EQUAL}
+ *
+ * @class GreaterThanOrEqualValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let GreaterThanOrEqualValidator = class GreaterThanOrEqualValidator extends Validator {
+    constructor(message = DEFAULT_ERROR_MESSAGES.GREATER_THAN_OR_EQUAL) {
+        super(message);
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ComparisonValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options, instance) {
+        let comparisonPropertyValue;
+        try {
+            comparisonPropertyValue = getValueByPath(instance, options.propertyToCompare);
+        }
+        catch (e) {
+            return this.getMessage(e.message || this.message);
+        }
+        try {
+            if ((isValidForGteOrLteComparison(value, comparisonPropertyValue) &&
+                isEqual(value, comparisonPropertyValue)) ||
+                isGreaterThan(value, comparisonPropertyValue))
+                return undefined;
+            throw new Error(options.message || this.message);
+        }
+        catch (e) {
+            return this.getMessage(e.message, options.propertyToCompare);
+        }
+    }
+};
+GreaterThanOrEqualValidator = __decorate([
+    validator(ValidationKeys.GREATER_THAN_OR_EQUAL),
+    __metadata("design:paramtypes", [String])
+], GreaterThanOrEqualValidator);
+export { GreaterThanOrEqualValidator };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/validation/Validators/GreaterThanValidator.d.ts

@@ -0,0 +1,27 @@
+import { Validator } from "./Validator";
+import type { ComparisonValidatorOptions } from "../types";
+/**
+ * @summary Greater Than Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#GREATER_THAN}
+ *
+ * @class GreaterThanValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class GreaterThanValidator extends Validator<ComparisonValidatorOptions> {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ComparisonValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: any, options: ComparisonValidatorOptions, instance: any): string | undefined;
+}

package/lib/esm/validation/Validators/GreaterThanValidator.js

@@ -0,0 +1,62 @@
+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";
+import { DEFAULT_ERROR_MESSAGES, ValidationKeys } from "./constants";
+import { validator } from "./decorators";
+import { getValueByPath, isGreaterThan } from "./utils";
+/**
+ * @summary Greater Than Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#GREATER_THAN}
+ *
+ * @class GreaterThanValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let GreaterThanValidator = class GreaterThanValidator extends Validator {
+    constructor(message = DEFAULT_ERROR_MESSAGES.GREATER_THAN) {
+        super(message);
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ComparisonValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options, instance) {
+        let comparisonPropertyValue;
+        try {
+            comparisonPropertyValue = getValueByPath(instance, options.propertyToCompare);
+        }
+        catch (e) {
+            return this.getMessage(e.message || this.message);
+        }
+        try {
+            if (!isGreaterThan(value, comparisonPropertyValue))
+                throw new Error(options.message || this.message);
+        }
+        catch (e) {
+            return this.getMessage(e.message, options.propertyToCompare);
+        }
+        return undefined;
+    }
+};
+GreaterThanValidator = __decorate([
+    validator(ValidationKeys.GREATER_THAN),
+    __metadata("design:paramtypes", [String])
+], GreaterThanValidator);
+export { GreaterThanValidator };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/validation/Validators/LessThanOrEqualValidator.d.ts

@@ -0,0 +1,27 @@
+import { Validator } from "./Validator";
+import type { ComparisonValidatorOptions } from "../types";
+/**
+ * @summary Less Than or Equal Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LESS_THAN_OR_EQUAL}
+ *
+ * @class LessThanOrEqualValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class LessThanOrEqualValidator extends Validator<ComparisonValidatorOptions> {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ComparisonValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: any, options: ComparisonValidatorOptions, instance: any): string | undefined;
+}

package/lib/esm/validation/Validators/LessThanOrEqualValidator.js

@@ -0,0 +1,65 @@
+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";
+import { DEFAULT_ERROR_MESSAGES, ValidationKeys } from "./constants";
+import { validator } from "./decorators";
+import { getValueByPath, isLessThan, isValidForGteOrLteComparison, } from "./utils";
+import { isEqual } from "@decaf-ts/reflection";
+/**
+ * @summary Less Than or Equal Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LESS_THAN_OR_EQUAL}
+ *
+ * @class LessThanOrEqualValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let LessThanOrEqualValidator = class LessThanOrEqualValidator extends Validator {
+    constructor(message = DEFAULT_ERROR_MESSAGES.LESS_THAN_OR_EQUAL) {
+        super(message);
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ComparisonValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options, instance) {
+        let comparisonPropertyValue;
+        try {
+            comparisonPropertyValue = getValueByPath(instance, options.propertyToCompare);
+        }
+        catch (e) {
+            return this.getMessage(e.message || this.message);
+        }
+        try {
+            if ((isValidForGteOrLteComparison(value, comparisonPropertyValue) &&
+                isEqual(value, comparisonPropertyValue)) ||
+                isLessThan(value, comparisonPropertyValue))
+                return undefined;
+            throw new Error(options.message || this.message);
+        }
+        catch (e) {
+            return this.getMessage(e.message, options.propertyToCompare);
+        }
+    }
+};
+LessThanOrEqualValidator = __decorate([
+    validator(ValidationKeys.LESS_THAN_OR_EQUAL),
+    __metadata("design:paramtypes", [String])
+], LessThanOrEqualValidator);
+export { LessThanOrEqualValidator };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/validation/Validators/LessThanValidator.d.ts

@@ -0,0 +1,27 @@
+import { Validator } from "./Validator";
+import type { ComparisonValidatorOptions } from "../types";
+/**
+ * @summary Less Than Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LESS_THAN}
+ *
+ * @class LessThanValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class LessThanValidator extends Validator<ComparisonValidatorOptions> {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ComparisonValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: any, options: ComparisonValidatorOptions, instance: any): string | undefined;
+}

package/lib/esm/validation/Validators/LessThanValidator.js

@@ -0,0 +1,62 @@
+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";
+import { DEFAULT_ERROR_MESSAGES, ValidationKeys } from "./constants";
+import { validator } from "./decorators";
+import { getValueByPath, isLessThan } from "./utils";
+/**
+ * @summary Less Than Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LESS_THAN}
+ *
+ * @class LessThanValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let LessThanValidator = class LessThanValidator extends Validator {
+    constructor(message = DEFAULT_ERROR_MESSAGES.LESS_THAN) {
+        super(message);
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ComparisonValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options, instance) {
+        let comparisonPropertyValue;
+        try {
+            comparisonPropertyValue = getValueByPath(instance, options.propertyToCompare);
+        }
+        catch (e) {
+            return this.getMessage(e.message || this.message);
+        }
+        try {
+            if (!isLessThan(value, comparisonPropertyValue))
+                throw new Error(options.message || this.message);
+        }
+        catch (e) {
+            return this.getMessage(e.message, options.propertyToCompare);
+        }
+        return undefined;
+    }
+};
+LessThanValidator = __decorate([
+    validator(ValidationKeys.LESS_THAN),
+    __metadata("design:paramtypes", [String])
+], LessThanValidator);
+export { LessThanValidator };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/validation/Validators/ListValidator.d.ts

@@ -1,62 +1,24 @@
 import { Validator } from "./Validator";
 import { ListValidatorOptions } from "../types";
 /**
- * @description Validator for checking if elements in a list or set match expected types
- * @summary The ListValidator validates that all elements in an array or Set match the expected types.
- * It checks each element against a list of allowed class types and ensures type consistency.
- * This validator is typically used with the @list decorator.
+ * @summary List Validator
  *
- * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
  *
  * @class ListValidator
  * @extends Validator
  *
- * @example
- * ```typescript
- * // Create a list validator with default error message
- * const listValidator = new ListValidator();
- *
- * // Create a list validator with custom error message
- * const customListValidator = new ListValidator("All items must be of the specified type");
- *
- * // Validate a list
- * const options = { clazz: ["String", "Number"] };
- * const result = listValidator.hasErrors(["test", 123], options); // undefined (valid)
- * const invalidResult = listValidator.hasErrors([new Date()], options); // Returns error message (invalid)
- * ```
- *
- * @mermaid
- * sequenceDiagram
- *   participant C as Client
- *   participant V as ListValidator
- *
- *   C->>V: new ListValidator(message)
- *   C->>V: hasErrors(value, options)
- *   alt value is empty
- *     V-->>C: undefined (valid)
- *   else value has elements
- *     V->>V: Check each element's type
- *     alt All elements match allowed types
- *       V-->>C: undefined (valid)
- *     else Some elements don't match
- *       V-->>C: Error message
- *     end
- *   end
- *
  * @category Validators
  */
 export declare class ListValidator extends Validator<ListValidatorOptions> {
     constructor(message?: string);
     /**
-     * @description Checks if all elements in a list or set match the expected types
-     * @summary Validates that each element in the provided array or Set matches one of the
-     * class types specified in the options. For object types, it checks the constructor name,
-     * and for primitive types, it compares against the lowercase type name.
+     * @summary Validates a model
      *
-     * @param {any[] | Set<any>} value - The array or Set to validate
-     * @param {ListValidatorOptions} options - Configuration options containing the allowed class types
+     * @param {any[] | Set<any>} value
+     * @param {ListValidatorOptions} options
      *
-     * @return {string | undefined} Error message if validation fails, undefined if validation passes
+     * @return {string | undefined}
      *
      * @override
      *