@platecms/delta-validation 0.4.1 → 0.7.0

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

@@ -0,0 +1,168 @@
+import { RuleType } from "../enums/rule-types.enum";
+import { ValidationContext } from "../types/validation-context.interface";
+import { ValidationErrorData } from "../types/validation-error-data.interface";
+import { SchemaType } from "../types/validation-schema.interface";
+import { BaseValidationSchema } from "./base.schema";
+
+// Concrete implementation for testing
+class TestValidationSchema extends BaseValidationSchema<string, TestValidationSchema> {
+  public readonly type: SchemaType = "string";
+
+  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: ["string"] },
+          },
+        },
+      ];
+    }
+    return [];
+  }
+
+  protected _validateAgainstSchema(_value: string, _context: ValidationContext = {}): ValidationErrorData[] {
+    return [];
+  }
+}
+
+describe("BaseValidationSchema", () => {
+  let schema: TestValidationSchema;
+
+  beforeEach(() => {
+    schema = new TestValidationSchema();
+  });
+
+  describe("required validation", () => {
+    it("passes validation when value is provided and required is false", () => {
+      const result = schema.validate("test", { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when value is provided and required is true", () => {
+      schema.required(true);
+      const result = schema.validate("test", { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when value is null and required is true", () => {
+      schema.required(true);
+      const result = schema.validate(null as unknown as string, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Value is required");
+    });
+
+    it("fails validation when value is undefined and required is true", () => {
+      schema.required(true);
+      const result = schema.validate(undefined as unknown as string, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Value is required");
+    });
+
+    it("passes validation when value is null and required is false", () => {
+      schema.required(false);
+      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 and required is false", () => {
+      schema.required(false);
+      const result = schema.validate(undefined as unknown as string, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("message handling", () => {
+    it("uses custom message when provided", () => {
+      schema.message("Custom error message");
+      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("Custom error message");
+    });
+
+    it("uses default message when no custom message is provided", () => {
+      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");
+    });
+  });
+
+  describe("allowed values validation", () => {
+    it("passes validation when value is in allowed values", () => {
+      schema.allowedValues(["test", "other"]);
+      const result = schema.validate("test", { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when value is not in allowed values", () => {
+      schema.allowedValues(["test", "other"]);
+      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 test, other");
+    });
+
+    it("passes validation 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("type checking", () => {
+    it("fails validation 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");
+    });
+
+    it("passes validation when value is a string", () => {
+      const result = schema.validate("test", { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("context handling", () => {
+    it("uses provided path from context", () => {
+      const result = schema.validate(123 as unknown as string, { path: ["user", "name"] });
+      expect(result.errors[0].path).toEqual(["user", "name"]);
+    });
+
+    it("uses empty array when no path is provided", () => {
+      const result = schema.validate(123 as unknown as string);
+      expect(result.errors[0].path).toEqual([]);
+    });
+
+    it("handles undefined context", () => {
+      const result = schema.validate(123 as unknown as string, undefined);
+      expect(result.errors[0].path).toEqual([]);
+    });
+  });
+
+  describe("chaining", () => {
+    it("supports method chaining", () => {
+      const result = schema
+        .required(true)
+        .message("Custom message")
+        .allowedValues(["test"])
+        .validate("test", { path: ["test"] });
+
+      expect(result.isValid).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,150 @@
+import { ContentValueType } 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 { ValidationResult } from "../types/validation-result.interface";
+import { SchemaType, ValidationSchema } from "../types/validation-schema.interface";
+import {
+  AllowedValuesValidationRuleSettings,
+  validateValueAllowedValues,
+} from "../validation-rules/allowed-values.validation-rule";
+
+/**
+ * Base abstract class for all validation schemas.
+ * @template TType - The type of the value to validate.
+ * @template TSelf - The type of the schema itself.
+ */
+export abstract class BaseValidationSchema<TType, TSelf extends BaseValidationSchema<TType, TSelf>>
+  implements ValidationSchema<TType>
+{
+  protected _required?: boolean;
+  protected _message?: string;
+  protected _validationRule?: RuleInstance<unknown>;
+  protected _allowedValues?: unknown[];
+  public abstract readonly type: SchemaType;
+
+  public constructor(validationRule?: RuleInstance<unknown>) {
+    if (validationRule) {
+      this._validationRule = {
+        id: validationRule.id,
+        prn: validationRule.prn,
+        ruleType: validationRule.ruleType,
+        settings: validationRule.settings,
+      };
+    }
+  }
+
+  public required(required: boolean): TSelf {
+    this._required = required;
+    return this as unknown as TSelf;
+  }
+
+  public message(msg: string): TSelf {
+    this._message = msg;
+    return this as unknown as TSelf;
+  }
+
+  public allowedValues(values: unknown[]): TSelf {
+    this._allowedValues = values;
+    return this as unknown as TSelf;
+  }
+
+  /**
+   * Validates a value against the schema.
+   * Calls the _typeCheck and _validateAgainstSchema methods, which are implemented by the concrete schemas.
+   * @param value - The value to validate.
+   * @param context - The context of the validation, including the path of the value.
+   * @returns The validation result.
+   */
+  public validate(value: TType, context: ValidationContext = {}): ValidationResult {
+    const errors: ValidationErrorData[] = [];
+    const path = context?.path ?? [];
+
+    // 1) required
+    const isRequired = this._required ?? false;
+    if (isRequired && (value === undefined || value === null)) {
+      return {
+        isValid: false,
+        errors: [
+          {
+            path,
+            message: this._message ?? "Value is required",
+            provided: value,
+            validationRule: {
+              ruleType: RuleType.COUNT,
+              settings: {
+                min: 1,
+                max: 1,
+              },
+            },
+          },
+        ],
+      };
+    }
+    if (!isRequired && (value === undefined || value === null)) {
+      return {
+        isValid: true,
+        errors: [],
+      };
+    }
+
+    // 2) type/shape
+    errors.push(...this._typeCheck(value, path));
+    if (errors.length > 0) {
+      return {
+        isValid: false,
+        errors,
+      };
+    }
+
+    // 3) validate against schema
+    errors.push(...this._validateAgainstSchema(value, context));
+    if (errors.length > 0) {
+      return {
+        isValid: false,
+        errors,
+      };
+    }
+
+    // 4) validate against allowed values
+    const allowedValuesError = this._validateAllowedValues(value, path);
+    if (allowedValuesError) {
+      errors.push(allowedValuesError);
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors,
+    };
+  }
+
+  private _validateAllowedValues(
+    value: unknown,
+    path: string[],
+  ): ValidationErrorData<AllowedValuesValidationRuleSettings> | null {
+    if (this._allowedValues === undefined) {
+      return null;
+    }
+
+    const validationRule = this._validationRule ?? {
+      ruleType: RuleType.ALLOWED_VALUES,
+      settings: {
+        allowedValues: this._allowedValues,
+      },
+    };
+
+    return validateWithFunction<AllowedValuesValidationRuleSettings, ContentValueType>(
+      value as ContentValueType,
+      validationRule as RuleInstance<AllowedValuesValidationRuleSettings>,
+      path,
+      this._message ?? "Value is not in allowed values list",
+      validateValueAllowedValues,
+    );
+  }
+
+  protected abstract _typeCheck(value: TType, path: string[]): ValidationErrorData[];
+
+  protected abstract _validateAgainstSchema(value: TType, context: ValidationContext): ValidationErrorData[];
+}

package/src/lib/schemas/content-value.schema.spec.ts

@@ -0,0 +1,133 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueTypeNames } from "@platecms/delta-types";
+import { RuleType } from "../enums/rule-types.enum";
+import { ContentValueValidationSchema } from "./content-value.schema";
+import { Root } from "@platecms/delta-cast";
+
+describe("ContentValueValidationSchema", () => {
+  let schema: ContentValueValidationSchema;
+
+  beforeEach(() => {
+    schema = new ContentValueValidationSchema();
+  });
+
+  describe("type checking", () => {
+    it("passes validation when value is a string", () => {
+      const result = schema.validate("test string", { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    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 a boolean", () => {
+      const result = schema.validate(true, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when value is a Date", () => {
+      const result = schema.validate(new Date("2023-01-01"), { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when value is a PRN", () => {
+      const prn = PRN.fromString("prn:plate:-1:cxc:content-item:1");
+      const result = schema.validate(prn, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("passes validation when value is a Root (smart text)", () => {
+      const root: Root = { type: "root", children: [] };
+      const result = schema.validate(root, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("allowed value types validation", () => {
+    it("passes validation when value type is in allowed types (number)", () => {
+      schema.allowedValueTypes([ContentValueTypeNames.STRING, ContentValueTypeNames.NUMBER]);
+      const result = schema.validate(42, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when value type is not in allowed types", () => {
+      schema.allowedValueTypes([ContentValueTypeNames.STRING, ContentValueTypeNames.NUMBER]);
+      const result = schema.validate(true, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toContain("The value must be of the correct type");
+    });
+
+    it("passes validation when no allowed value types are set", () => {
+      const result = schema.validate("any content value", { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("handles multiple allowed types", () => {
+      schema.allowedValueTypes([
+        ContentValueTypeNames.STRING,
+        ContentValueTypeNames.NUMBER,
+        ContentValueTypeNames.BOOLEAN,
+      ]);
+
+      const stringResult = schema.validate("test", { path: ["test"] });
+      const numberResult = schema.validate(42, { path: ["test"] });
+      const booleanResult = schema.validate(true, { path: ["test"] });
+
+      expect(stringResult.isValid).toBe(true);
+      expect(numberResult.isValid).toBe(true);
+      expect(booleanResult.isValid).toBe(true);
+    });
+  });
+
+  describe("allowed content types validation", () => {
+    it("passes validation when PRN content type is in allowed types", () => {
+      const allowedTypes = [PRN.fromString("prn:plate:-1:cxc:content-item:1")];
+      schema.allowedContentTypes(allowedTypes);
+
+      const prn = PRN.fromString("prn:plate:-1:cxc:content-item:1");
+      const result = schema.validate(prn, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("uses validation rule for value type validation", () => {
+      const allowedValueTypes = [ContentValueTypeNames.STRING, ContentValueTypeNames.NUMBER];
+      const mockRule = {
+        ruleType: RuleType.VALUE_TYPE,
+        settings: { allowedTypes: allowedValueTypes },
+        prn: PRN.fromString("prn:plate:-1:cxc:validation-rule:1"),
+      };
+
+      const schemaWithRule = new ContentValueValidationSchema(mockRule).allowedValueTypes(allowedValueTypes);
+      const result = schemaWithRule.validate(true, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+    });
+  });
+
+  describe("method chaining", () => {
+    it("supports method chaining", () => {
+      const allowedValueTypes = [ContentValueTypeNames.STRING, ContentValueTypeNames.NUMBER];
+      const allowedContentTypes = [PRN.fromString("prn:plate:-1:cxc:content-item:1")];
+
+      const result = schema
+        .allowedValueTypes(allowedValueTypes)
+        .allowedContentTypes(allowedContentTypes)
+        .message("Custom content value message")
+        .validate("test string", { path: ["test"] });
+
+      expect(result.isValid).toBe(true);
+    });
+  });
+});

package/src/lib/schemas/content-value.schema.ts

@@ -0,0 +1,61 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType, ContentValueTypeName } 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 {
+  ValueTypeValidationRuleSettings,
+  validateValueValueType,
+} from "../validation-rules/value-type.validation-rule";
+import { BaseValidationSchema } from "./base.schema";
+
+export class ContentValueValidationSchema extends BaseValidationSchema<ContentValueType, ContentValueValidationSchema> {
+  public readonly type = "content-value";
+  private _allowedValueTypes?: ContentValueTypeName<ContentValueType>[];
+  private _allowedContentTypes?: PRN[];
+
+  public allowedContentTypes(types: PRN[]): this {
+    this._allowedContentTypes = types;
+    return this;
+  }
+
+  public allowedValueTypes(types: ContentValueTypeName<ContentValueType>[]): this {
+    this._allowedValueTypes = types;
+    return this;
+  }
+
+  protected _typeCheck(value: unknown, path: string[]): ValidationErrorData[] {
+    const allowedValueTypesError = this._validateAllowedValueTypes(value as ContentValueType, path);
+    return allowedValueTypesError ? [allowedValueTypesError] : [];
+  }
+
+  protected _validateAgainstSchema(_value: ContentValueType, _context: ValidationContext = {}): ValidationErrorData[] {
+    return [];
+  }
+
+  private _validateAllowedValueTypes(
+    value: ContentValueType,
+    path: string[],
+  ): ValidationErrorData<ValueTypeValidationRuleSettings> | null {
+    if (this._allowedValueTypes === undefined) {
+      return null;
+    }
+
+    const validationRule = this._validationRule ?? {
+      ruleType: RuleType.VALUE_TYPE,
+      settings: {
+        allowedTypes: this._allowedValueTypes,
+      },
+    };
+
+    return validateWithFunction<ValueTypeValidationRuleSettings, ContentValueType>(
+      value,
+      validationRule as RuleInstance<ValueTypeValidationRuleSettings>,
+      path,
+      this._message ?? "Value type validation failed",
+      validateValueValueType,
+    );
+  }
+}

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

@@ -0,0 +1,144 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { RuleType } from "../enums/rule-types.enum";
+import { DateValidationSchema } from "./date.schema";
+
+describe("DateValidationSchema", () => {
+  let schema: DateValidationSchema;
+
+  beforeEach(() => {
+    schema = new DateValidationSchema();
+  });
+
+  describe("type checking", () => {
+    it("passes validation when value is a Date object", () => {
+      const result = schema.validate(new Date("2023-01-01"), { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when value is a date string", () => {
+      const result = schema.validate("2023-01-01" as unknown as Date, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Value must be a valid date");
+      expect(result.errors[0].path).toEqual(["test"]);
+    });
+
+    it("fails validation when value is not a valid date", () => {
+      const result = schema.validate("invalid-date" as unknown as Date, { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Value must be a valid date");
+      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 Date, { 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 Date, { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("range validation", () => {
+    it("passes validation when date is within min and max bounds", () => {
+      const startDate = new Date("2023-01-01");
+      const endDate = new Date("2023-12-31");
+      schema.start(startDate).end(endDate);
+
+      const result = schema.validate(new Date("2023-06-15"), { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when date is before minimum", () => {
+      const startDate = new Date("2023-01-01");
+      schema.start(startDate);
+
+      const result = schema.validate(new Date("2022-12-31"), { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toContain("The date must be greater than or equal");
+    });
+
+    it("fails validation when date is after maximum", () => {
+      const endDate = new Date("2023-12-31");
+      schema.end(endDate);
+
+      const result = schema.validate(new Date("2024-01-01"), { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toContain("The date must be lower than or equal");
+    });
+
+    it("passes validation when no min/max constraints are set", () => {
+      const result = schema.validate(new Date("2030-01-01"), { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("uses validation rule for range validation", () => {
+      const startDate = new Date("2023-01-01");
+      const endDate = new Date("2023-12-31");
+      const mockRule = {
+        ruleType: RuleType.DATE_BETWEEN,
+        settings: { start: startDate, end: endDate },
+        prn: PRN.fromString("prn:plate:-1:cxc:validation-rule:1"),
+      };
+
+      schema = new DateValidationSchema(mockRule).start(startDate).end(endDate);
+      const result = schema.validate(new Date("2024-01-01"), { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+    });
+  });
+
+  describe("allowed values validation", () => {
+    it("passes validation when date is in allowed values", () => {
+      const allowedDates = [new Date("2023-01-01"), new Date("2023-06-15"), new Date("2023-12-31")];
+      schema.allowedValues(allowedDates);
+
+      const result = schema.validate(new Date("2023-06-15"), { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("fails validation when date is not in allowed values", () => {
+      const allowedDates = [new Date("2023-01-01"), new Date("2023-06-15"), new Date("2023-12-31")];
+      schema.allowedValues(allowedDates);
+
+      const result = schema.validate(new Date("2023-03-15"), { path: ["test"] });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toContain("The provided value must be one of");
+    });
+
+    it("passes validation when no allowed values are set", () => {
+      const result = schema.validate(new Date("2030-01-01"), { path: ["test"] });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("method chaining", () => {
+    it("supports method chaining", () => {
+      const startDate = new Date("2023-01-01");
+      const endDate = new Date("2023-12-31");
+      const allowedDates = [new Date("2023-06-15")];
+
+      const result = schema
+        .start(startDate)
+        .end(endDate)
+        .allowedValues(allowedDates)
+        .message("Custom date message")
+        .validate(new Date("2023-06-15"), { path: ["test"] });
+
+      expect(result.isValid).toBe(true);
+    });
+  });
+});