@platecms/delta-validation 1.2.0 → 1.4.0

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

@@ -1,5 +1,6 @@
 import { PRN } from "@platecms/delta-plate-resource-notation";
 import { DecimalCountValidationRule } from "./decimal-count.validation-rule";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 
 describe("DecimalCountValidationRule", () => {
   const rulePrn = PRN.fromString("prn:plate:-1:cms:validation-rule:decimal-count");
@@ -43,4 +44,29 @@ describe("DecimalCountValidationRule", () => {
       });
     });
   });
+
+  describe("classifyUpdate", () => {
+    let rule: DecimalCountValidationRule;
+
+    beforeEach(() => {
+      rule = new DecimalCountValidationRule(rulePrn, {
+        max: 4,
+      });
+    });
+
+    it.each([
+      [ValidationRuleUpdateImpact.NONE, { max: 5 }], // increase max
+      [ValidationRuleUpdateImpact.NONE, { max: 4 }], // unchanged
+      [ValidationRuleUpdateImpact.INVALIDATES, { max: 3 }], // tighten
+    ])("returns %s when the new max is %s", (expected, newSettings) => {
+      expect(rule.classifyUpdate(newSettings)).toBe(expected);
+    });
+  });
+
+  describe("classifyCreate", () => {
+    it("returns INVALIDATES", () => {
+      const rule = new DecimalCountValidationRule(rulePrn, { max: 0 });
+      expect(rule.classifyCreate()).toBe(ValidationRuleUpdateImpact.INVALIDATES);
+    });
+  });
 });

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

@@ -4,6 +4,7 @@ import { RuleInstance } from "../types/rule-instance.interface";
 import { RuleType } from "../enums/rule-types.enum";
 import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
 import { validationFunctionFromValidateValue } from "./validation-rule-function.factory";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 
 function getDecimalCount(value: number): number {
   const [_, decimalDigits] = value.toString().split(".");
@@ -45,6 +46,17 @@ export class DecimalCountValidationRule extends BaseValidationRule<DecimalCountV
   public override validate(values: ContentValueType[]): ContentValidationResultType[] {
     return validateDecimalCount(values, this);
   }
+
+  public override classifyCreate(): ValidationRuleUpdateImpact {
+    return ValidationRuleUpdateImpact.INVALIDATES;
+  }
+
+  public override classifyUpdate(newSettings: DecimalCountValidationRuleSettings): ValidationRuleUpdateImpact {
+    const oldMax = this.settings.max;
+    const newMax = newSettings.max;
+
+    return newMax >= oldMax ? ValidationRuleUpdateImpact.NONE : ValidationRuleUpdateImpact.INVALIDATES;
+  }
 }
 
 export interface DecimalCountValidationRuleSettings {

package/src/lib/validation-rules/number-between.validation-rule.spec.ts

@@ -1,6 +1,7 @@
 import { PRN } from "@platecms/delta-plate-resource-notation";
 import { InvalidValidationRuleSettingsError } from "../errors/invalid-validation-rule-settings.error";
 import { NumberBetweenValidationRule } from "./number-between.validation-rule";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 
 describe("NumberBetweenValidationRule", () => {
   const rulePrn = PRN.fromString("prn:plate:-1:cms:validation-rule:1");
@@ -74,4 +75,47 @@ describe("NumberBetweenValidationRule", () => {
       });
     });
   });
+
+  describe("classifyUpdate", () => {
+    it.each([
+      // OLD: { min: 1, max: 5 }
+      [ValidationRuleUpdateImpact.NONE, { min: 1, max: 5 }, { min: 1, max: 6 }], // widen upper bound
+      [ValidationRuleUpdateImpact.NONE, { min: 1, max: 5 }, { min: 0, max: 5 }], // widen lower bound
+      [ValidationRuleUpdateImpact.NONE, { min: 1, max: 5 }, { min: 0, max: 6 }], // widen both bounds
+      [ValidationRuleUpdateImpact.NONE, { min: 1, max: 5 }, { min: 1 }], // remove upper bound (→ Infinity)
+      [ValidationRuleUpdateImpact.NONE, { min: 1, max: 5 }, { max: 5 }], // remove lower bound (→ -Infinity)
+      [ValidationRuleUpdateImpact.INVALIDATES, { min: 1, max: 5 }, { min: 0, max: 4 }], // narrow upper bound
+      [ValidationRuleUpdateImpact.INVALIDATES, { min: 1, max: 5 }, { min: 2, max: 5 }], // narrow lower bound
+      [ValidationRuleUpdateImpact.INVALIDATES, { min: 1, max: 5 }, { min: 2, max: 4 }], // narrow both bounds
+      [ValidationRuleUpdateImpact.NONE, { min: 1, max: 5 }, { min: 1, max: 5 }], // unchanged
+
+      // OLD: { min: 1 }  (max = Infinity)
+      [ValidationRuleUpdateImpact.NONE, { min: 1 }, { min: 0 }], // widen lower bound
+      [ValidationRuleUpdateImpact.INVALIDATES, { min: 1 }, { min: 2 }], // narrow lower bound
+      [ValidationRuleUpdateImpact.INVALIDATES, { min: 1 }, { min: 1, max: 5 }], // introduce upper bound (tightening)
+      [ValidationRuleUpdateImpact.NONE, { min: 1 }, {}], // remove lower bound (→ -Infinity)
+
+      // OLD: { max: 5 }  (min = -Infinity)
+      [ValidationRuleUpdateImpact.NONE, { max: 5 }, { max: 6 }], // widen upper bound
+      [ValidationRuleUpdateImpact.INVALIDATES, { max: 5 }, { max: 4 }], // narrow upper bound
+      [ValidationRuleUpdateImpact.INVALIDATES, { max: 5 }, { min: 1, max: 5 }], // introduce lower bound (tightening)
+      [ValidationRuleUpdateImpact.NONE, { max: 5 }, {}], // remove upper bound (→ Infinity)
+
+      // OLD: spans negatives
+      [ValidationRuleUpdateImpact.NONE, { min: -5, max: 5 }, { min: -6, max: 5 }], // widen lower bound into negatives
+      [ValidationRuleUpdateImpact.NONE, { min: -5, max: 5 }, { min: -5, max: 6 }], // widen upper bound
+      [ValidationRuleUpdateImpact.INVALIDATES, { min: -5, max: 5 }, { min: -4, max: 5 }], // tighten lower bound
+      [ValidationRuleUpdateImpact.INVALIDATES, { min: -5, max: 5 }, { min: -5, max: 4 }], // tighten upper bound
+    ])("returns %s when old settings are %s and new settings are %s", (expected, oldSettings, newSettings) => {
+      const rule = new NumberBetweenValidationRule(rulePrn, oldSettings);
+      expect(rule.classifyUpdate(newSettings)).toBe(expected);
+    });
+  });
+
+  describe("classifyCreate", () => {
+    it("returns INVALIDATES", () => {
+      const rule = new NumberBetweenValidationRule(rulePrn, { min: 1, max: 2 });
+      expect(rule.classifyCreate()).toBe(ValidationRuleUpdateImpact.INVALIDATES);
+    });
+  });
 });

package/src/lib/validation-rules/number-between.validation-rule.ts

@@ -6,6 +6,7 @@ import { RuleInstance } from "../types/rule-instance.interface";
 import { RuleType } from "../enums/rule-types.enum";
 import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
 import { validationFunctionFromValidateValue } from "./validation-rule-function.factory";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 
 export function validateValueNumberBetween(
   value: ContentValueType,
@@ -50,6 +51,19 @@ export class NumberBetweenValidationRule extends BaseValidationRule<NumberBetwee
   public override validate(values: ContentValueType[]): ContentValidationResultType[] {
     return validateNumberBetween(values, this);
   }
+
+  public override classifyCreate(): ValidationRuleUpdateImpact {
+    return ValidationRuleUpdateImpact.INVALIDATES;
+  }
+
+  public override classifyUpdate(newSettings: NumberBetweenValidationRuleSettings): ValidationRuleUpdateImpact {
+    const oldSettings = this.settings;
+    const [oldMin, oldMax] = [oldSettings.min ?? 0, oldSettings.max ?? Infinity];
+    const [newMin, newMax] = [newSettings.min ?? 0, newSettings.max ?? Infinity];
+    const isExtending = newMin <= oldMin && newMax >= oldMax;
+
+    return isExtending ? ValidationRuleUpdateImpact.NONE : ValidationRuleUpdateImpact.INVALIDATES;
+  }
 }
 
 export interface NumberBetweenValidationRuleSettings {

package/src/lib/validation-rules/relatable-content-types.validation-rule.spec.ts

@@ -1,6 +1,7 @@
 import { PRN } from "@platecms/delta-plate-resource-notation";
 import { InvalidValidationArgumentsError } from "../errors/invalid-validation-arguments.error";
 import { RelatableContentTypesValidationRule } from "./relatable-content-types.validation-rule";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 
 describe("RelatableContentTypesValidationRule", () => {
   const rulePrn = PRN.fromString("prn:plate:-1:cms:validation-rule:1");
@@ -21,15 +22,39 @@ describe("RelatableContentTypesValidationRule", () => {
     });
   });
 
-  it.each([
-    [contentItemPrn, allowedContentTypes[0], true],
-    [contentItemPrn, disallowedContentType, false],
-    ["not a ContentItem", disallowedContentType, false],
-  ])("returns %s for the provided content item", (contentItem, contentType, expected) => {
-    expect(rule.validate([contentItem], [contentType])).toBeContentValidationResult([expected]);
+  describe("validate", () => {
+    it.each([
+      [contentItemPrn, allowedContentTypes[0], true],
+      [contentItemPrn, disallowedContentType, false],
+      ["not a ContentItem", disallowedContentType, false],
+    ])("returns %s for the provided content item", (contentItem, contentType, expected) => {
+      expect(rule.validate([contentItem], [contentType])).toBeContentValidationResult([expected]);
+    });
+
+    it("throws an error if the value does not have a ContentType", () => {
+      expect(() => rule.validate([contentItemPrn])).toThrowError(InvalidValidationArgumentsError);
+    });
   });
 
-  it("throws an error if the value does not have a ContentType", () => {
-    expect(() => rule.validate([contentItemPrn])).toThrowError(InvalidValidationArgumentsError);
+  describe("classifyUpdate", () => {
+    it.each([
+      [
+        ValidationRuleUpdateImpact.NONE,
+        { allowedContentTypes: [...allowedContentTypes, PRN.fromString("prn:plate:-1:cms:content-type:3")] },
+      ], // extending
+      [ValidationRuleUpdateImpact.NONE, { allowedContentTypes: [...allowedContentTypes] }], // unchanged
+      [
+        ValidationRuleUpdateImpact.INVALIDATES,
+        { allowedContentTypes: [PRN.fromString("prn:plate:-1:cms:content-type:3")] },
+      ], // tightening
+    ])("returns %s when the new allowed content types are %s", (expected, newSettings) => {
+      expect(rule.classifyUpdate(newSettings)).toBe(expected);
+    });
+  });
+
+  describe("classifyCreate", () => {
+    it("returns INVALIDATES", () => {
+      expect(rule.classifyCreate()).toBe(ValidationRuleUpdateImpact.INVALIDATES);
+    });
   });
 });

package/src/lib/validation-rules/relatable-content-types.validation-rule.ts

@@ -5,6 +5,8 @@ import { ValidationErrorDetails } from "../errors/validation-error-details";
 import { RuleInstance } from "../types/rule-instance.interface";
 import { RuleType } from "../enums/rule-types.enum";
 import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
+import { isSuperset } from "../helpers/is-superset.helper";
 
 function validateValueRelatableContentTypes<TContentType>(
   value: ContentValueType,
@@ -54,6 +56,21 @@ export class RelatableContentTypesValidationRule extends BaseValidationRule<
 
     return validateRelatableContentTypes(values, this, contentTypes);
   }
+
+  public override classifyCreate(): ValidationRuleUpdateImpact {
+    return ValidationRuleUpdateImpact.INVALIDATES;
+  }
+
+  public override classifyUpdate(
+    newSettings: RelatableContentTypesValidationRuleSettings<PRN>,
+  ): ValidationRuleUpdateImpact {
+    const oldAllowedContentTypes = this.settings.allowedContentTypes;
+    const newAllowedContentTypes = newSettings.allowedContentTypes;
+
+    return isSuperset(newAllowedContentTypes, oldAllowedContentTypes)
+      ? ValidationRuleUpdateImpact.NONE
+      : ValidationRuleUpdateImpact.INVALIDATES;
+  }
 }
 
 export interface RelatableContentTypesValidationRuleSettings<TContentType> {

package/src/lib/validation-rules/string-format.validation-rule.spec.ts

@@ -1,43 +1,69 @@
 import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 import { StringFormatValidationRule } from "./string-format.validation-rule";
 
 describe("StringFormatValidationRule", () => {
   const rulePrn = PRN.fromString("prn:plate:-1:cms:validation-rule:string-format");
 
-  describe("with an email regex", () => {
-    let rule: StringFormatValidationRule;
+  describe("validate", () => {
+    describe("with an email regex", () => {
+      let rule: StringFormatValidationRule;
 
-    beforeEach(() => {
-      rule = new StringFormatValidationRule(rulePrn, {
-        allowedFormat: "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$",
+      beforeEach(() => {
+        rule = new StringFormatValidationRule(rulePrn, {
+          allowedFormat: "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$",
+        });
+      });
+
+      it.each([
+        ["david@getplate.com", true],
+        ["david@getplate", false],
+        [123, null],
+      ])("returns %s for the provided value", (value, expected) => {
+        expect(rule.validate([value])).toBeContentValidationResult([expected]);
       });
     });
 
-    it.each([
-      ["david@getplate.com", true],
-      ["david@getplate", false],
-      [123, null],
-    ])("returns %s for the provided value", (value, expected) => {
-      expect(rule.validate([value])).toBeContentValidationResult([expected]);
+    describe("with a just letters regex", () => {
+      let rule: StringFormatValidationRule;
+
+      beforeEach(() => {
+        rule = new StringFormatValidationRule(rulePrn, {
+          allowedFormat: "^[a-zA-Z]+$",
+        });
+      });
+
+      it.each([
+        ["abc", true],
+        ["abc123", false],
+        ["", false],
+        [123, null],
+      ])("returns %s for the provided value", (value, expected) => {
+        expect(rule.validate([value])).toBeContentValidationResult([expected]);
+      });
     });
   });
 
-  describe("with a just letters regex", () => {
+  describe("classifyUpdate", () => {
     let rule: StringFormatValidationRule;
+    const allowedFormat = "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$";
 
     beforeEach(() => {
-      rule = new StringFormatValidationRule(rulePrn, {
-        allowedFormat: "^[a-zA-Z]+$",
-      });
+      rule = new StringFormatValidationRule(rulePrn, { allowedFormat });
     });
 
     it.each([
-      ["abc", true],
-      ["abc123", false],
-      ["", false],
-      [123, null],
-    ])("returns %s for the provided value", (value, expected) => {
-      expect(rule.validate([value])).toBeContentValidationResult([expected]);
+      [ValidationRuleUpdateImpact.NONE, { allowedFormat }], // unchanged
+      [ValidationRuleUpdateImpact.INVALIDATES, { allowedFormat: "^[a-zA-Z]+$" }], // changing format
+    ])("returns %s when the new allowed format is %s", (expected, newSettings) => {
+      expect(rule.classifyUpdate(newSettings)).toBe(expected);
+    });
+  });
+
+  describe("classifyCreate", () => {
+    it("returns INVALIDATES", () => {
+      const rule = new StringFormatValidationRule(rulePrn, { allowedFormat: "^[a-zA-Z]+$" });
+      expect(rule.classifyCreate()).toBe(ValidationRuleUpdateImpact.INVALIDATES);
     });
   });
 });

package/src/lib/validation-rules/string-format.validation-rule.ts

@@ -4,6 +4,7 @@ import { RuleInstance } from "../types/rule-instance.interface";
 import { RuleType } from "../enums/rule-types.enum";
 import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
 import { validationFunctionFromValidateValue } from "./validation-rule-function.factory";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 
 export function validateValueStringFormat(
   value: ContentValueType,
@@ -43,6 +44,19 @@ export class StringFormatValidationRule extends BaseValidationRule<StringFormatV
   public override validate(values: ContentValueType[]): ContentValidationResultType[] {
     return validateStringFormat(values, this);
   }
+
+  public override classifyCreate(): ValidationRuleUpdateImpact {
+    return ValidationRuleUpdateImpact.INVALIDATES;
+  }
+
+  public override classifyUpdate(newSettings: StringFormatValidationRuleSettings): ValidationRuleUpdateImpact {
+    const oldAllowedFormat = this.settings.allowedFormat;
+    const newAllowedFormat = newSettings.allowedFormat;
+
+    return oldAllowedFormat === newAllowedFormat
+      ? ValidationRuleUpdateImpact.NONE
+      : ValidationRuleUpdateImpact.INVALIDATES;
+  }
 }
 
 export interface StringFormatValidationRuleSettings {

package/src/lib/validation-rules/value-type.validation-rule.spec.ts

@@ -1,108 +1,138 @@
 import { PRN } from "@platecms/delta-plate-resource-notation";
-import { ContentValueType, ContentValueTypeNames } from "@platecms/delta-types";
+import { ContentValueType, ContentValueTypeName, ContentValueTypeNames } from "@platecms/delta-types";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 import { ValueTypeValidationRule, ValueTypeValidationRuleSettings } from "./value-type.validation-rule";
 
 describe("ValueTypeValidationRule", () => {
   const rulePrn = PRN.fromString("prn:plate:-1:cms:validation-rule:value-type");
 
-  describe.each([
-    [
-      "with allowed string type",
-      { allowedTypes: [ContentValueTypeNames.STRING] },
+  describe("validate", () => {
+    describe.each([
       [
-        ["foo", true],
-        [123, false],
+        "with allowed string type",
+        { allowedTypes: [ContentValueTypeNames.STRING] },
+        [
+          ["foo", true],
+          [123, false],
+        ],
       ],
-    ],
-    [
-      "with allowed number type",
-      { allowedTypes: [ContentValueTypeNames.NUMBER] },
       [
-        [123, true],
-        ["foo", false],
+        "with allowed number type",
+        { allowedTypes: [ContentValueTypeNames.NUMBER] },
+        [
+          [123, true],
+          ["foo", false],
+        ],
       ],
-    ],
-    [
-      "with allowed boolean type",
-      { allowedTypes: [ContentValueTypeNames.BOOLEAN] },
       [
-        [true, true],
-        ["foo", false],
+        "with allowed boolean type",
+        { allowedTypes: [ContentValueTypeNames.BOOLEAN] },
+        [
+          [true, true],
+          ["foo", false],
+        ],
       ],
-    ],
-    [
-      "with allowed date type",
-      { allowedTypes: [ContentValueTypeNames.DATE] },
       [
-        [new Date(), true],
-        ["foo", false],
+        "with allowed date type",
+        { allowedTypes: [ContentValueTypeNames.DATE] },
+        [
+          [new Date(), true],
+          ["foo", false],
+        ],
       ],
-    ],
-    [
-      "with allowed content item type",
-      { allowedTypes: [ContentValueTypeNames.CONTENT_ITEM] },
       [
-        [PRN.fromString("prn:plate:-1:cms:content-item:1"), true],
-        ["foo", false],
+        "with allowed content item type",
+        { allowedTypes: [ContentValueTypeNames.CONTENT_ITEM] },
+        [
+          [PRN.fromString("prn:plate:-1:cms:content-item:1"), true],
+          ["foo", false],
+        ],
       ],
-    ],
-    [
-      "with allowed asset type",
-      { allowedTypes: [ContentValueTypeNames.ASSET] },
       [
-        [PRN.fromString("prn:plate:-1:ps:asset:1"), true],
-        ["foo", false],
+        "with allowed asset type",
+        { allowedTypes: [ContentValueTypeNames.ASSET] },
+        [
+          [PRN.fromString("prn:plate:-1:ps:asset:1"), true],
+          ["foo", false],
+        ],
       ],
-    ],
-    [
-      "with allowed path part type",
-      { allowedTypes: [ContentValueTypeNames.PATH_PART] },
       [
-        [PRN.fromString("prn:plate:-1:cms:path-part:1"), true],
-        ["foo", false],
+        "with allowed path part type",
+        { allowedTypes: [ContentValueTypeNames.PATH_PART] },
+        [
+          [PRN.fromString("prn:plate:-1:cms:path-part:1"), true],
+          ["foo", false],
+        ],
       ],
-    ],
-    [
-      "with allowed grid placement type",
-      { allowedTypes: [ContentValueTypeNames.GRID_PLACEMENT] },
       [
-        [PRN.fromString("prn:plate:-1:cms:grid-placement:1"), true],
-        ["foo", false],
+        "with allowed grid placement type",
+        { allowedTypes: [ContentValueTypeNames.GRID_PLACEMENT] },
+        [
+          [PRN.fromString("prn:plate:-1:cms:grid-placement:1"), true],
+          ["foo", false],
+        ],
       ],
-    ],
-    [
-      "with allowed smart text type",
-      { allowedTypes: [ContentValueTypeNames.SMART_TEXT] },
       [
-        [{ type: "root", children: [] }, true],
-        [PRN.fromString("prn:plate:-1:cms:grid-placement:1"), false],
+        "with allowed smart text type",
+        { allowedTypes: [ContentValueTypeNames.SMART_TEXT] },
+        [
+          [{ type: "root", children: [] }, true],
+          [PRN.fromString("prn:plate:-1:cms:grid-placement:1"), false],
+        ],
       ],
-    ],
-    [
-      "with incorrect prn",
-      { allowedTypes: [ContentValueTypeNames.CONTENT_ITEM] },
-      [[PRN.fromString("prn:plate:-1:ps:asset:1"), false]],
-    ],
-    [
-      "with multiple types",
-      {
-        allowedTypes: [ContentValueTypeNames.STRING, ContentValueTypeNames.CONTENT_ITEM],
-      },
       [
-        ["foo", true],
-        [PRN.fromString("prn:plate:-1:cms:content-item:1"), true],
-        [new Date(), false],
+        "with incorrect prn",
+        { allowedTypes: [ContentValueTypeNames.CONTENT_ITEM] },
+        [[PRN.fromString("prn:plate:-1:ps:asset:1"), false]],
       ],
-    ],
-  ])("%s", (_, ruleConfig, testCases: unknown[]) => {
+      [
+        "with multiple types",
+        {
+          allowedTypes: [ContentValueTypeNames.STRING, ContentValueTypeNames.CONTENT_ITEM],
+        },
+        [
+          ["foo", true],
+          [PRN.fromString("prn:plate:-1:cms:content-item:1"), true],
+          [new Date(), false],
+        ],
+      ],
+    ])("%s", (_, ruleConfig, testCases: unknown[]) => {
+      let rule: ValueTypeValidationRule;
+
+      beforeEach(() => {
+        rule = new ValueTypeValidationRule(rulePrn, ruleConfig as ValueTypeValidationRuleSettings);
+      });
+
+      it.each(testCases)("returns %s for the provided value", (value, expected) => {
+        expect(rule.validate([value as ContentValueType])).toBeContentValidationResult([expected as boolean]);
+      });
+    });
+  });
+
+  describe("classifyUpdate", () => {
     let rule: ValueTypeValidationRule;
+    const allowedTypes: ContentValueTypeName<ContentValueType>[] = [
+      ContentValueTypeNames.STRING,
+      ContentValueTypeNames.NUMBER,
+    ];
 
     beforeEach(() => {
-      rule = new ValueTypeValidationRule(rulePrn, ruleConfig as ValueTypeValidationRuleSettings);
+      rule = new ValueTypeValidationRule(rulePrn, { allowedTypes });
     });
 
-    it.each(testCases)("returns %s for the provided value", (value, expected) => {
-      expect(rule.validate([value as ContentValueType])).toBeContentValidationResult([expected]);
+    it.each([
+      [ValidationRuleUpdateImpact.NONE, { allowedTypes: [...allowedTypes, ContentValueTypeNames.BOOLEAN] }], // extending
+      [ValidationRuleUpdateImpact.NONE, { allowedTypes: [...allowedTypes] }], // unchanged
+      [ValidationRuleUpdateImpact.BREAKS, { allowedTypes: [ContentValueTypeNames.BOOLEAN] }], // tightening
+    ])("returns %s when the new allowed types are %s", (expected, newSettings) => {
+      expect(rule.classifyUpdate(newSettings as ValueTypeValidationRuleSettings)).toBe(expected);
+    });
+  });
+
+  describe("classifyCreate", () => {
+    it("returns BREAKS", () => {
+      const rule = new ValueTypeValidationRule(rulePrn, { allowedTypes: [ContentValueTypeNames.STRING] });
+      expect(rule.classifyCreate()).toBe(ValidationRuleUpdateImpact.BREAKS);
     });
   });
 });

package/src/lib/validation-rules/value-type.validation-rule.ts

@@ -1,16 +1,18 @@
 import { InvalidCastError, validateCast } from "@platecms/delta-cast";
 import { PRN } from "@platecms/delta-plate-resource-notation";
 import { ContentValueType, ContentValueTypeName, ContentValueTypeNames } from "@platecms/delta-types";
+import { RuleType } from "../enums/rule-types.enum";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { isSuperset } from "../helpers/is-superset.helper";
 import { RuleInstance } from "../types/rule-instance.interface";
-import { RuleType } from "../enums/rule-types.enum";
 import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
 import { validationFunctionFromValidateValue } from "./validation-rule-function.factory";
 
 /**
  * Mapping of PRN resource type to Content Value Type Name.
  */
-const prnResourceTypeToContentValueTypeNameMap: Record<string, ContentValueTypeNames> = {
+const prnResourceTypeToContentValueTypeNameMap: Record<string, ContentValueTypeName<PRN>> = {
   /* eslint-disable @typescript-eslint/naming-convention */
   "content-item": ContentValueTypeNames.CONTENT_ITEM,
   asset: ContentValueTypeNames.ASSET,
@@ -68,6 +70,19 @@ export class ValueTypeValidationRule extends BaseValidationRule<ValueTypeValidat
   public override validate(values: ContentValueType[]): ContentValidationResultType[] {
     return validateValueType(values, this);
   }
+
+  public override classifyCreate(): ValidationRuleUpdateImpact {
+    return ValidationRuleUpdateImpact.BREAKS;
+  }
+
+  public override classifyUpdate(newSettings: ValueTypeValidationRuleSettings): ValidationRuleUpdateImpact {
+    const oldAllowedTypes = this.settings.allowedTypes;
+    const newAllowedTypes = newSettings.allowedTypes;
+
+    return isSuperset(newAllowedTypes, oldAllowedTypes)
+      ? ValidationRuleUpdateImpact.NONE
+      : ValidationRuleUpdateImpact.BREAKS;
+  }
 }
 
 // The value type can be one or more of the types specified in the ContentValueType type