Merge branch 'Alpha-9' into Polymorphic-map-to-target-Mapping-fix-Publish

Author: DocSvartz

src/Mapster.Async.Tests/AsyncTest.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using MapsterMapper;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Shouldly;
 
@@ -87,6 +88,22 @@ public async Task NestedAsync()
             dtoOwnership.Owner.Name.ShouldBe("John Doe");
         }
 
+        [TestMethod]
+        public async Task SimplyAsync()
+        {
+            TypeAdapterConfig<Poco, Dto>.NewConfig()
+                .AfterMappingAsync(async dest => { dest.Name = await GetName(); });
+
+            var poco = new Poco { Id = "foo" };
+            var dto = await poco.AdaptAsync<Dto>();
+            dto.Name.ShouldBe("bar");
+
+            IMapper instance = new Mapper();
+
+            var destination = await instance.MapAsync<Dto>(poco);
+            destination.Name.ShouldBe("bar");
+        }
+
         private static async Task<string> GetName()
         {
             await Task.Delay(1);

src/Mapster.Async/TypeAdapterExtensions.cs

@@ -1,4 +1,5 @@
-using System;
+using MapsterMapper;
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
@@ -101,5 +102,44 @@ public static async Task<TDestination> AdaptToAsync<TDestination>(this IAdapterB
             }
         }
 
+
+        /// <summary>
+        /// Map asynchronously to destination type.
+        /// </summary>
+        /// <typeparam name="TDestination">Destination type to map.</typeparam>
+        /// <param name="builder"></param>
+        /// <returns>Type of destination object that mapped.</returns>
+        public static async Task<TDestination> AdaptAsync<TDestination>(this object? source)
+        {
+            return await source.BuildAdapter().AdaptToTypeAsync<TDestination>();
+        }
+
+
+        /// <summary>
+        /// Map asynchronously to destination type.
+        /// </summary>
+        /// <typeparam name="TDestination">Destination type to map.</typeparam>
+        /// <param name="builder"></param>
+        /// <param name="config">Configuration</param>
+        /// <returns>Type of destination object that mapped.</returns>
+        public static async Task<TDestination> AdaptAsync<TDestination>(this object? source, TypeAdapterConfig config)
+        {
+            return await source.BuildAdapter(config).AdaptToTypeAsync<TDestination>();
+        }
+
+    }
+
+    public static class IMapperAsyncExtentions
+    {
+        /// <summary>
+        /// Map asynchronously to destination type.
+        /// </summary>
+        /// <typeparam name="TDestination">Destination type to map.</typeparam>
+        /// <param name="builder"></param>
+        /// <returns>Type of destination object that mapped.</returns>
+        public static async Task<TDestination> MapAsync<TDestination>(this IMapper mapper, object? source)
+        {
+            return await mapper.From(source).AdaptToTypeAsync<TDestination>();
+        }
     }
 }

src/Mapster.Core/Enums/ProjectToTypeAutoMapping.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Mapster.Enums
+{
+    public enum ProjectToTypeAutoMapping
+    {
+        AllTypes = 0,
+        WithoutCollections = 1,
+        OnlyPrimitiveTypes = 2,
+    }
+}

src/Mapster.Core/Utils/ProjectToTypeVisitors.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using System.Linq.Expressions;
+
+namespace Mapster.Utils
+{
+    public sealed class TopLevelMemberNameVisitor : ExpressionVisitor
+    {
+        public string? MemeberName { get; private set; }
+
+        public override Expression Visit(Expression node)
+        {
+            if (node == null)
+                return null;
+            switch (node.NodeType)
+            {
+                case ExpressionType.MemberAccess:
+                    {
+                        if (string.IsNullOrEmpty(MemeberName))
+                            MemeberName = ((MemberExpression)node).Member.Name;
+
+                        return base.Visit(node);
+                    }
+            }
+
+            return base.Visit(node);
+        }
+    }
+
+    public sealed class QuoteVisitor : ExpressionVisitor
+    {
+        public List<UnaryExpression> Quotes { get; private set; } = new();
+
+        public override Expression Visit(Expression node)
+        {
+            if (node == null)
+                return null;
+            switch (node.NodeType)
+            {
+                case ExpressionType.Quote:
+                    {
+                        Quotes.Add((UnaryExpression)node);
+                        return base.Visit(node);
+                    }
+            }
+
+            return base.Visit(node);
+        }
+    }
+}

src/Mapster.EFCore.Tests/EFCoreTest.cs

@@ -1,11 +1,11 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using Mapster.EFCore.Tests.Models;
 using MapsterMapper;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Shouldly;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace Mapster.EFCore.Tests
 {
@@ -67,6 +67,27 @@ public void MapperInstance_From_OrderBy()
             var last = orderedQuery.Last();
             last.LastName.ShouldBe("Olivetto");
         }
+
+        [TestMethod]
+        public void MergeIncludeWhenUsingEFCoreProjectToType()
+        {
+            var options = new DbContextOptionsBuilder<SchoolContext>()
+                .UseInMemoryDatabase(Guid.NewGuid().ToString("N"))
+                .Options;
+            var context = new SchoolContext(options);
+            DbInitializer.Initialize(context);
+
+            var mapsterInstance = new Mapper();
+
+            var query = context.Students
+                .Include(x => x.Enrollments.OrderByDescending(x => x.StudentID).Take(1))
+                .EFCoreProjectToType<StudentDto>();
+
+            var first = query.First();
+
+            first.Enrollments.Count.ShouldBe(1);
+            first.LastName.ShouldBe("Alexander");
+        }
     }
 
     public class StudentDto

src/Mapster.EFCore/EFCoreExtensions.cs

@@ -0,0 +1,96 @@
+using Mapster.Enums;
+using Mapster.Models;
+using Mapster.Utils;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace Mapster.EFCore
+{
+    public static class EFCoreExtensions
+    {
+        public static IQueryable<TDestination> EFCoreProjectToType<TDestination>(this IQueryable source, 
+            TypeAdapterConfig? config = null, ProjectToTypeAutoMapping autoMapConfig = ProjectToTypeAutoMapping.WithoutCollections)
+        {
+            var allInclude = new IncludeVisitor();
+            allInclude.Visit(source.Expression);
+
+            if (config == null)
+            {
+                config = TypeAdapterConfig.GlobalSettings
+                .Clone()
+                .ForType(source.ElementType, typeof(TDestination))
+                .Config;
+
+                var mapTuple = new TypeTuple(source.ElementType, typeof(TDestination));
+
+                TypeAdapterRule rule;
+                config.RuleMap.TryGetValue(mapTuple, out rule);
+
+                if(rule != null)
+                {
+                    rule.Settings.ProjectToTypeMapConfig = autoMapConfig;
+
+                    foreach (var item in allInclude.IncludeExpression)
+                    {
+                        var find = rule.Settings.Resolvers.Find(x => x.SourceMemberName == item.Key);
+                        if (find != null)
+                        {
+                            find.Invoker = (LambdaExpression)item.Value.Operand;
+                            find.SourceMemberName = null;
+                        }
+                        else
+                            rule.Settings.ProjectToTypeResolvers.TryAdd(item.Key, item.Value);
+                    }
+                }
+            }
+            else
+            {
+                config = config.Clone()
+                    .ForType(source.ElementType, typeof(TDestination))
+                    .Config;
+            }
+            
+            return source.ProjectToType<TDestination>(config);
+        }
+    }
+
+
+    internal class IncludeVisitor : ExpressionVisitor
+    {
+        public Dictionary<string, UnaryExpression> IncludeExpression { get; protected set; } = new();
+        private bool IsInclude(Expression node) => node.Type.Name.StartsWith("IIncludableQueryable");
+
+        [return: NotNullIfNotNull("node")]
+        public override Expression Visit(Expression node)
+        {
+            if (node == null)
+                return null;
+
+            switch (node.NodeType)
+            {
+                case ExpressionType.Call:
+                    {
+                        if (IsInclude(node))
+                        {
+                            var QuoteVisiter = new QuoteVisitor();
+                            QuoteVisiter.Visit(node);
+
+                            foreach (var item in QuoteVisiter.Quotes)
+                            {
+                                var memberv = new TopLevelMemberNameVisitor();
+                                memberv.Visit(item);
+
+                                IncludeExpression.TryAdd(memberv.MemeberName, item);
+                            }
+                        }
+                        return base.Visit(node);
+                    }
+            }
+
+            return base.Visit(node);
+        }
+    }
+
+}

src/Mapster.Tests/WhenExplicitMappingRequired.cs

@@ -13,6 +13,7 @@ public class WhenExplicitMappingRequired
         public void TestCleanup()
         {
             TypeAdapterConfig.GlobalSettings.RequireExplicitMapping = false;
+            TypeAdapterConfig.GlobalSettings.RequireExplicitMappingPrimitive = false;
             TypeAdapterConfig.GlobalSettings.Clear();
         }
 
@@ -140,8 +141,60 @@ public void UnmappedChildPocoShouldFailed()
             setter.Compile(); // Should fail here
         }
 
+        [TestMethod]
+        public void RequireExplicitMappingPrimitiveWork()
+        {
+            TypeAdapterConfig.GlobalSettings.RequireExplicitMappingPrimitive = true;
+
+            TypeAdapterConfig<Source783, Destination783>.NewConfig();
+
+            Should.Throw<CompileException>(() => 
+            {
+                TypeAdapterConfig.GlobalSettings.Compile(); // throw CompileException
+            });
+
+            byte byteSource = 10;
+
+            byteSource.Adapt<byte>(); // Should work when the type is mapped to itself
+
+            Should.Throw<CompileException>(() =>
+            {
+                byteSource.Adapt<int>();  // throw CompileException, Do not map to another primitive type without registering the configuration
+            });
+
+            Should.NotThrow(() =>
+            {
+                TypeAdapterConfig<byte, int>.NewConfig(); 
+
+                byteSource.Adapt<int>();  // Not throw CompileException when config is registering
+            });
+
+            Should.NotThrow(() =>
+            {
+                TypeAdapterConfig<Source783, Destination783>.NewConfig()
+                    .Map(dest=> dest.MyProperty, src=> int.Parse(src.MyProperty)); 
+                // it work works because int.Parse return Type Int. Type is mapped to itself (int -> int) without config.
+
+                var sourceMapconfig = new Source783() { MyProperty = "128" };
+                var resultMapconfig = sourceMapconfig.Adapt<Destination783>();
+
+                resultMapconfig.MyProperty.ShouldBe(128);
+            });
+
+        }
+
+
         #region TestClasses
+        
+        public class Source783
+        {
+            public string MyProperty { get; set; } = "";
+        }
 
+        public class Destination783
+        {
+            public int MyProperty { get; set; }
+        }
 
         public enum NameEnum
         {

src/Mapster.Tests/WhenIgnoringNonMapped.cs

@@ -12,6 +12,7 @@ public void Should_Ignore_Non_Mapped()
         {
             TypeAdapterConfig<SimplePoco, SimpleDto>.NewConfig()
                 .Map(dest => dest.Id, src => src.Id)
+                .RequireDestinationMemberSource(true)
                 .IgnoreNonMapped(true)
                 .Compile();
 

src/Mapster.Tests/WhenMappingInitProperty.cs

@@ -19,7 +19,7 @@ public void WhenMappingToHiddenandNewInitFieldDestination()
         var c =  source.Adapt<BDestination>(); 
         var s = source.Adapt(new BDestination());
 
-        ((ADestination)c).Id.ShouldBe(156);
+        ((ADestination)c).Id.ShouldBe(default); // Hidden Base member is not mapping
         s.Id.ShouldBe(156);
     }
 
@@ -33,7 +33,7 @@ public void WhenMappingToHiddenandNewInitFieldWithConstructUsing()
         var c = source.Adapt<BDestination>();
         var s = source.Adapt(new BDestination());
 
-        ((ADestination)c).Id.ShouldBe(256);
+        ((ADestination)c).Id.ShouldBe(default); // Hidden Base member is not mapping
         s.Id.ShouldBe(256);
     }