@platecms/delta-validation 1.18.0 → 1.20.0

package/package.json

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

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

@@ -1,3 +1,4 @@
+import { Root } from "@platecms/delta-cast";
 import { PRN } from "@platecms/delta-plate-resource-notation";
 import { ContentValueTypeNames } from "@platecms/delta-types";
 import { RuleType } from "../enums/rule-types.enum";
@@ -77,6 +78,41 @@ describe("ruleToSchema", () => {
       const validationResult = schema.validate(["invalid-email"], { path: ["test"] });
       expect(validationResult.isValid).toBe(false);
     });
+
+    it("ignores values that are not strings, so a link or smart text value can be saved", () => {
+      // Arrange
+      const rule = {
+        ruleType: RuleType.STRING_FORMAT,
+        settings: { allowedFormat: "^https?://" },
+        prn: mockPrn,
+      };
+      const pathPart = PRN.fromString("prn:plate:-1:cms:path-part:1");
+      const smartText: Root = { type: "root", children: [] };
+
+      // Act
+      const validationResult = ruleToSchema(rule).validate([pathPart, smartText], { path: ["test"] });
+
+      // Assert
+      expect(validationResult).toEqual({ isValid: true, errors: [] });
+    });
+
+    it("still rejects a non-matching string next to values of other types", () => {
+      // Arrange
+      const rule = {
+        ruleType: RuleType.STRING_FORMAT,
+        settings: { allowedFormat: "^https?://" },
+        prn: mockPrn,
+      };
+      const pathPart = PRN.fromString("prn:plate:-1:cms:path-part:1");
+
+      // Act
+      const validationResult = ruleToSchema(rule).validate([pathPart, "not a url"], { path: ["test"] });
+
+      // Assert
+      expect(validationResult.isValid).toBe(false);
+      expect(validationResult.errors).toHaveLength(1);
+      expect(validationResult.errors[0].message).toBe("String does not match the required format");
+    });
   });
 
   describe("NUMBER_BETWEEN rule", () => {
@@ -217,6 +253,24 @@ describe("ruleToSchema", () => {
     });
   });
 
+  describe("rules for one value type", () => {
+    it.each([
+      { ruleType: RuleType.NUMBER_BETWEEN, settings: { min: 0, max: 100 } },
+      { ruleType: RuleType.DECIMAL_COUNT, settings: { max: 2 } },
+      { ruleType: RuleType.DATE_BETWEEN, settings: { start: new Date("2023-01-01"), end: new Date("2023-12-31") } },
+    ])("$ruleType ignores values of other types", ({ ruleType, settings }) => {
+      // Arrange
+      const rule = { ruleType, settings, prn: mockPrn };
+      const values = ["text", PRN.fromString("prn:plate:-1:cms:path-part:1")];
+
+      // Act
+      const validationResult = ruleToSchema(rule).validate(values, { path: ["test"] });
+
+      // Assert
+      expect(validationResult).toEqual({ isValid: true, errors: [] });
+    });
+  });
+
   describe("VALUE_TYPE rule", () => {
     it("converts VALUE_TYPE rule to array schema with inner content-value schema", () => {
       const ruleInstance = {

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

@@ -1,5 +1,5 @@
 import { PRN } from "@platecms/delta-plate-resource-notation";
-import { ContentValueType } from "@platecms/delta-types";
+import { ContentValueType, ContentValueTypeName, ContentValueTypeNames } 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";
@@ -15,6 +15,21 @@ 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";
+import { ValidationSchema } from "../types/validation-schema.interface";
+
+/**
+ * Applies a schema only to the values of one type, as fieldsToSchema does: a field can allow several types
+ * (a link, or smart text, next to plain text), and checking that every value has an allowed type is the VALUE_TYPE
+ * rule's job, not this rule's.
+ */
+function ofValueType(
+  valueType: ContentValueTypeName<ContentValueType>,
+  schema: ValidationSchema<ContentValueType>,
+): ArrayValidationSchema<ContentValueType> {
+  return new ArrayValidationSchema<ContentValueType>().of(
+    new ContentValueValidationSchema().subSchema(valueType, schema),
+  );
+}
 
 export function ruleToSchema(ruleInstance: RuleInstance<unknown>): ArrayValidationSchema<ContentValueType> {
   switch (ruleInstance.ruleType) {
@@ -34,7 +49,8 @@ export function ruleToSchema(ruleInstance: RuleInstance<unknown>): ArrayValidati
 
     case RuleType.STRING_FORMAT: {
       const formatSettings = ruleInstance.settings as StringFormatValidationRuleSettings;
-      return new ArrayValidationSchema<ContentValueType>().of(
+      return ofValueType(
+        ContentValueTypeNames.STRING,
         new StringValidationSchema(ruleInstance).format(formatSettings.allowedFormat),
       );
     }
@@ -50,7 +66,7 @@ export function ruleToSchema(ruleInstance: RuleInstance<unknown>): ArrayValidati
         numberSchema.max(numberSettings.max);
       }
 
-      return new ArrayValidationSchema<ContentValueType>().of(numberSchema);
+      return ofValueType(ContentValueTypeNames.NUMBER, numberSchema);
     }
 
     case RuleType.DATE_BETWEEN: {
@@ -64,12 +80,13 @@ export function ruleToSchema(ruleInstance: RuleInstance<unknown>): ArrayValidati
         dateSchema.end(dateSettings.end);
       }
 
-      return new ArrayValidationSchema<ContentValueType>().of(dateSchema);
+      return ofValueType(ContentValueTypeNames.DATE, dateSchema);
     }
 
     case RuleType.DECIMAL_COUNT: {
       const decimalSettings = ruleInstance.settings as DecimalCountValidationRuleSettings;
-      return new ArrayValidationSchema<ContentValueType>().of(
+      return ofValueType(
+        ContentValueTypeNames.NUMBER,
         new NumberValidationSchema(ruleInstance).maxDecimals(decimalSettings.max),
       );
     }