@platecms/delta-validation 0.6.0 → 0.7.0

package/src/lib/helpers/validate-with-function.spec.ts

@@ -0,0 +1,264 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../enums/rule-types.enum";
+import { validateWithFunction } from "./validate-with-function";
+
+describe("validate-with-function", () => {
+  const mockRulePrn = PRN.fromString("prn:plate:-1:cxc:validation-rule:1");
+  const mockPath = ["content-type-prn", "content-field-prn"];
+  const fallbackErrorMessage = "Validation failed";
+
+  function createMockRule(settings: object = {}): RuleInstance<object> {
+    return {
+      id: "test-rule",
+      prn: mockRulePrn,
+      settings,
+      ruleType: RuleType.COUNT,
+    };
+  }
+
+  describe("validateWithFunction", () => {
+    it("returns null when validation function returns true", () => {
+      const mockRule = createMockRule();
+      const mockValidationFunction = vi.fn().mockReturnValue(true);
+
+      const result = validateWithFunction(
+        "test-value",
+        mockRule,
+        mockPath,
+        fallbackErrorMessage,
+        mockValidationFunction,
+      );
+
+      expect(result).toBeNull();
+      expect(mockValidationFunction).toHaveBeenCalledWith("test-value", mockRule);
+    });
+
+    it("returns null when validation function returns null", () => {
+      const mockRule = createMockRule();
+      const mockValidationFunction = vi.fn().mockReturnValue(null);
+
+      const result = validateWithFunction(
+        "test-value",
+        mockRule,
+        mockPath,
+        fallbackErrorMessage,
+        mockValidationFunction,
+      );
+
+      expect(result).toBeNull();
+      expect(mockValidationFunction).toHaveBeenCalledWith("test-value", mockRule);
+    });
+
+    it("returns ValidationErrorData when validation function returns ValidationErrorDetails", () => {
+      const mockRule = createMockRule();
+      const validationError = new ValidationErrorDetails("Custom error message", mockRule);
+      const mockValidationFunction = vi.fn().mockReturnValue(validationError);
+
+      const result = validateWithFunction(
+        "test-value",
+        mockRule,
+        mockPath,
+        fallbackErrorMessage,
+        mockValidationFunction,
+      );
+
+      expect(result).toEqual({
+        path: mockPath,
+        message: "Custom error message",
+        provided: "test-value",
+        validationRule: mockRule,
+      });
+      expect(mockValidationFunction).toHaveBeenCalledWith("test-value", mockRule);
+    });
+
+    it("returns ValidationErrorData with fallback message when validation function returns non-ValidationErrorDetails", () => {
+      const mockRule = createMockRule();
+      const mockValidationFunction = vi.fn().mockReturnValue("some-other-result");
+
+      const result = validateWithFunction(
+        "test-value",
+        mockRule,
+        mockPath,
+        fallbackErrorMessage,
+        mockValidationFunction,
+      );
+
+      expect(result).toEqual({
+        path: mockPath,
+        message: fallbackErrorMessage,
+        provided: "test-value",
+        validationRule: mockRule,
+      });
+      expect(mockValidationFunction).toHaveBeenCalledWith("test-value", mockRule);
+    });
+
+    it("returns ValidationErrorData when validation function throws an Error", () => {
+      const mockRule = createMockRule();
+      const errorMessage = "Validation function error";
+      const mockValidationFunction = vi.fn().mockImplementation(() => {
+        throw new Error(errorMessage);
+      });
+
+      const result = validateWithFunction(
+        "test-value",
+        mockRule,
+        mockPath,
+        fallbackErrorMessage,
+        mockValidationFunction,
+      );
+
+      expect(result).toEqual({
+        path: mockPath,
+        message: errorMessage,
+        provided: "test-value",
+        validationRule: mockRule,
+      });
+      expect(mockValidationFunction).toHaveBeenCalledWith("test-value", mockRule);
+    });
+
+    it("returns ValidationErrorData with fallback message when validation function throws non-Error", () => {
+      const mockRule = createMockRule();
+      const mockValidationFunction = vi.fn().mockImplementation(() => {
+        throw "string error" as unknown as Error;
+      });
+
+      const result = validateWithFunction(
+        "test-value",
+        mockRule,
+        mockPath,
+        fallbackErrorMessage,
+        mockValidationFunction,
+      );
+
+      expect(result).toEqual({
+        path: mockPath,
+        message: fallbackErrorMessage,
+        provided: "test-value",
+        validationRule: mockRule,
+      });
+      expect(mockValidationFunction).toHaveBeenCalledWith("test-value", mockRule);
+    });
+
+    it("handles different ContentValueType values", () => {
+      const mockRule = createMockRule();
+      const mockValidationFunction = vi.fn().mockReturnValue(true);
+
+      // Test with string
+      const stringResult = validateWithFunction(
+        "string-value",
+        mockRule,
+        mockPath,
+        fallbackErrorMessage,
+        mockValidationFunction,
+      );
+      expect(stringResult).toBeNull();
+
+      // Test with number
+      const numberResult = validateWithFunction(42, mockRule, mockPath, fallbackErrorMessage, mockValidationFunction);
+      expect(numberResult).toBeNull();
+
+      // Test with boolean
+      const booleanResult = validateWithFunction(
+        true,
+        mockRule,
+        mockPath,
+        fallbackErrorMessage,
+        mockValidationFunction,
+      );
+      expect(booleanResult).toBeNull();
+
+      // Test with Date
+      const dateResult = validateWithFunction(
+        new Date("2023-01-01"),
+        mockRule,
+        mockPath,
+        fallbackErrorMessage,
+        mockValidationFunction,
+      );
+      expect(dateResult).toBeNull();
+
+      // Test with PRN
+      const prnResult = validateWithFunction(
+        PRN.fromString("prn:plate:-1:cxc:content-item:1"),
+        mockRule,
+        mockPath,
+        fallbackErrorMessage,
+        mockValidationFunction,
+      );
+      expect(prnResult).toBeNull();
+
+      // Test with Root (smart text)
+      const rootResult = validateWithFunction(
+        { type: "root", children: [] },
+        mockRule,
+        mockPath,
+        fallbackErrorMessage,
+        mockValidationFunction,
+      );
+      expect(rootResult).toBeNull();
+    });
+  });
+
+  describe("validateWithFunction with arrays", () => {
+    it("handles empty values array", () => {
+      const mockRule = createMockRule();
+      const validationError = new ValidationErrorDetails("Empty array error", mockRule);
+      const mockValidationFunction = vi.fn().mockReturnValue(validationError);
+      const values: ContentValueType[] = [];
+
+      const result = validateWithFunction(values, mockRule, mockPath, fallbackErrorMessage, mockValidationFunction);
+
+      expect(result).toEqual({
+        path: mockPath,
+        message: "Empty array error",
+        provided: values,
+        validationRule: mockRule,
+      });
+      expect(mockValidationFunction).toHaveBeenCalledWith(values, mockRule);
+    });
+
+    it("handles mixed content value types in array", () => {
+      const mockRule = createMockRule();
+      const validationError = new ValidationErrorDetails("Mixed types error", mockRule);
+      const mockValidationFunction = vi.fn().mockReturnValue(validationError);
+      const values: ContentValueType[] = [
+        "string",
+        42,
+        true,
+        new Date("2023-01-01"),
+        PRN.fromString("prn:plate:-1:cxc:content-item:1"),
+        { type: "root", children: [] },
+      ];
+
+      const result = validateWithFunction(values, mockRule, mockPath, fallbackErrorMessage, mockValidationFunction);
+
+      expect(result).toEqual({
+        path: mockPath,
+        message: "Mixed types error",
+        provided: values,
+        validationRule: mockRule,
+      });
+      expect(mockValidationFunction).toHaveBeenCalledWith(values, mockRule);
+    });
+
+    it("handles single value in array", () => {
+      const mockRule = createMockRule();
+      const validationError = new ValidationErrorDetails("Single value error", mockRule);
+      const mockValidationFunction = vi.fn().mockReturnValue(validationError);
+      const values: ContentValueType[] = ["single-value"];
+
+      const result = validateWithFunction(values, mockRule, mockPath, fallbackErrorMessage, mockValidationFunction);
+
+      expect(result).toEqual({
+        path: mockPath,
+        message: "Single value error",
+        provided: values,
+        validationRule: mockRule,
+      });
+      expect(mockValidationFunction).toHaveBeenCalledWith(values, mockRule);
+    });
+  });
+});

package/src/lib/helpers/validate-with-function.ts

@@ -0,0 +1,45 @@
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ValidationErrorData } from "../types/validation-error-data.interface";
+import { ContentValidationResultType } from "../validation-rules/base.validation-rule";
+
+function validateWithFunctionInternal<TSettings extends object, TValue>(
+  value: TValue,
+  validationRule: RuleInstance<TSettings>,
+  path: string[],
+  fallbackErrorMessage: string,
+  validationFunction: (value: TValue, validationRule: RuleInstance<TSettings>) => ContentValidationResultType,
+): ValidationErrorData<TSettings> | null {
+  let validationResult: ContentValidationResultType;
+  try {
+    validationResult = validationFunction(value, validationRule);
+  } catch (error) {
+    return {
+      path,
+      message: error instanceof Error ? error.message : fallbackErrorMessage,
+      provided: value,
+      validationRule,
+    };
+  }
+
+  if (validationResult === true || validationResult === null) {
+    return null;
+  }
+
+  return {
+    path,
+    message: validationResult instanceof ValidationErrorDetails ? validationResult.message : fallbackErrorMessage,
+    provided: value,
+    validationRule,
+  };
+}
+
+export function validateWithFunction<TSettings extends object, TType>(
+  valueOrValues: TType,
+  validationRule: RuleInstance<TSettings>,
+  path: string[],
+  fallbackErrorMessage: string,
+  validationFunction: (input: TType, validationRule: RuleInstance<TSettings>) => ContentValidationResultType,
+): ValidationErrorData<TSettings> | null {
+  return validateWithFunctionInternal(valueOrValues, validationRule, path, fallbackErrorMessage, validationFunction);
+}

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

@@ -0,0 +1,127 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+import { RuleType } from "../enums/rule-types.enum";
+import { ArrayValidationSchema } from "./array.schema";
+import { StringValidationSchema } from "./string.schema";
+
+describe("ArrayValidationSchema", () => {
+  let schema: ArrayValidationSchema<ContentValueType>;
+
+  beforeEach(() => {
+    schema = new ArrayValidationSchema<ContentValueType>();
+  });
+
+  describe("type checking", () => {
+    it("passes validation when value is an array", () => {
+      const result = schema.validate([1, 2, 3] as ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when value is not an array", () => {
+      const result = schema.validate("not an array" as unknown as ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Value must be an array");
+    });
+
+    it("passes validation when value is null (allowed by default)", () => {
+      const result = schema.validate(null as unknown as ContentValueType[], { 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 ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("count validation", () => {
+    it("passes validation when array length is within min and max bounds", () => {
+      schema.min(2).max(4);
+      const result = schema.validate([1, 2, 3] as ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when array length is below minimum", () => {
+      schema.min(3);
+      const result = schema.validate([1, 2] as ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toContain("The amount of provided values must be");
+    });
+
+    it("fails validation when array length is above maximum", () => {
+      schema.max(2);
+      const result = schema.validate([1, 2, 3] as ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toContain("The amount of provided values must be");
+    });
+
+    it("passes validation when no min/max constraints are set", () => {
+      const result = schema.validate([1, 2, 3, 4, 5] as ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("handles empty array with min constraint", () => {
+      schema.min(1);
+      const result = schema.validate([] as ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+    });
+
+    it("handles empty array with max constraint", () => {
+      schema.max(2);
+      const result = schema.validate([] as ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("item validation", () => {
+    it("handles empty array with item schema", () => {
+      const stringSchema = new StringValidationSchema();
+      schema.of(stringSchema);
+      const result = schema.validate([] as ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("does not validate items when no item schema is set", () => {
+      const result = schema.validate(["string", 123, true] as ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("integration with validation rules", () => {
+    it("uses validation rule for count validation", () => {
+      const mockRule = {
+        ruleType: RuleType.COUNT,
+        settings: { min: 2, max: 4 },
+        id: "count-rule",
+        prn: PRN.fromString("prn:plate:-1:cxc:validation-rule:1"),
+      };
+
+      const schemaWithRule = new ArrayValidationSchema<ContentValueType>(mockRule);
+      const result = schemaWithRule.validate([1, 2, 3] as ContentValueType[], { path: ["test"] });
+      expect(result.isValid).toBe(true);
+    });
+  });
+
+  describe("method chaining", () => {
+    it("supports method chaining", () => {
+      const result = schema
+        .min(1)
+        .max(5)
+        .validate([1, 2, 3] as ContentValueType[], { path: ["test"] });
+
+      expect(result.isValid).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,104 @@
+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 { ValidationSchema } from "../types/validation-schema.interface";
+import { CountValidationRuleSettings, validateValuesCount } from "../validation-rules/count.validation-rule";
+import { BaseValidationSchema } from "./base.schema";
+
+export class ArrayValidationSchema<T> extends BaseValidationSchema<T[], ArrayValidationSchema<T>> {
+  public readonly type = "array";
+  private _itemSchema?: ValidationSchema<T>;
+  private _min?: number;
+  private _max?: number;
+
+  public of(itemSchema: ValidationSchema<T>): this {
+    this._itemSchema = itemSchema;
+    return this;
+  }
+
+  public min(min: number): this {
+    this._min = min;
+    return this;
+  }
+
+  public max(max: number): this {
+    this._max = max;
+    return this;
+  }
+
+  protected _typeCheck(value: unknown, path: string[]): ValidationErrorData[] {
+    if (!Array.isArray(value)) {
+      return [
+        {
+          path,
+          message: this._message ?? "Value must be an array",
+          provided: value,
+          validationRule: {
+            ruleType: RuleType.COUNT,
+            settings: {
+              min: this._min,
+              max: this._max,
+            },
+          },
+        },
+      ];
+    }
+    return [];
+  }
+
+  protected _validateAgainstSchema(value: T[], context: ValidationContext = {}): ValidationErrorData[] {
+    const errors: ValidationErrorData[] = [];
+
+    const itemsCountError = this._validateCount(value, context.path ?? []);
+    if (itemsCountError) {
+      errors.push(itemsCountError);
+    }
+
+    errors.push(...this._validateItems(value, context));
+
+    return errors;
+  }
+
+  private _validateCount(value: T[], path: string[]): ValidationErrorData<CountValidationRuleSettings> | null {
+    if (this._min === undefined && this._max === undefined && this._validationRule === undefined) {
+      return null;
+    }
+
+    const validationRule = this._validationRule ?? {
+      ruleType: RuleType.COUNT,
+      settings: {
+        min: this._min,
+        max: this._max,
+      },
+    };
+
+    return validateWithFunction<CountValidationRuleSettings, T[]>(
+      value,
+      validationRule as RuleInstance<CountValidationRuleSettings>,
+      path,
+      this._message ?? "Array count validation failed",
+      validateValuesCount,
+    );
+  }
+
+  private _validateItems(value: T[], context: ValidationContext): ValidationErrorData[] {
+    if (this._itemSchema === undefined) {
+      return [];
+    }
+
+    const errors: ValidationErrorData[] = [];
+    for (let i = 0; i < value.length; i++) {
+      const itemValidationResult = this._itemSchema.validate(value[i], {
+        ...context,
+        path: [...(context.path ?? []), i.toString()],
+      });
+      if (!itemValidationResult.isValid) {
+        errors.push(...itemValidationResult.errors);
+      }
+    }
+
+    return errors;
+  }
+}