feat: ✨ Remove IncludeAsAttribute and related logic

Author: erlendellefsen

JsonApiToolkit.Tests/Mapping/EntityMapperTests.cs

@@ -0,0 +1,66 @@
+using JsonApiToolkit.Mapping;
+using JsonApiToolkit.Tests.Models;
+
+namespace JsonApiToolkit.Tests.Mapping;
+
+public class EntityMapperTests
+{
+    [Fact]
+    public void GetAttributeProperties_IncludesForeignKeyIds()
+    {
+        var attributeProperties = EntityMapper.GetAttributeProperties(typeof(TestEntity));
+        var propertyNames = attributeProperties.Select(p => p.Name).ToList();
+
+        // Should include foreign key ID
+        Assert.Contains("RelatedEntityId", propertyNames);
+        
+        // Should NOT include the primary ID
+        Assert.DoesNotContain("Id", propertyNames);
+        
+        // Should include other regular properties
+        Assert.Contains("Name", propertyNames);
+        Assert.Contains("Description", propertyNames);
+        Assert.Contains("CreatedAt", propertyNames);
+        Assert.Contains("IsActive", propertyNames);
+        Assert.Contains("Status", propertyNames);
+    }
+
+    [Fact]
+    public void GetAttributeProperties_ExcludesOnlyPrimaryId()
+    {
+        var attributeProperties = EntityMapper.GetAttributeProperties(typeof(TestChildEntity));
+        var propertyNames = attributeProperties.Select(p => p.Name).ToList();
+
+        // Should include foreign key ID
+        Assert.Contains("TestEntityId", propertyNames);
+        
+        // Should NOT include the primary ID
+        Assert.DoesNotContain("Id", propertyNames);
+        
+        // Should include other properties
+        Assert.Contains("Name", propertyNames);
+    }
+
+    [Fact]
+    public void GetRelationshipProperties_DoesNotIncludeForeignKeyIds()
+    {
+        var relationshipProperties = EntityMapper.GetRelationshipProperties(typeof(TestEntity));
+        var propertyNames = relationshipProperties.Select(p => p.Name).ToList();
+
+        // Should include actual relationships
+        Assert.Contains("RelatedEntity", propertyNames);
+        Assert.Contains("Children", propertyNames);
+        
+        // Should NOT include foreign key IDs
+        Assert.DoesNotContain("RelatedEntityId", propertyNames);
+    }
+
+    [Fact]
+    public void GetIdProperty_IdentifiesPrimaryId()
+    {
+        var idProperty = EntityMapper.GetIdProperty(typeof(TestEntity));
+        
+        Assert.NotNull(idProperty);
+        Assert.Equal("Id", idProperty.Name);
+    }
+}

JsonApiToolkit.Tests/Mapping/JsonApiMapperTests.cs

@@ -31,6 +31,24 @@ public void ToResourceObject_MapsEntityCorrectly()
         Assert.Equal(true, resourceObject.Attributes["isActive"]);
     }
 
+    [Fact]
+    public void ToResourceObject_IncludesForeignKeyIdsInAttributes()
+    {
+        var entity = new TestEntity
+        {
+            Id = 1,
+            Name = "Test Entity",
+            RelatedEntityId = 42,
+        };
+
+        var resourceObject = JsonApiMapper.ToResourceObject(entity, "testEntities");
+
+        // Foreign key IDs should be included in attributes
+        Assert.NotNull(resourceObject.Attributes);
+        Assert.True(resourceObject.Attributes.ContainsKey("relatedEntityId"));
+        Assert.Equal(42, resourceObject.Attributes["relatedEntityId"]);
+    }
+
     [Fact]
     public void ToResourceObject_WithRelationships_MapsRelationshipsCorrectly()
     {

JsonApiToolkit/Mapping/EntityMapper.cs

@@ -56,14 +56,6 @@ private static readonly ConcurrentDictionary<
         );
     }
 
-    /// <summary>
-    /// Tag to be used on Ids that should be included as attributes in a JSON:API resource object.
-    /// </summary>
-    /// <remarks>
-    /// Overrides the default behavior of excluding ID properties from attribute mapping.
-    /// </remarks>
-    [AttributeUsage(AttributeTargets.Property)]
-    public class IncludeAsAttributeAttribute : Attribute;
 
     /// <summary>
     /// Identifies the properties that should be mapped as attributes in a JSON:API resource object.
@@ -74,7 +66,7 @@ public class IncludeAsAttributeAttribute : Attribute;
     /// Uses a cached approach to improve performance over repeated calls. Excludes:
     /// <list type="bullet">
     /// <item>
-    /// <description>Properties used as IDs (ending with "Id" or named "Id")</description>
+    /// <description>The primary ID property (to avoid duplication with the resource's id field)</description>
     /// </item>
     /// <item>
     /// <description>Properties identified as relationships</description>
@@ -86,32 +78,29 @@ public class IncludeAsAttributeAttribute : Attribute;
     /// <description>Collection properties (except strings)</description>
     /// </item>
     /// </list>
-    /// The resulting properties typically represent scalar values of the entity.
+    /// The resulting properties typically represent scalar values of the entity, including foreign key IDs.
     /// </remarks>
     public static List<PropertyInfo> GetAttributeProperties(Type type)
     {
         return s_attributePropertyCache.GetOrAdd(
             type,
             t =>
             {
+                PropertyInfo? idProperty = GetIdProperty(t);
                 List<PropertyInfo> relationshipProps = GetRelationshipProperties(t);
                 var relationshipNames = relationshipProps.Select(p => p.Name).ToHashSet();
 
                 return t.GetProperties()
                     .Where(p =>
-                        p.GetCustomAttribute<IncludeAsAttributeAttribute>() != null
-                        || (
-                            !p.Name.EndsWith("Id")
-                            && p.Name != "Id"
-                            && !relationshipNames.Contains(p.Name)
-                            && p.CanRead
-                            && p.GetMethod?.IsPublic == true
-                            && (
-                                p.PropertyType == typeof(string)
-                                || (
-                                    !typeof(IEnumerable).IsAssignableFrom(p.PropertyType)
-                                    || p.PropertyType == typeof(string)
-                                )
+                        p != idProperty // Exclude only the primary ID
+                        && !relationshipNames.Contains(p.Name)
+                        && p.CanRead
+                        && p.GetMethod?.IsPublic == true
+                        && (
+                            p.PropertyType == typeof(string)
+                            || (
+                                !typeof(IEnumerable).IsAssignableFrom(p.PropertyType)
+                                || p.PropertyType == typeof(string)
                             )
                         )
                     )
@@ -146,24 +135,21 @@ public static List<PropertyInfo> GetRelationshipProperties(Type type)
             {
                 return t.GetProperties()
                     .Where(p =>
-                        p.GetCustomAttribute<IncludeAsAttributeAttribute>() != null
-                        || (
-                            p.CanRead
-                            && p.GetMethod?.IsPublic == true
-                            && (
-                                (
-                                    typeof(IEnumerable).IsAssignableFrom(p.PropertyType)
-                                    && p.PropertyType != typeof(string)
-                                )
-                                || (
-                                    !p.PropertyType.IsPrimitive
-                                    && !p.PropertyType.IsValueType
-                                    && p.PropertyType != typeof(string)
-                                    && p.PropertyType != typeof(DateTime)
-                                    && p.PropertyType != typeof(DateTime?)
-                                    && p.PropertyType != typeof(Guid)
-                                    && p.PropertyType != typeof(Guid?)
-                                )
+                        p.CanRead
+                        && p.GetMethod?.IsPublic == true
+                        && (
+                            (
+                                typeof(IEnumerable).IsAssignableFrom(p.PropertyType)
+                                && p.PropertyType != typeof(string)
+                            )
+                            || (
+                                !p.PropertyType.IsPrimitive
+                                && !p.PropertyType.IsValueType
+                                && p.PropertyType != typeof(string)
+                                && p.PropertyType != typeof(DateTime)
+                                && p.PropertyType != typeof(DateTime?)
+                                && p.PropertyType != typeof(Guid)
+                                && p.PropertyType != typeof(Guid?)
                             )
                         )
                     )

docs/docs/querying.md

@@ -71,32 +71,8 @@ With this request, the toolkit will:
 
 - **Filtering on included resources**: Filters only apply to the main resource type. To filter based on related entity properties, structure your query at the main entity level or use custom controller logic.
 
-## Missing Attributes in JSON:API Responses
+## Attribute Mapping
 
-When using our JSON:API implementation, you might notice that certain properties—such as `CompanyTenantId`—are not included in the API responses. This is because the default attribute mapping logic intentionally excludes any property that ends with "`Id`" (other than the primary `Id`).
-
-### Default Behavior and Rationale
-
-This behavior is deliberate and conforms to JSON:API best practices:
-- **Separation of Identity and Attributes:** The primary identifier is kept separate from the resource’s attributes. The `"id"` field uniquely identifies a resource, while attributes describe its state.
-- **Avoiding Redundancy:** By not duplicating identifier values as attributes, the response remains clean and unambiguous.
-- **Clarifying Relationships:** Properties ending in "`Id`" often indicate foreign keys or relational links. Excluding them from attributes discourages treating these as simple data values.
-
-### How to Circumvent the Default Behavior
-
-If your design requires that additional identifier fields be exposed as attributes—because they carry significant, non-relational context—you can override the default exclusion by using the `[IncludeAsAttribute]` attribute. For example:
-
-```csharp
-using static JsonApiToolkit.Mapping.EntityMapper;
-
-public class Company
-{
-    public Guid Id { get; set; }
-    public string CompanyName { get; set; } = string.Empty;
-    public string CompanyCode { get; set; } = string.Empty;
-    [IncludeAsAttribute]
-    public Guid CompanyTenantId { get; set; }
-}
-```
+The primary ID property is automatically excluded from attributes since it's already present in the resource's `"id"` field.