.Net 10

Author: phongnguyend

src/EntityFrameworkCore.SqlServer.SimpleBulks.Tests/Database/JsonOwnedTypeOrder.cs

@@ -0,0 +1,8 @@
+namespace EntityFrameworkCore.SqlServer.SimpleBulks.Tests.Database;
+
+public class JsonOwnedTypeOrder
+{
+    public int Id { get; set; }
+
+    public OwnedTypeAddress ShippingAddress { get; set; }
+}

src/EntityFrameworkCore.SqlServer.SimpleBulks.Tests/Database/TestDbContext.cs

@@ -23,6 +23,8 @@ public class TestDbContext : DbContext
 
     public DbSet<JsonComplexTypeOrder> JsonComplexTypeOrders { get; set; }
 
+    public DbSet<JsonOwnedTypeOrder> JsonOwnedTypeOrders { get; set; }
+
     public DbSet<Blog> Blogs { get; set; }
 
     public DbSet<RssBlog> RssBlogs { get; set; }
@@ -71,6 +73,16 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
             });
         });
 
+        modelBuilder.Entity<JsonOwnedTypeOrder>().OwnsOne(x => x.ShippingAddress, x =>
+        {
+            x.ToJson();
+            //x.ToJson("xxx").HasColumnType("json");
+            x.OwnsOne(y => y.Location, y =>
+            {
+                y.HasJsonPropertyName("xxx");
+            });
+        });
+
         base.OnModelCreating(modelBuilder);
     }
 }

src/EntityFrameworkCore.SqlServer.SimpleBulks.Tests/DbContextExtensions/GetPropertiesTests.cs

@@ -385,4 +385,91 @@ private static void WriteObject(Utf8JsonWriter writer, object obj, IReadOnlyList
 
         writer.WriteEndObject();
     }
+
+    [Fact]
+    public void GetProperties_JsonOwnedType_ReturnsCorrectColumnInformation()
+    {
+        // Arrange
+        var dbContext = new TestDbContext("", "");
+
+        // Act
+        var properties = dbContext.GetProperties(typeof(JsonOwnedTypeOrder));
+
+        // Assert
+        Assert.Equal(2, properties.Count);
+
+        var property = properties.First(p => p.PropertyName == "Id");
+        Assert.Equal(typeof(int), property.PropertyType);
+        Assert.Equal("Id", property.ColumnName);
+        Assert.Equal("int", property.ColumnType);
+        Assert.Equal(ValueGenerated.OnAdd, property.ValueGenerated);
+        Assert.Null(property.DefaultValueSql);
+        Assert.True(property.IsPrimaryKey);
+        Assert.False(property.IsRowVersion);
+
+        property = properties.First(p => p.PropertyName == "ShippingAddress");
+        Assert.Equal(typeof(OwnedTypeAddress), property.PropertyType);
+        Assert.Equal("ShippingAddress", property.ColumnName);
+        Assert.Equal("nvarchar(max)", property.ColumnType);
+        Assert.Equal(ValueGenerated.Never, property.ValueGenerated);
+        Assert.Null(property.DefaultValueSql);
+        Assert.False(property.IsPrimaryKey);
+        Assert.False(property.IsRowVersion);
+        Assert.True(property.IsJson);
+        Assert.NotNull(property.JsonPropertyWriters);
+
+        // Verify that the JsonPropertyWriters have correct structure
+        var writers = property.JsonPropertyWriters;
+        var flattenedWriters = property.GetFlattenedJsonPropertyWriters();
+        Assert.Equal(3, writers.Count); // Street and Location
+
+        var streetWriter = writers.FirstOrDefault(w => w.ClrPropertyName == "Street");
+        Assert.NotNull(streetWriter);
+        Assert.Equal("Street", streetWriter.JsonPropertyName);
+        Assert.Equal("Street", streetWriter.FullJsonPath);
+        Assert.Equal("Street", streetWriter.FullClrPropertyName);
+        Assert.Equal(typeof(string), streetWriter.PropertyType);
+        Assert.False(streetWriter.IsNestedComplexType);
+
+        var locationWriter = writers.FirstOrDefault(w => w.ClrPropertyName == "Location");
+        Assert.NotNull(locationWriter);
+        Assert.Equal("xxx", locationWriter.JsonPropertyName); // Mapped to "xxx" in TestDbContext
+        Assert.Equal("xxx", locationWriter.FullJsonPath);
+        Assert.Equal("Location", locationWriter.FullClrPropertyName);
+        Assert.Equal(typeof(OwnedTypeLocation), locationWriter.PropertyType);
+        Assert.True(locationWriter.IsNestedComplexType);
+        Assert.NotNull(locationWriter.NestedProperties);
+        Assert.Equal(3, locationWriter.NestedProperties.Count); // Lat and Lng
+
+        var latWriter = locationWriter.NestedProperties.FirstOrDefault(w => w.ClrPropertyName == "Lat");
+        Assert.NotNull(latWriter);
+        Assert.Equal("xxx.Lat", latWriter.FullJsonPath);
+        Assert.Equal("Location.Lat", latWriter.FullClrPropertyName);
+        Assert.Equal(typeof(double), latWriter.PropertyType);
+
+        var lngWriter = locationWriter.NestedProperties.FirstOrDefault(w => w.ClrPropertyName == "Lng");
+        Assert.NotNull(lngWriter);
+        Assert.Equal("xxx.Lng", lngWriter.FullJsonPath);
+        Assert.Equal("Location.Lng", lngWriter.FullClrPropertyName);
+        Assert.Equal(typeof(double), lngWriter.PropertyType);
+
+        // Verify serialization using JsonPropertyWriters
+        var testAddress = new OwnedTypeAddress
+        {
+            Street = "123 Main St",
+            Location = new OwnedTypeLocation
+            {
+                Lat = 40.7128,
+                Lng = -74.0060
+            }
+        };
+
+        var json = SerializeWithJsonPropertyWriters(testAddress, writers);
+        Assert.NotNull(json);
+        Assert.Contains("Street", json);
+        Assert.Contains("123 Main St", json);
+        Assert.Contains("xxx", json); // Location is mapped to "xxx"
+        Assert.Contains("Lat", json);
+        Assert.Contains("Lng", json);
+    }
 }

src/EntityFrameworkCore.SqlServer.SimpleBulks/Extensions/DbContextExtensions.cs

@@ -152,7 +152,8 @@ public static IReadOnlyList<ColumnInfor> GetProperties(this DbContext dbContext,
 
                 if (ownedProperty.TargetEntityType.IsMappedToJson())
                 {
-
+                    // For owned entities mapped to JSON, add the owned navigation itself as a single JSON column
+                    AddJsonOwnedProperty(data, ownedProperty);
                 }
                 else
                 {
@@ -256,6 +257,78 @@ private static List<JsonPropertyWriter> BuildJsonPropertyWriters(IComplexType co
         return writers;
     }
 
+    private static List<JsonPropertyWriter> BuildJsonPropertyWriters(IEntityType entityType, string clrPrefix = "", string jsonPrefix = "")
+    {
+        var writers = new List<JsonPropertyWriter>();
+
+        // Add writers for scalar properties on the owned entity type
+        foreach (var property in entityType.GetProperties())
+        {
+            var jsonPropertyName = property.GetJsonPropertyName() ?? property.Name;
+            var readerWriter = property.GetJsonValueReaderWriter() ?? property.GetTypeMapping().JsonValueReaderWriter;
+
+            writers.Add(new JsonPropertyWriter
+            {
+                JsonPropertyName = jsonPropertyName,
+                ClrPropertyName = property.Name,
+                FullJsonPath = string.IsNullOrEmpty(jsonPrefix) ? jsonPropertyName : $"{jsonPrefix}.{jsonPropertyName}",
+                FullClrPropertyName = string.IsNullOrEmpty(clrPrefix) ? property.Name : $"{clrPrefix}.{property.Name}",
+                PropertyType = property.ClrType,
+                ReaderWriter = readerWriter,
+                NestedProperties = null
+            });
+        }
+
+        var ownedProperties = entityType.GetNavigations().Where(n => n.TargetEntityType.IsOwned());
+
+        // Add writers for complex properties on the owned entity type
+        foreach (var nestedOwnedProperty in ownedProperties)
+        {
+            // For complex properties mapped to JSON inside the owned entity, add a single JSON writer
+            var jsonPropertyName = nestedOwnedProperty.TargetEntityType.GetJsonPropertyName() ?? nestedOwnedProperty.Name;
+            var fullJsonPath = string.IsNullOrEmpty(jsonPrefix) ? jsonPropertyName : $"{jsonPrefix}.{jsonPropertyName}";
+            var fullClrPropertyName = string.IsNullOrEmpty(clrPrefix) ? nestedOwnedProperty.Name : $"{clrPrefix}.{nestedOwnedProperty.Name}";
+
+            var nestedWriters = BuildJsonPropertyWriters(nestedOwnedProperty.TargetEntityType, fullClrPropertyName, fullJsonPath);
+
+            writers.Add(new JsonPropertyWriter
+            {
+                JsonPropertyName = jsonPropertyName,
+                ClrPropertyName = nestedOwnedProperty.Name,
+                FullJsonPath = fullJsonPath,
+                FullClrPropertyName = fullClrPropertyName,
+                PropertyType = nestedOwnedProperty.ClrType,
+                ReaderWriter = null,
+                NestedProperties = nestedWriters
+            });
+        }
+
+        return writers;
+    }
+
+    private static void AddJsonOwnedProperty(List<ColumnInfor> columnInfors, INavigation ownedNavigation)
+    {
+        var containerColumnName = ownedNavigation.TargetEntityType.GetContainerColumnName();
+        var containerColumnType = ownedNavigation.TargetEntityType.GetContainerColumnType() ?? "nvarchar(max)";
+
+        var jsonPropertyWriters = BuildJsonPropertyWriters(ownedNavigation.TargetEntityType);
+
+        columnInfors.Add(new ColumnInfor
+        {
+            PropertyName = ownedNavigation.Name,
+            PropertyType = ownedNavigation.TargetEntityType.ClrType,
+            ColumnName = containerColumnName,
+            ColumnType = containerColumnType,
+            ValueGenerated = ValueGenerated.Never,
+            DefaultValueSql = null,
+            IsPrimaryKey = false,
+            IsRowVersion = false,
+            ValueConverter = null,
+            IsJson = true,
+            JsonPropertyWriters = jsonPropertyWriters
+        });
+    }
+
     private static void AddComplexProperty(List<ColumnInfor> columnInfors, IComplexProperty complexProperty, StoreObjectIdentifier storeObjectIdentifier, string prefix = "")
     {
         var entityProperties = complexProperty.ComplexType.GetProperties();