Implementation of litedb-org#2722

[Key] / [NotMapped] from DataAnnotations

Author: surgicalcoder

LiteDBX.Tests/Mapper/CustomMapping_Tests.cs

@@ -1,4 +1,6 @@
-using FluentAssertions;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using FluentAssertions;
 using Xunit;
 
 namespace LiteDbX.Tests.Mapper;
@@ -28,14 +30,77 @@ public void Custom_Id_In_Interface()
 
         var obj = new ConcreteClass { CustomId = "myid", Name = "myname" };
         var doc = mapper.Serialize(obj) as BsonDocument;
-        doc["_id"].Should().NotBeNull();
+        Assert.NotNull(doc);
+        doc!["_id"].Should().NotBeNull();
         doc["_id"].Should().Be("myid");
         doc["CustomName"].Should().NotBe(BsonValue.Null);
         doc["CustomName"].Should().Be("myname");
         doc["Name"].Should().Be(BsonValue.Null);
         doc.Keys.ExpectCount(2);
     }
 
+    [Fact]
+    public void Key_Attribute_Is_Mapped_As_Id_With_AutoId_Disabled()
+    {
+        var mapper = new BsonMapper();
+
+        var entityMapper = mapper.GetEntityMapper(typeof(UserWithKeyAttribute));
+
+        entityMapper.Id.Should().NotBeNull();
+        entityMapper.Id.MemberName.Should().Be(nameof(UserWithKeyAttribute.Key));
+        entityMapper.Id.FieldName.Should().Be("_id");
+        entityMapper.Id.AutoId.Should().BeFalse();
+    }
+
+    [Fact]
+    public void Key_Attribute_Serializes_And_Deserializes_As_Id()
+    {
+        var mapper = new BsonMapper();
+
+        var doc = mapper.Serialize(new UserWithKeyAttribute(42, "John")) as BsonDocument;
+
+        Assert.NotNull(doc);
+        doc!["_id"].Should().Be(42);
+        doc["Name"].Should().Be("John");
+        doc.Keys.ExpectCount(2);
+
+        var hydrated = mapper.ToObject<UserWithKeyAttribute>(new BsonDocument { ["_id"] = 7, ["Name"] = "Jane" });
+
+        hydrated.Key.Should().Be(7);
+        hydrated.Name.Should().Be("Jane");
+    }
+
+    [Fact]
+    public void NotMapped_Attribute_Is_Ignored_During_Mapping_And_Serialization()
+    {
+        var mapper = new BsonMapper();
+
+        var entityMapper = mapper.GetEntityMapper(typeof(ClassWithNotMappedAttribute));
+        entityMapper.Members.Should().NotContain(x => x.MemberName == nameof(ClassWithNotMappedAttribute.Ignore));
+
+        var doc = mapper.Serialize(new ClassWithNotMappedAttribute { Id = 1, Keep = "K", Ignore = "I" }) as BsonDocument;
+
+        Assert.NotNull(doc);
+        doc!["_id"].Should().Be(1);
+        doc["Keep"].Should().Be("K");
+        doc.ContainsKey("Ignore").Should().BeFalse();
+        doc.Keys.ExpectCount(2);
+    }
+
+    [Fact]
+    public void NotMapped_Attribute_On_Inherited_Property_Is_Ignored()
+    {
+        var mapper = new BsonMapper();
+
+        var doc = mapper.Serialize(new DerivedClassWithInheritedNotMapped { Id = 9, Keep = "keep", Hidden = "secret" }) as BsonDocument;
+
+        Assert.NotNull(doc);
+        doc!["_id"].Should().Be(9);
+        doc["Keep"].Should().Be("keep");
+        doc.ContainsKey("Hidden").Should().BeFalse();
+        doc.Keys.ExpectCount(2);
+    }
+
     public class UserWithCustomId
     {
         public UserWithCustomId(int key, string name)
@@ -58,4 +123,41 @@ public abstract class BaseClass
     }
 
     public class ConcreteClass : BaseClass { }
+
+    public class UserWithKeyAttribute
+    {
+        public UserWithKeyAttribute(int key, string name)
+        {
+            Key = key;
+            Name = name;
+        }
+
+        [Key]
+        public int Key { get; }
+
+        public string Name { get; }
+    }
+
+    public class ClassWithNotMappedAttribute
+    {
+        public int Id { get; set; }
+
+        public string Keep { get; set; }
+
+        [NotMapped]
+        public string Ignore { get; set; }
+    }
+
+    public abstract class BaseClassWithNotMapped
+    {
+        public int Id { get; set; }
+
+        [NotMapped]
+        public string Hidden { get; set; }
+    }
+
+    public class DerivedClassWithInheritedNotMapped : BaseClassWithNotMapped
+    {
+        public string Keep { get; set; }
+    }
 }

LiteDBX/Client/Mapper/BsonMapper.GetEntityMapper.cs

@@ -14,6 +14,20 @@ public partial class BsonMapper
     /// </summary>
     private readonly ConcurrentDictionary<Type, EntityMapper> _entities = new();
 
+#if NET8_0_OR_GREATER
+    private static bool HasDataAnnotationsKeyAttribute(MemberInfo memberInfo)
+        => CustomAttributeExtensions.IsDefined(memberInfo, typeof(global::System.ComponentModel.DataAnnotations.KeyAttribute), true);
+
+    private static bool HasDataAnnotationsNotMappedAttribute(MemberInfo memberInfo)
+        => CustomAttributeExtensions.IsDefined(memberInfo, typeof(global::System.ComponentModel.DataAnnotations.Schema.NotMappedAttribute), true);
+#else
+    private static bool HasDataAnnotationsKeyAttribute(MemberInfo _)
+        => false;
+
+    private static bool HasDataAnnotationsNotMappedAttribute(MemberInfo _)
+        => false;
+#endif
+
     /// <summary>
     /// Get property mapper between typed .NET class and BsonDocument - Cache results
     /// </summary>
@@ -66,13 +80,13 @@ protected void BuildEntityMapper(EntityMapper mapper)
         var fieldAttr = typeof(BsonFieldAttribute);
         var dbrefAttr = typeof(BsonRefAttribute);
 
-        var members = GetTypeMembers(mapper.ForType);
+        var members = GetTypeMembers(mapper.ForType).ToArray();
         var id = GetIdMember(members);
 
         foreach (var memberInfo in members)
         {
-            // checks [BsonIgnore]
-            if (CustomAttributeExtensions.IsDefined(memberInfo, ignoreAttr, true))
+            // checks [BsonIgnore] / [NotMapped]
+            if (CustomAttributeExtensions.IsDefined(memberInfo, ignoreAttr, true) || HasDataAnnotationsNotMappedAttribute(memberInfo))
             {
                 continue;
             }
@@ -103,6 +117,7 @@ protected void BuildEntityMapper(EntityMapper mapper)
             // check if property has [BsonId] to get with was setted AutoId = true
             var autoId = (BsonIdAttribute)CustomAttributeExtensions.GetCustomAttributes(memberInfo, idAttr, true)
                                                                    .FirstOrDefault();
+            var hasDataAnnotationsKeyAttribute = HasDataAnnotationsKeyAttribute(memberInfo);
 
             // get data type
             var dataType = memberInfo is PropertyInfo
@@ -115,7 +130,7 @@ protected void BuildEntityMapper(EntityMapper mapper)
             // create a property mapper
             var member = new MemberMapper
             {
-                AutoId = autoId == null ? true : autoId.AutoId,
+                AutoId = autoId?.AutoId ?? !hasDataAnnotationsKeyAttribute,
                 FieldName = name,
                 MemberName = memberInfo.Name,
                 DataType = dataType,
@@ -156,8 +171,9 @@ protected virtual MemberInfo GetIdMember(IEnumerable<MemberInfo> members)
     {
         return Reflection.SelectMember(members,
             x => CustomAttributeExtensions.IsDefined(x, typeof(BsonIdAttribute), true),
+            x => HasDataAnnotationsKeyAttribute(x),
             x => x.Name.Equals("Id", StringComparison.OrdinalIgnoreCase),
-            x => x.Name.Equals(x.DeclaringType.Name + "Id", StringComparison.OrdinalIgnoreCase));
+            x => x.DeclaringType != null && x.Name.Equals(x.DeclaringType.Name + "Id", StringComparison.OrdinalIgnoreCase));
     }
 
     /// <summary>