feat: ✨ Allow collections and json columns to be mapped

Author: erlendellefsen

JsonApiToolkit.Tests/Mapping/JsonColumnMappingTests.cs

@@ -0,0 +1,133 @@
+using JsonApiToolkit.Mapping;
+using JsonApiToolkit.Models.Resources;
+
+namespace JsonApiToolkit.Tests.Mapping;
+
+public class JsonColumnMappingTests
+{
+    public class EntityWithJsonColumns
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = string.Empty;
+
+        // These collections have no ID properties, simulating EF Core owned entities stored as JSON
+        public List<JsonData> JsonDataList { get; set; } = new();
+        public ICollection<ExploitationReport> ExploitationReports { get; set; } =
+            new List<ExploitationReport>();
+
+        // This has an ID property, so should be a relationship
+        public List<RelatedEntity> RelatedEntities { get; set; } = new();
+    }
+
+    public class JsonData
+    {
+        public string Type { get; set; } = string.Empty;
+        public string Value { get; set; } = string.Empty;
+        public DateTime Timestamp { get; set; }
+        // No Id property - this is owned entity stored as JSON
+    }
+
+    public class ExploitationReport
+    {
+        public string Description { get; set; } = string.Empty;
+        public string Severity { get; set; } = string.Empty;
+        // No Id property - this is owned entity stored as JSON
+    }
+
+    public class RelatedEntity
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = string.Empty;
+    }
+
+    [Fact]
+    public void GetAttributeProperties_IncludesJsonColumns()
+    {
+        // Arrange
+        Type entityType = typeof(EntityWithJsonColumns);
+
+        // Act
+        var attributeProperties = EntityMapper.GetAttributeProperties(entityType);
+        var attributeNames = attributeProperties.Select(p => p.Name).ToList();
+
+        // Assert
+        Assert.Contains("Name", attributeNames);
+        Assert.Contains("JsonDataList", attributeNames); // Should be included as attribute (no IDs)
+        Assert.Contains("ExploitationReports", attributeNames); // Should be included as attribute (no IDs)
+        Assert.DoesNotContain("RelatedEntities", attributeNames); // Should NOT be attribute (has IDs)
+    }
+
+    [Fact]
+    public void GetRelationshipProperties_ExcludesJsonColumns()
+    {
+        // Arrange
+        Type entityType = typeof(EntityWithJsonColumns);
+
+        // Act
+        var relationshipProperties = EntityMapper.GetRelationshipProperties(entityType);
+        var relationshipNames = relationshipProperties.Select(p => p.Name).ToList();
+
+        // Assert
+        Assert.DoesNotContain("JsonDataList", relationshipNames); // Should NOT be relationship (no IDs)
+        Assert.DoesNotContain("ExploitationReports", relationshipNames); // Should NOT be relationship (no IDs)
+        Assert.Contains("RelatedEntities", relationshipNames); // Should be relationship (has IDs)
+    }
+
+    [Fact]
+    public void ToResourceObject_MapsJsonColumnsAsAttributes()
+    {
+        // Arrange
+        var entity = new EntityWithJsonColumns
+        {
+            Id = 1,
+            Name = "Test Entity",
+            JsonDataList = new List<JsonData>
+            {
+                new()
+                {
+                    Type = "warning",
+                    Value = "test warning",
+                    Timestamp = DateTime.Now,
+                },
+                new()
+                {
+                    Type = "error",
+                    Value = "test error",
+                    Timestamp = DateTime.Now,
+                },
+            },
+            ExploitationReports = new List<ExploitationReport>
+            {
+                new() { Description = "CVE-2024-1234", Severity = "High" },
+            },
+            RelatedEntities = new List<RelatedEntity>
+            {
+                new() { Id = 10, Name = "Related 1" },
+            },
+        };
+
+        // Act
+        ResourceObject resource = JsonApiMapper.ToResourceObject(entity, "entityWithJsonColumns");
+
+        // Assert
+        Assert.NotNull(resource.Attributes);
+        Assert.Equal("Test Entity", resource.Attributes["name"]);
+
+        // JSON columns should be in attributes
+        Assert.True(resource.Attributes.ContainsKey("jsonDataList"));
+        Assert.True(resource.Attributes.ContainsKey("exploitationReports"));
+
+        // Verify the JSON data is preserved
+        var jsonDataList = resource.Attributes["jsonDataList"] as List<JsonData>;
+        Assert.NotNull(jsonDataList);
+        Assert.Equal(2, jsonDataList.Count);
+
+        var exploitationReports =
+            resource.Attributes["exploitationReports"] as ICollection<ExploitationReport>;
+        Assert.NotNull(exploitationReports);
+        Assert.Single(exploitationReports);
+
+        // RelatedEntities should NOT be in attributes (it's a relationship)
+        Assert.False(resource.Attributes.ContainsKey("relatedEntities"));
+    }
+}

JsonApiToolkit/Mapping/EntityMapper.cs

@@ -56,7 +56,6 @@ private static readonly ConcurrentDictionary<
         );
     }
 
-
     /// <summary>
     /// Identifies the properties that should be mapped as attributes in a JSON:API resource object.
     /// </summary>
@@ -93,16 +92,9 @@ public static List<PropertyInfo> GetAttributeProperties(Type type)
                 return t.GetProperties()
                     .Where(p =>
                         p != idProperty // Exclude only the primary ID
-                        && !relationshipNames.Contains(p.Name)
+                        && !relationshipNames.Contains(p.Name) // Exclude properties identified as relationships
                         && p.CanRead
                         && p.GetMethod?.IsPublic == true
-                        && (
-                            p.PropertyType == typeof(string)
-                            || (
-                                !typeof(IEnumerable).IsAssignableFrom(p.PropertyType)
-                                || p.PropertyType == typeof(string)
-                            )
-                        )
                     )
                     .ToList();
             }
@@ -126,6 +118,7 @@ public static List<PropertyInfo> GetAttributeProperties(Type type)
     /// </item>
     /// </list>
     /// <para>Excludes common value types like string, DateTime, and Guid.</para>
+    /// <para>Collections of entities without ID properties (e.g., EF Core owned entities stored as JSON) are excluded and treated as attributes instead.</para>
     /// </remarks>
     public static List<PropertyInfo> GetRelationshipProperties(Type type)
     {
@@ -141,6 +134,7 @@ public static List<PropertyInfo> GetRelationshipProperties(Type type)
                             (
                                 typeof(IEnumerable).IsAssignableFrom(p.PropertyType)
                                 && p.PropertyType != typeof(string)
+                                && HasIdProperty(GetCollectionElementType(p.PropertyType)) // Only include collections where items have IDs
                             )
                             || (
                                 !p.PropertyType.IsPrimitive
@@ -150,6 +144,7 @@ public static List<PropertyInfo> GetRelationshipProperties(Type type)
                                 && p.PropertyType != typeof(DateTime?)
                                 && p.PropertyType != typeof(Guid)
                                 && p.PropertyType != typeof(Guid?)
+                                && !typeof(IEnumerable).IsAssignableFrom(p.PropertyType) // Exclude collections from complex object relationships
                             )
                         )
                     )
@@ -172,4 +167,55 @@ public static string GetResourceType(Type type)
         string name = type.Name;
         return name.ToCamelCase();
     }
+
+    /// <summary>
+    /// Checks if a type has an ID property.
+    /// </summary>
+    /// <param name="type">The type to check</param>
+    /// <returns>True if the type has an ID property, false otherwise</returns>
+    private static bool HasIdProperty(Type? type)
+    {
+        if (type == null)
+            return false;
+        return GetIdProperty(type) != null;
+    }
+
+    /// <summary>
+    /// Gets the element type of a collection.
+    /// </summary>
+    /// <param name="collectionType">The collection type</param>
+    /// <returns>The element type, or null if not a collection</returns>
+    private static Type? GetCollectionElementType(Type collectionType)
+    {
+        // String is not considered a collection for our purposes
+        if (collectionType == typeof(string))
+        {
+            return null;
+        }
+
+        // Check if it's a generic collection
+        if (collectionType.IsGenericType)
+        {
+            Type[] genericArgs = collectionType.GetGenericArguments();
+            if (genericArgs.Length == 1)
+            {
+                return genericArgs[0];
+            }
+        }
+
+        // Check if it implements IEnumerable<T>
+        Type? enumerable = collectionType
+            .GetInterfaces()
+            .FirstOrDefault(i =>
+                i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>)
+            );
+
+        if (enumerable != null)
+        {
+            return enumerable.GetGenericArguments()[0];
+        }
+
+        // For non-generic collections, we can't determine the element type
+        return null;
+    }
 }