@platecms/delta-validation 1.2.0 → 1.4.0

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

@@ -0,0 +1,223 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { RuleType } from "../enums/rule-types.enum";
+import { NumberValidationSchema } from "./number.schema";
+import { ObjectValidationSchema } from "./object.schema";
+import { StringValidationSchema } from "./string.schema";
+
+type TestObject = Record<string, unknown>;
+
+describe("ObjectValidationSchema", () => {
+  let objectSchema: ObjectValidationSchema<TestObject>;
+
+  beforeEach(() => {
+    objectSchema = new ObjectValidationSchema<TestObject>();
+  });
+
+  describe("type checking", () => {
+    it("passes validation when value is an object", () => {
+      const validationResult = objectSchema.validate({ alpha: 1, beta: 2 }, { path: ["test"] });
+
+      expect(validationResult.isValid).toBe(true);
+      expect(validationResult.errors).toHaveLength(0);
+    });
+
+    it("fails validation when value is not an object", () => {
+      const validationResult = objectSchema.validate("not an object" as unknown as TestObject, {
+        path: ["test"],
+      });
+
+      expect(validationResult.isValid).toBe(false);
+      expect(validationResult.errors).toHaveLength(1);
+      expect(validationResult.errors[0].message).toBe("Value must be an object");
+    });
+
+    it("fails validation when value is an array", () => {
+      const validationResult = objectSchema.validate([1, 2, 3] as unknown as TestObject, {
+        path: ["test"],
+      });
+
+      expect(validationResult.isValid).toBe(false);
+      expect(validationResult.errors).toHaveLength(1);
+      expect(validationResult.errors[0].message).toBe("Value must be an object");
+    });
+
+    it("fails validation when value is a number", () => {
+      const validationResult = objectSchema.validate(42 as unknown as TestObject, {
+        path: ["test"],
+      });
+
+      expect(validationResult.isValid).toBe(false);
+      expect(validationResult.errors).toHaveLength(1);
+      expect(validationResult.errors[0].message).toBe("Value must be an object");
+    });
+
+    it("passes validation when value is null (allowed by default)", () => {
+      const validationResult = objectSchema.validate(null as unknown as TestObject, {
+        path: ["test"],
+      });
+
+      expect(validationResult.isValid).toBe(true);
+      expect(validationResult.errors).toHaveLength(0);
+    });
+
+    it("passes validation when value is undefined (allowed by default)", () => {
+      const validationResult = objectSchema.validate(undefined as unknown as TestObject, {
+        path: ["test"],
+      });
+
+      expect(validationResult.isValid).toBe(true);
+      expect(validationResult.errors).toHaveLength(0);
+    });
+  });
+
+  describe("count validation", () => {
+    it("passes validation when object keys count is within min and max bounds", () => {
+      objectSchema.min(2).max(4);
+
+      const validationResult = objectSchema.validate({ alpha: 1, beta: 2, gamma: 3 }, { path: ["test"] });
+
+      expect(validationResult.isValid).toBe(true);
+      expect(validationResult.errors).toHaveLength(0);
+    });
+
+    it("fails validation when object keys count is below minimum", () => {
+      objectSchema.min(3);
+
+      const validationResult = objectSchema.validate({ alpha: 1, beta: 2 }, { path: ["test"] });
+
+      expect(validationResult.isValid).toBe(false);
+      expect(validationResult.errors).toHaveLength(1);
+      expect(validationResult.errors[0].message).toContain("object keys");
+    });
+
+    it("fails validation when object keys count is above maximum", () => {
+      objectSchema.max(2);
+
+      const validationResult = objectSchema.validate({ alpha: 1, beta: 2, gamma: 3 }, { path: ["test"] });
+
+      expect(validationResult.isValid).toBe(false);
+      expect(validationResult.errors).toHaveLength(1);
+      expect(validationResult.errors[0].message).toContain("object keys");
+    });
+
+    it("passes validation when no min/max constraints are set", () => {
+      const validationResult = objectSchema.validate(
+        { alpha: 1, beta: 2, gamma: 3, delta: 4, epsilon: 5 },
+        { path: ["test"] },
+      );
+
+      expect(validationResult.isValid).toBe(true);
+      expect(validationResult.errors).toHaveLength(0);
+    });
+
+    it("handles empty object with min constraint", () => {
+      objectSchema.min(1);
+
+      const validationResult = objectSchema.validate({}, { path: ["test"] });
+
+      expect(validationResult.isValid).toBe(false);
+      expect(validationResult.errors).toHaveLength(1);
+    });
+
+    it("handles empty object with max constraint", () => {
+      objectSchema.max(2);
+
+      const validationResult = objectSchema.validate({}, { path: ["test"] });
+
+      expect(validationResult.isValid).toBe(true);
+      expect(validationResult.errors).toHaveLength(0);
+    });
+  });
+
+  describe("shape validation", () => {
+    it("validates object keys against shape schema", () => {
+      const stringValidationSchema = new StringValidationSchema();
+      objectSchema.of({ name: stringValidationSchema });
+
+      const validationResult = objectSchema.validate({ name: "John" }, { path: ["test"] });
+
+      expect(validationResult.isValid).toBe(true);
+      expect(validationResult.errors).toHaveLength(0);
+    });
+
+    it("fails when shape property fails validation", () => {
+      const stringValidationSchema = new StringValidationSchema();
+      objectSchema.of({ name: stringValidationSchema });
+
+      const validationResult = objectSchema.validate({ name: 123 }, { path: ["test"] });
+
+      expect(validationResult.isValid).toBe(false);
+      expect(validationResult.errors.length).toBeGreaterThan(0);
+      expect(validationResult.errors[0].path).toEqual(["test", "name"]);
+    });
+
+    it("does not validate shape when no shape is set", () => {
+      const valueWithArbitraryKeys: TestObject = {
+        name: "string",
+        count: 123,
+        flag: true,
+      };
+
+      const validationResult = objectSchema.validate(valueWithArbitraryKeys, {
+        path: ["test"],
+      });
+
+      expect(validationResult.isValid).toBe(true);
+      expect(validationResult.errors).toHaveLength(0);
+    });
+
+    it("validates nested shape with multiple keys", () => {
+      const stringValidationSchema = new StringValidationSchema();
+      const numberValidationSchema = new NumberValidationSchema();
+      objectSchema.of({ name: stringValidationSchema, age: numberValidationSchema });
+
+      const validationResult = objectSchema.validate({ name: "Jane", age: 30 }, { path: ["user"] });
+
+      expect(validationResult.isValid).toBe(true);
+      expect(validationResult.errors).toHaveLength(0);
+    });
+
+    it("collects errors for multiple invalid shape properties", () => {
+      const stringValidationSchema = new StringValidationSchema();
+      const numberValidationSchema = new NumberValidationSchema();
+      objectSchema.of({ name: stringValidationSchema, age: numberValidationSchema });
+
+      const validationResult = objectSchema.validate({ name: 123, age: "not a number" }, { path: ["user"] });
+
+      expect(validationResult.isValid).toBe(false);
+      expect(validationResult.errors).toHaveLength(2);
+      expect(validationResult.errors.map((error) => error.path)).toContainEqual(["user", "name"]);
+      expect(validationResult.errors.map((error) => error.path)).toContainEqual(["user", "age"]);
+    });
+  });
+
+  describe("integration with validation rules", () => {
+    it("uses validation rule for count validation", () => {
+      const countValidationRuleMock = {
+        ruleType: RuleType.COUNT,
+        settings: { min: 2, max: 4 },
+        id: "count-rule",
+        prn: PRN.fromString("prn:plate:-1:cms:validation-rule:1"),
+      };
+
+      const objectSchemaWithCountRule = new ObjectValidationSchema<TestObject>(countValidationRuleMock);
+      const validationResult = objectSchemaWithCountRule.validate({ alpha: 1, beta: 2, gamma: 3 }, { path: ["test"] });
+
+      expect(validationResult.isValid).toBe(true);
+    });
+  });
+
+  describe("method chaining", () => {
+    it("supports method chaining", () => {
+      const stringValidationSchema = new StringValidationSchema();
+
+      const validationResult = objectSchema
+        .min(1)
+        .max(5)
+        .of({ key: stringValidationSchema })
+        .validate({ key: "value" }, { path: ["test"] });
+
+      expect(validationResult.isValid).toBe(true);
+    });
+  });
+});

package/src/lib/schemas/object.schema.ts

@@ -0,0 +1,106 @@
+import { RuleType } from "../enums/rule-types.enum";
+import { validateWithFunction } from "../helpers/validate-with-function";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ValidationContext } from "../types/validation-context.interface";
+import { ValidationErrorData } from "../types/validation-error-data.interface";
+import { SchemaType, ValidationSchema } from "../types/validation-schema.interface";
+import { CountValidationRuleSettings, validateKeysCount } from "../validation-rules/count.validation-rule";
+import { BaseValidationSchema } from "./base.schema";
+
+export type Shape = Record<string, ValidationSchema<SchemaType>>;
+
+export class ObjectValidationSchema<T = unknown> extends BaseValidationSchema<T, ObjectValidationSchema<T>> {
+  public readonly type = "object";
+  private _shape?: Shape;
+  private _min?: number;
+  private _max?: number;
+
+  public of(shape: Shape): this {
+    this._shape = shape;
+    return this;
+  }
+
+  public min(min: number): this {
+    this._min = min;
+    return this;
+  }
+
+  public max(max: number): this {
+    this._max = max;
+    return this;
+  }
+
+  protected _typeCheck(value: unknown, path: string[]): ValidationErrorData[] {
+    if (typeof value === "object" && !Array.isArray(value)) {
+      return [];
+    }
+
+    return [
+      {
+        path,
+        message: this._message ?? "Value must be an object",
+        provided: value,
+        validationRule: {
+          ruleType: RuleType.VALUE_TYPE,
+          settings: {},
+        },
+      },
+    ];
+  }
+
+  protected _validateAgainstSchema(value: T, context: ValidationContext = {}): ValidationErrorData[] {
+    const errors: ValidationErrorData[] = [];
+
+    const itemsCountError = this._validateCount(value, context.path ?? []);
+    if (itemsCountError) {
+      errors.push(itemsCountError);
+    }
+
+    errors.push(...this._validateObject(value, context));
+
+    return errors;
+  }
+
+  private _validateCount(value: T, path: string[]): ValidationErrorData<CountValidationRuleSettings> | null {
+    if (this._min === undefined && this._max === undefined && this._validationRule === undefined) {
+      return null;
+    }
+
+    const validationRule = this._validationRule ?? {
+      ruleType: RuleType.COUNT,
+      settings: {
+        min: this._min,
+        max: this._max,
+      },
+    };
+
+    return validateWithFunction<CountValidationRuleSettings, T>(
+      value,
+      validationRule as RuleInstance<CountValidationRuleSettings>,
+      path,
+      this._message ?? "Object keys count validation failed",
+      validateKeysCount,
+    );
+  }
+
+  private _validateObject(value: T, context: ValidationContext): ValidationErrorData[] {
+    if (this._shape === undefined) {
+      return [];
+    }
+
+    const indexableValue = value as unknown as Record<string, unknown>;
+
+    const errors: ValidationErrorData[] = [];
+    for (const key of Object.keys(this._shape)) {
+      const result = this._shape[key].validate(indexableValue[key], {
+        ...context,
+        path: [...(context.path ?? []), key],
+      });
+      if (!result.isValid) {
+        errors.push(...result.errors);
+      }
+    }
+
+    return errors;
+  }
+}

package/src/lib/types/validation-schema.interface.ts

@@ -1,7 +1,7 @@
 import { ValidationContext } from "./validation-context.interface";
 import { ValidationResult } from "./validation-result.interface";
 
-export type SchemaType = "array" | "content-value" | "date" | "number" | "string" | "union";
+export type SchemaType = "array" | "content-value" | "date" | "number" | "object" | "string" | "union";
 
 /**
  * TType represents the value type this schema validates.

package/src/lib/validation-rules/allowed-values.validation-rule.spec.ts

@@ -1,6 +1,7 @@
 import { PRN } from "@platecms/delta-plate-resource-notation";
 import { ContentValueType } from "@platecms/delta-types";
 import { AllowedValuesValidationRule } from "./allowed-values.validation-rule";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 
 describe("AllowedValuesValidationRule", () => {
   let rulePrn: PRN;
@@ -54,4 +55,28 @@ describe("AllowedValuesValidationRule", () => {
       });
     });
   });
+
+  describe("classifyUpdate", () => {
+    let rule: AllowedValuesValidationRule;
+    const allowedValues = [1, "2", true, new Date("2020-01-01"), PRN.fromString("prn:plate:-1:cms:content-item:1")];
+
+    beforeEach(() => {
+      rule = new AllowedValuesValidationRule(rulePrn, { allowedValues });
+    });
+
+    it.each([
+      [ValidationRuleUpdateImpact.NONE, { allowedValues: [...allowedValues, "a"] }], // extending
+      [ValidationRuleUpdateImpact.NONE, { allowedValues: [...allowedValues] }], // unchanged
+      [ValidationRuleUpdateImpact.INVALIDATES, { allowedValues: ["a"] }], // tightening
+    ])("returns %s when the new allowed values are %s", (expected, newSettings) => {
+      expect(rule.classifyUpdate(newSettings)).toBe(expected);
+    });
+  });
+
+  describe("classifyCreate", () => {
+    it("returns INVALIDATES", () => {
+      const rule = new AllowedValuesValidationRule(rulePrn, { allowedValues: [] });
+      expect(rule.classifyCreate()).toBe(ValidationRuleUpdateImpact.INVALIDATES);
+    });
+  });
 });

package/src/lib/validation-rules/allowed-values.validation-rule.ts

@@ -5,6 +5,8 @@ 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";
+import { isSuperset } from "../helpers/is-superset.helper";
 
 export function validateValueAllowedValues(
   value: ContentValueType,
@@ -46,6 +48,19 @@ export class AllowedValuesValidationRule extends BaseValidationRule<AllowedValue
   public override validate(values: ContentValueType[]): ContentValidationResultType[] {
     return validateAllowedValues(values, this);
   }
+
+  public override classifyCreate(): ValidationRuleUpdateImpact {
+    return ValidationRuleUpdateImpact.INVALIDATES;
+  }
+
+  public override classifyUpdate(newSettings: AllowedValuesValidationRuleSettings): ValidationRuleUpdateImpact {
+    const oldAllowedValues = this.settings.allowedValues;
+    const newAllowedValues = newSettings.allowedValues;
+
+    return isSuperset(newAllowedValues, oldAllowedValues)
+      ? ValidationRuleUpdateImpact.NONE
+      : ValidationRuleUpdateImpact.INVALIDATES;
+  }
 }
 
 export interface AllowedValuesValidationRuleSettings {

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

@@ -1,8 +1,9 @@
 import { PRN } from "@platecms/delta-plate-resource-notation";
 import { ContentValueType } 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 { RuleInstance } from "../types/rule-instance.interface";
-import { RuleType } from "../enums/rule-types.enum";
 
 export type ContentValidationResultType<TRuleInstance extends RuleInstance<unknown> = RuleInstance<unknown>> =
   | ValidationErrorDetails<TRuleInstance>
@@ -29,7 +30,23 @@ export abstract class BaseValidationRule<TSettings> implements RuleInstance<TSet
    * and the result will be returned in the first element of the array. E.g. the CountValidationRule.
    * @param values ContentValueType[] to validate
    */
-  public validate(_: ContentValueType[]): ContentValidationResultType[] {
-    throw new Error("validate method must be overridden.");
-  }
+  public abstract validate(_: ContentValueType[]): ContentValidationResultType[];
+
+  /**
+   * Classifies the impact of creating a validation rule.
+   * - {@link ValidationRuleUpdateImpact.INVALIDATES}: Some existing data may become invalid but can be fixed (e.g. adding constraints); set owners to draft.
+   * - {@link ValidationRuleUpdateImpact.BREAKS}: Only for VALUE_TYPE; all current values become invalid (e.g. adding type constraint); clear values and set owners to draft.
+   * @returns The impact of the create.
+   */
+  public abstract classifyCreate(): ValidationRuleUpdateImpact;
+
+  /**
+   * Classifies the impact of updating a validation rule's settings.
+   * - {@link ValidationRuleUpdateImpact.NONE}: Update does not make existing data invalid (e.g. loosening constraints).
+   * - {@link ValidationRuleUpdateImpact.INVALIDATES}: Some existing data may become invalid but can be fixed (e.g. tightening constraints); set owners to draft.
+   * - {@link ValidationRuleUpdateImpact.BREAKS}: Only for VALUE_TYPE; all current values become invalid (e.g. changing type); clear values and set owners to draft.
+   * @param newSettings - The new settings to classify the update impact for.
+   * @returns The impact of the update.
+   */
+  public abstract classifyUpdate(_: TSettings): ValidationRuleUpdateImpact;
 }

package/src/lib/validation-rules/count.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 { CountValidationRule } from "./count.validation-rule";
+import { ValidationRuleUpdateImpact } from "../enums/validation-rule-update-impact.enum";
 
 describe("CountValidationRule", () => {
   const rulePrn = PRN.fromString("prn:plate:-1:cms:validation-rule:1");
@@ -64,4 +65,41 @@ describe("CountValidationRule", () => {
       });
     });
   });
+
+  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 (→ 0)
+      [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 (→ 0)
+
+      // OLD: { max: 5 }  (min = 0)
+      [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)
+    ])("returns %s when old settings are %s and new settings are %s", (expected, oldSettings, newSettings) => {
+      const rule = new CountValidationRule(rulePrn, oldSettings);
+      expect(rule.classifyUpdate(newSettings)).toBe(expected);
+    });
+  });
+
+  describe("classifyCreate", () => {
+    it("returns INVALIDATES", () => {
+      const rule = new CountValidationRule(rulePrn, { min: 1, max: 3 });
+      expect(rule.classifyCreate()).toBe(ValidationRuleUpdateImpact.INVALIDATES);
+    });
+  });
 });

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

@@ -5,6 +5,7 @@ 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";
 
 export function validateValuesCount<T>(
   values: T[],
@@ -25,6 +26,27 @@ export function validateValuesCount<T>(
   return true;
 }
 
+export function validateKeysCount<T>(
+  value: T,
+  ruleInstance: RuleInstance<CountValidationRuleSettings>,
+): ContentValidationResultType {
+  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,
+    );
+  }
+  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 true;
+}
+
 /**
  * Wrapper for validateValuesCount that wraps the result in an array to keep the same interface as the other validation functions.
  */
@@ -52,6 +74,19 @@ export class CountValidationRule extends BaseValidationRule<CountValidationRuleS
   public override validate(value: ContentValueType[]): ContentValidationResultType[] {
     return validateCount(value, this);
   }
+
+  public override classifyCreate(): ValidationRuleUpdateImpact {
+    return ValidationRuleUpdateImpact.INVALIDATES;
+  }
+
+  public override classifyUpdate(newSettings: CountValidationRuleSettings): ValidationRuleUpdateImpact {
+    const oldSettings = this.settings;
+    const [oldMin, oldMax] = [oldSettings.min ?? 0, oldSettings.max ?? Infinity];
+    const [newMin, newMax] = [newSettings.min ?? 0, newSettings.max ?? Infinity];
+    const isLoosening = newMin <= oldMin && newMax >= oldMax;
+
+    return isLoosening ? ValidationRuleUpdateImpact.NONE : ValidationRuleUpdateImpact.INVALIDATES;
+  }
 }
 
 export interface CountValidationRuleSettings {

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

@@ -1,4 +1,5 @@
 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";
 
@@ -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,
@@ -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 {