@platecms/delta-validation 0.4.1 → 0.7.0

package/src/lib/schemas/date.schema.ts

@@ -0,0 +1,82 @@
+import { ContentValueTypeNames } from "@platecms/delta-types";
+import { RuleType } from "../enums/rule-types.enum";
+import { validateWithFunction } from "../helpers/validate-with-function";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ValidationContext } from "../types/validation-context.interface";
+import { ValidationErrorData } from "../types/validation-error-data.interface";
+import {
+  DateBetweenValidationRuleSettings,
+  validateValueDateBetween,
+} from "../validation-rules/date-between.validation-rule";
+import { BaseValidationSchema } from "./base.schema";
+
+export class DateValidationSchema extends BaseValidationSchema<Date, DateValidationSchema> {
+  public readonly type = "date";
+  private _start?: Date;
+  private _end?: Date;
+
+  public start(start: Date): this {
+    this._start = start;
+    return this;
+  }
+
+  public end(end: Date): this {
+    this._end = end;
+    return this;
+  }
+
+  protected _typeCheck(value: unknown, path: string[]): ValidationErrorData[] {
+    if (!(value instanceof Date)) {
+      return [
+        {
+          path,
+          message: this._message ?? "Value must be a valid date",
+          provided: value,
+          validationRule: {
+            ruleType: RuleType.VALUE_TYPE,
+            settings: { allowedTypes: [ContentValueTypeNames.DATE] },
+          },
+        },
+      ];
+    }
+
+    return [];
+  }
+
+  protected _validateAgainstSchema(value: Date, context: ValidationContext = {}): ValidationErrorData[] {
+    const path = context.path ?? [];
+    const errors: ValidationErrorData[] = [];
+
+    const dateBetweenError = this._validateDateBetween(value, path);
+    if (dateBetweenError) {
+      errors.push(dateBetweenError);
+    }
+
+    return errors;
+  }
+
+  private _validateDateBetween(
+    value: Date,
+    path: string[],
+  ): ValidationErrorData<DateBetweenValidationRuleSettings> | null {
+    if (this._start === undefined && this._end === undefined) {
+      return null;
+    }
+
+    const validationRule = this._validationRule ?? {
+      ruleType: RuleType.DATE_BETWEEN,
+      settings: {
+        start: this._start,
+        end: this._end,
+      },
+    };
+
+    return validateWithFunction<DateBetweenValidationRuleSettings, Date>(
+      value,
+      validationRule as RuleInstance<DateBetweenValidationRuleSettings>,
+      path,
+      this._message ?? "Date is outside allowed range",
+      validateValueDateBetween,
+    );
+  }
+}

package/src/lib/schemas/number.schema.spec.ts

@@ -0,0 +1,232 @@
+import { NumberValidationSchema } from "./number.schema";
+
+describe("NumberValidationSchema", () => {
+  let schema: NumberValidationSchema;
+
+  beforeEach(() => {
+    schema = new NumberValidationSchema();
+  });
+
+  describe("type checking", () => {
+    it("passes validation when value is a number", () => {
+      const result = schema.validate(42, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when value is zero", () => {
+      const result = schema.validate(0, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when value is negative", () => {
+      const result = schema.validate(-42, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when value is a decimal", () => {
+      const result = schema.validate(3.14, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when value is a string that can be converted to number", () => {
+      const result = schema.validate("42" as unknown as number, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when value cannot be converted to a number", () => {
+      const result = schema.validate("not-a-number" as unknown as number, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Value must be a valid number");
+      expect(result.errors[0].path).toEqual(["test"]);
+    });
+
+    it("passes validation when value is null", () => {
+      const result = schema.validate(null as unknown as number, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when value is undefined", () => {
+      const result = schema.validate(undefined as unknown as number, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when value is an object that cannot be converted", () => {
+      const result = schema.validate({ value: 42 } as unknown as number, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Value must be a valid number");
+    });
+
+    it("fails validation when value is NaN", () => {
+      const result = schema.validate(NaN, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Value must be a valid number");
+    });
+  });
+
+  describe("range validation", () => {
+    it("passes validation when number is within min and max bounds", () => {
+      schema.min(0).max(100);
+      const result = schema.validate(50, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when number is below minimum", () => {
+      schema.min(10);
+      const result = schema.validate(5, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toContain("The value must be greater than or equal");
+    });
+
+    it("fails validation when number is above maximum", () => {
+      schema.max(100);
+      const result = schema.validate(150, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toContain("The value must be less than or equal");
+    });
+
+    it("passes validation when number equals minimum", () => {
+      schema.min(10);
+      const result = schema.validate(10, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when number equals maximum", () => {
+      schema.max(100);
+      const result = schema.validate(100, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when no min/max constraints are set", () => {
+      const result = schema.validate(999999, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("handles decimal numbers with constraints", () => {
+      schema.min(0).max(10);
+      const result = schema.validate(3.14, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("decimal count validation", () => {
+    it("passes validation when decimal places are within limit", () => {
+      schema.maxDecimals(2);
+      const result = schema.validate(3.14, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when decimal places exceed limit", () => {
+      schema.maxDecimals(2);
+      const result = schema.validate(3.14159, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toContain("The number must not have more than");
+    });
+
+    it("passes validation when number has no decimal places", () => {
+      schema.maxDecimals(2);
+      const result = schema.validate(42, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when number has exactly the maximum decimal places", () => {
+      schema.maxDecimals(3);
+      const result = schema.validate(3.141, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when no decimal constraint is set", () => {
+      const result = schema.validate(3.14159265359, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("handles zero decimal places", () => {
+      schema.maxDecimals(0);
+      const result = schema.validate(3.14, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+    });
+  });
+
+  describe("allowed values validation", () => {
+    it("passes validation when number is in allowed values", () => {
+      schema.allowedValues([1, 2.5, -1, 42]);
+      const result = schema.validate(42, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when number is not in allowed values", () => {
+      schema.allowedValues([1, 2, 3, 42]);
+      const result = schema.validate(99, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("The provided value must be one of 1, 2, 3, 42");
+    });
+
+    it("passes validation when no allowed values are set", () => {
+      const result = schema.validate(999, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("method chaining", () => {
+    it("supports method chaining", () => {
+      const result = schema
+        .min(0)
+        .max(100)
+        .maxDecimals(2)
+        .allowedValues([3.14, 2.71])
+        .message("Custom number message")
+        .validate(3.14, { path: ["test"] });
+
+      expect(result.isValid).toBe(true);
+    });
+  });
+
+  describe("complex validation scenarios", () => {
+    it("combines multiple validations", () => {
+      schema.min(0).max(100).maxDecimals(2).allowedValues([3.14, 2.71]);
+
+      const result = schema.validate(3.14159, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1); // Only decimal count validation fails
+    });
+
+    it("handles multiple validation failures", () => {
+      schema.min(10).max(100).maxDecimals(0);
+
+      const result = schema.validate(5.5, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(2); // Both range and decimal count validation fail
+    });
+
+    it("provides correct error paths", () => {
+      const result = schema.min(10).validate(5, { path: ["user", "age"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].path).toEqual(["user", "age"]);
+    });
+  });
+});

package/src/lib/schemas/number.schema.ts

@@ -0,0 +1,123 @@
+import { ContentValueTypeNames } from "@platecms/delta-types";
+import { RuleType } from "../enums/rule-types.enum";
+import { validateWithFunction } from "../helpers/validate-with-function";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ValidationContext } from "../types/validation-context.interface";
+import { ValidationErrorData } from "../types/validation-error-data.interface";
+import {
+  DecimalCountValidationRuleSettings,
+  validateValueDecimalCount,
+} from "../validation-rules/decimal-count.validation-rule";
+import {
+  NumberBetweenValidationRuleSettings,
+  validateValueNumberBetween,
+} from "../validation-rules/number-between.validation-rule";
+import { BaseValidationSchema } from "./base.schema";
+
+export class NumberValidationSchema extends BaseValidationSchema<number, NumberValidationSchema> {
+  public readonly type = "number";
+  private _min?: number;
+  private _max?: number;
+  private _maxDecimals?: number;
+
+  public min(min: number): this {
+    this._min = min;
+    return this;
+  }
+
+  public max(max: number): this {
+    this._max = max;
+    return this;
+  }
+
+  public maxDecimals(maxDecimals: number): this {
+    this._maxDecimals = maxDecimals;
+    return this;
+  }
+
+  protected _typeCheck(value: unknown, path: string[]): ValidationErrorData[] {
+    const numberValue = Number(value);
+
+    if (Number.isNaN(numberValue)) {
+      return [
+        {
+          path,
+          message: this._message ?? "Value must be a valid number",
+          provided: value,
+          validationRule: {
+            ruleType: RuleType.VALUE_TYPE,
+            settings: { allowedTypes: [ContentValueTypeNames.NUMBER] },
+          },
+        },
+      ];
+    }
+
+    return [];
+  }
+
+  protected _validateAgainstSchema(value: number, context: ValidationContext = {}): ValidationErrorData[] {
+    const path = context.path ?? [];
+    const errors: ValidationErrorData[] = [];
+
+    const numberBetweenError = this._validateNumberBetween(value, path);
+    if (numberBetweenError) {
+      errors.push(numberBetweenError);
+    }
+
+    const decimalCountError = this._validateDecimalCount(value, path);
+    if (decimalCountError) {
+      errors.push(decimalCountError);
+    }
+
+    return errors;
+  }
+
+  private _validateNumberBetween(
+    value: number,
+    path: string[],
+  ): ValidationErrorData<NumberBetweenValidationRuleSettings> | null {
+    if (this._min === undefined && this._max === undefined) {
+      return null;
+    }
+
+    const validationRule = this._validationRule ?? {
+      ruleType: RuleType.NUMBER_BETWEEN,
+      settings: {
+        min: this._min,
+        max: this._max,
+      },
+    };
+
+    return validateWithFunction<NumberBetweenValidationRuleSettings, number>(
+      value,
+      validationRule as RuleInstance<NumberBetweenValidationRuleSettings>,
+      path,
+      this._message ?? "Number is outside allowed range",
+      validateValueNumberBetween,
+    );
+  }
+
+  private _validateDecimalCount(
+    value: number,
+    path: string[],
+  ): ValidationErrorData<DecimalCountValidationRuleSettings> | null {
+    if (this._maxDecimals === undefined) {
+      return null;
+    }
+
+    const validationRule = this._validationRule ?? {
+      ruleType: RuleType.DECIMAL_COUNT,
+      settings: {
+        max: this._maxDecimals,
+      },
+    };
+
+    return validateWithFunction<DecimalCountValidationRuleSettings, number>(
+      value,
+      validationRule as RuleInstance<DecimalCountValidationRuleSettings>,
+      path,
+      this._message ?? "Number has too many decimal places",
+      validateValueDecimalCount,
+    );
+  }
+}

package/src/lib/schemas/string.schema.spec.ts

@@ -0,0 +1,135 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { RuleType } from "../enums/rule-types.enum";
+import { StringValidationSchema } from "./string.schema";
+
+describe("StringValidationSchema", () => {
+  let schema: StringValidationSchema;
+
+  beforeEach(() => {
+    schema = new StringValidationSchema();
+  });
+
+  describe("type checking", () => {
+    it("passes when value is a string", () => {
+      const result = schema.validate("test", { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails when value is not a string", () => {
+      const result = schema.validate(123 as unknown as string, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Value must be a string");
+      expect(result.errors[0].path).toEqual(["test"]);
+    });
+
+    it("passes validation when value is null (allowed by default)", () => {
+      const result = schema.validate(null as unknown as string, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when value is undefined (allowed by default)", () => {
+      const result = schema.validate(undefined as unknown as string, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when value is an object", () => {
+      const result = schema.validate({ key: "value" } as unknown as string, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Value must be a string");
+    });
+
+    it("fails validation when value is an array", () => {
+      const result = schema.validate(["test"] as unknown as string, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Value must be a string");
+    });
+  });
+
+  describe("format validation", () => {
+    it("passes validation when string matches email format", () => {
+      schema.format(".*@.*\\..*");
+      const result = schema.validate("test@example.com", { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when string does not match email format", () => {
+      schema.format(".*@.*\\..*");
+      const result = schema.validate("invalid-email", { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toContain("String does not match the required format");
+    });
+
+    it("passes validation when no format is specified", () => {
+      const result = schema.validate("any string", { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("rejects invalid email formats", () => {
+      schema.format(".*@.*\\..*");
+
+      const invalidEmails = ["no-at-sign", "missing-dot@domain", "just@", "@just"];
+
+      invalidEmails.forEach((email) => {
+        const result = schema.validate(email, { path: ["test"] });
+        expect(result.isValid).toBe(false);
+      });
+    });
+
+    it("uses validation rule for format validation", () => {
+      const mockRule = {
+        ruleType: RuleType.STRING_FORMAT,
+        settings: { allowedFormat: ".*@.*\\..*" },
+        prn: PRN.fromString("prn:plate:-1:cxc:validation-rule:1"),
+      };
+
+      const schemaWithRule = new StringValidationSchema(mockRule);
+      const result = schemaWithRule.validate("invalid-email", { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+    });
+  });
+
+  describe("allowed values validation", () => {
+    it("passes when string is in allowed values", () => {
+      schema.allowedValues(["option1", "option2", "option3"]);
+      const result = schema.validate("option2", { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails when string is not in allowed values", () => {
+      schema.allowedValues(["option1", "option2", "option3"]);
+      const result = schema.validate("invalid", { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("The provided value must be one of option1, option2, option3");
+    });
+
+    it("passes when no allowed values are set", () => {
+      const result = schema.validate("any string", { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("method chaining", () => {
+    it("supports method chaining", () => {
+      const result = schema
+        .format(".*@.*\\..*")
+        .allowedValues(["test@example.com"])
+        .message("Custom string message")
+        .validate("test@example.com", { path: ["test"] });
+
+      expect(result.isValid).toBe(true);
+    });
+  });
+});

package/src/lib/schemas/string.schema.ts

@@ -0,0 +1,73 @@
+import { ContentValueTypeNames } from "@platecms/delta-types";
+import { RuleType } from "../enums/rule-types.enum";
+import { validateWithFunction } from "../helpers/validate-with-function";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ValidationContext } from "../types/validation-context.interface";
+import { ValidationErrorData } from "../types/validation-error-data.interface";
+import {
+  StringFormatValidationRuleSettings,
+  validateValueStringFormat,
+} from "../validation-rules/string-format.validation-rule";
+import { BaseValidationSchema } from "./base.schema";
+
+export class StringValidationSchema extends BaseValidationSchema<string, StringValidationSchema> {
+  public readonly type = "string";
+  private _format?: string;
+
+  public format(fmt: string): StringValidationSchema {
+    this._format = fmt;
+    return this;
+  }
+
+  protected _typeCheck(value: unknown, path: string[]): ValidationErrorData[] {
+    if (typeof value !== "string") {
+      return [
+        {
+          path,
+          message: this._message ?? "Value must be a string",
+          provided: value,
+          validationRule: {
+            ruleType: RuleType.VALUE_TYPE,
+            settings: { allowedTypes: [ContentValueTypeNames.STRING] },
+          },
+        },
+      ];
+    }
+    return [];
+  }
+
+  protected _validateAgainstSchema(value: string, context: ValidationContext = {}): ValidationErrorData[] {
+    const errors: ValidationErrorData[] = [];
+
+    const stringFormatError = this._validateStringFormat(value, context.path ?? []);
+    if (stringFormatError) {
+      errors.push(stringFormatError);
+    }
+
+    return errors;
+  }
+
+  private _validateStringFormat(
+    value: string,
+    path: string[],
+  ): ValidationErrorData<StringFormatValidationRuleSettings> | null {
+    if (this._format === undefined && this._validationRule === undefined) {
+      return null;
+    }
+
+    const validationRule = this._validationRule ?? {
+      ruleType: RuleType.STRING_FORMAT,
+      settings: {
+        allowedFormat: this._format!,
+      },
+    };
+
+    return validateWithFunction<StringFormatValidationRuleSettings, string>(
+      value,
+      validationRule as RuleInstance<StringFormatValidationRuleSettings>,
+      path,
+      this._message ?? "String format validation failed",
+      validateValueStringFormat,
+    );
+  }
+}

package/src/lib/test-utils/setup-files.ts

@@ -0,0 +1 @@
+import "./validation-result-matcher";