@platecms/delta-validation 1.2.0 → 1.3.0

package/package.json

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

package/src/index.ts

@@ -1,19 +1,20 @@
+export * from "./lib/enums/rule-types.enum";
+export * from "./lib/enums/validation-rule-update-impact.enum";
 export * from "./lib/errors/invalid-validation-arguments.error";
 export * from "./lib/errors/invalid-validation-rule-settings.error";
-export * from "./lib/errors/validation.error";
 export * from "./lib/errors/validation-error-details";
+export * from "./lib/errors/validation.error";
 export * from "./lib/helpers/deserialize-validation-rule";
-export * from "./lib/validation-rules/number-between.validation-rule";
-export type * from "./lib/types/existing-content-validation-rules-settings.type";
+export * from "./lib/helpers/fields-to-schema";
 export * from "./lib/helpers/rule-to-schema";
 export * from "./lib/helpers/schema-builder";
+export type * from "./lib/types/existing-content-validation-rules-settings.type";
+export type * from "./lib/types/existing-content-validation-rules.type";
 export type * from "./lib/types/existing-validation-schemas.type";
+export type * from "./lib/types/rule-instance.interface";
+export type * from "./lib/types/validation-context.interface";
 export type * from "./lib/types/validation-error-data.interface";
 export type * from "./lib/types/validation-result.interface";
-export type * from "./lib/types/validation-context.interface";
-export type * from "./lib/types/rule-instance.interface";
-export * from "./lib/enums/rule-types.enum";
-export type * from "./lib/types/existing-content-validation-rules.type";
 export * from "./lib/validation-rules/allowed-values.validation-rule";
 export * from "./lib/validation-rules/base.validation-rule";
 export * from "./lib/validation-rules/count.validation-rule";

package/src/lib/enums/validation-rule-update-impact.enum.ts

@@ -0,0 +1,5 @@
+export enum ValidationRuleUpdateImpact {
+  NONE = "NONE",
+  BREAKS = "BREAKS",
+  INVALIDATES = "INVALIDATES",
+}

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

@@ -0,0 +1,184 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueTypeNames } from "@platecms/delta-types";
+import { RuleType } from "../enums/rule-types.enum";
+import { ObjectValidationSchema } from "../schemas/object.schema";
+import { FieldToValidate, fieldsToSchema } from "./fields-to-schema";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ValidationResult } from "../types/validation-result.interface";
+
+describe("fieldsToSchema", () => {
+  const mockPrn = PRN.fromString("prn:plate:-1:cms:validation-rule:1");
+
+  function mkField(slug: string, rules: RuleInstance<unknown>[] = []): FieldToValidate {
+    return {
+      slug,
+      contentValidationRules: rules.map((rule) => ({ ...rule, prn: rule.prn ?? mockPrn })),
+    };
+  }
+
+  function validateOk(schema: ObjectValidationSchema, value: unknown): ValidationResult {
+    const res = schema.validate(value, { path: [] });
+    expect(res.isValid).toBe(true);
+    expect(res.errors?.length ?? 0).toBe(0);
+    return res;
+  }
+
+  function validateFail(schema: ObjectValidationSchema, value: unknown): ValidationResult {
+    const res = schema.validate(value, { path: [] });
+    expect(res.isValid).toBe(false);
+    expect(res.errors?.length).toBeGreaterThan(0);
+    return res;
+  }
+
+  function expectError(res: ValidationResult, opts: { pathEndsWith?: (number | string)[]; ruleType?: RuleType }): void {
+    const err = res.errors[0];
+    if (opts.pathEndsWith) {
+      expect(err.path.slice(-opts.pathEndsWith.length)).toEqual(opts.pathEndsWith);
+    }
+    if (opts.ruleType !== undefined) {
+      expect(err.validationRule?.ruleType).toBe(opts.ruleType);
+    }
+  }
+
+  it("returns ObjectValidationSchema with type object", () => {
+    const schema = fieldsToSchema([]);
+    expect(schema).toBeInstanceOf(ObjectValidationSchema);
+    expect(schema.type).toBe("object");
+  });
+
+  it("accepts empty object when contentFields is empty", () => {
+    validateOk(fieldsToSchema([]), {});
+  });
+
+  it("treats missing field as empty array (if this is your intended contract)", () => {
+    // If your contract is different, flip this test accordingly.
+    const schema = fieldsToSchema([mkField("items", [])]);
+    validateOk(schema, {}); // missing key
+    validateOk(schema, { items: [] }); // explicit
+  });
+
+  it("rejects non-array field values", () => {
+    const schema = fieldsToSchema([mkField("items", [])]);
+    const res = validateFail(schema, { items: "nope" });
+    expectError(res, { pathEndsWith: ["items"] });
+  });
+
+  describe("COUNT", () => {
+    const schema = fieldsToSchema([mkField("items", [{ ruleType: RuleType.COUNT, settings: { min: 1, max: 2 } }])]);
+
+    test.each([
+      [{ items: [] }, false],
+      [{ items: [1] }, true],
+      [{ items: [1, 2] }, true],
+      [{ items: [1, 2, 3] }, false],
+    ])("COUNT %o => %s", (input, ok) => {
+      const res = schema.validate(input, { path: [] });
+      expect(res.isValid).toBe(ok);
+      if (!ok) {
+        expectError(res, { pathEndsWith: ["items"], ruleType: RuleType.COUNT });
+      }
+    });
+  });
+
+  describe("ALLOWED_VALUES", () => {
+    const schema = fieldsToSchema([
+      mkField("choice", [{ ruleType: RuleType.ALLOWED_VALUES, settings: { allowedValues: ["a", "b"] } }]),
+    ]);
+
+    it("accepts allowed and rejects not allowed", () => {
+      validateOk(schema, { choice: ["a"] });
+
+      const res = validateFail(schema, { choice: ["x"] });
+      expectError(res, { pathEndsWith: ["choice", "0"], ruleType: RuleType.ALLOWED_VALUES });
+    });
+  });
+
+  describe("VALUE_TYPE", () => {
+    const schema = fieldsToSchema([
+      mkField("vals", [
+        {
+          ruleType: RuleType.VALUE_TYPE,
+          settings: { allowedTypes: [ContentValueTypeNames.STRING, ContentValueTypeNames.NUMBER] },
+        },
+      ]),
+    ]);
+
+    it("accepts allowed and rejects disallowed", () => {
+      validateOk(schema, { vals: ["ok", 1] });
+
+      const res = validateFail(schema, { vals: [true] });
+      // Depending on your validator, the error could be on vals[0] or vals.
+      expect(res.errors[0].validationRule?.ruleType).toBe(RuleType.VALUE_TYPE);
+    });
+  });
+
+  describe("STRING_FORMAT", () => {
+    const schema = fieldsToSchema([
+      mkField("emails", [{ ruleType: RuleType.STRING_FORMAT, settings: { allowedFormat: ".*@.*\\..*" } }]),
+    ]);
+
+    it("accepts matching and rejects non-matching", () => {
+      validateOk(schema, { emails: ["a@b.co"] });
+
+      const res = validateFail(schema, { emails: ["invalid"] });
+      expectError(res, { pathEndsWith: ["emails", "0"], ruleType: RuleType.STRING_FORMAT });
+    });
+  });
+
+  describe("NUMBER_BETWEEN", () => {
+    const schema = fieldsToSchema([
+      mkField("scores", [{ ruleType: RuleType.NUMBER_BETWEEN, settings: { min: 0, max: 100 } }]),
+    ]);
+
+    test.each([
+      [{ scores: [50] }, true],
+      [{ scores: [-1] }, false],
+      [{ scores: [101] }, false],
+    ])("NUMBER_BETWEEN %o => %s", (input, ok) => {
+      const res = schema.validate(input, { path: [] });
+      expect(res.isValid).toBe(ok);
+      if (!ok) {
+        expectError(res, { ruleType: RuleType.NUMBER_BETWEEN });
+      }
+    });
+  });
+
+  describe("DECIMAL_COUNT", () => {
+    const schema = fieldsToSchema([mkField("amounts", [{ ruleType: RuleType.DECIMAL_COUNT, settings: { max: 2 } }])]);
+
+    it("accepts within max decimals and rejects above", () => {
+      validateOk(schema, { amounts: [3.14] });
+
+      const res = validateFail(schema, { amounts: [3.141] });
+      expectError(res, { ruleType: RuleType.DECIMAL_COUNT });
+    });
+  });
+
+  describe("DATE_BETWEEN", () => {
+    const start = new Date("2023-01-01");
+    const end = new Date("2023-12-31");
+
+    const schema = fieldsToSchema([mkField("dates", [{ ruleType: RuleType.DATE_BETWEEN, settings: { start, end } }])]);
+
+    it("accepts in range and rejects outside", () => {
+      validateOk(schema, { dates: [new Date("2023-06-01")] });
+
+      const res = validateFail(schema, { dates: [new Date("2024-01-01")] });
+      expectError(res, { ruleType: RuleType.DATE_BETWEEN });
+    });
+  });
+
+  describe("multiple fields", () => {
+    const schema = fieldsToSchema([
+      mkField("tags", []),
+      mkField("count", [{ ruleType: RuleType.COUNT, settings: { min: 0, max: 1 } }]),
+    ]);
+
+    it("accepts valid and rejects invalid count with correct path", () => {
+      validateOk(schema, { tags: [], count: [1] });
+
+      const res = validateFail(schema, { tags: [], count: [1, 2] });
+      expectError(res, { pathEndsWith: ["count"], ruleType: RuleType.COUNT });
+    });
+  });
+});

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

@@ -0,0 +1,141 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType, ContentValueTypeNames } from "@platecms/delta-types";
+import { RuleType } from "../enums/rule-types.enum";
+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 { ObjectValidationSchema, Shape } from "../schemas/object.schema";
+import { StringValidationSchema } from "../schemas/string.schema";
+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";
+
+interface FieldToValidate {
+  slug: string;
+  contentValidationRules: RuleInstance<unknown>[];
+}
+
+interface FieldSchemaBuilder {
+  array: ArrayValidationSchema<ContentValueType>;
+  item: ContentValueValidationSchema;
+}
+
+function createFieldBuilder(): FieldSchemaBuilder {
+  const item = new ContentValueValidationSchema();
+  const array = new ArrayValidationSchema<ContentValueType>().of(item);
+  return { array, item };
+}
+
+function applyRule(builder: FieldSchemaBuilder, rule: RuleInstance<unknown>): void {
+  switch (rule.ruleType) {
+    case RuleType.COUNT: {
+      const settings = rule.settings as CountValidationRuleSettings;
+      builder.array.min(settings.min ?? 0).max(settings.max ?? 0);
+      return;
+    }
+
+    case RuleType.ALLOWED_VALUES: {
+      const settings = rule.settings as AllowedValuesValidationRuleSettings;
+      builder.item.allowedValues(settings.allowedValues);
+      return;
+    }
+
+    case RuleType.VALUE_TYPE: {
+      const settings = rule.settings as ValueTypeValidationRuleSettings;
+      builder.item.allowedValueTypes(settings.allowedTypes);
+      return;
+    }
+
+    case RuleType.RELATABLE_CONTENT_TYPES: {
+      const settings = rule.settings as RelatableContentTypesValidationRuleSettings<PRN>;
+      builder.item.allowedContentTypes(settings.allowedContentTypes);
+      return;
+    }
+
+    case RuleType.STRING_FORMAT: {
+      const settings = rule.settings as StringFormatValidationRuleSettings;
+      builder.item.subSchema(
+        ContentValueTypeNames.STRING,
+        new StringValidationSchema(rule).format(settings.allowedFormat),
+      );
+      return;
+    }
+
+    case RuleType.NUMBER_BETWEEN: {
+      const settings = rule.settings as NumberBetweenValidationRuleSettings;
+      const num =
+        (builder.item.subSchemas[ContentValueTypeNames.NUMBER] as NumberValidationSchema | undefined) ??
+        new NumberValidationSchema();
+
+      if (settings.min !== undefined) {
+        num.min(settings.min);
+      }
+      if (settings.max !== undefined) {
+        num.max(settings.max);
+      }
+
+      builder.item.subSchema(ContentValueTypeNames.NUMBER, num);
+      return;
+    }
+
+    case RuleType.DECIMAL_COUNT: {
+      const settings = rule.settings as DecimalCountValidationRuleSettings;
+      const num =
+        (builder.item.subSchemas[ContentValueTypeNames.NUMBER] as NumberValidationSchema | undefined) ??
+        new NumberValidationSchema();
+      num.maxDecimals(settings.max);
+
+      builder.item.subSchema(ContentValueTypeNames.NUMBER, num);
+      return;
+    }
+
+    case RuleType.DATE_BETWEEN: {
+      const settings = rule.settings as DateBetweenValidationRuleSettings;
+      const date = new DateValidationSchema(rule);
+
+      if (settings.start) {
+        date.start(settings.start);
+      }
+      if (settings.end) {
+        date.end(settings.end);
+      }
+
+      builder.item.subSchema(ContentValueTypeNames.DATE, date);
+    }
+  }
+}
+
+/**
+ * Generates an object validation schema based on the provided content fields and their associated validation rules.
+ *
+ * Iterates over each field, applies its content validation rules to a builder, and constructs a validation schema shape
+ * with field slugs as keys. The resulting shape is set as the structure for a new ObjectValidationSchema.
+ *
+ * @param contentFields Array of validated field definitions, each containing validation rules to apply.
+ * @returns An ObjectValidationSchema instance representing the entire set of fields with their validation logic.
+ */
+function fieldsToSchema(contentFields: FieldToValidate[]): ObjectValidationSchema {
+  const shape: Shape = {};
+
+  for (const field of contentFields) {
+    const builder = createFieldBuilder();
+
+    for (const rule of field.contentValidationRules) {
+      applyRule(builder, rule);
+    }
+
+    shape[field.slug] = builder.array;
+  }
+
+  return new ObjectValidationSchema().of(shape);
+}
+
+export { fieldsToSchema };
+export type { FieldToValidate };

package/src/lib/helpers/get-content-value-type-name.ts

@@ -0,0 +1,26 @@
+import {
+  ContentValueType,
+  ContentValueTypeName,
+  ContentValueTypeNames,
+  PRN_RESOURCE_TYPE_TO_CONTENT_VALUE_TYPE_NAME_MAP,
+} from "@platecms/delta-types";
+import { PRN } from "@platecms/delta-plate-resource-notation";
+
+export function getContentValueTypeName(value: ContentValueType): ContentValueTypeName<ContentValueType> {
+  if (typeof value === "string") {
+    return ContentValueTypeNames.STRING;
+  }
+  if (typeof value === "number") {
+    return ContentValueTypeNames.NUMBER;
+  }
+  if (typeof value === "boolean") {
+    return ContentValueTypeNames.BOOLEAN;
+  }
+  if (value instanceof Date) {
+    return ContentValueTypeNames.DATE;
+  }
+  if (value instanceof PRN) {
+    return PRN_RESOURCE_TYPE_TO_CONTENT_VALUE_TYPE_NAME_MAP[value.resourceType];
+  }
+  return ContentValueTypeNames.SMART_TEXT;
+}

package/src/lib/helpers/is-superset.helper.ts

@@ -0,0 +1,4 @@
+export function isSuperset<T>(superset: T[], subset: T[]): boolean {
+  const set = new Set(superset);
+  return subset.every((item) => set.has(item));
+}

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

@@ -2,6 +2,7 @@ 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 { ObjectValidationSchema } from "../schemas/object.schema";
 import { StringValidationSchema } from "../schemas/string.schema";
 
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
@@ -22,6 +23,10 @@ export class SchemaBuilder {
     return new ArrayValidationSchema<T>();
   }
 
+  public static object<T>(): ObjectValidationSchema<T> {
+    return new ObjectValidationSchema<T>();
+  }
+
   public static contentValue(): ContentValueValidationSchema {
     return new ContentValueValidationSchema();
   }

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

@@ -10,11 +10,20 @@ import {
   validateValueValueType,
 } from "../validation-rules/value-type.validation-rule";
 import { BaseValidationSchema } from "./base.schema";
+import { ValidationSchema } from "../types/validation-schema.interface";
+import { getContentValueTypeName } from "../helpers/get-content-value-type-name";
+
+type SubSchemas = Partial<Record<ContentValueTypeName<ContentValueType>, ValidationSchema<ContentValueType>>>;
 
 export class ContentValueValidationSchema extends BaseValidationSchema<ContentValueType, ContentValueValidationSchema> {
   public readonly type = "content-value";
   private _allowedValueTypes?: ContentValueTypeName<ContentValueType>[];
   private _allowedContentTypes?: PRN[];
+  private _subSchemas: SubSchemas = {};
+
+  public get subSchemas(): SubSchemas {
+    return this._subSchemas;
+  }
 
   public allowedContentTypes(types: PRN[]): this {
     this._allowedContentTypes = types;
@@ -26,13 +35,29 @@ export class ContentValueValidationSchema extends BaseValidationSchema<ContentVa
     return this;
   }
 
+  public subSchema(type: ContentValueTypeName<ContentValueType>, schema: ValidationSchema<ContentValueType>): this {
+    this._subSchemas[type] = schema;
+    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 [];
+  protected _validateAgainstSchema(value: ContentValueType, context: ValidationContext = {}): ValidationErrorData[] {
+    const errors: ValidationErrorData[] = [];
+    const valueType = getContentValueTypeName(value);
+
+    const subSchema = this._subSchemas[valueType];
+    if (subSchema !== undefined) {
+      const result = subSchema.validate(value, context);
+      if (!result.isValid) {
+        errors.push(...result.errors);
+      }
+    }
+
+    return errors;
   }
 
   private _validateAllowedValueTypes(