Adds an overload for AddValueObjectConverters with ComplexPropertyBuilder

Author: PawelGerr

src/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Sources/Extensions/EntityTypeBuilderExtensions.cs

@@ -129,6 +129,60 @@ public static OwnedNavigationBuilder AddValueObjectConverters(
       return entityTypeBuilder;
    }
 
+#if COMPLEX_TYPES
+
+   /// <summary>
+   /// Adds value converter to all properties that are Smart Enums or keyed Value Objects.
+   /// Properties with a value provider are skipped.
+   /// </summary>
+   /// <param name="complexPropertyBuilder">The complex property builder.</param>
+   /// <param name="validateOnWrite">In case of a validatable Smart Enum, ensures that the item is valid before writing it to database.</param>
+   /// <param name="useConstructorForRead">For keyed value objects only. Use the constructor instead of the factory method when reading the data from database.</param>
+   /// <param name="configureEnumsAndKeyedValueObjects">Action for further configuration of the property.</param>
+   /// <returns>The entity type builder for method chaining.</returns>
+   public static ComplexPropertyBuilder<TComplex> AddValueObjectConverters<TComplex>(
+      this ComplexPropertyBuilder<TComplex> complexPropertyBuilder,
+      bool validateOnWrite,
+      bool useConstructorForRead = true,
+      Action<IMutableProperty>? configureEnumsAndKeyedValueObjects = null)
+      where TComplex : class
+   {
+      ((ComplexPropertyBuilder)complexPropertyBuilder).AddValueObjectConverters(
+         validateOnWrite,
+         useConstructorForRead,
+         configureEnumsAndKeyedValueObjects);
+
+      return complexPropertyBuilder;
+   }
+
+   /// <summary>
+   /// Adds value converter to all properties that are Smart Enums or keyed Value Objects.
+   /// Properties with a value provider are skipped.
+   /// </summary>
+   /// <param name="complexPropertyBuilder">The complex property builder.</param>
+   /// <param name="validateOnWrite">In case of a validatable Smart Enum, ensures that the item is valid before writing it to database.</param>
+   /// <param name="useConstructorForRead">For keyed value objects only. Use the constructor instead of the factory method when reading the data from database.</param>
+   /// <param name="configureEnumsAndKeyedValueObjects">Action for further configuration of the property.</param>
+   /// <returns>The entity type builder for method chaining.</returns>
+   public static ComplexPropertyBuilder AddValueObjectConverters(
+      this ComplexPropertyBuilder complexPropertyBuilder,
+      bool validateOnWrite,
+      bool useConstructorForRead = true,
+      Action<IMutableProperty>? configureEnumsAndKeyedValueObjects = null)
+   {
+      configureEnumsAndKeyedValueObjects ??= Empty.Action;
+
+      AddConvertersForComplexProperty(
+         complexPropertyBuilder.Metadata,
+         validateOnWrite,
+         useConstructorForRead,
+         null, // Cache for a single entity will be more of a drawback
+         configureEnumsAndKeyedValueObjects);
+
+      return complexPropertyBuilder;
+   }
+#endif
+
    internal static void AddConvertersToEntity(
       this IMutableEntityType entity,
       bool validateOnWrite,
@@ -330,13 +384,23 @@ private static void AddConverterForComplexProperties(
    {
       foreach (var complexProperty in entity.GetComplexProperties())
       {
-         AddSmartEnumAndKeyedValueObjects(complexProperty.ComplexType, validateOnWrite, useConstructorForRead, converterLookup, configureEnumsAndKeyedValueObjects);
-         AddNonKeyedValueObjectMembers(complexProperty.ComplexType);
-
-         AddConverterForScalarProperties(complexProperty.ComplexType, validateOnWrite, useConstructorForRead, converterLookup, configureEnumsAndKeyedValueObjects);
-         AddConverterForComplexProperties(complexProperty.ComplexType, validateOnWrite, useConstructorForRead, converterLookup, configureEnumsAndKeyedValueObjects);
+         AddConvertersForComplexProperty(complexProperty, validateOnWrite, useConstructorForRead, converterLookup, configureEnumsAndKeyedValueObjects);
       }
    }
+
+   private static void AddConvertersForComplexProperty(
+      IMutableComplexProperty complexProperty,
+      bool validateOnWrite,
+      bool useConstructorForRead,
+      Dictionary<Type, ValueConverter>? converterLookup,
+      Action<IMutableProperty> configureEnumsAndKeyedValueObjects)
+   {
+      AddSmartEnumAndKeyedValueObjects(complexProperty.ComplexType, validateOnWrite, useConstructorForRead, converterLookup, configureEnumsAndKeyedValueObjects);
+      AddNonKeyedValueObjectMembers(complexProperty.ComplexType);
+
+      AddConverterForScalarProperties(complexProperty.ComplexType, validateOnWrite, useConstructorForRead, converterLookup, configureEnumsAndKeyedValueObjects);
+      AddConverterForComplexProperties(complexProperty.ComplexType, validateOnWrite, useConstructorForRead, converterLookup, configureEnumsAndKeyedValueObjects);
+   }
 #endif
 
    private static PropertyBuilder FindPropertyBuilder((EntityTypeBuilder?, OwnedNavigationBuilder?) builders, IMutableEntityType entityType, string propertyName)

test/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Tests.Sources/Extensions/EntityTypeBuilderExtensionsTests/AddValueObjectConverters.cs

@@ -46,6 +46,19 @@ public void Should_add_converters_for_complex_types()
 
          ValidateConverter(complexProperty.ComplexType, nameof(TestComplexType.TestEnum));
       }
+
+      [Fact]
+      public void Should_add_converters_for_complex_types_inside_complex_type_configuration()
+      {
+         using var ctx = new TestDbContext(
+            new DbContextOptionsBuilder<TestDbContext>().UseSqlite("DataSource=:memory:").Options,
+            ValueConverterRegistration.ComplexTypeConfiguration);
+
+         var entityType = ctx.Model.FindEntityType(typeof(TestEntityWithComplexType)) ?? throw new Exception("Entity not found");
+         var complexProperty = entityType.FindComplexProperty(nameof(TestEntityWithComplexType.TestComplexType)) ?? throw new Exception("Complex type property not found");
+
+         ValidateConverter(complexProperty.ComplexType, nameof(TestComplexType.TestEnum));
+      }
 #endif
 
       [Fact]

test/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Tests.Sources/TestEntities/TestDbContext.cs

@@ -33,17 +33,13 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
       base.OnModelCreating(modelBuilder);
 
-      TestEntity_with_OwnedTypes.Configure(
-         modelBuilder,
-         _valueConverterRegistration == ValueConverterRegistration.EntityConfiguration);
-      TestEntity_with_Enum_and_ValueObjects.Configure(
-         modelBuilder,
-         _valueConverterRegistration == ValueConverterRegistration.EntityConfiguration);
+      var configureOnEntityTypeLevel = _valueConverterRegistration is ValueConverterRegistration.EntityConfiguration or ValueConverterRegistration.ComplexTypeConfiguration;
+
+      TestEntity_with_OwnedTypes.Configure(modelBuilder, configureOnEntityTypeLevel);
+      TestEntity_with_Enum_and_ValueObjects.Configure(modelBuilder, configureOnEntityTypeLevel);
 
 #if COMPLEX_TYPES
-      TestEntityWithComplexType.Configure(
-         modelBuilder,
-         _valueConverterRegistration == ValueConverterRegistration.EntityConfiguration);
+      TestEntityWithComplexType.Configure(modelBuilder, _valueConverterRegistration);
 #endif
 
       if (_valueConverterRegistration == ValueConverterRegistration.OnModelCreating)

test/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Tests.Sources/TestEntities/TestEntityWithComplexType.cs

@@ -11,7 +11,7 @@ public class TestEntityWithComplexType
 
    public static void Configure(
       ModelBuilder modelBuilder,
-      bool registerValueConverters)
+      ValueConverterRegistration valueConverterRegistration)
    {
       modelBuilder.Entity<TestEntityWithComplexType>(builder =>
       {
@@ -20,9 +20,12 @@ public static void Configure(
                                  {
                                     b.IsRequired();
                                     b.Property(t => t.TestEnum);
+
+                                    if (valueConverterRegistration == ValueConverterRegistration.ComplexTypeConfiguration)
+                                       b.AddValueObjectConverters(true);
                                  });
 
-         if (registerValueConverters)
+         if (valueConverterRegistration == ValueConverterRegistration.EntityConfiguration)
             builder.AddValueObjectConverters(true);
       });
    }

test/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Tests.Sources/TestEntities/ValueConverterRegistration.cs

@@ -4,5 +4,6 @@ public enum ValueConverterRegistration
 {
    None,
    OnModelCreating,
-   EntityConfiguration
+   EntityConfiguration,
+   ComplexTypeConfiguration
 }