@platecms/delta-validation 1.12.1 → 1.13.0

package/package.json

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

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

@@ -51,7 +51,7 @@ describe("ArrayValidationSchema", () => {
       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");
+      expect(result.errors[0].message).toBe("The number of provided values must be greater than or equal to 3.");
     });
 
     it("fails validation when array length is above maximum", () => {
@@ -59,7 +59,7 @@ describe("ArrayValidationSchema", () => {
       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");
+      expect(result.errors[0].message).toBe("The number of provided values must be less than or equal to 2.");
     });
 
     it("passes validation when no min/max constraints are set", () => {

package/src/lib/validation-rules/count.validation-rule.spec.ts

@@ -1,5 +1,6 @@
 import { PRN } from "@platecms/delta-plate-resource-notation";
 import { InvalidValidationRuleSettingsError } from "../errors/invalid-validation-rule-settings.error";
+import { ValidationErrorDetails } from "../errors/validation-error-details";
 import { CountValidationRule } from "./count.validation-rule";
 import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 
@@ -31,6 +32,30 @@ describe("CountValidationRule", () => {
       ])("returns %s if the value count is within the bounds", (value, expected) => {
         expect(rule.validate(value)).toBeContentValidationResult([expected]);
       });
+
+      it("returns a required-field message when min is 1 and no values are provided", () => {
+        // Arrange & Act
+        const [result] = rule.validate([]);
+
+        // Assert
+        expect(result).toBeInstanceOf(ValidationErrorDetails);
+        if (!(result instanceof ValidationErrorDetails)) {
+          throw new Error("Expected ValidationErrorDetails");
+        }
+        expect(result.message).toBe("This is a required field");
+      });
+
+      it("returns a max count message when too many values are provided", () => {
+        // Arrange & Act
+        const [result] = rule.validate([1, 2, 3, 4]);
+
+        // Assert
+        expect(result).toBeInstanceOf(ValidationErrorDetails);
+        if (!(result instanceof ValidationErrorDetails)) {
+          throw new Error("Expected ValidationErrorDetails");
+        }
+        expect(result.message).toBe("The number of provided values must be less than or equal to 3.");
+      });
     });
 
     describe("with only min", () => {
@@ -49,6 +74,23 @@ describe("CountValidationRule", () => {
       });
     });
 
+    describe("with min greater than 1", () => {
+      it("returns a count message when fewer than the minimum values are provided", () => {
+        // Arrange
+        const rule = new CountValidationRule(rulePrn, { min: 2 });
+
+        // Act
+        const [result] = rule.validate([1]);
+
+        // Assert
+        expect(result).toBeInstanceOf(ValidationErrorDetails);
+        if (!(result instanceof ValidationErrorDetails)) {
+          throw new Error("Expected ValidationErrorDetails");
+        }
+        expect(result.message).toBe("The number of provided values must be greater than or equal to 2.");
+      });
+    });
+
     describe("with only max", () => {
       let rule: CountValidationRule;
 

package/src/lib/validation-rules/count.validation-rule.ts

@@ -7,21 +7,39 @@ import { RuleType } from "../enums/rule-types.enum";
 import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
 import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 
+const REQUIRED_FIELD_MESSAGE = "This is a required field";
+
+function minValuesCountMessage(min: number): string {
+  if (min === 1) {
+    return REQUIRED_FIELD_MESSAGE;
+  }
+  return `The number of provided values must be greater than or equal to ${min}.`;
+}
+
+function maxValuesCountMessage(max: number): string {
+  return `The number of provided values must be less than or equal to ${max}.`;
+}
+
+function minKeysCountMessage(min: number): string {
+  if (min === 1) {
+    return REQUIRED_FIELD_MESSAGE;
+  }
+  return `The number of provided object keys must be greater than or equal to ${min}.`;
+}
+
+function maxKeysCountMessage(max: number): string {
+  return `The number of provided object keys must be less than or equal to ${max}.`;
+}
+
 export function validateValuesCount<T>(
   values: T[],
   ruleInstance: RuleInstance<CountValidationRuleSettings>,
 ): ContentValidationResultType {
   if (ruleInstance.settings.min != null && values.length < ruleInstance.settings.min) {
-    return new ValidationErrorDetails(
-      `The amount of provided values must be greater than or equal ${ruleInstance.settings.min}.`,
-      ruleInstance,
-    );
+    return new ValidationErrorDetails(minValuesCountMessage(ruleInstance.settings.min), ruleInstance);
   }
   if (ruleInstance.settings.max != null && values.length > ruleInstance.settings.max) {
-    return new ValidationErrorDetails(
-      `The amount of provided values must be be less than or equal ${ruleInstance.settings.max}.`,
-      ruleInstance,
-    );
+    return new ValidationErrorDetails(maxValuesCountMessage(ruleInstance.settings.max), ruleInstance);
   }
   return true;
 }
@@ -33,16 +51,10 @@ export function validateKeysCount<T>(
   const indexableValue = value as unknown as Record<string, unknown>;
 
   if (ruleInstance.settings.min != null && Object.keys(indexableValue).length < ruleInstance.settings.min) {
-    return new ValidationErrorDetails(
-      `The amount of provided object keys must be greater than or equal ${ruleInstance.settings.min}.`,
-      ruleInstance,
-    );
+    return new ValidationErrorDetails(minKeysCountMessage(ruleInstance.settings.min), ruleInstance);
   }
   if (ruleInstance.settings.max != null && Object.keys(indexableValue).length > ruleInstance.settings.max) {
-    return new ValidationErrorDetails(
-      `The amount of provided object keys must be be less than or equal ${ruleInstance.settings.max}.`,
-      ruleInstance,
-    );
+    return new ValidationErrorDetails(maxKeysCountMessage(ruleInstance.settings.max), ruleInstance);
   }
   return true;
 }