@platecms/delta-validation 0.4.1 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platecms/delta-validation",
-  "version": "0.4.1",
+  "version": "0.7.0",
   "description": "This package contains the validation system for Plate.",
   "license": "UNLICENSED",
   "publishConfig": {
@@ -17,12 +17,11 @@
     "src/**/*"
   ],
   "peerDependencies": {
-    "@platecms/delta-cast": "0.4.1",
-    "@platecms/delta-plate-resource-notation": "0.4.1",
-    "@platecms/delta-types": "0.4.1",
+    "@platecms/delta-cast": "0.7.0",
+    "@platecms/delta-plate-resource-notation": "0.7.0",
+    "@platecms/delta-types": "0.7.0",
     "class-transformer": "0.5.1",
     "reflect-metadata": "0.2.2",
     "tslib": "2.8.1"
-  },
-  "type": "commonjs"
+  }
 }

package/src/lib/enums/rule-types.enum.ts

@@ -0,0 +1,10 @@
+export enum RuleType {
+  ALLOWED_VALUES = "ALLOWED_VALUES",
+  COUNT = "COUNT",
+  DATE_BETWEEN = "DATE_BETWEEN",
+  DECIMAL_COUNT = "DECIMAL_COUNT",
+  NUMBER_BETWEEN = "NUMBER_BETWEEN",
+  RELATABLE_CONTENT_TYPES = "RELATABLE_CONTENT_TYPES",
+  STRING_FORMAT = "STRING_FORMAT",
+  VALUE_TYPE = "VALUE_TYPE",
+}

package/src/lib/errors/invalid-validation-arguments.error.ts

@@ -0,0 +1 @@
+export class InvalidValidationArgumentsError extends Error {}

package/src/lib/errors/invalid-validation-rule-settings.error.ts

@@ -0,0 +1 @@
+export class InvalidValidationRuleSettingsError extends Error {}

package/src/lib/errors/validation-error-details.ts

@@ -0,0 +1,15 @@
+import { Transform } from "class-transformer";
+import { deserializeValidationRule } from "../helpers/deserialize-validation-rule";
+import { RuleInstance } from "../types/rule-instance.interface";
+
+export class ValidationErrorDetails<TRuleInstance extends RuleInstance<unknown>> {
+  public readonly message: string;
+
+  @Transform((validationRule: unknown) => deserializeValidationRule(validationRule))
+  public readonly validationRule: TRuleInstance;
+
+  public constructor(message: string, validationRule: TRuleInstance) {
+    this.message = message;
+    this.validationRule = validationRule;
+  }
+}

package/src/lib/errors/validation.error.ts

@@ -0,0 +1,18 @@
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ValidationErrorData } from "../types/validation-error-data.interface";
+
+export class ValidationError<TSettings extends object = object>
+  extends Error
+  implements ValidationErrorData<TSettings>
+{
+  public readonly path: string[];
+  public readonly validationRule: RuleInstance<TSettings>;
+  public readonly provided: unknown;
+
+  public constructor(path: string[], message: string, validationRule: RuleInstance<TSettings>, provided: unknown) {
+    super(message);
+    this.path = path;
+    this.validationRule = validationRule;
+    this.provided = provided;
+  }
+}

package/src/lib/helpers/deserialize-validation-rule.ts

@@ -0,0 +1,94 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ExistingContentValidationRules } from "../types/existing-content-validation-rules.type";
+import { RuleType } from "../enums/rule-types.enum";
+import {
+  AllowedValuesValidationRule,
+  AllowedValuesValidationRuleSettings,
+} from "../validation-rules/allowed-values.validation-rule";
+import { CountValidationRule, CountValidationRuleSettings } from "../validation-rules/count.validation-rule";
+import {
+  DateBetweenValidationRule,
+  DateBetweenValidationRuleSettings,
+} from "../validation-rules/date-between.validation-rule";
+import {
+  DecimalCountValidationRule,
+  DecimalCountValidationRuleSettings,
+} from "../validation-rules/decimal-count.validation-rule";
+import {
+  NumberBetweenValidationRule,
+  NumberBetweenValidationRuleSettings,
+} from "../validation-rules/number-between.validation-rule";
+import {
+  RelatableContentTypesValidationRule,
+  RelatableContentTypesValidationRuleSettings,
+} from "../validation-rules/relatable-content-types.validation-rule";
+import {
+  StringFormatValidationRule,
+  StringFormatValidationRuleSettings,
+} from "../validation-rules/string-format.validation-rule";
+import {
+  ValueTypeValidationRule,
+  ValueTypeValidationRuleSettings,
+} from "../validation-rules/value-type.validation-rule";
+
+/**
+ * @param input The input containing the untyped rule: `const input = { value: untypedRule }`
+ */
+export function deserializeValidationRule(input: unknown): ExistingContentValidationRules {
+  if (typeof input !== "object" || input == null) {
+    throw new Error(`The input is not an object or is null. Input: '${JSON.stringify(input)}'`);
+  }
+
+  if (input["value" as keyof object] == null) {
+    throw new Error(`The input does not contain a 'value' property. Input: '${JSON.stringify(input)}'`);
+  }
+
+  // Check the property ruleType of the validationRule object and initialize the appropriate class.
+  const rawValidationRule = input["value" as keyof object] as ExistingContentValidationRules;
+
+  switch (rawValidationRule.ruleType) {
+    case RuleType.ALLOWED_VALUES:
+      return new AllowedValuesValidationRule(
+        rawValidationRule.prn,
+        rawValidationRule.settings as AllowedValuesValidationRuleSettings,
+      );
+    case RuleType.COUNT:
+      return new CountValidationRule(rawValidationRule.prn, rawValidationRule.settings as CountValidationRuleSettings);
+    case RuleType.DATE_BETWEEN:
+      return new DateBetweenValidationRule(
+        rawValidationRule.prn,
+        rawValidationRule.settings as DateBetweenValidationRuleSettings,
+      );
+    case RuleType.DECIMAL_COUNT:
+      return new DecimalCountValidationRule(
+        rawValidationRule.prn,
+        rawValidationRule.settings as DecimalCountValidationRuleSettings,
+      );
+    case RuleType.NUMBER_BETWEEN:
+      return new NumberBetweenValidationRule(
+        rawValidationRule.prn,
+        rawValidationRule.settings as NumberBetweenValidationRuleSettings,
+      );
+    case RuleType.RELATABLE_CONTENT_TYPES:
+      return new RelatableContentTypesValidationRule(
+        rawValidationRule.prn,
+        rawValidationRule.settings as RelatableContentTypesValidationRuleSettings<PRN>,
+      );
+    case RuleType.STRING_FORMAT:
+      return new StringFormatValidationRule(
+        rawValidationRule.prn,
+        rawValidationRule.settings as StringFormatValidationRuleSettings,
+      );
+    case RuleType.VALUE_TYPE:
+      return new ValueTypeValidationRule(
+        rawValidationRule.prn,
+        rawValidationRule.settings as ValueTypeValidationRuleSettings,
+      );
+    default:
+      throw new Error(
+        `Unknown validation rule type: ${
+          rawValidationRule.ruleType as string
+        }. Rule: ${JSON.stringify(rawValidationRule)}`,
+      );
+  }
+}

package/src/lib/helpers/rule-to-schema.spec.ts

@@ -0,0 +1,254 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueTypeNames } from "@platecms/delta-types";
+import { RuleType } from "../enums/rule-types.enum";
+import { ArrayValidationSchema } from "../schemas/array.schema";
+import { ruleToSchema } from "./rule-to-schema";
+
+describe("ruleToSchema", () => {
+  const mockPrn = PRN.fromString("prn:plate:-1:cxc:validation-rule:1");
+
+  describe("ALLOWED_VALUES rule", () => {
+    it("converts ALLOWED_VALUES rule to array schema with inner content-value schema", () => {
+      const rule = {
+        ruleType: RuleType.ALLOWED_VALUES,
+        settings: { allowedValues: ["option1", "option2", "option3"] },
+        prn: PRN.fromString("prn:plate:-1:cxc:validation-rule:1"),
+      };
+
+      const schema = ruleToSchema(rule);
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+
+      const validationResult = schema.validate(["option1", "invalid"], { path: ["test"] });
+      expect(validationResult.isValid).toBe(false);
+      expect(validationResult.errors).toHaveLength(1);
+      expect(validationResult.errors[0].message).toBe("The provided value must be one of option1, option2, option3");
+    });
+  });
+
+  describe("COUNT rule", () => {
+    it("converts COUNT rule to array schema", () => {
+      const ruleInstance = {
+        ruleType: RuleType.COUNT,
+        settings: {
+          min: 1,
+          max: 10,
+        },
+        prn: mockPrn,
+      };
+
+      const schema = ruleToSchema(ruleInstance);
+
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+      expect(schema.type).toBe("array");
+
+      const validationResult = schema.validate([], { path: ["test"] });
+      expect(validationResult.isValid).toBe(false);
+      expect(validationResult.errors).toHaveLength(1);
+    });
+
+    it("handles COUNT rule with undefined min/max", () => {
+      const ruleInstance = {
+        ruleType: RuleType.COUNT,
+        settings: {},
+        prn: mockPrn,
+      };
+
+      const schema = ruleToSchema(ruleInstance);
+
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+      expect(schema.type).toBe("array");
+
+      const validationResult = schema.validate([1, 2, 3], { path: ["test"] });
+      expect(validationResult.isValid).toBe(true);
+    });
+  });
+
+  describe("STRING_FORMAT rule", () => {
+    it("converts STRING_FORMAT rule to array schema with inner string schema", () => {
+      const rule = {
+        ruleType: RuleType.STRING_FORMAT,
+        settings: { allowedFormat: ".*@.*\\..*" },
+        prn: PRN.fromString("prn:plate:-1:cxc:validation-rule:1"),
+      };
+
+      const schema = ruleToSchema(rule);
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+
+      const validationResult = schema.validate(["invalid-email"], { path: ["test"] });
+      expect(validationResult.isValid).toBe(false);
+    });
+  });
+
+  describe("NUMBER_BETWEEN rule", () => {
+    it("converts NUMBER_BETWEEN rule to array schema with inner number schema", () => {
+      const ruleInstance = {
+        ruleType: RuleType.NUMBER_BETWEEN,
+        settings: {
+          min: 0,
+          max: 100,
+        },
+        prn: mockPrn,
+      };
+
+      const schema = ruleToSchema(ruleInstance);
+
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+      expect(schema.type).toBe("array");
+
+      const validationResult = schema.validate([150], { path: ["test"] });
+      expect(validationResult.isValid).toBe(false);
+    });
+
+    it("handles NUMBER_BETWEEN rule with only min", () => {
+      const ruleInstance = {
+        ruleType: RuleType.NUMBER_BETWEEN,
+        settings: {
+          min: 0,
+        },
+        prn: mockPrn,
+      };
+
+      const schema = ruleToSchema(ruleInstance);
+
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+      expect(schema.type).toBe("array");
+
+      const validationResult = schema.validate([-1], { path: ["test"] });
+      expect(validationResult.isValid).toBe(false);
+    });
+
+    it("handles NUMBER_BETWEEN rule with only max", () => {
+      const ruleInstance = {
+        ruleType: RuleType.NUMBER_BETWEEN,
+        settings: {
+          max: 100,
+        },
+        prn: mockPrn,
+      };
+
+      const schema = ruleToSchema(ruleInstance);
+
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+      expect(schema.type).toBe("array");
+
+      const validationResult = schema.validate([150], { path: ["test"] });
+      expect(validationResult.isValid).toBe(false);
+    });
+  });
+
+  describe("DATE_BETWEEN rule", () => {
+    it("converts DATE_BETWEEN rule to array schema with inner date schema", () => {
+      const startDate = new Date("2023-01-01");
+      const endDate = new Date("2023-12-31");
+      const ruleInstance = {
+        ruleType: RuleType.DATE_BETWEEN,
+        settings: {
+          start: startDate,
+          end: endDate,
+        },
+        prn: mockPrn,
+      };
+
+      const schema = ruleToSchema(ruleInstance);
+
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+      expect(schema.type).toBe("array");
+
+      const validationResult = schema.validate([new Date("2024-01-01")], { path: ["test"] });
+      expect(validationResult.isValid).toBe(false);
+    });
+
+    it("handles DATE_BETWEEN rule with only min", () => {
+      const startDate = new Date("2023-01-01");
+      const ruleInstance = {
+        ruleType: RuleType.DATE_BETWEEN,
+        settings: {
+          start: startDate,
+        },
+        prn: mockPrn,
+      };
+
+      const schema = ruleToSchema(ruleInstance);
+
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+      expect(schema.type).toBe("array");
+
+      const validationResult = schema.validate([new Date("2022-01-01")], { path: ["test"] });
+      expect(validationResult.isValid).toBe(false);
+    });
+
+    it("handles DATE_BETWEEN rule with only max", () => {
+      const endDate = new Date("2023-12-31");
+      const ruleInstance = {
+        ruleType: RuleType.DATE_BETWEEN,
+        settings: {
+          end: endDate,
+        },
+        prn: mockPrn,
+      };
+
+      const schema = ruleToSchema(ruleInstance);
+
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+      expect(schema.type).toBe("array");
+
+      const validationResult = schema.validate([new Date("2024-01-01")], { path: ["test"] });
+      expect(validationResult.isValid).toBe(false);
+    });
+  });
+
+  describe("DECIMAL_COUNT rule", () => {
+    it("converts DECIMAL_COUNT rule to array schema with inner number schema", () => {
+      const ruleInstance = {
+        ruleType: RuleType.DECIMAL_COUNT,
+        settings: {
+          max: 2,
+        },
+        prn: mockPrn,
+      };
+
+      const schema = ruleToSchema(ruleInstance);
+
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+      expect(schema.type).toBe("array");
+
+      const validationResult = schema.validate([3.14159], { path: ["test"] });
+      expect(validationResult.isValid).toBe(false);
+    });
+  });
+
+  describe("VALUE_TYPE rule", () => {
+    it("converts VALUE_TYPE rule to array schema with inner content-value schema", () => {
+      const ruleInstance = {
+        ruleType: RuleType.VALUE_TYPE,
+        settings: {
+          allowedTypes: [ContentValueTypeNames.STRING, ContentValueTypeNames.NUMBER],
+        },
+        prn: mockPrn,
+      };
+
+      const schema = ruleToSchema(ruleInstance);
+
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+
+      const validationResult = schema.validate([true], { path: ["test"] });
+      expect(validationResult.isValid).toBe(false);
+    });
+  });
+
+  describe("RELATABLE_CONTENT_TYPES rule", () => {
+    it("converts RELATABLE_CONTENT_TYPES rule to array schema with inner content-value schema", () => {
+      const rule = {
+        ruleType: RuleType.RELATABLE_CONTENT_TYPES,
+        settings: { allowedTypes: [ContentValueTypeNames.STRING, ContentValueTypeNames.NUMBER] },
+        prn: PRN.fromString("prn:plate:-1:cxc:validation-rule:1"),
+      };
+
+      const schema = ruleToSchema(rule);
+      expect(schema).toBeInstanceOf(ArrayValidationSchema);
+
+      const validationResult = schema.validate(["string"], { path: ["test"] });
+      expect(validationResult.isValid).toBe(true);
+    });
+  });
+});

package/src/lib/helpers/rule-to-schema.ts

@@ -0,0 +1,95 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+import { RuleType } from "../enums/rule-types.enum";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { AllowedValuesValidationRuleSettings } from "../validation-rules/allowed-values.validation-rule";
+import { CountValidationRuleSettings } from "../validation-rules/count.validation-rule";
+import { DateBetweenValidationRuleSettings } from "../validation-rules/date-between.validation-rule";
+import { DecimalCountValidationRuleSettings } from "../validation-rules/decimal-count.validation-rule";
+import { NumberBetweenValidationRuleSettings } from "../validation-rules/number-between.validation-rule";
+import { RelatableContentTypesValidationRuleSettings } from "../validation-rules/relatable-content-types.validation-rule";
+import { StringFormatValidationRuleSettings } from "../validation-rules/string-format.validation-rule";
+import { ValueTypeValidationRuleSettings } from "../validation-rules/value-type.validation-rule";
+import { ArrayValidationSchema } from "../schemas/array.schema";
+import { ContentValueValidationSchema } from "../schemas/content-value.schema";
+import { StringValidationSchema } from "../schemas/string.schema";
+import { NumberValidationSchema } from "../schemas/number.schema";
+import { DateValidationSchema } from "../schemas/date.schema";
+
+export function ruleToSchema(ruleInstance: RuleInstance<unknown>): ArrayValidationSchema<ContentValueType> {
+  switch (ruleInstance.ruleType) {
+    case RuleType.ALLOWED_VALUES: {
+      const settings = ruleInstance.settings as AllowedValuesValidationRuleSettings;
+      return new ArrayValidationSchema<ContentValueType>().of(
+        new ContentValueValidationSchema(ruleInstance).allowedValues(settings.allowedValues),
+      );
+    }
+
+    case RuleType.COUNT: {
+      const countSettings = ruleInstance.settings as CountValidationRuleSettings;
+      return new ArrayValidationSchema<ContentValueType>(ruleInstance)
+        .min(countSettings.min ?? 0)
+        .max(countSettings.max ?? 0);
+    }
+
+    case RuleType.STRING_FORMAT: {
+      const formatSettings = ruleInstance.settings as StringFormatValidationRuleSettings;
+      return new ArrayValidationSchema<ContentValueType>().of(
+        new StringValidationSchema(ruleInstance).format(formatSettings.allowedFormat),
+      );
+    }
+
+    case RuleType.NUMBER_BETWEEN: {
+      const numberSettings = ruleInstance.settings as NumberBetweenValidationRuleSettings;
+      const numberSchema = new NumberValidationSchema(ruleInstance);
+
+      if (numberSettings.min !== undefined) {
+        numberSchema.min(numberSettings.min);
+      }
+      if (numberSettings.max !== undefined) {
+        numberSchema.max(numberSettings.max);
+      }
+
+      return new ArrayValidationSchema<ContentValueType>().of(numberSchema);
+    }
+
+    case RuleType.DATE_BETWEEN: {
+      const dateSettings = ruleInstance.settings as DateBetweenValidationRuleSettings;
+      const dateSchema = new DateValidationSchema(ruleInstance);
+
+      if (dateSettings.start) {
+        dateSchema.start(dateSettings.start);
+      }
+      if (dateSettings.end) {
+        dateSchema.end(dateSettings.end);
+      }
+
+      return new ArrayValidationSchema<ContentValueType>().of(dateSchema);
+    }
+
+    case RuleType.DECIMAL_COUNT: {
+      const decimalSettings = ruleInstance.settings as DecimalCountValidationRuleSettings;
+      return new ArrayValidationSchema<ContentValueType>().of(
+        new NumberValidationSchema(ruleInstance).maxDecimals(decimalSettings.max),
+      );
+    }
+
+    case RuleType.VALUE_TYPE: {
+      const valueTypeSettings = ruleInstance.settings as ValueTypeValidationRuleSettings;
+      return new ArrayValidationSchema<ContentValueType>().of(
+        new ContentValueValidationSchema(ruleInstance).allowedValueTypes(valueTypeSettings.allowedTypes),
+      );
+    }
+
+    case RuleType.RELATABLE_CONTENT_TYPES: {
+      const relatableSettings = ruleInstance.settings as RelatableContentTypesValidationRuleSettings<PRN>;
+      return new ArrayValidationSchema<ContentValueType>().of(
+        new ContentValueValidationSchema(ruleInstance).allowedContentTypes(relatableSettings.allowedContentTypes),
+      );
+    }
+
+    default: {
+      return new ArrayValidationSchema<ContentValueType>();
+    }
+  }
+}

package/src/lib/helpers/schema-builder.spec.ts

@@ -0,0 +1,52 @@
+import { SchemaBuilder } from "./schema-builder";
+import { StringValidationSchema } from "../schemas/string.schema";
+import { NumberValidationSchema } from "../schemas/number.schema";
+import { DateValidationSchema } from "../schemas/date.schema";
+import { ArrayValidationSchema } from "../schemas/array.schema";
+import { ContentValueValidationSchema } from "../schemas/content-value.schema";
+import { ContentValueTypeNames } from "@platecms/delta-types";
+
+describe("SchemaBuilder", () => {
+  it("creates string schema correctly", () => {
+    const stringSchema = SchemaBuilder.string();
+    expect(stringSchema).toBeInstanceOf(StringValidationSchema);
+  });
+
+  it("creates number schema correctly", () => {
+    const numberSchema = SchemaBuilder.number();
+    expect(numberSchema).toBeInstanceOf(NumberValidationSchema);
+  });
+
+  it("creates date schema correctly", () => {
+    const dateSchema = SchemaBuilder.date();
+    expect(dateSchema).toBeInstanceOf(DateValidationSchema);
+  });
+
+  it("creates array schema correctly", () => {
+    const arraySchema = SchemaBuilder.array();
+    expect(arraySchema).toBeInstanceOf(ArrayValidationSchema);
+  });
+
+  it("creates content value schema correctly", () => {
+    const contentValueSchema = SchemaBuilder.contentValue();
+    expect(contentValueSchema).toBeInstanceOf(ContentValueValidationSchema);
+  });
+
+  it("supports complex schema composition", () => {
+    const contentValueSchema = SchemaBuilder.contentValue().allowedValueTypes([
+      ContentValueTypeNames.STRING,
+      ContentValueTypeNames.NUMBER,
+    ]);
+
+    const arraySchema = SchemaBuilder.array().min(1).max(10).of(contentValueSchema);
+
+    expect(arraySchema).toBeInstanceOf(ArrayValidationSchema);
+  });
+
+  it("validates complex nested schemas", () => {
+    const arraySchema = SchemaBuilder.array().of(SchemaBuilder.number().min(0));
+
+    const result = arraySchema.validate([1, 2, 3], { path: ["test"] });
+    expect(result.isValid).toBe(true);
+  });
+});

package/src/lib/helpers/schema-builder.ts

@@ -0,0 +1,28 @@
+import { ArrayValidationSchema } from "../schemas/array.schema";
+import { ContentValueValidationSchema } from "../schemas/content-value.schema";
+import { DateValidationSchema } from "../schemas/date.schema";
+import { NumberValidationSchema } from "../schemas/number.schema";
+import { StringValidationSchema } from "../schemas/string.schema";
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class SchemaBuilder {
+  public static string(): StringValidationSchema {
+    return new StringValidationSchema();
+  }
+
+  public static number(): NumberValidationSchema {
+    return new NumberValidationSchema();
+  }
+
+  public static date(): DateValidationSchema {
+    return new DateValidationSchema();
+  }
+
+  public static array<T>(): ArrayValidationSchema<T> {
+    return new ArrayValidationSchema<T>();
+  }
+
+  public static contentValue(): ContentValueValidationSchema {
+    return new ContentValueValidationSchema();
+  }
+}