Added wrapper EF collations, collation checks, and provider comparers.

Author: Timovzl

DomainModeling.Generator/Configurators/EntityFrameworkConfigurationGenerator.cs

@@ -0,0 +1,38 @@
+using Microsoft.Extensions.Logging;
+
+namespace Architect.DomainModeling.Tests.Common;
+
+public sealed class CapturingLoggerProvider : ILoggerProvider
+{
+	public IReadOnlyList<string> Logs => this._logs;
+	private readonly List<string> _logs = [];
+
+	public ILogger CreateLogger(string categoryName)
+	{
+		return new CapturingLogger(this._logs);
+	}
+
+	public void Dispose()
+	{
+	}
+
+	public sealed class CapturingLogger(
+		List<string> logs)
+		: ILogger
+	{
+		public IDisposable? BeginScope<TState>(TState state) where TState : notnull
+		{
+			return null;
+		}
+
+		public bool IsEnabled(LogLevel logLevel)
+		{
+			return true;
+		}
+
+		public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+		{
+			logs.Add($"[{logLevel}] {formatter(state, exception)}");
+		}
+	}
+}

DomainModeling.Tests/Common/CapturingLoggerProvider.cs

@@ -1,8 +1,12 @@
+using System.Diagnostics.CodeAnalysis;
+using Architect.DomainModeling.Configuration;
 using Architect.DomainModeling.Conversions;
+using Architect.DomainModeling.Tests.Common;
 using Architect.DomainModeling.Tests.IdentityTestTypes;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Conventions;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Microsoft.Extensions.Logging;
 using Xunit;
 
 namespace Architect.DomainModeling.Tests.EntityFramework;
@@ -11,12 +15,20 @@ public sealed class EntityFrameworkConfigurationGeneratorTests : IDisposable
 {
 	internal static bool AllowParameterizedConstructors = true;
 
+	private ILoggerFactory LoggerFactory { get; }
+	private CapturingLoggerProvider CapturingLoggerProvider { get; }
+
 	private string UniqueName { get; } = Guid.NewGuid().ToString("N");
 	private TestDbContext DbContext { get; }
 
 	public EntityFrameworkConfigurationGeneratorTests()
 	{
-		this.DbContext = new TestDbContext($"DataSource={this.UniqueName};Mode=Memory;Cache=Shared;");
+		this.CapturingLoggerProvider = new CapturingLoggerProvider();
+		this.LoggerFactory = Microsoft.Extensions.Logging.LoggerFactory.Create(options => options
+			.SetMinimumLevel(LogLevel.Debug)
+			.AddProvider(this.CapturingLoggerProvider));
+
+		this.DbContext = new TestDbContext($"DataSource={this.UniqueName};Mode=Memory;Cache=Shared;", this.LoggerFactory);
 		this.DbContext.Database.OpenConnection();
 	}
 
@@ -61,7 +73,7 @@ public void ConfigureConventions_WithAllExtensionsCalled_ShouldBeAbleToWorkWithA
 
 		Assert.Equal(2, reloadedDomainEvent.Id);
 
-		Assert.Equal(2, reloadedEntity.Id.Value);
+		Assert.Equal("A", reloadedEntity.Id.Value);
 		Assert.Equal("One", reloadedEntity.Values.One);
 		Assert.Equal(2m, reloadedEntity.Values.Two);
 		Assert.Equal(3, reloadedEntity.Values.Three.Value?.Value.Value);
@@ -76,13 +88,32 @@ public void ConfigureConventions_WithAllExtensionsCalled_ShouldBeAbleToWorkWithA
 		var providerClrTypeForStringWrapperWithCustomIntCore = mappingForStringWithCustomIntCore?.GetValueConverter()?.ProviderClrType;
 		Assert.Equal("INTEGER", columnTypeForStringWrapperWithCustomIntCore);
 		Assert.Equal(typeof(int), providerClrTypeForStringWrapperWithCustomIntCore);
+
+		// Case-sensitivity should be honored, even during key comparisons
+		Assert.Same(reloadedEntity, this.DbContext.Set<EntityForEF>().Find(new EntityForEFId("a")));
+
+		// The database's collation should have been made ignore-case by our ConfigureIdentityConventions() options
+		Assert.Same(reloadedEntity, this.DbContext.Set<EntityForEF>().SingleOrDefault(x => x.Id == "a"));
+
+		// The logs should warn that Wrapper1ForEF has a mismatching collation in the database
+		var logs = this.CapturingLoggerProvider.Logs;
+		var warning = Assert.Single(logs, log => log.StartsWith("[Warning]"));
+		Assert.Equal("[Warning] Architect.DomainModeling.Tests.EntityFramework.ValueObjectForEF.One uses OrdinalIgnoreCase comparisons, but the default SQLite database collation acts more like Ordinal - use the options in ConfigureIdentityConventions() and ConfigureWrapperValueObjectConventions() to specify default collations, or configure property collations manually", warning);
+
+		// The logs should show that certain collations were set
+		Assert.Contains(logs, log => log.Equals("[Debug] Set collation BINARY for SomeStringId properties based on the type's case-sensitivity"));
+		Assert.Contains(logs, log => log.Equals("[Debug] Set collation NOCASE for EntityForEFId properties based on the type's case-sensitivity"));
 	}
 }
 
 internal sealed class TestDbContext(
-	string connectionString)
-	: DbContext(new DbContextOptionsBuilder<TestDbContext>().UseSqlite(connectionString).Options)
+	string connectionString, ILoggerFactory loggerFactory)
+	: DbContext(new DbContextOptionsBuilder<TestDbContext>()
+		.UseLoggerFactory(loggerFactory)
+		.UseSqlite(connectionString).Options)
 {
+	[SuppressMessage("CodeQuality", "IDE0079:Remove unnecessary suppression", Justification = "Suppression is necessary.")]
+	[SuppressMessage("Usage", "CA2263:Prefer generic overload when type is known", Justification = "We have no generic info for types received from callbacks.")]
 	protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
 	{
 		configurationBuilder.Conventions.Remove<ConstructorBindingConvention>();
@@ -91,17 +122,23 @@ protected override void ConfigureConventions(ModelConfigurationBuilder configura
 
 		configurationBuilder.ConfigureDomainModelConventions(domainModel =>
 		{
-			domainModel.ConfigureIdentityConventions();
+			domainModel.ConfigureIdentityConventions(new IdentityConfigurationOptions() { CaseSensitiveCollation = "BINARY", IgnoreCaseCollation = "NOCASE", });
 			domainModel.ConfigureWrapperValueObjectConventions();
 			domainModel.ConfigureEntityConventions();
 			domainModel.ConfigureDomainEventConventions();
-		});
 
-		// For a wrapper whose core type EF does not support, overwriting the conventions with our own should work
-		configurationBuilder.Properties<LazyStringWrapper>()
-			.HaveConversion<LazyStringWrapperConverter>();
-		configurationBuilder.DefaultTypeMapping<LazyStringWrapper>()
-			.HasConversion<LazyStringWrapperConverter>();
+			domainModel.CustomizeWrapperValueObjectConventions(context =>
+			{
+				// For a wrapper whose core type EF does not support, overwriting the conventions with our own should work
+				if (context.CoreType == typeof(Lazy<string>))
+				{
+					context.ConfigurationBuilder.Properties(context.ModelType)
+						.HaveConversion(typeof(LazyStringWrapperConverter));
+					context.ConfigurationBuilder.DefaultTypeMapping(context.ModelType)
+						.HasConversion(typeof(LazyStringWrapperConverter));
+				}
+			});
+		});
 	}
 
 	private class LazyStringWrapperConverter : ValueConverter<LazyStringWrapper, string>
@@ -168,8 +205,14 @@ public DomainEventForEF(DomainEventForEFId id, object ignored)
 [IdentityValueObject<decimal>]
 public readonly partial record struct DomainEventForEFId;
 
+[IdentityValueObject<string>]
+public partial record struct EntityForEFId
+{
+	private StringComparison StringComparison => StringComparison.OrdinalIgnoreCase;
+}
+
 [Entity]
-internal sealed class EntityForEF : Entity<EntityForEFId, int>
+internal sealed class EntityForEF : Entity<EntityForEFId>
 {
 	/// <summary>
 	/// This lets us test if a constructor is used or not.
@@ -179,7 +222,7 @@ internal sealed class EntityForEF : Entity<EntityForEFId, int>
 	public ValueObjectForEF Values { get; }
 
 	public EntityForEF(ValueObjectForEF values)
-		: base(id: 2)
+		: base(id: "A")
 	{
 		if (!EntityFrameworkConfigurationGeneratorTests.AllowParameterizedConstructors)
 			throw new InvalidOperationException("Deserialization was not allowed to use the parameterized constructors.");
@@ -200,7 +243,7 @@ private EntityForEF()
 [WrapperValueObject<string>]
 internal sealed partial class Wrapper1ForEF
 {
-	protected override StringComparison StringComparison => StringComparison.Ordinal;
+	protected override StringComparison StringComparison => StringComparison.OrdinalIgnoreCase;
 
 	/// <summary>
 	/// This lets us test if a constructor is used or not.

DomainModeling.Tests/EntityFramework/EntityFrameworkConfigurationGeneratorTests.cs

@@ -1,5 +1,4 @@
 using System.Diagnostics.CodeAnalysis;
-using Architect.DomainModeling.Conversions;
 
 namespace Architect.DomainModeling.Configuration;
 

DomainModeling/Configuration/IIdentityConfigurator.cs

@@ -1,5 +1,4 @@
 using System.Diagnostics.CodeAnalysis;
-using Architect.DomainModeling.Conversions;
 
 namespace Architect.DomainModeling.Configuration;
 

DomainModeling/Configuration/IWrapperValueObjectConfigurator.cs

@@ -0,0 +1,5 @@
+namespace Architect.DomainModeling.Configuration;
+
+public record class IdentityConfigurationOptions : ValueWrapperConfigurationOptions
+{
+}

DomainModeling/Configuration/IdentityConfigurationOptions.cs

@@ -0,0 +1,27 @@
+namespace Architect.DomainModeling.Configuration;
+
+/// <summary>
+/// Base options for value wrappers, used by both <see cref="IdentityConfigurationOptions"/> and <see cref="WrapperValueObjectConfigurationOptions"/>.
+/// </summary>
+public abstract record class ValueWrapperConfigurationOptions
+{
+	/// <summary>
+	/// <para>
+	/// If specified, this collation is set on configured <see langword="string"/> <see cref="IIdentity{T}"/> types that use <see cref="StringComparison.Ordinal"/>.
+	/// </para>
+	/// <para>
+	/// This helps the database column match the model's behavior.
+	/// </para>
+	/// </summary>
+	public string? CaseSensitiveCollation { get; init; }
+
+	/// <summary>
+	/// <para>
+	/// If specified, this collation is set on configured <see langword="string"/> <see cref="IIdentity{T}"/> types that use <see cref="StringComparison.OrdinalIgnoreCase"/>.
+	/// </para>
+	/// <para>
+	/// This helps the database column match the model's behavior.
+	/// </para>
+	/// </summary>
+	public string? IgnoreCaseCollation { get; init; }
+}

DomainModeling/Configuration/ValueWrapperConfigurationOptions.cs

@@ -0,0 +1,5 @@
+namespace Architect.DomainModeling.Configuration;
+
+public record class WrapperValueObjectConfigurationOptions : ValueWrapperConfigurationOptions
+{
+}

DomainModeling/Configuration/WrapperValueObjectConfigurationOptions.cs

@@ -37,15 +37,19 @@ Release notes:
 Platform support:
 - BREAKING: Platform support: Dropped support for .NET 6.0 and .NET 7.0 (EOL).
 
-The base class is dead. Long live the interface!
-
 Completed support for nested wrappers:
 - Feature: Nested WrapperValueObject/Identity types can now also wrap/unwrap and serialize/deserialize directly to/from their core (deepest) underlying type.
 - Feature: EF conversions for such types now automatically map to and from the core type.
 - Feature: A deeper underlying type can be simulated, e.g. LazyStringId : IIdentity<Lazy<string>>, ICoreValueWrapper<LazyStringId, string>.
 - BREAKING: ISerializableDomainObject is deprecated in favor of IValueWrapper, a clear and comprehensive type to represented generic value wrappers.
 - BREAKING: IIdentityConfigurator and IWrapperValueObjectConfigurator now receive an additional type parameter on their methods, namely the core type.
 
+Correct string comparisons with EF:
+- Feature: ConfigureIdentityConventions()/ConfigureWrapperValueObjectConventions() now set a PROVIDER value comparer for each string wrapper property, matching the type's case-sensitivity. Since EF Core 7, EF compares keys using the provider type instead of the model type.
+- Feature: ConfigureIdentityConventions()/ConfigureWrapperValueObjectConventions() now warn if a string wrapper property has a collation mismatching the type's case-sensitivity, unless collation was explicitly chosen.
+- Feature: ConfigureIdentityConventions()/ConfigureWrapperValueObjectConventions() now take an optional "options" parameter, which allows specifying the respective collations for case-sensitive vs. ignore-case string wrappers.
+- Feature: ConfigureDomainModelConventions() now has convenience extension methods CustomizeIdentityConventions()/CustomizeWrapperValueObjectConventions(), for easy custom conventions, such as based on the core underlying type.
+
 Performance:
 - Enhancement: Reduced assembly size by having source-generated WrapperValueObject/Identity types use generic JSON serializers instead of generating their own.
 - Enhancement: Improved source generator performance.

DomainModeling/DomainModeling.csproj

@@ -371,27 +371,53 @@ internal sealed class MyDbContext : DbContext
 {
 	// Snip
 
+	[SuppressMessage("CodeQuality", "IDE0079:Remove unnecessary suppression", Justification = "Suppression is necessary.")]
+	[SuppressMessage("Usage", "CA2263:Prefer generic overload when type is known", Justification = "We have no generic info for types received from callbacks.")]
 	protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
 	{
 		// Recommended to keep EF from throwing if it sees no usable constructor, if we are keeping it from using constructors anyway
 		configurationBuilder.Conventions.Remove<ConstructorBindingConvention>();
 
 		configurationBuilder.ConfigureDomainModelConventions(domainModel =>
 		{
+			// Defaults
 			domainModel.ConfigureIdentityConventions();
 			domainModel.ConfigureWrapperValueObjectConventions();
 			domainModel.ConfigureEntityConventions();
 			domainModel.ConfigureDomainEventConventions();
+
+			domainModel.CustomizeIdentityConventions(context =>
+			{
+				// Example: Use fixed-length strings with a binary collation for all string IIdentities
+				if (context.CoreType == typeof(string))
+				{
+					context.ConfigurationBuilder.Properties(context.ModelType)
+						.HaveMaxLength(16)
+						.AreFixedLength()
+						.UseCollation("Latin1_General_100_BIN2");
+				}
+			});
+
+			domainModel.CustomizeWrapperValueObjectConventions(context =>
+			{
+				// Example: Use DECIMAL(19, 9) for all decimal wrappers
+				if (context.CoreType == typeof(decimal))
+				{
+					context.ConfigurationBuilder.Properties(context.ModelType)
+						.HavePrecision(19, 9);
+				}
+			});
 		});
 	}
 }
 ```
 
 `ConfigureDomainModelConventions()` itself does not have any effect other than to invoke its action, which allows the specific mapping kinds to be chosen.
 The inner calls, such as to `ConfigureIdentityConventions()`, configure the various conventions.
+The `Customize*()` methods make it easy to specify your own conventions, such as for every identity or wrapper value object with a string at its core.
 
 Thanks to the provided conventions, no manual boilerplate mappings are needed, like conversions to primitives.
-The developer need only write meaningful mappings, such as the maximum length of a string property.
+Property-specific mappings are only needed where they are meaningful, such as the maximum length of a particular string property.
 
 Since only conventions are registered, regular mappings can override any part of the provided behavior.