@cratis/arc 18.5.0 → 18.6.0

package/validation/for_Validator/when_defining_multiple_rules_for_same_property.ts

@@ -0,0 +1,32 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Validator } from '../Validator';
+import '../RuleBuilderExtensions';
+
+interface TestType {
+    name: string;
+}
+
+describe("when defining multiple rules for same property", () => {
+    let validator: Validator<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof validator.validate>;
+
+    beforeEach(() => {
+        validator = new Validator<TestType>();
+        validator.ruleFor(t => t.name).notEmpty().minLength(3);
+        
+        instance = { name: 'ab' };
+    
+        results = validator.validate(instance);
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+
+    it("should_have_error_for_min_length", () => {
+        results[0].message.should.include('3');
+    });
+});

package/validation/for_Validator/when_using_custom_error_message.ts

@@ -0,0 +1,30 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Validator } from '../Validator';
+import '../RuleBuilderExtensions';
+
+interface TestType {
+    email: string;
+}
+
+describe("when using custom error message", () => {
+    let validator: Validator<TestType>;
+    let instance: TestType;
+    let customMessage: string;
+    let results: ReturnType<typeof validator.validate>;
+
+    beforeEach(() => {
+        customMessage = 'Email is required';
+        validator = new Validator<TestType>();
+        validator.ruleFor(t => t.email).notEmpty().withMessage(customMessage);
+        
+        instance = { email: '' };
+    
+        results = validator.validate(instance);
+    });
+
+    it("should_use_custom_error_message", () => {
+        results[0].message.should.equal(customMessage);
+    });
+});

package/validation/for_Validator/when_validating/with_all_rules_passing.ts

@@ -0,0 +1,34 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Validator } from '../../Validator';
+import '../../RuleBuilderExtensions';
+
+interface TestType {
+    name: string;
+    age: number;
+}
+
+describe("when validating with all rules passing", () => {
+    let validator: Validator<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof validator.validate>;
+
+    beforeEach(() => {
+        validator = new Validator<TestType>();
+        validator.ruleFor(t => t.name).notEmpty();
+        validator.ruleFor(t => t.age).greaterThanOrEqual(18);
+        
+        instance = { name: 'John', age: 25 };
+    
+        results = validator.validate(instance);
+    });
+
+    it("should_return_no_validation_errors", () => {
+        results.should.be.empty;
+    });
+
+    it("should_indicate_instance_is_valid", () => {
+        validator.isValidFor(instance).should.be.true;
+    });
+});

package/validation/for_Validator/when_validating/with_multiple_rules_failing.ts

@@ -0,0 +1,38 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Validator } from '../../Validator';
+import '../../RuleBuilderExtensions';
+
+interface TestType {
+    name: string;
+    age: number;
+}
+
+describe("when validating with multiple rules failing", () => {
+    let validator: Validator<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof validator.validate>;
+
+    beforeEach(() => {
+        validator = new Validator<TestType>();
+        validator.ruleFor(t => t.name).notEmpty();
+        validator.ruleFor(t => t.age).greaterThanOrEqual(18);
+        
+        instance = { name: '', age: 15 };
+    
+        results = validator.validate(instance);
+    });
+
+    it("should_return_two_validation_errors", () => {
+        results.should.have.lengthOf(2);
+    });
+
+    it("should_have_error_for_name_property", () => {
+        results.some(r => r.members.includes('name')).should.be.true;
+    });
+
+    it("should_have_error_for_age_property", () => {
+        results.some(r => r.members.includes('age')).should.be.true;
+    });
+});

package/validation/for_Validator/when_validating/with_one_rule_failing.ts

@@ -0,0 +1,38 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Validator } from '../../Validator';
+import '../../RuleBuilderExtensions';
+
+interface TestType {
+    name: string;
+    age: number;
+}
+
+describe("when validating with one rule failing", () => {
+    let validator: Validator<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof validator.validate>;
+
+    beforeEach(() => {
+        validator = new Validator<TestType>();
+        validator.ruleFor(t => t.name).notEmpty();
+        validator.ruleFor(t => t.age).greaterThanOrEqual(18);
+        
+        instance = { name: '', age: 25 };
+    
+        results = validator.validate(instance);
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+
+    it("should_indicate_instance_is_not_valid", () => {
+        validator.isValidFor(instance).should.be.false;
+    });
+
+    it("should_have_error_for_name_property", () => {
+        results[0].members.should.include('name');
+    });
+});

package/validation/index.ts

@@ -3,3 +3,14 @@
 
 export * from './Validator';
 export * from './ValidationResult';
+export * from './ValidationResultSeverity';
+export * from './IValidationRule';
+export * from './PropertyValidator';
+export * from './PropertyRule';
+export * from './RuleBuilder';
+export * from './RuleBuilderExtensions';
+export * from './rules/NotEmptyRule';
+export * from './rules/LengthRules';
+export * from './rules/EmailRule';
+export * from './rules/RegexRule';
+export * from './rules/ComparisonRules';

package/validation/rules/ComparisonRules.ts

@@ -0,0 +1,96 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { PropertyRule } from '../PropertyRule';
+
+/**
+ * Validation rule that checks if a number is greater than a specified value.
+ * @template T The type being validated.
+ */
+export class GreaterThanRule<T> extends PropertyRule<T, number> {
+    /**
+     * Initializes a new instance of the {@link GreaterThanRule} class.
+     * @param propertyAccessor Function to access the property value from the instance.
+     * @param threshold The value that the property must be greater than.
+     */
+    constructor(propertyAccessor: (instance: T) => number, private readonly threshold: number) {
+        super(propertyAccessor, `'{PropertyName}' must be greater than ${threshold}.`);
+    }
+
+    /** @inheritdoc */
+    protected isValid(value: number): boolean {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        return value > this.threshold;
+    }
+}
+
+/**
+ * Validation rule that checks if a number is greater than or equal to a specified value.
+ * @template T The type being validated.
+ */
+export class GreaterThanOrEqualRule<T> extends PropertyRule<T, number> {
+    /**
+     * Initializes a new instance of the {@link GreaterThanOrEqualRule} class.
+     * @param propertyAccessor Function to access the property value from the instance.
+     * @param threshold The value that the property must be greater than or equal to.
+     */
+    constructor(propertyAccessor: (instance: T) => number, private readonly threshold: number) {
+        super(propertyAccessor, `'{PropertyName}' must be greater than or equal to ${threshold}.`);
+    }
+
+    /** @inheritdoc */
+    protected isValid(value: number): boolean {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        return value >= this.threshold;
+    }
+}
+
+/**
+ * Validation rule that checks if a number is less than a specified value.
+ * @template T The type being validated.
+ */
+export class LessThanRule<T> extends PropertyRule<T, number> {
+    /**
+     * Initializes a new instance of the {@link LessThanRule} class.
+     * @param propertyAccessor Function to access the property value from the instance.
+     * @param threshold The value that the property must be less than.
+     */
+    constructor(propertyAccessor: (instance: T) => number, private readonly threshold: number) {
+        super(propertyAccessor, `'{PropertyName}' must be less than ${threshold}.`);
+    }
+
+    /** @inheritdoc */
+    protected isValid(value: number): boolean {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        return value < this.threshold;
+    }
+}
+
+/**
+ * Validation rule that checks if a number is less than or equal to a specified value.
+ * @template T The type being validated.
+ */
+export class LessThanOrEqualRule<T> extends PropertyRule<T, number> {
+    /**
+     * Initializes a new instance of the {@link LessThanOrEqualRule} class.
+     * @param propertyAccessor Function to access the property value from the instance.
+     * @param threshold The value that the property must be less than or equal to.
+     */
+    constructor(propertyAccessor: (instance: T) => number, private readonly threshold: number) {
+        super(propertyAccessor, `'{PropertyName}' must be less than or equal to ${threshold}.`);
+    }
+
+    /** @inheritdoc */
+    protected isValid(value: number): boolean {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        return value <= this.threshold;
+    }
+}

package/validation/rules/EmailRule.ts

@@ -0,0 +1,28 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { PropertyRule } from '../PropertyRule';
+
+/**
+ * Validation rule that checks if a string matches an email pattern.
+ * @template T The type being validated.
+ */
+export class EmailRule<T> extends PropertyRule<T, string> {
+    private static readonly emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+    /**
+     * Initializes a new instance of the {@link EmailRule} class.
+     * @param propertyAccessor Function to access the property value from the instance.
+     */
+    constructor(propertyAccessor: (instance: T) => string) {
+        super(propertyAccessor, "'{PropertyName}' is not a valid email address.");
+    }
+
+    /** @inheritdoc */
+    protected isValid(value: string): boolean {
+        if (value === null || value === undefined || value === '') {
+            return true; // Use NotNull/NotEmpty for null checks
+        }
+        return EmailRule.emailRegex.test(value);
+    }
+}

package/validation/rules/LengthRules.ts

@@ -0,0 +1,74 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { PropertyRule } from '../PropertyRule';
+
+/**
+ * Validation rule that checks if a string has a minimum length.
+ * @template T The type being validated.
+ */
+export class MinLengthRule<T> extends PropertyRule<T, string> {
+    /**
+     * Initializes a new instance of the {@link MinLengthRule} class.
+     * @param propertyAccessor Function to access the property value from the instance.
+     * @param minLength The minimum length required.
+     */
+    constructor(propertyAccessor: (instance: T) => string, private readonly minLength: number) {
+        super(propertyAccessor, `'{PropertyName}' must be at least ${minLength} characters.`);
+    }
+
+    /** @inheritdoc */
+    protected isValid(value: string): boolean {
+        if (value === null || value === undefined) {
+            return true; // Use NotNull/NotEmpty for null checks
+        }
+        return value.length >= this.minLength;
+    }
+}
+
+/**
+ * Validation rule that checks if a string has a maximum length.
+ * @template T The type being validated.
+ */
+export class MaxLengthRule<T> extends PropertyRule<T, string> {
+    /**
+     * Initializes a new instance of the {@link MaxLengthRule} class.
+     * @param propertyAccessor Function to access the property value from the instance.
+     * @param maxLength The maximum length allowed.
+     */
+    constructor(propertyAccessor: (instance: T) => string, private readonly maxLength: number) {
+        super(propertyAccessor, `'{PropertyName}' must be at most ${maxLength} characters.`);
+    }
+
+    /** @inheritdoc */
+    protected isValid(value: string): boolean {
+        if (value === null || value === undefined) {
+            return true; // Use NotNull/NotEmpty for null checks
+        }
+        return value.length <= this.maxLength;
+    }
+}
+
+/**
+ * Validation rule that checks if a string has an exact length.
+ * @template T The type being validated.
+ */
+export class LengthRule<T> extends PropertyRule<T, string> {
+    /**
+     * Initializes a new instance of the {@link LengthRule} class.
+     * @param propertyAccessor Function to access the property value from the instance.
+     * @param min The minimum length required.
+     * @param max The maximum length allowed.
+     */
+    constructor(propertyAccessor: (instance: T) => string, private readonly min: number, private readonly max: number) {
+        super(propertyAccessor, `'{PropertyName}' must be between ${min} and ${max} characters.`);
+    }
+
+    /** @inheritdoc */
+    protected isValid(value: string): boolean {
+        if (value === null || value === undefined) {
+            return true; // Use NotNull/NotEmpty for null checks
+        }
+        return value.length >= this.min && value.length <= this.max;
+    }
+}

package/validation/rules/NotEmptyRule.ts

@@ -0,0 +1,51 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { PropertyRule } from '../PropertyRule';
+
+/**
+ * Validation rule that checks if a value is not null, undefined, or empty.
+ * @template T The type being validated.
+ */
+export class NotEmptyRule<T> extends PropertyRule<T, unknown> {
+    /**
+     * Initializes a new instance of the {@link NotEmptyRule} class.
+     * @param propertyAccessor Function to access the property value from the instance.
+     */
+    constructor(propertyAccessor: (instance: T) => unknown) {
+        super(propertyAccessor, "'{PropertyName}' must not be empty.");
+    }
+
+    /** @inheritdoc */
+    protected isValid(value: unknown): boolean {
+        if (value === null || value === undefined) {
+            return false;
+        }
+        if (typeof value === 'string' && value.trim() === '') {
+            return false;
+        }
+        if (Array.isArray(value) && value.length === 0) {
+            return false;
+        }
+        return true;
+    }
+}
+
+/**
+ * Validation rule that checks if a value is not null or undefined.
+ * @template T The type being validated.
+ */
+export class NotNullRule<T> extends PropertyRule<T, unknown> {
+    /**
+     * Initializes a new instance of the {@link NotNullRule} class.
+     * @param propertyAccessor Function to access the property value from the instance.
+     */
+    constructor(propertyAccessor: (instance: T) => unknown) {
+        super(propertyAccessor, "'{PropertyName}' must not be empty.");
+    }
+
+    /** @inheritdoc */
+    protected isValid(value: unknown): boolean {
+        return value !== null && value !== undefined;
+    }
+}

package/validation/rules/RegexRule.ts

@@ -0,0 +1,28 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { PropertyRule } from '../PropertyRule';
+
+/**
+ * Validation rule that checks if a value matches a regular expression.
+ * @template T The type being validated.
+ */
+export class RegexRule<T> extends PropertyRule<T, string> {
+    /**
+     * Initializes a new instance of the {@link RegexRule} class.
+     * @param propertyAccessor Function to access the property value from the instance.
+     * @param pattern The regular expression pattern to match.
+     * @param errorMessage Optional error message.
+     */
+    constructor(propertyAccessor: (instance: T) => string, private readonly pattern: RegExp, errorMessage?: string) {
+        super(propertyAccessor, errorMessage || "'{PropertyName}' is not in the correct format.");
+    }
+
+    /** @inheritdoc */
+    protected isValid(value: string): boolean {
+        if (value === null || value === undefined || value === '') {
+            return true; // Use NotNull/NotEmpty for null checks
+        }
+        return this.pattern.test(value);
+    }
+}

package/validation/rules/for_EmailRule/when_validating/with_empty_string.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { EmailRule } from '../../EmailRule';
+
+interface TestType {
+    value: string;
+}
+
+describe("when validating with empty string", () => {
+    let rule: EmailRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new EmailRule<TestType>(t => t.value);
+        instance = { value: '' };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_no_validation_errors", () => {
+        results.should.be.empty;
+    });
+});

package/validation/rules/for_EmailRule/when_validating/with_invalid_email.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { EmailRule } from '../../EmailRule';
+
+interface TestType {
+    value: string;
+}
+
+describe("when validating with invalid email", () => {
+    let rule: EmailRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new EmailRule<TestType>(t => t.value);
+        instance = { value: 'notanemail' };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+});

package/validation/rules/for_EmailRule/when_validating/with_valid_email.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { EmailRule } from '../../EmailRule';
+
+interface TestType {
+    value: string;
+}
+
+describe("when validating with valid email", () => {
+    let rule: EmailRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new EmailRule<TestType>(t => t.value);
+        instance = { value: 'test@example.com' };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_no_validation_errors", () => {
+        results.should.be.empty;
+    });
+});

package/validation/rules/for_GreaterThanOrEqualRule/when_validating/with_value_equal_to_threshold.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { GreaterThanOrEqualRule } from '../../ComparisonRules';
+
+interface TestType {
+    value: number;
+}
+
+describe("when validating with value equal to threshold", () => {
+    let rule: GreaterThanOrEqualRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new GreaterThanOrEqualRule<TestType>(t => t.value, 18);
+        instance = { value: 18 };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_no_validation_errors", () => {
+        results.should.be.empty;
+    });
+});

package/validation/rules/for_GreaterThanRule/when_validating/with_value_equal_to_threshold.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { GreaterThanRule } from '../../ComparisonRules';
+
+interface TestType {
+    value: number;
+}
+
+describe("when validating with value equal to threshold", () => {
+    let rule: GreaterThanRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new GreaterThanRule<TestType>(t => t.value, 18);
+        instance = { value: 18 };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+});

package/validation/rules/for_GreaterThanRule/when_validating/with_value_greater_than_threshold.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { GreaterThanRule } from '../../ComparisonRules';
+
+interface TestType {
+    value: number;
+}
+
+describe("when validating with value greater than threshold", () => {
+    let rule: GreaterThanRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new GreaterThanRule<TestType>(t => t.value, 18);
+        instance = { value: 25 };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_no_validation_errors", () => {
+        results.should.be.empty;
+    });
+});

package/validation/rules/for_GreaterThanRule/when_validating/with_value_less_than_threshold.ts

@@ -0,0 +1,29 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { GreaterThanRule } from '../../ComparisonRules';
+
+interface TestType {
+    value: number;
+}
+
+describe("when validating with value less than threshold", () => {
+    let rule: GreaterThanRule<TestType>;
+    let instance: TestType;
+    let results: ReturnType<typeof rule.validate>;
+
+    beforeEach(() => {
+        rule = new GreaterThanRule<TestType>(t => t.value, 18);
+        instance = { value: 15 };
+    
+        results = rule.validate(instance, 'value');
+    });
+
+    it("should_return_one_validation_error", () => {
+        results.should.have.lengthOf(1);
+    });
+
+    it("should_include_threshold_in_message", () => {
+        results[0].message.should.include('18');
+    });
+});