@platecms/delta-validation 0.13.0 → 1.3.0

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

@@ -1,9 +1,10 @@
 import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 import { InvalidValidationRuleSettingsError } from "../errors/invalid-validation-rule-settings.error";
 import { DateBetweenValidationRule } from "./date-between.validation-rule";
 
 describe("DateBetweenValidationRule", () => {
-  const rulePrn = PRN.fromString("prn:plate:-1:cxc:validation-rule:1");
+  const rulePrn = PRN.fromString("prn:plate:-1:cms:validation-rule:1");
 
   describe("constructor", () => {
     it("throws an error if min and max are not provided", () => {
@@ -74,4 +75,86 @@ describe("DateBetweenValidationRule", () => {
       });
     });
   });
+
+  describe("classifyUpdate", () => {
+    // eslint-disable-next-line func-style, id-length
+    const d = (iso: string): Date => new Date(iso);
+
+    it.each([
+      // OLD: bounded range
+      [
+        ValidationRuleUpdateImpact.NONE,
+        { start: d("2025-01-10"), end: d("2025-01-20") },
+        { start: d("2025-01-10"), end: d("2025-01-21") },
+      ], // widen end
+      [
+        ValidationRuleUpdateImpact.NONE,
+        { start: d("2025-01-10"), end: d("2025-01-20") },
+        { start: d("2025-01-09"), end: d("2025-01-20") },
+      ], // widen start (earlier)
+      [
+        ValidationRuleUpdateImpact.NONE,
+        { start: d("2025-01-10"), end: d("2025-01-20") },
+        { start: d("2025-01-09"), end: d("2025-01-21") },
+      ], // widen both
+
+      [ValidationRuleUpdateImpact.NONE, { start: d("2025-01-10"), end: d("2025-01-20") }, { start: d("2025-01-10") }], // remove end (→ Infinity)
+      [ValidationRuleUpdateImpact.NONE, { start: d("2025-01-10"), end: d("2025-01-20") }, { end: d("2025-01-20") }], // remove start (→ -Infinity)
+      [ValidationRuleUpdateImpact.NONE, { start: d("2025-01-10"), end: d("2025-01-20") }, {}], // remove both
+      [
+        ValidationRuleUpdateImpact.INVALIDATES,
+        { start: d("2025-01-10"), end: d("2025-01-20") },
+        { start: d("2025-01-10"), end: d("2025-01-19") },
+      ], // narrow end (earlier)
+      [
+        ValidationRuleUpdateImpact.INVALIDATES,
+        { start: d("2025-01-10"), end: d("2025-01-20") },
+        { start: d("2025-01-11"), end: d("2025-01-20") },
+      ], // narrow start (later)
+      [
+        ValidationRuleUpdateImpact.INVALIDATES,
+        { start: d("2025-01-10"), end: d("2025-01-20") },
+        { start: d("2025-01-11"), end: d("2025-01-19") },
+      ], // narrow both
+      // unchanged
+      [
+        ValidationRuleUpdateImpact.NONE,
+        { start: d("2025-01-10"), end: d("2025-01-20") },
+        { start: d("2025-01-10"), end: d("2025-01-20") },
+      ], // unchanged
+
+      // OLD: start-only (end = Infinity)
+      [ValidationRuleUpdateImpact.NONE, { start: d("2025-01-10") }, { start: d("2025-01-09") }], // widen start (earlier)
+      [ValidationRuleUpdateImpact.INVALIDATES, { start: d("2025-01-10") }, { start: d("2025-01-11") }], // narrow start (later)
+      [
+        ValidationRuleUpdateImpact.INVALIDATES,
+        { start: d("2025-01-10") },
+        { start: d("2025-01-10"), end: d("2025-01-20") },
+      ], // introduce end (tightening)
+      [ValidationRuleUpdateImpact.NONE, { start: d("2025-01-10") }, {}], // remove start (→ -Infinity)
+
+      // OLD: end-only (start = -Infinity)
+      [ValidationRuleUpdateImpact.NONE, { end: d("2025-01-20") }, { end: d("2025-01-21") }], // widen end (later)
+      [ValidationRuleUpdateImpact.INVALIDATES, { end: d("2025-01-20") }, { end: d("2025-01-19") }], // narrow end (earlier)
+      [
+        ValidationRuleUpdateImpact.INVALIDATES,
+        { end: d("2025-01-20") },
+        { start: d("2025-01-10"), end: d("2025-01-20") },
+      ], // introduce start (tightening)
+      [ValidationRuleUpdateImpact.NONE, { end: d("2025-01-20") }, {}], // remove end (→ Infinity)
+    ])("returns %s when old settings are %s and new settings are %s", (expected, oldSettings, newSettings) => {
+      const rule = new DateBetweenValidationRule(rulePrn, oldSettings);
+      expect(rule.classifyUpdate(newSettings)).toBe(expected);
+    });
+  });
+
+  describe("classifyCreate", () => {
+    it("returns INVALIDATES", () => {
+      const rule = new DateBetweenValidationRule(rulePrn, {
+        start: new Date(2020, 1, 2, 3, 4, 5),
+        end: new Date(2020, 1, 3, 3, 4, 6),
+      });
+      expect(rule.classifyCreate()).toBe(ValidationRuleUpdateImpact.INVALIDATES);
+    });
+  });
 });

package/src/lib/validation-rules/date-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 validateValueDateBetween(
   value: ContentValueType,
@@ -15,15 +16,15 @@ export function validateValueDateBetween(
     return null;
   }
 
-  if (ruleInstance.settings.start != null && value < ruleInstance.settings.start) {
+  if (ruleInstance.settings.start != null && value < new Date(ruleInstance.settings.start as unknown as Date)) {
     return new ValidationErrorDetails(
-      `The date must be greater than or equal ${ruleInstance.settings.start.toDateString()}`,
+      `The date must be greater than or equal ${new Date(ruleInstance.settings.start).toDateString()}`,
       ruleInstance,
     );
   }
-  if (ruleInstance.settings.end != null && value > ruleInstance.settings.end) {
+  if (ruleInstance.settings.end != null && value > new Date(ruleInstance.settings.end)) {
     return new ValidationErrorDetails(
-      `The date must be lower than or equal ${ruleInstance.settings.end.toDateString()}`,
+      `The date must be lower than or equal ${new Date(ruleInstance.settings.end).toDateString()}`,
       ruleInstance,
     );
   }
@@ -46,6 +47,20 @@ export class DateBetweenValidationRule extends BaseValidationRule<DateBetweenVal
   public override validate(values: ContentValueType[]): ContentValidationResultType[] {
     return validateDateBetween(values, this);
   }
+
+  public override classifyCreate(): ValidationRuleUpdateImpact {
+    return ValidationRuleUpdateImpact.INVALIDATES;
+  }
+
+  public override classifyUpdate(newSettings: DateBetweenValidationRuleSettings): ValidationRuleUpdateImpact {
+    const oldStart = this.settings.start ? this.settings.start.getTime() : -Infinity;
+    const oldEnd = this.settings.end ? this.settings.end.getTime() : Infinity;
+    const newStart = newSettings.start ? newSettings.start.getTime() : -Infinity;
+    const newEnd = newSettings.end ? newSettings.end.getTime() : Infinity;
+    const extending = newStart <= oldStart && newEnd >= oldEnd;
+
+    return extending ? ValidationRuleUpdateImpact.NONE : ValidationRuleUpdateImpact.INVALIDATES;
+  }
 }
 
 export interface DateBetweenValidationRuleSettings {

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

@@ -1,8 +1,9 @@
 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:cxc:validation-rule:decimal-count");
+  const rulePrn = PRN.fromString("prn:plate:-1:cms:validation-rule:decimal-count");
 
   describe("validate", () => {
     describe("with max of 0", () => {
@@ -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,9 +1,10 @@
 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:cxc:validation-rule:1");
+  const rulePrn = PRN.fromString("prn:plate:-1:cms:validation-rule:1");
 
   describe("constructor", () => {
     it("throws an error if min and max are not provided", () => {
@@ -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,17 +1,18 @@
 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:cxc:validation-rule:1");
-  const contentItemPrn = PRN.fromString("prn:plate:-1:cxc:content-item:1");
+  const rulePrn = PRN.fromString("prn:plate:-1:cms:validation-rule:1");
+  const contentItemPrn = PRN.fromString("prn:plate:-1:cms:content-item:1");
 
   const allowedContentTypes = [
-    PRN.fromString("prn:plate:-1:cxc:content-type:1"),
-    PRN.fromString("prn:plate:-1:cxc:content-type:2"),
+    PRN.fromString("prn:plate:-1:cms:content-type:1"),
+    PRN.fromString("prn:plate:-1:cms:content-type:2"),
   ];
 
-  const disallowedContentType = PRN.fromString("prn:plate:-1:cxc:content-type:3");
+  const disallowedContentType = PRN.fromString("prn:plate:-1:cms:content-type:3");
 
   let rule: RelatableContentTypesValidationRule;
 
@@ -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:cxc:validation-rule:string-format");
+  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 {