diff --git a/Directory.Packages.props b/Directory.Packages.props
index 2f83626fe..e7165e6f2 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -9,6 +9,7 @@
+
diff --git a/src/FluentCMS.Core/Content/Validation/ConditionEvaluator.cs b/src/FluentCMS.Core/Content/Validation/ConditionEvaluator.cs
new file mode 100644
index 000000000..d306b586d
--- /dev/null
+++ b/src/FluentCMS.Core/Content/Validation/ConditionEvaluator.cs
@@ -0,0 +1,58 @@
+using System.Globalization;
+using FluentCMS.Schema;
+
+namespace FluentCMS.Core.Content.Validation;
+
+public static class ConditionEvaluator
+{
+ public static bool Evaluate(Condition condition, IReadOnlyDictionary values)
+ {
+ ArgumentNullException.ThrowIfNull(condition);
+ ArgumentNullException.ThrowIfNull(values);
+
+ switch (condition.Operator)
+ {
+ case ConditionOperator.Equal:
+ return Matches(Get(values, condition), condition.Values[0]);
+ case ConditionOperator.In:
+ var actual = Get(values, condition);
+ return condition.Values.Any(expected => Matches(actual, expected));
+ case ConditionOperator.IsEmpty:
+ return FieldValue.IsEmpty(Get(values, condition));
+ case ConditionOperator.And:
+ return condition.Operands.All(operand => Evaluate(operand, values));
+ case ConditionOperator.Or:
+ return condition.Operands.Any(operand => Evaluate(operand, values));
+ case ConditionOperator.Not:
+ return !Evaluate(condition.Operands[0], values);
+ default:
+ throw new ArgumentException($"Unknown condition operator {condition.Operator}.", nameof(condition));
+ }
+ }
+
+ // An unknown field is null.
+ private static object? Get(IReadOnlyDictionary values, Condition condition) =>
+ condition.FieldName is { } name && values.TryGetValue(name, out var value) ? value : null;
+
+ // A list matches when one of its items does (a multi select "equals" a value it contains), and an empty list matches null.
+ private static bool Matches(object? actual, object? expected)
+ {
+ if (FieldValue.Items(actual) is { } items)
+ {
+ var list = items.ToList();
+ return expected is null ? list.Count == 0 : list.Any(item => Same(FieldValue.Normalize(item), expected));
+ }
+
+ return Same(FieldValue.Normalize(actual), expected);
+ }
+
+ private static bool Same(object? actual, object? expected) => (actual, expected) switch
+ {
+ (null, null) => true,
+ (null, _) or (_, null) => false,
+ (string left, string right) => string.Equals(left, right, StringComparison.Ordinal),
+ (bool left, bool right) => left == right,
+ (long or decimal, long or decimal) => Convert.ToDecimal(actual, CultureInfo.InvariantCulture) == Convert.ToDecimal(expected, CultureInfo.InvariantCulture),
+ _ => false,
+ };
+}
diff --git a/src/FluentCMS.Core/Content/Validation/ConditionJson.cs b/src/FluentCMS.Core/Content/Validation/ConditionJson.cs
new file mode 100644
index 000000000..5a5d42613
--- /dev/null
+++ b/src/FluentCMS.Core/Content/Validation/ConditionJson.cs
@@ -0,0 +1,53 @@
+using System.Text;
+using System.Text.Json;
+using FluentCMS.Core.Schema;
+using FluentCMS.Schema;
+
+namespace FluentCMS.Core.Content.Validation;
+
+// A condition in the JSON shape schema.json holds, by way of the schema reader and writer, so there is one format.
+public static class ConditionJson
+{
+ public static void Write(Condition condition, Utf8JsonWriter writer)
+ {
+ ArgumentNullException.ThrowIfNull(condition);
+ ArgumentNullException.ThrowIfNull(writer);
+ SchemaJsonWriter.WriteCondition(writer, condition);
+ }
+
+ public static string ToJson(Condition condition)
+ {
+ using var stream = new MemoryStream();
+ using (var writer = new Utf8JsonWriter(stream))
+ {
+ Write(condition, writer);
+ }
+
+ return Encoding.UTF8.GetString(stream.ToArray());
+ }
+
+ public static Condition Read(JsonElement element)
+ {
+ // The reader reports problems on a builder; one without types fails its build with exactly those problems.
+ var builder = new SchemaBuilder();
+ var condition = new SchemaJsonReader(builder).ReadCondition(element, "condition");
+
+ try
+ {
+ builder.Build();
+ }
+ catch (SchemaValidationException exception)
+ {
+ throw new JsonException($"The condition is not valid: {string.Join(" ", exception.Errors.Select(error => error.Message.TrimStart(':', ' ')))}");
+ }
+
+ return condition ?? throw new JsonException("The condition is not valid.");
+ }
+
+ public static Condition Parse(string json)
+ {
+ ArgumentNullException.ThrowIfNull(json);
+ using var document = JsonDocument.Parse(json);
+ return Read(document.RootElement);
+ }
+}
diff --git a/src/FluentCMS.Core/Content/Validation/DeclarativeValidator.cs b/src/FluentCMS.Core/Content/Validation/DeclarativeValidator.cs
new file mode 100644
index 000000000..00f397a17
--- /dev/null
+++ b/src/FluentCMS.Core/Content/Validation/DeclarativeValidator.cs
@@ -0,0 +1,264 @@
+using System.Collections.Concurrent;
+using System.Globalization;
+using System.Text.RegularExpressions;
+using FluentCMS.Content;
+using FluentCMS.Schema;
+
+namespace FluentCMS.Core.Content.Validation;
+
+// A field that was checked, so the custom field validators see exactly the fields the declarative rules saw.
+internal sealed record FieldVisit(SchemaType Owner, SchemaField Field, string Path, object? Value, IReadOnlyDictionary Siblings);
+
+// Required, RequiredWhen, length, range, pattern and select options, for every visible field, recursing into
+// components and blocks. A block or component instance is a dictionary keyed by API field name (a block carries
+// its block name under "type") or a CLR object whose public properties are the fields.
+internal sealed class DeclarativeValidator(SchemaModel model)
+{
+ private const string TypeKey = "type";
+ private const int MaxNestingDepth = 8;
+ private static readonly TimeSpan MatchTimeout = TimeSpan.FromSeconds(1);
+
+ private readonly ConcurrentDictionary _patterns = new();
+
+ public void Validate(SchemaType type, IReadOnlyDictionary values, ValidationContext context, List visits) =>
+ ValidateFields(type, values, "", context, visits, 0);
+
+ private void ValidateFields(SchemaType type, IReadOnlyDictionary values, string prefix, ValidationContext context, List visits, int depth)
+ {
+ foreach (var field in type.Fields)
+ {
+ // A hidden field is not part of the entry, whatever it holds.
+ if (field.VisibleWhen is not null && !ConditionEvaluator.Evaluate(field.VisibleWhen, values))
+ {
+ continue;
+ }
+
+ values.TryGetValue(field.Name, out var value);
+ var path = prefix + field.Name;
+ visits.Add(new FieldVisit(type, field, path, value, values));
+
+ if (FieldValue.IsEmpty(value))
+ {
+ CheckRequired(field, path, values, context);
+ continue;
+ }
+
+ CheckLength(field, path, value, context);
+ CheckItems(field, path, value, context);
+
+ if (depth < MaxNestingDepth)
+ {
+ Recurse(field, path, value, context, visits, depth + 1);
+ }
+ }
+ }
+
+ private static void CheckRequired(SchemaField field, string path, IReadOnlyDictionary values, ValidationContext context)
+ {
+ if (context.Mode != ValidationMode.Publish)
+ {
+ return;
+ }
+
+ if (field.Required)
+ {
+ context.AddError(path, ValidationErrorCodes.Required, "A value is required.");
+ }
+ else if (field.RequiredWhen is not null && ConditionEvaluator.Evaluate(field.RequiredWhen, values))
+ {
+ context.AddError(path, ValidationErrorCodes.RequiredByCondition, $"A value is required when {field.RequiredWhen}.");
+ }
+ }
+
+ // A text is limited in characters; a multiple field, and blocks, in items.
+ private static void CheckLength(SchemaField field, string path, object? value, ValidationContext context)
+ {
+ int length;
+ string unit;
+ if (IsList(field) && FieldValue.Items(value) is { } items)
+ {
+ length = items.Count();
+ unit = "items";
+ }
+ else if (!field.Multiple && value is string text)
+ {
+ length = text.Length;
+ unit = "characters";
+ }
+ else
+ {
+ return;
+ }
+
+ if (field.MinLength is { } min && length < min)
+ {
+ context.AddError(path, ValidationErrorCodes.MinLength, $"Must have at least {min} {unit}, has {length}.");
+ }
+
+ if (field.MaxLength is { } max && length > max)
+ {
+ context.AddError(path, ValidationErrorCodes.MaxLength, $"Must have at most {max} {unit}, has {length}.");
+ }
+ }
+
+ // The rules on the value itself, applied to each item of a multiple field at its own path (tags[1]).
+ private void CheckItems(SchemaField field, string path, object? value, ValidationContext context)
+ {
+ if (field.FieldType is ValidatedFieldTypes.Component or ValidatedFieldTypes.Blocks)
+ {
+ return;
+ }
+
+ if (field.Multiple && FieldValue.Items(value) is { } items)
+ {
+ var index = 0;
+ foreach (var item in items)
+ {
+ CheckValue(field, $"{path}[{index++}]", item, context);
+ }
+ }
+ else if (!field.Multiple)
+ {
+ CheckValue(field, path, value, context);
+ }
+ }
+
+ private void CheckValue(SchemaField field, string path, object? value, ValidationContext context)
+ {
+ if (FieldValue.IsEmpty(value))
+ {
+ return;
+ }
+
+ if (RangeValue(value) is { } number)
+ {
+ if (field.Minimum is { } min && number < min)
+ {
+ context.AddError(path, ValidationErrorCodes.BelowMinimum, $"Must be at least {Format(min)}.");
+ }
+
+ if (field.Maximum is { } max && number > max)
+ {
+ context.AddError(path, ValidationErrorCodes.AboveMaximum, $"Must be at most {Format(max)}.");
+ }
+ }
+
+ if (field.Pattern is not null && value is string text && !Matches(field, text))
+ {
+ context.AddError(path, ValidationErrorCodes.PatternMismatch, $"Does not match the pattern {field.Pattern}.");
+ }
+
+ if (field.FieldType == ValidatedFieldTypes.Select
+ && field.Settings.TryGetValue(FieldSettings.Options, out var setting)
+ && setting is IEnumerable options
+ && FieldValue.Normalize(value) is { } option
+ && !options.Contains(option as string, StringComparer.Ordinal))
+ {
+ context.AddError(path, ValidationErrorCodes.NotAnAllowedOption, $"{option} is not one of: {string.Join(", ", options)}.");
+ }
+ }
+
+ private void Recurse(SchemaField field, string path, object? value, ValidationContext context, List visits, int depth)
+ {
+ if (field.FieldType == ValidatedFieldTypes.Component
+ && field.Settings.TryGetValue(FieldSettings.Component, out var name)
+ && model.FindComponent((string)name) is { } component)
+ {
+ if (field.Multiple)
+ {
+ var index = 0;
+ foreach (var item in FieldValue.Items(value) ?? [])
+ {
+ ValidateInstance(component, item, $"{path}[{index++}].", context, visits, depth);
+ }
+ }
+ else
+ {
+ ValidateInstance(component, value, $"{path}.", context, visits, depth);
+ }
+ }
+ else if (field.FieldType == ValidatedFieldTypes.Blocks)
+ {
+ var allowed = field.Settings.TryGetValue(FieldSettings.Blocks, out var setting) && setting is IEnumerable names ? names.ToList() : [];
+ var index = 0;
+ foreach (var item in FieldValue.Items(value) ?? [])
+ {
+ var itemPath = $"{path}[{index++}]";
+ var block = FindBlock(item);
+ if (block is null || !allowed.Contains(block.Name))
+ {
+ context.AddError(itemPath, ValidationErrorCodes.NotAnAllowedOption, $"The block type {BlockName(item) ?? "(none)"} is not one of: {string.Join(", ", allowed)}.");
+ continue;
+ }
+
+ ValidateInstance(block, item, $"{itemPath}.", context, visits, depth);
+ }
+ }
+ }
+
+ private void ValidateInstance(SchemaType type, object? instance, string prefix, ValidationContext context, List visits, int depth)
+ {
+ if (FieldValue.ReadInstance(instance) is { } values)
+ {
+ ValidateFields(type, values, prefix, context, visits, depth);
+ }
+ }
+
+ private SchemaType? FindBlock(object? item) => BlockName(item) is { } name ? model.FindBlock(name) : null;
+
+ private string? BlockName(object? item)
+ {
+ if (item is IReadOnlyDictionary dictionary)
+ {
+ return dictionary.TryGetValue(TypeKey, out var name) ? name as string : null;
+ }
+
+ if (item is IDictionary mutable)
+ {
+ return mutable.TryGetValue(TypeKey, out var name) ? name as string : null;
+ }
+
+ return item is null ? null : model.Blocks.FirstOrDefault(block => block.ClrType == item.GetType())?.Name;
+ }
+
+ private bool Matches(SchemaField field, string text)
+ {
+ var regex = _patterns.GetOrAdd(field, static f => new Regex(f.Pattern!, RegexOptions.CultureInvariant, MatchTimeout));
+ try
+ {
+ return regex.IsMatch(text);
+ }
+ catch (RegexMatchTimeoutException)
+ {
+ return false;
+ }
+ }
+
+ private static bool IsList(SchemaField field) => field.Multiple || field.FieldType == ValidatedFieldTypes.Blocks;
+
+ // Only numbers have a range; the model does not say whether a bound on a date means days or seconds.
+ // A float beyond what a decimal holds counts as the nearest decimal bound, so it is out of range in its direction.
+ private static decimal? RangeValue(object? value) => value switch
+ {
+ byte or sbyte or short or ushort or int or uint or long or ulong or decimal => Convert.ToDecimal(value, CultureInfo.InvariantCulture),
+ float or double => Clamp(Convert.ToDouble(value, CultureInfo.InvariantCulture)),
+ _ => null,
+ };
+
+ private static decimal? Clamp(double number) => number switch
+ {
+ double.NaN => null,
+ >= (double)decimal.MaxValue => decimal.MaxValue,
+ <= (double)decimal.MinValue => decimal.MinValue,
+ _ => (decimal)number,
+ };
+
+ private static string Format(decimal number) => number.ToString("G29", CultureInfo.InvariantCulture);
+}
+
+internal static class ValidatedFieldTypes
+{
+ public const string Select = "select";
+ public const string Component = "component";
+ public const string Blocks = "blocks";
+}
diff --git a/src/FluentCMS.Core/Content/Validation/FieldValue.cs b/src/FluentCMS.Core/Content/Validation/FieldValue.cs
new file mode 100644
index 000000000..fc28792ff
--- /dev/null
+++ b/src/FluentCMS.Core/Content/Validation/FieldValue.cs
@@ -0,0 +1,80 @@
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Reflection;
+using FluentCMS.Media;
+using FluentCMS.Schema;
+
+namespace FluentCMS.Core.Content.Validation;
+
+// How validation reads a value: whether it is empty, what it compares as, and how a component or block instance
+// is read, either a dictionary keyed by API field name or a CLR object whose public properties are the fields.
+internal static class FieldValue
+{
+ private static readonly ConcurrentDictionary Properties = new();
+
+ public static bool IsEmpty(object? value) => value switch
+ {
+ null => true,
+ string text => string.IsNullOrWhiteSpace(text),
+ Guid id => id == Guid.Empty,
+ MediaRef media => media.IsEmpty,
+ IEnumerable items => !items.GetEnumerator().MoveNext(),
+ _ => IsEmptyRef(value),
+ };
+
+ // The value as a schema stores it: null, string, bool, long or decimal. An enum member is its camelCase
+ // name, a reference is its id. Anything else cannot be compared with a condition value.
+ public static object? Normalize(object? value)
+ {
+ if (value is null)
+ {
+ return null;
+ }
+
+ if (IsRef(value.GetType()))
+ {
+ return value.GetType().GetProperty("Id")!.GetValue(value)?.ToString();
+ }
+
+ try
+ {
+ return SchemaValue.Normalize(value);
+ }
+ catch (ArgumentException)
+ {
+ return value;
+ }
+ }
+
+ public static IEnumerable? Items(object? value) =>
+ value is IEnumerable and not string and not IReadOnlyDictionary ? ((IEnumerable)value).Cast() : null;
+
+ public static IReadOnlyDictionary? ReadInstance(object? instance)
+ {
+ switch (instance)
+ {
+ case null:
+ return null;
+ case IReadOnlyDictionary dictionary:
+ return dictionary;
+ case IDictionary mutable:
+ return new Dictionary(mutable, StringComparer.Ordinal);
+ }
+
+ var values = new Dictionary(StringComparer.Ordinal);
+ foreach (var property in Properties.GetOrAdd(instance.GetType(), ReadableProperties))
+ {
+ values[SchemaNaming.ToCamelCase(property.Name)] = property.GetValue(instance);
+ }
+
+ return values;
+ }
+
+ private static PropertyInfo[] ReadableProperties(Type type) =>
+ [.. type.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(property => property.GetIndexParameters().Length == 0 && property.CanRead)];
+
+ private static bool IsRef(Type type) => type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Ref<>);
+
+ private static bool IsEmptyRef(object value) =>
+ IsRef(value.GetType()) && (bool)value.GetType().GetProperty("IsEmpty")!.GetValue(value)!;
+}
diff --git a/src/FluentCMS.Core/Content/Validation/ValidationPipeline.cs b/src/FluentCMS.Core/Content/Validation/ValidationPipeline.cs
new file mode 100644
index 000000000..2be217666
--- /dev/null
+++ b/src/FluentCMS.Core/Content/Validation/ValidationPipeline.cs
@@ -0,0 +1,141 @@
+using System.Collections.Concurrent;
+using System.Reflection;
+using FluentCMS.Content;
+using FluentCMS.Schema;
+
+namespace FluentCMS.Core.Content.Validation;
+
+public sealed class ValidationPipeline(SchemaModel model, IServiceProvider services)
+{
+ private readonly DeclarativeValidator _declarative = new(model);
+ private readonly ConcurrentDictionary<(Type Owner, string Field), Type?> _propertyTypes = new();
+
+ public async ValueTask ValidateAsync(
+ SchemaType type,
+ IReadOnlyDictionary values,
+ object? entry,
+ OperationContext operation,
+ ValidationMode mode,
+ CancellationToken cancellationToken)
+ {
+ ArgumentNullException.ThrowIfNull(type);
+ ArgumentNullException.ThrowIfNull(values);
+ ArgumentNullException.ThrowIfNull(operation);
+
+ var context = new ValidationContext(type, values, operation, mode, entry);
+
+ var visits = new List();
+ _declarative.Validate(type, values, context, visits);
+
+ foreach (var visit in visits)
+ {
+ await RunFieldValidatorsAsync(visit, context, cancellationToken);
+ }
+
+ if (entry is not null)
+ {
+ await RunEntryValidatorsAsync(entry, context, cancellationToken);
+ }
+
+ // Uniqueness (a database query, #2693) and reference integrity on publish (#2695) slot in here, after the
+ // validators that need no I/O, so they only run for an entry that is otherwise sound.
+ return context.Errors.Count == 0 ? ValidationResult.Success : new ValidationResult(context.Errors);
+ }
+
+ private async ValueTask RunFieldValidatorsAsync(FieldVisit visit, ValidationContext root, CancellationToken cancellationToken)
+ {
+ var fieldType = FieldClrType(visit);
+ var context = root.ForField(visit.Owner, visit.Field, visit.Path, visit.Siblings);
+
+ if (fieldType is not null && fieldType != typeof(object))
+ {
+ await FieldValidatorInvoker.For(fieldType).InvokeAsync(services, visit.Value, context, cancellationToken);
+ }
+
+ await FieldValidatorInvoker.For(typeof(object)).InvokeAsync(services, visit.Value, context, cancellationToken);
+ }
+
+ private async ValueTask RunEntryValidatorsAsync(object entry, ValidationContext root, CancellationToken cancellationToken)
+ {
+ var context = root.ForEntry();
+ for (var type = entry.GetType(); type is not null && type != typeof(object); type = type.BaseType)
+ {
+ await EntryValidatorInvoker.For(type).InvokeAsync(services, entry, context, cancellationToken);
+ }
+ }
+
+ // The type of the property the field was read from; a field of a type defined without a class has the type of its value.
+ private Type? FieldClrType(FieldVisit visit)
+ {
+ var declared = visit.Owner.ClrType is { } owner
+ ? _propertyTypes.GetOrAdd((owner, visit.Field.Name), static key => PropertyType(key.Owner, key.Field))
+ : null;
+
+ return declared ?? visit.Value?.GetType();
+ }
+
+ private static Type? PropertyType(Type owner, string fieldName)
+ {
+ var property = owner.GetProperties(BindingFlags.Public | BindingFlags.Instance)
+ .FirstOrDefault(candidate => SchemaNaming.ToCamelCase(candidate.Name) == fieldName);
+
+ return property is null ? null : Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
+ }
+
+ private abstract class FieldValidatorInvoker
+ {
+ private static readonly ConcurrentDictionary Cache = new();
+
+ public static FieldValidatorInvoker For(Type fieldType) =>
+ Cache.GetOrAdd(fieldType, static type => (FieldValidatorInvoker)Activator.CreateInstance(typeof(FieldValidatorInvoker<>).MakeGenericType(type))!);
+
+ public abstract ValueTask InvokeAsync(IServiceProvider services, object? value, ValidationContext context, CancellationToken cancellationToken);
+ }
+
+ private sealed class FieldValidatorInvoker : FieldValidatorInvoker
+ {
+ public override async ValueTask InvokeAsync(IServiceProvider services, object? value, ValidationContext context, CancellationToken cancellationToken)
+ {
+ // A null cannot be given to a validator of a value type.
+ if (services.GetService(typeof(IEnumerable>)) is not IEnumerable> validators
+ || (value is null && typeof(T).IsValueType)
+ || (value is not null && value is not T))
+ {
+ return;
+ }
+
+ foreach (var validator in validators)
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ await validator.ValidateAsync((T?)value, context, cancellationToken);
+ }
+ }
+ }
+
+ private abstract class EntryValidatorInvoker
+ {
+ private static readonly ConcurrentDictionary Cache = new();
+
+ public static EntryValidatorInvoker For(Type entryType) =>
+ Cache.GetOrAdd(entryType, static type => (EntryValidatorInvoker)Activator.CreateInstance(typeof(EntryValidatorInvoker<>).MakeGenericType(type))!);
+
+ public abstract ValueTask InvokeAsync(IServiceProvider services, object entry, ValidationContext context, CancellationToken cancellationToken);
+ }
+
+ private sealed class EntryValidatorInvoker : EntryValidatorInvoker
+ {
+ public override async ValueTask InvokeAsync(IServiceProvider services, object entry, ValidationContext context, CancellationToken cancellationToken)
+ {
+ if (services.GetService(typeof(IEnumerable>)) is not IEnumerable> validators)
+ {
+ return;
+ }
+
+ foreach (var validator in validators)
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ await validator.ValidateAsync((T)entry, context, cancellationToken);
+ }
+ }
+ }
+}
diff --git a/src/FluentCMS.Core/Schema/SchemaJsonReader.cs b/src/FluentCMS.Core/Schema/SchemaJsonReader.cs
index d2e9ff7dd..3f116578c 100644
--- a/src/FluentCMS.Core/Schema/SchemaJsonReader.cs
+++ b/src/FluentCMS.Core/Schema/SchemaJsonReader.cs
@@ -356,7 +356,7 @@ private bool ReadDisplay(JsonElement element, string path, List f.Display(label, help, placeholder, group, tab, width));
}
- private Condition? ReadCondition(JsonElement element, string path)
+ internal Condition? ReadCondition(JsonElement element, string path)
{
if (element.ValueKind != JsonValueKind.Object)
{
diff --git a/src/FluentCMS.Core/Schema/SchemaJsonWriter.cs b/src/FluentCMS.Core/Schema/SchemaJsonWriter.cs
index 9b64d23ec..106a5c058 100644
--- a/src/FluentCMS.Core/Schema/SchemaJsonWriter.cs
+++ b/src/FluentCMS.Core/Schema/SchemaJsonWriter.cs
@@ -136,7 +136,7 @@ private static void WriteField(Utf8JsonWriter writer, SchemaField field)
writer.WriteEndObject();
}
- private static void WriteCondition(Utf8JsonWriter writer, Condition condition)
+ internal static void WriteCondition(Utf8JsonWriter writer, Condition condition)
{
writer.WriteStartObject();
switch (condition.Operator)
diff --git a/src/FluentCMS.Sdk/Content/IEntryValidator.cs b/src/FluentCMS.Sdk/Content/IEntryValidator.cs
new file mode 100644
index 000000000..8436f2db4
--- /dev/null
+++ b/src/FluentCMS.Sdk/Content/IEntryValidator.cs
@@ -0,0 +1,16 @@
+namespace FluentCMS.Content;
+
+///
+/// Validates a whole entry, for rules that span fields or need a service. Register it in the service collection;
+/// it runs after every field has been checked, for entries whose CLR type is or derives from it.
+///
+/// The CLR type of the entry.
+public interface IEntryValidator
+{
+ /// Validates an entry, adding errors to the context.
+ /// The entry.
+ /// What the validator knows about the entry; is .
+ /// Cancels the validation.
+ /// A task that completes when the entry has been checked.
+ ValueTask ValidateAsync(T entry, ValidationContext context, CancellationToken cancellationToken);
+}
diff --git a/src/FluentCMS.Sdk/Content/IFieldValidator.cs b/src/FluentCMS.Sdk/Content/IFieldValidator.cs
new file mode 100644
index 000000000..d00baaecb
--- /dev/null
+++ b/src/FluentCMS.Sdk/Content/IFieldValidator.cs
@@ -0,0 +1,17 @@
+namespace FluentCMS.Content;
+
+///
+/// Validates the value of a field. Register it in the service collection; it runs for every field whose
+/// CLR type is (use to see every field) after the declarative
+/// rules, and is skipped for a hidden field. A value reaches only validators of reference types.
+///
+/// The CLR type of the field value.
+public interface IFieldValidator
+{
+ /// Validates a value, adding errors to the context.
+ /// The value of the field.
+ /// What the validator knows about the entry, with set.
+ /// Cancels the validation.
+ /// A task that completes when the value has been checked.
+ ValueTask ValidateAsync(TField? value, ValidationContext context, CancellationToken cancellationToken);
+}
diff --git a/src/FluentCMS.Sdk/Content/ValidationContext.cs b/src/FluentCMS.Sdk/Content/ValidationContext.cs
new file mode 100644
index 000000000..309bf0b1a
--- /dev/null
+++ b/src/FluentCMS.Sdk/Content/ValidationContext.cs
@@ -0,0 +1,117 @@
+using FluentCMS.Schema;
+
+namespace FluentCMS.Content;
+
+/// What a custom validator knows about the entry being validated, and where it reports problems.
+public sealed class ValidationContext
+{
+ private readonly List _errors;
+
+ /// Creates a context, for the pipeline or for unit tests of a validator.
+ /// The type of the entry.
+ /// The values of the entry, by API field name.
+ /// The operation that causes the validation.
+ /// Whether a draft is saved or the entry is published.
+ /// The typed entry, if there is one.
+ /// The field being validated, or for an entry validator.
+ /// The path of that field; defaults to its name.
+ /// The type that declares the field; defaults to .
+ public ValidationContext(
+ SchemaType type,
+ IReadOnlyDictionary values,
+ OperationContext operation,
+ ValidationMode mode,
+ object? entry = null,
+ SchemaField? field = null,
+ string? path = null,
+ SchemaType? container = null)
+ : this(type, values, operation, mode, entry, field, path, container, [])
+ {
+ }
+
+ private ValidationContext(
+ SchemaType type,
+ IReadOnlyDictionary values,
+ OperationContext operation,
+ ValidationMode mode,
+ object? entry,
+ SchemaField? field,
+ string? path,
+ SchemaType? container,
+ List errors)
+ {
+ ArgumentNullException.ThrowIfNull(type);
+ ArgumentNullException.ThrowIfNull(values);
+ ArgumentNullException.ThrowIfNull(operation);
+
+ Type = type;
+ Container = container ?? type;
+ Values = values;
+ Operation = operation;
+ Mode = mode;
+ Entry = entry;
+ Field = field;
+ Path = field is null ? "" : path ?? field.Name;
+ _errors = errors;
+ }
+
+ /// The type of the entry.
+ public SchemaType Type { get; }
+
+ /// The type that declares : the entry type at the top level, the component or block type for a field inside one.
+ public SchemaType Container { get; }
+
+ /// The field being validated, or for an entry validator.
+ public SchemaField? Field { get; }
+
+ /// The path of in the API shape, such as seo.metaTitle; empty for an entry validator.
+ public string Path { get; }
+
+ /// The typed entry, or when the entry is only a set of values.
+ public object? Entry { get; }
+
+ /// The values next to the field, by API field name. For a field of a component or block, those of the same component or block.
+ public IReadOnlyDictionary Values { get; }
+
+ /// The operation that causes the validation; it gives the principal, origin, site and locale.
+ public OperationContext Operation { get; }
+
+ /// Whether a draft is saved or the entry is published.
+ public ValidationMode Mode { get; }
+
+ /// Every error added so far, by the declarative rules and by validators.
+ public IReadOnlyList Errors => _errors;
+
+ /// Adds an error at a path.
+ /// The path in the API shape; empty for the entry as a whole.
+ /// A stable code; plugins should use their own prefix. An empty code becomes .
+ /// A message for people.
+ public void AddError(string path, string code, string message)
+ {
+ ArgumentNullException.ThrowIfNull(path);
+ ArgumentException.ThrowIfNullOrEmpty(message);
+ _errors.Add(new ValidationError(path, string.IsNullOrEmpty(code) ? ValidationErrorCodes.Custom : code, message));
+ }
+
+ /// Adds an error to the field being validated.
+ /// A stable code. An empty code becomes .
+ /// A message for people.
+ /// There is no current field, as in an entry validator.
+ public void AddError(string code, string message)
+ {
+ if (Field is null)
+ {
+ throw new InvalidOperationException("There is no current field; give the path of the error.");
+ }
+
+ AddError(Path, code, message);
+ }
+
+ // Shares the error list, so what a field validator reports lands in the result of the run.
+ internal ValidationContext ForField(SchemaType container, SchemaField field, string path, IReadOnlyDictionary values) =>
+ new(Type, values, Operation, Mode, Entry, field, path, container, _errors);
+
+ // The entry-level view of the same run.
+ internal ValidationContext ForEntry() =>
+ new(Type, Values, Operation, Mode, Entry, null, null, null, _errors);
+}
diff --git a/src/FluentCMS.Sdk/Content/ValidationError.cs b/src/FluentCMS.Sdk/Content/ValidationError.cs
new file mode 100644
index 000000000..392dee4ef
--- /dev/null
+++ b/src/FluentCMS.Sdk/Content/ValidationError.cs
@@ -0,0 +1,7 @@
+namespace FluentCMS.Content;
+
+/// One problem found while validating an entry.
+/// The path of the field in the API shape, such as videoUrl, seo.metaTitle, sections[2].heading or tags[1]. Empty for a problem with the entry as a whole.
+/// A stable code, FCMS21xx for the built-in rules; see .
+/// A message for people.
+public sealed record ValidationError(string Path, string Code, string Message);
diff --git a/src/FluentCMS.Sdk/Content/ValidationErrorCodes.cs b/src/FluentCMS.Sdk/Content/ValidationErrorCodes.cs
new file mode 100644
index 000000000..422702121
--- /dev/null
+++ b/src/FluentCMS.Sdk/Content/ValidationErrorCodes.cs
@@ -0,0 +1,35 @@
+namespace FluentCMS.Content;
+
+/// The codes of the built-in validation rules, so plugins and clients can match on them.
+public static class ValidationErrorCodes
+{
+ /// A required field has no value.
+ public const string Required = "FCMS2101";
+
+ /// The value is shorter than the field's minimum length, or a multiple field has too few items.
+ public const string MinLength = "FCMS2102";
+
+ /// The value is longer than the field's maximum length, or a multiple field has too many items.
+ public const string MaxLength = "FCMS2103";
+
+ /// The value is below the field's minimum.
+ public const string BelowMinimum = "FCMS2104";
+
+ /// The value is above the field's maximum.
+ public const string AboveMaximum = "FCMS2105";
+
+ /// The value does not match the field's regular expression.
+ public const string PatternMismatch = "FCMS2106";
+
+ /// The value is not one of the allowed options, or a block is of a type the field does not allow.
+ public const string NotAnAllowedOption = "FCMS2107";
+
+ /// The value cannot be read as the type of the field.
+ public const string InvalidValue = "FCMS2108";
+
+ /// A custom validator rejected the value without giving a code.
+ public const string Custom = "FCMS2109";
+
+ /// The field's RequiredWhen condition holds and the field has no value.
+ public const string RequiredByCondition = "FCMS2110";
+}
diff --git a/src/FluentCMS.Sdk/Content/ValidationException.cs b/src/FluentCMS.Sdk/Content/ValidationException.cs
new file mode 100644
index 000000000..e57dc179d
--- /dev/null
+++ b/src/FluentCMS.Sdk/Content/ValidationException.cs
@@ -0,0 +1,36 @@
+namespace FluentCMS.Content;
+
+///
+/// Thrown when an entry breaks validation rules. The HTTP layer maps it to a 422 problem details response
+/// whose errors array holds { path, code, message } for each error.
+///
+public sealed class ValidationException : Exception
+{
+ /// Creates the exception.
+ /// The errors; there must be at least one.
+ public ValidationException(IEnumerable errors)
+ : base(BuildMessage(errors, out var list))
+ {
+ Errors = list;
+ }
+
+ /// The errors, in the order they were found.
+ public IReadOnlyList Errors { get; }
+
+ private static string BuildMessage(IEnumerable errors, out IReadOnlyList list)
+ {
+ ArgumentNullException.ThrowIfNull(errors);
+ list = [.. errors];
+ if (list.Count == 0)
+ {
+ throw new ArgumentException("A validation exception needs at least one error.", nameof(errors));
+ }
+
+ return list.Count == 1
+ ? $"Validation failed: {Describe(list[0])}"
+ : $"Validation failed with {list.Count} errors: {string.Join("; ", list.Select(Describe))}";
+ }
+
+ private static string Describe(ValidationError error) =>
+ error.Path.Length == 0 ? $"{error.Code} {error.Message}" : $"{error.Path}: {error.Code} {error.Message}";
+}
diff --git a/src/FluentCMS.Sdk/Content/ValidationMode.cs b/src/FluentCMS.Sdk/Content/ValidationMode.cs
new file mode 100644
index 000000000..deef0d013
--- /dev/null
+++ b/src/FluentCMS.Sdk/Content/ValidationMode.cs
@@ -0,0 +1,11 @@
+namespace FluentCMS.Content;
+
+/// Which rules a validation run enforces.
+public enum ValidationMode
+{
+ /// A draft save: Required and RequiredWhen are skipped so incomplete work can be saved.
+ Draft = 1,
+
+ /// A publish: every rule is enforced.
+ Publish = 2,
+}
diff --git a/src/FluentCMS.Sdk/Content/ValidationResult.cs b/src/FluentCMS.Sdk/Content/ValidationResult.cs
new file mode 100644
index 000000000..977d14e0c
--- /dev/null
+++ b/src/FluentCMS.Sdk/Content/ValidationResult.cs
@@ -0,0 +1,22 @@
+namespace FluentCMS.Content;
+
+/// The outcome of validating an entry.
+public sealed class ValidationResult
+{
+ /// Creates a result.
+ /// The errors, in the order they were found.
+ public ValidationResult(IEnumerable errors)
+ {
+ ArgumentNullException.ThrowIfNull(errors);
+ Errors = [.. errors];
+ }
+
+ /// The result of a valid entry.
+ public static ValidationResult Success { get; } = new([]);
+
+ /// Whether no rule was broken.
+ public bool IsValid => Errors.Count == 0;
+
+ /// The errors, in the order they were found: fields in declaration order, then custom field validators, then entry validators.
+ public IReadOnlyList Errors { get; }
+}
diff --git a/src/FluentCMS.Sdk/PublicAPI.Unshipped.txt b/src/FluentCMS.Sdk/PublicAPI.Unshipped.txt
index 826d5933d..adbb214ca 100644
--- a/src/FluentCMS.Sdk/PublicAPI.Unshipped.txt
+++ b/src/FluentCMS.Sdk/PublicAPI.Unshipped.txt
@@ -1,4 +1,8 @@
#nullable enable
+FluentCMS.Content.IEntryValidator
+FluentCMS.Content.IEntryValidator.ValidateAsync(T entry, FluentCMS.Content.ValidationContext! context, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.ValueTask
+FluentCMS.Content.IFieldValidator
+FluentCMS.Content.IFieldValidator.ValidateAsync(TField? value, FluentCMS.Content.ValidationContext! context, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.ValueTask
FluentCMS.Content.IOperationContextAccessor
FluentCMS.Content.IOperationContextAccessor.Current.get -> FluentCMS.Content.OperationContext?
FluentCMS.Content.IOperationContextAccessor.Current.set -> void
@@ -43,6 +47,41 @@ FluentCMS.Content.PrincipalKind.ApiKey = 3 -> FluentCMS.Content.PrincipalKind
FluentCMS.Content.PrincipalKind.Member = 2 -> FluentCMS.Content.PrincipalKind
FluentCMS.Content.PrincipalKind.ServiceAccount = 4 -> FluentCMS.Content.PrincipalKind
FluentCMS.Content.PrincipalKind.System = 5 -> FluentCMS.Content.PrincipalKind
+FluentCMS.Content.ValidationContext
+FluentCMS.Content.ValidationContext.AddError(string! code, string! message) -> void
+FluentCMS.Content.ValidationContext.AddError(string! path, string! code, string! message) -> void
+FluentCMS.Content.ValidationContext.Container.get -> FluentCMS.Schema.SchemaType!
+FluentCMS.Content.ValidationContext.Entry.get -> object?
+FluentCMS.Content.ValidationContext.Errors.get -> System.Collections.Generic.IReadOnlyList!
+FluentCMS.Content.ValidationContext.Field.get -> FluentCMS.Schema.SchemaField?
+FluentCMS.Content.ValidationContext.Mode.get -> FluentCMS.Content.ValidationMode
+FluentCMS.Content.ValidationContext.Operation.get -> FluentCMS.Content.OperationContext!
+FluentCMS.Content.ValidationContext.Path.get -> string!
+FluentCMS.Content.ValidationContext.Type.get -> FluentCMS.Schema.SchemaType!
+FluentCMS.Content.ValidationContext.ValidationContext(FluentCMS.Schema.SchemaType! type, System.Collections.Generic.IReadOnlyDictionary! values, FluentCMS.Content.OperationContext! operation, FluentCMS.Content.ValidationMode mode, object? entry = null, FluentCMS.Schema.SchemaField? field = null, string? path = null, FluentCMS.Schema.SchemaType? container = null) -> void
+FluentCMS.Content.ValidationContext.Values.get -> System.Collections.Generic.IReadOnlyDictionary!
+FluentCMS.Content.ValidationError
+FluentCMS.Content.ValidationError.$() -> FluentCMS.Content.ValidationError!
+FluentCMS.Content.ValidationError.Code.get -> string!
+FluentCMS.Content.ValidationError.Code.init -> void
+FluentCMS.Content.ValidationError.Deconstruct(out string! Path, out string! Code, out string! Message) -> void
+FluentCMS.Content.ValidationError.Equals(FluentCMS.Content.ValidationError? other) -> bool
+FluentCMS.Content.ValidationError.Message.get -> string!
+FluentCMS.Content.ValidationError.Message.init -> void
+FluentCMS.Content.ValidationError.Path.get -> string!
+FluentCMS.Content.ValidationError.Path.init -> void
+FluentCMS.Content.ValidationError.ValidationError(string! Path, string! Code, string! Message) -> void
+FluentCMS.Content.ValidationErrorCodes
+FluentCMS.Content.ValidationException
+FluentCMS.Content.ValidationException.Errors.get -> System.Collections.Generic.IReadOnlyList!
+FluentCMS.Content.ValidationException.ValidationException(System.Collections.Generic.IEnumerable! errors) -> void
+FluentCMS.Content.ValidationMode
+FluentCMS.Content.ValidationMode.Draft = 1 -> FluentCMS.Content.ValidationMode
+FluentCMS.Content.ValidationMode.Publish = 2 -> FluentCMS.Content.ValidationMode
+FluentCMS.Content.ValidationResult
+FluentCMS.Content.ValidationResult.Errors.get -> System.Collections.Generic.IReadOnlyList!
+FluentCMS.Content.ValidationResult.IsValid.get -> bool
+FluentCMS.Content.ValidationResult.ValidationResult(System.Collections.Generic.IEnumerable! errors) -> void
FluentCMS.Media.MediaRef
FluentCMS.Media.MediaRef.Deconstruct(out System.Guid Id) -> void
FluentCMS.Media.MediaRef.Equals(FluentCMS.Media.MediaRef other) -> bool
@@ -369,6 +408,16 @@ FluentCMS.Sites.SiteId.SiteId() -> void
FluentCMS.Sites.SiteId.SiteId(System.Guid Value) -> void
FluentCMS.Sites.SiteId.Value.get -> System.Guid
FluentCMS.Sites.SiteId.Value.init -> void
+const FluentCMS.Content.ValidationErrorCodes.AboveMaximum = "FCMS2105" -> string!
+const FluentCMS.Content.ValidationErrorCodes.BelowMinimum = "FCMS2104" -> string!
+const FluentCMS.Content.ValidationErrorCodes.Custom = "FCMS2109" -> string!
+const FluentCMS.Content.ValidationErrorCodes.InvalidValue = "FCMS2108" -> string!
+const FluentCMS.Content.ValidationErrorCodes.MaxLength = "FCMS2103" -> string!
+const FluentCMS.Content.ValidationErrorCodes.MinLength = "FCMS2102" -> string!
+const FluentCMS.Content.ValidationErrorCodes.NotAnAllowedOption = "FCMS2107" -> string!
+const FluentCMS.Content.ValidationErrorCodes.PatternMismatch = "FCMS2106" -> string!
+const FluentCMS.Content.ValidationErrorCodes.Required = "FCMS2101" -> string!
+const FluentCMS.Content.ValidationErrorCodes.RequiredByCondition = "FCMS2110" -> string!
const FluentCMS.Schema.FieldSettings.Blocks = "blocks" -> string!
const FluentCMS.Schema.FieldSettings.Component = "component" -> string!
const FluentCMS.Schema.FieldSettings.Options = "options" -> string!
@@ -383,6 +432,9 @@ override FluentCMS.Content.OperationContext.ToString() -> string!
override FluentCMS.Content.Principal.Equals(object? obj) -> bool
override FluentCMS.Content.Principal.GetHashCode() -> int
override FluentCMS.Content.Principal.ToString() -> string!
+override FluentCMS.Content.ValidationError.Equals(object? obj) -> bool
+override FluentCMS.Content.ValidationError.GetHashCode() -> int
+override FluentCMS.Content.ValidationError.ToString() -> string!
override FluentCMS.Media.MediaRef.GetHashCode() -> int
override FluentCMS.Media.MediaRef.ToString() -> string!
override FluentCMS.Media.MediaRefList.Equals(object? obj) -> bool
@@ -405,6 +457,9 @@ override FluentCMS.Sites.SiteId.ToString() -> string!
static FluentCMS.Content.OperationContext.operator !=(FluentCMS.Content.OperationContext? left, FluentCMS.Content.OperationContext? right) -> bool
static FluentCMS.Content.OperationContext.operator ==(FluentCMS.Content.OperationContext? left, FluentCMS.Content.OperationContext? right) -> bool
static FluentCMS.Content.Principal.System.get -> FluentCMS.Content.Principal!
+static FluentCMS.Content.ValidationError.operator !=(FluentCMS.Content.ValidationError? left, FluentCMS.Content.ValidationError? right) -> bool
+static FluentCMS.Content.ValidationError.operator ==(FluentCMS.Content.ValidationError? left, FluentCMS.Content.ValidationError? right) -> bool
+static FluentCMS.Content.ValidationResult.Success.get -> FluentCMS.Content.ValidationResult!
static FluentCMS.Media.MediaRef.operator !=(FluentCMS.Media.MediaRef left, FluentCMS.Media.MediaRef right) -> bool
static FluentCMS.Media.MediaRef.operator ==(FluentCMS.Media.MediaRef left, FluentCMS.Media.MediaRef right) -> bool
static FluentCMS.Media.MediaRefList.Create(System.ReadOnlySpan items) -> FluentCMS.Media.MediaRefList!
diff --git a/src/FluentCMS.Sdk/Schema/ConditionField.cs b/src/FluentCMS.Sdk/Schema/ConditionField.cs
index 7de75f68f..8601b6bfc 100644
--- a/src/FluentCMS.Sdk/Schema/ConditionField.cs
+++ b/src/FluentCMS.Sdk/Schema/ConditionField.cs
@@ -26,7 +26,7 @@ public Condition In(params object?[] values)
return new(ConditionOperator.In, Name, values.Select(value => SchemaValue.Normalize(value)), []);
}
- /// Holds when the field has no value: , an empty string or an empty list.
+ /// Holds when the field has no value: , an empty or whitespace-only string, or an empty list.
/// The condition.
public Condition IsEmpty() => new(ConditionOperator.IsEmpty, Name, [], []);
}
diff --git a/src/FluentCMS.Sdk/Schema/RegularExpressionAttribute.cs b/src/FluentCMS.Sdk/Schema/RegularExpressionAttribute.cs
index 6156aaa56..c8a398299 100644
--- a/src/FluentCMS.Sdk/Schema/RegularExpressionAttribute.cs
+++ b/src/FluentCMS.Sdk/Schema/RegularExpressionAttribute.cs
@@ -1,6 +1,9 @@
namespace FluentCMS.Schema;
-/// Requires the value of a text field to match a regular expression.
+///
+/// Requires the value of a text field to match a regular expression. The pattern may match anywhere in the value,
+/// as an OpenAPI pattern does, so anchor it with ^ and $ to match the whole value.
+///
/// The regular expression.
[AttributeUsage(AttributeTargets.Property, Inherited = false)]
public sealed class RegularExpressionAttribute(string pattern) : Attribute
diff --git a/tests/FluentCMS.Core.Tests/Content/Validation/ConditionTests.cs b/tests/FluentCMS.Core.Tests/Content/Validation/ConditionTests.cs
new file mode 100644
index 000000000..091419e64
--- /dev/null
+++ b/tests/FluentCMS.Core.Tests/Content/Validation/ConditionTests.cs
@@ -0,0 +1,179 @@
+#pragma warning disable CA1861
+using FluentCMS.Core.Content.Validation;
+using FluentCMS.Core.Tests.Schema.Samples;
+using FluentCMS.Media;
+using FluentCMS.Schema;
+using Shouldly;
+using Xunit;
+
+namespace FluentCMS.Core.Tests.Content.Validation;
+
+public class ConditionTests
+{
+ private static readonly Condition Video = Condition.Field("category").Equals(ArticleCategory.Video);
+ private static readonly Condition NoTitle = Condition.Field("title").IsEmpty();
+
+ private static Dictionary Values(params (string Name, object? Value)[] values) =>
+ values.ToDictionary(pair => pair.Name, pair => pair.Value);
+
+ public static TheoryData Conditions => new()
+ {
+ { "equal", Video },
+ { "equal number", Condition.Field("count").Equals(5) },
+ { "equal bool", Condition.Field("flag").Equals(true) },
+ { "equal null", Condition.Field("title").Equals(null) },
+ { "in", Condition.Field("category").In(ArticleCategory.News, "video", 3) },
+ { "isEmpty", NoTitle },
+ { "and", Video.And(NoTitle) },
+ { "or", Video.Or(NoTitle) },
+ { "not", Video.Not() },
+ { "nested", Video.And(NoTitle.Not()).Or(Condition.Field("count").In(1, 2.5m).Not()).And(Condition.Field("flag").Equals(false)) },
+ };
+
+ private static readonly Dictionary[] Samples =
+ [
+ Values(),
+ Values(("category", ArticleCategory.Video), ("title", "T"), ("count", 5), ("flag", true)),
+ Values(("category", "news"), ("title", ""), ("count", 2.5m), ("flag", false)),
+ Values(("category", ArticleCategory.Opinion), ("title", null), ("count", 1L), ("flag", false)),
+ ];
+
+ [Theory]
+ [MemberData(nameof(Conditions))]
+ public void ConditionsRoundTripThroughJson(string name, Condition condition)
+ {
+ var json = ConditionJson.ToJson(condition);
+
+ var read = ConditionJson.Parse(json);
+
+ ConditionJson.ToJson(read).ShouldBe(json, name);
+ read.ToString().ShouldBe(condition.ToString(), name);
+ read.Operator.ShouldBe(condition.Operator, name);
+ }
+
+ [Theory]
+ [MemberData(nameof(Conditions))]
+ public void ConditionsEvaluateTheSameFromCSharpAndFromJson(string name, Condition condition)
+ {
+ var fromJson = ConditionJson.Parse(ConditionJson.ToJson(condition));
+
+ foreach (var values in Samples)
+ {
+ ConditionEvaluator.Evaluate(fromJson, values).ShouldBe(ConditionEvaluator.Evaluate(condition, values), name);
+ }
+ }
+
+ [Fact]
+ public void JsonHasTheShapeOfTheSchemaFile()
+ {
+ ConditionJson.ToJson(Video).ShouldBe("""{"field":"category","equals":"video"}""");
+ ConditionJson.ToJson(Condition.Field("a").In(1, "b")).ShouldBe("""{"field":"a","in":[1,"b"]}""");
+ ConditionJson.ToJson(NoTitle).ShouldBe("""{"field":"title","isEmpty":true}""");
+ ConditionJson.ToJson(Video.And(NoTitle.Not())).ShouldBe(
+ """{"and":[{"field":"category","equals":"video"},{"not":{"field":"title","isEmpty":true}}]}""");
+ }
+
+ [Fact]
+ public void AnInvalidConditionIsRejected()
+ {
+ Should.Throw(() => ConditionJson.Parse("""{"field":"a","equals":1,"in":[1]}"""))
+ .Message.ShouldContain("exactly one");
+ Should.Throw(() => ConditionJson.Parse("[]"));
+ }
+
+ [Fact]
+ public void AnEnumValueMatchesItsCamelCaseName()
+ {
+ ConditionEvaluator.Evaluate(Video, Values(("category", ArticleCategory.Video))).ShouldBeTrue();
+ ConditionEvaluator.Evaluate(Video, Values(("category", "video"))).ShouldBeTrue();
+ ConditionEvaluator.Evaluate(Video, Values(("category", ArticleCategory.News))).ShouldBeFalse();
+ }
+
+ [Fact]
+ public void StringsAreComparedOrdinally()
+ {
+ ConditionEvaluator.Evaluate(Condition.Field("a").Equals("x"), Values(("a", "X"))).ShouldBeFalse();
+ }
+
+ [Fact]
+ public void NumbersAreComparedByValueAcrossTypes()
+ {
+ var five = Condition.Field("n").Equals(5);
+
+ foreach (object value in new object[] { 5, 5L, 5m, 5.0m, (short)5, 5.0 })
+ {
+ ConditionEvaluator.Evaluate(five, Values(("n", value))).ShouldBeTrue(value.GetType().Name);
+ }
+
+ ConditionEvaluator.Evaluate(five, Values(("n", 6))).ShouldBeFalse();
+ ConditionEvaluator.Evaluate(Condition.Field("n").Equals(2.5m), Values(("n", 2.5))).ShouldBeTrue();
+ ConditionEvaluator.Evaluate(five, Values(("n", "5"))).ShouldBeFalse();
+ }
+
+ [Fact]
+ public void AnUnknownFieldIsNull()
+ {
+ var values = Values();
+
+ ConditionEvaluator.Evaluate(Condition.Field("missing").Equals(null), values).ShouldBeTrue();
+ ConditionEvaluator.Evaluate(Condition.Field("missing").IsEmpty(), values).ShouldBeTrue();
+ ConditionEvaluator.Evaluate(Condition.Field("missing").Equals("x"), values).ShouldBeFalse();
+ ConditionEvaluator.Evaluate(Condition.Field("missing").In("x", null), values).ShouldBeTrue();
+ }
+
+ [Fact]
+ public void AMultiSelectEqualsAValueItContains()
+ {
+ var values = Values(("labels", new[] { "a", "b" }));
+
+ ConditionEvaluator.Evaluate(Condition.Field("labels").Equals("b"), values).ShouldBeTrue();
+ ConditionEvaluator.Evaluate(Condition.Field("labels").Equals("c"), values).ShouldBeFalse();
+ ConditionEvaluator.Evaluate(Condition.Field("labels").In("c", "a"), values).ShouldBeTrue();
+ ConditionEvaluator.Evaluate(Condition.Field("labels").Equals(null), Values(("labels", Array.Empty()))).ShouldBeTrue();
+ }
+
+ [Fact]
+ public void AndOrAndNotCombineTheirOperands()
+ {
+ var values = Values(("a", 1));
+ var holds = Condition.Field("a").Equals(1);
+ var fails = Condition.Field("a").Equals(2);
+
+ ConditionEvaluator.Evaluate(holds.And(holds), values).ShouldBeTrue();
+ ConditionEvaluator.Evaluate(holds.And(fails), values).ShouldBeFalse();
+ ConditionEvaluator.Evaluate(fails.Or(holds), values).ShouldBeTrue();
+ ConditionEvaluator.Evaluate(fails.Or(fails), values).ShouldBeFalse();
+ ConditionEvaluator.Evaluate(fails.Not(), values).ShouldBeTrue();
+ }
+
+ public static TheoryData IsEmptyMatrix => new()
+ {
+ { "null", null, true },
+ { "empty string", "", true },
+ { "whitespace", " \t", true },
+ { "empty array", Array.Empty(), true },
+ { "empty list", new List(), true },
+ { "empty block list", new BlockList(), true },
+ { "empty ref list", new RefList(), true },
+ { "empty media list", new MediaRefList(), true },
+ { "default media", default(MediaRef), true },
+ { "default ref", default(Ref), true },
+ { "empty guid", Guid.Empty, true },
+ { "text", "x", false },
+ { "zero", 0, false },
+ { "false", false, false },
+ { "list", new[] { "a" }, false },
+ { "block list", new BlockList([new HeroBlock()]), false },
+ { "ref list", new RefList([new Ref(Guid.NewGuid())]), false },
+ { "ref", new Ref(Guid.NewGuid()), false },
+ { "media", new MediaRef(Guid.NewGuid()), false },
+ { "enum", ArticleCategory.News, false },
+ };
+
+ [Theory]
+ [MemberData(nameof(IsEmptyMatrix))]
+ public void IsEmptyFollowsTheEmptinessRules(string name, object? value, bool expected)
+ {
+ ConditionEvaluator.Evaluate(Condition.Field("f").IsEmpty(), Values(("f", value))).ShouldBe(expected, name);
+ }
+}
diff --git a/tests/FluentCMS.Core.Tests/Content/Validation/CustomValidatorTests.cs b/tests/FluentCMS.Core.Tests/Content/Validation/CustomValidatorTests.cs
new file mode 100644
index 000000000..5fb04de58
--- /dev/null
+++ b/tests/FluentCMS.Core.Tests/Content/Validation/CustomValidatorTests.cs
@@ -0,0 +1,316 @@
+using FluentCMS.Content;
+using FluentCMS.Core.Tests.Schema.Samples;
+using FluentCMS.Schema;
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Xunit;
+
+namespace FluentCMS.Core.Tests.Content.Validation;
+
+public class CustomValidatorTests
+{
+ private sealed class Seen
+ {
+ public List<(string? Field, string Path, object? Value, ValidationContext Context)> Fields { get; } = [];
+
+ public List<(Article Entry, ValidationContext Context)> Entries { get; } = [];
+ }
+
+ private sealed class TitleValidator(Seen seen) : IFieldValidator
+ {
+ public ValueTask ValidateAsync(string? value, ValidationContext context, CancellationToken cancellationToken)
+ {
+ seen.Fields.Add((context.Field?.Name, context.Path, value, context));
+ if (context.Field?.Name == "title" && value == "Forbidden")
+ {
+ context.AddError("ACME0001", "That title is taken.");
+ }
+
+ return ValueTask.CompletedTask;
+ }
+ }
+
+ private sealed class AnyFieldValidator(Seen seen) : IFieldValidator