Merge pull request #651 from johelvisguzman/GH-565

(GH-565) Add support for fetching nested properties for enumerables

Author: johelvisguzman

src/DotNetToolkit.Repository.InMemory/README.md

@@ -1,11 +1,7 @@
 # Disclaimer
 This is intended for testing purposes only and should not be used in production code.
 
-# Issues
-There is currently an issue with join nested properties that has not yet been resolved, and because of this, it is not recommended to use this context in production code. For more info, see related issue [#556](https://github.com/johelvisguzman/DotNetToolkit.Repository/issues/565)
-
 # How to Use?
-
 ```csharp
 var options = new RepositoryOptionsBuilder()
     .UseInMemoryDatabase(...) // for an in-memory database (for testing purposes only)

src/DotNetToolkit.Repository/Configuration/Conventions/Internal/ForeignKeyConventionHelper.cs

@@ -1,6 +1,5 @@
 namespace DotNetToolkit.Repository.Configuration.Conventions.Internal
 {
-    using Extensions;
     using Extensions.Internal;
     using JetBrains.Annotations;
     using Properties;
@@ -14,63 +13,96 @@
 
     internal class ForeignKeyConventionHelper
     {
-        private static readonly ConcurrentDictionary<PropertyInfo, PropertyInfo[]> _foreignKeyCache = new ConcurrentDictionary<PropertyInfo, PropertyInfo[]>();
+        private static readonly ConcurrentDictionary<PropertyInfo, Result> _foreignKeyCache = new ConcurrentDictionary<PropertyInfo, Result>();
 
-        public static PropertyInfo[] GetForeignKeyPropertyInfos([NotNull] PropertyInfo pi)
+        public static Result GetForeignKeyPropertyInfos([NotNull] PropertyInfo pi)
         {
             Guard.NotNull(pi, nameof(pi));
-            
-            if (!_foreignKeyCache.TryGetValue(pi, out PropertyInfo[] result))
+
+            if (!_foreignKeyCache.TryGetValue(pi, out var result))
             {
                 result = GetForeignKeyPropertyInfosCore(pi);
                 _foreignKeyCache.TryAdd(pi, result);
             }
-            
+
             return result;
         }
 
-        private static PropertyInfo[] GetForeignKeyPropertyInfosCore(PropertyInfo pi)
+        private static Result GetForeignKeyPropertyInfosCore(PropertyInfo pi)
         {
             var foreignType = pi.PropertyType.GetGenericTypeOrDefault();
             var declaringType = pi.DeclaringType;
 
             if (foreignType.IsEnumerable() || declaringType.IsEnumerable())
-                return new PropertyInfo[0];
+                return null;
 
-            PropertyInfo[] propertyInfos = new PropertyInfo[0];
+            bool foundInSource;
 
-            if (TryGetForeignKeyPropertyInfos(foreignType, declaringType, out var foreignKeyPropertyInfosFromTarget, out _))
+            if (TryGetForeignKeyPropertyInfos(foreignType, declaringType,
+                out var foreignKeyPropertyInfos,
+                out var foreignNavPropertyInfo,
+                out var adjacentNavPropertyInfo))
+            {
+                foundInSource = false;
+                adjacentNavPropertyInfo = pi;
+            }
+            else if (TryGetForeignKeyPropertyInfos(declaringType, foreignType,
+                out foreignKeyPropertyInfos,
+                out foreignNavPropertyInfo,
+                out adjacentNavPropertyInfo))
             {
-                propertyInfos = foreignKeyPropertyInfosFromTarget;
+                foundInSource = true;
             }
-            else if (TryGetForeignKeyPropertyInfos(declaringType, foreignType, out _, out var primaryKeyPropertyInfosFromSource))
+            else
             {
-                propertyInfos = primaryKeyPropertyInfosFromSource;
+                return null;
             }
 
-            return propertyInfos;
+            var rightNavPi = pi;
+            var rightPiType = rightNavPi.PropertyType.GetGenericTypeOrDefault();
+            var rightKeysToJoinOn = foundInSource
+                ? PrimaryKeyConventionHelper.GetPrimaryKeyPropertyInfos(rightPiType)
+                : foreignKeyPropertyInfos;
+
+            var leftNavPi = foreignNavPropertyInfo;
+            var leftPiType = leftNavPi.PropertyType.GetGenericTypeOrDefault();
+            var leftKeysToJoinOn = foundInSource
+                ? foreignKeyPropertyInfos
+                : PrimaryKeyConventionHelper.GetPrimaryKeyPropertyInfos(leftPiType);
+
+            var newLeftNavPi = foundInSource ? adjacentNavPropertyInfo : leftNavPi;
+
+            return new Result(newLeftNavPi, leftKeysToJoinOn, rightNavPi, rightKeysToJoinOn);
         }
 
-        private static bool TryGetForeignKeyPropertyInfos(Type source, Type target, out PropertyInfo[] foreignKeyPropertyInfosFromTarget, out PropertyInfo[] primaryKeyPropertyInfosFromSource)
+        private static bool TryGetForeignKeyPropertyInfos(Type source, Type target,
+            out PropertyInfo[] foreignKeyPropertyInfos,
+            out PropertyInfo foreignNavPropertyInfo,
+            out PropertyInfo adjacentNavPropertyInfo)
         {
-            var properties = source.GetRuntimeProperties().Where(ModelConventionHelper.IsColumnMapped).ToList();
-            var foreignNavigationPropertyInfo = properties.SingleOrDefault(x => x.PropertyType == target);
-            var propertyInfos = new List<PropertyInfo>();
+            var propsFromSource = source.GetRuntimeProperties().Where(ModelConventionHelper.IsColumnMapped).ToList();
+            var propsFromTarget = target.GetRuntimeProperties().Where(ModelConventionHelper.IsColumnMapped).ToList();
+
+            var foreignNavPi = propsFromSource.FirstOrDefault(x => x.PropertyType == target);
+            var adjacentNavPi = propsFromTarget.FirstOrDefault(x => x.PropertyType == source);
 
-            foreignKeyPropertyInfosFromTarget = null;
-            primaryKeyPropertyInfosFromSource = null;
+            var foreignKeyPiList = new List<PropertyInfo>();
 
-            if (foreignNavigationPropertyInfo != null)
+            adjacentNavPropertyInfo = null;
+            foreignKeyPropertyInfos = null;
+            foreignNavPropertyInfo = null;
+
+            if (foreignNavPi != null)
             {
-                // Gets by checking the annotations
-                var propertyInfosWithForeignKeys = properties.Where(x => x.GetCustomAttribute<ForeignKeyAttribute>() != null).ToList();
+                // Gets by checking the annotations in source
+                var propertyInfosWithForeignKeys = propsFromSource.Where(x => x.GetCustomAttribute<ForeignKeyAttribute>() != null).ToList();
                 if (propertyInfosWithForeignKeys.Any())
                 {
                     // Ensure that the foreign key names are valid
                     foreach (var propertyInfosWithForeignKey in propertyInfosWithForeignKeys)
                     {
                         var foreignKeyAttributeName = propertyInfosWithForeignKey.GetCustomAttribute<ForeignKeyAttribute>().Name;
-                        if (!properties.Any(x => foreignKeyAttributeName.Equals(ModelConventionHelper.GetColumnName(x))))
+                        if (!propsFromSource.Any(x => foreignKeyAttributeName.Equals(ModelConventionHelper.GetColumnName(x))))
                         {
                             throw new InvalidOperationException(
                                 string.Format(
@@ -82,49 +114,66 @@ private static bool TryGetForeignKeyPropertyInfos(Type source, Type target, out
                     }
 
                     // Try to find by checking on the foreign key property
-                    propertyInfos = propertyInfosWithForeignKeys
+                    foreignKeyPiList = propertyInfosWithForeignKeys
                         .Where(DotNetToolkit.Repository.Extensions.Internal.PropertyInfoExtensions.IsPrimitive)
-                        .Where(x => x.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(foreignNavigationPropertyInfo.Name))
+                        .Where(x => x.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(foreignNavPi.Name))
                         .ToList();
 
                     // Try to find by checking on the navigation property
-                    if (!propertyInfos.Any())
+                    if (!foreignKeyPiList.Any())
                     {
-                        propertyInfos = properties
+                        foreignKeyPiList = propsFromSource
                             .Where(DotNetToolkit.Repository.Extensions.Internal.PropertyInfoExtensions.IsPrimitive)
-                            .Where(x => foreignNavigationPropertyInfo.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(ModelConventionHelper.GetColumnName(x)))
+                            .Where(x => foreignNavPi.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(ModelConventionHelper.GetColumnName(x)))
                             .ToList();
                     }
                 }
 
                 // Try to find by naming convention
                 var primaryKeyPropertyInfos = PrimaryKeyConventionHelper.GetPrimaryKeyPropertyInfos(target);
 
-                if (!propertyInfos.Any() && primaryKeyPropertyInfos.Any())
+                if (!foreignKeyPiList.Any() && primaryKeyPropertyInfos.Any())
                 {
                     foreach (var primaryKeyPropertyInfo in primaryKeyPropertyInfos)
                     {
                         var foreignPrimaryKeyName = ModelConventionHelper.GetColumnName(primaryKeyPropertyInfo);
-                        var propertyName = $"{foreignNavigationPropertyInfo.Name}{foreignPrimaryKeyName}";
-                        var propertyInfo = properties.FirstOrDefault(x => x.Name == propertyName);
+                        var propertyName = $"{foreignNavPi.Name}{foreignPrimaryKeyName}";
+                        var propertyInfo = propsFromSource.FirstOrDefault(x => x.Name == propertyName);
 
                         if (propertyInfo != null)
                         {
-                            propertyInfos.Add(propertyInfo);
+                            foreignKeyPiList.Add(propertyInfo);
                         }
                     }
                 }
 
-                if (propertyInfos.Any())
+                if (foreignKeyPiList.Any())
                 {
-                    foreignKeyPropertyInfosFromTarget = propertyInfos.ToArray();
-                    primaryKeyPropertyInfosFromSource = primaryKeyPropertyInfos;
+                    foreignKeyPropertyInfos = foreignKeyPiList.ToArray();
+                    foreignNavPropertyInfo = foreignNavPi;
+                    adjacentNavPropertyInfo = adjacentNavPi;
 
                     return true;
                 }
             }
 
             return false;
         }
+
+        public class Result
+        {
+            public PropertyInfo LeftNavPi { get; }
+            public PropertyInfo[] LeftKeysToJoinOn { get; }
+            public PropertyInfo RightNavPi { get; }
+            public PropertyInfo[] RightKeysToJoinOn { get; }
+
+            public Result(PropertyInfo leftNavPi, PropertyInfo[] leftKeysToJoinOn, PropertyInfo rightNavPi, PropertyInfo[] rightKeysToJoinOn)
+            {
+                LeftNavPi = leftNavPi;
+                LeftKeysToJoinOn = leftKeysToJoinOn;
+                RightNavPi = rightNavPi;
+                RightKeysToJoinOn = rightKeysToJoinOn;
+            }
+        }
     }
 }

src/DotNetToolkit.Repository/Extensions/EnumerableExtensions.cs

@@ -1,13 +1,10 @@
 namespace DotNetToolkit.Repository.Extensions
 {
     using Configuration.Conventions;
-    using Configuration.Conventions.Internal;
-    using Extensions.Internal;
     using JetBrains.Annotations;
     using Query;
     using Query.Strategies;
     using System;
-    using System.Collections;
     using System.Collections.Generic;
     using System.Linq;
     using System.Reflection;
@@ -18,9 +15,6 @@
     /// </summary>
     public static class EnumerableExtensions
     {
-        private static readonly MethodInfo _castMethod = typeof(Enumerable).GetMethod(nameof(Enumerable.Cast));
-        private static readonly MethodInfo _toListMethod = typeof(Enumerable).GetMethod(nameof(Enumerable.ToList));
-
         /// <summary>
         /// Apply a specification strategy options to the specified entity's query.
         /// </summary>
@@ -107,120 +101,15 @@ public static IEnumerable<T> ApplyFetchingOptions<T>([NotNull] this IEnumerable<
             Guard.NotNull(query, nameof(query));
             Guard.NotNull(innerQueryCallback, nameof(innerQueryCallback));
 
-            var mainTableType = typeof(T);
-            var mainTablePropertiesMap = mainTableType.GetRuntimeProperties().ToDictionary(x => x.Name);
             var fetchingPaths = fetchStrategy.DefaultIfFetchStrategyEmpty().PropertyPaths.ToList();
+            var fetchHelper = new FetchHelper<T>(innerQueryCallback);
 
-            foreach (var path in fetchingPaths)
-            {
-                // Only do a join when the primary table has a foreign key property for the join table
-                var joinTablePropertyInfo = mainTablePropertiesMap[path];
-                var joinTableForeignKeyPropertyInfos = ForeignKeyConventionHelper.GetForeignKeyPropertyInfos(joinTablePropertyInfo);
-
-                if (joinTableForeignKeyPropertyInfos != null && joinTableForeignKeyPropertyInfos.Length > 0)
-                {
-                    var joinTableType = joinTablePropertyInfo.PropertyType.TryGetGenericTypeOrDefault(out bool isJoinPropertyCollection);
-                    var innerQuery = innerQueryCallback(joinTableType);
-
-                    var mainTablePrimaryKeyPropertyInfos = PrimaryKeyConventionHelper.GetPrimaryKeyPropertyInfos(mainTableType);
-                    var mainTablePropertyInfo = joinTableType.GetRuntimeProperties().FirstOrDefault(x => x.PropertyType == mainTableType);
-
-                    var comparer = new ObjectArrayComparer();
-
-                    // key selector functions
-                    object[] outerKeySelectorFunc(T outer)
-                    {
-                        return mainTablePrimaryKeyPropertyInfos.Select(pi => pi.GetValue(outer)).ToArray();
-                    }
-
-                    object[] innerKeySelectorFunc(object inner)
-                    {
-                        return joinTableForeignKeyPropertyInfos.Select(pi => pi.GetValue(inner)).ToArray();
-                    }
-
-                    if (isJoinPropertyCollection)
-                    {
-                        query = query.GroupJoin(
-                            innerQuery,
-                            outerKeySelectorFunc,
-                            innerKeySelectorFunc,
-                            (outer, inner) =>
-                            {
-                                if (inner != null)
-                                {
-                                    var items = inner.Select(item =>
-                                    {
-                                        if (mainTablePropertyInfo != null)
-                                        {
-                                            // Sets the main table property in the join table
-                                            mainTablePropertyInfo.SetValue(item, outer);
-                                        }
-
-                                        return item;
-                                    }).ToList(joinTableType);
-
-                                    // Sets the join table property in the main table
-                                    joinTablePropertyInfo.SetValue(outer, items);
-                                }
-
-                                return outer;
-                            }, comparer);
-                    }
-                    else
-                    {
-                        query = query.LeftJoin(
-                            innerQuery,
-                            outerKeySelectorFunc,
-                            innerKeySelectorFunc,
-                            (outer, inner) =>
-                            {
-                                if (inner != null)
-                                {
-                                    if (mainTablePropertyInfo != null)
-                                    {
-                                        // Sets the main table property in the join table
-                                        mainTablePropertyInfo.SetValue(inner, outer);
-                                    }
-
-                                    // Sets the join table property in the main table
-                                    joinTablePropertyInfo.SetValue(outer, inner);
-                                }
-
-                                return outer;
-                            }, comparer);
-                    }
-                }
-            }
+            if (fetchingPaths.Any())
+                query = fetchingPaths.Aggregate(query, (current, path) => fetchHelper.Include(current, path));
 
             return query;
         }
 
-        private static ICollection ToList(this IEnumerable items, Type type)
-        {
-            var castItems = _castMethod
-                .MakeGenericMethod(new Type[] { type })
-                .Invoke(null, new object[] { items });
-
-            var list = _toListMethod
-                .MakeGenericMethod(new Type[] { type })
-                .Invoke(null, new object[] { castItems });
-
-            return (ICollection)list;
-        }
-
-        private static IEnumerable<TResult> LeftJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer)
-        {
-            return outer.GroupJoin(
-                    inner,
-                    outerKeySelector,
-                    innerKeySelector,
-                    (o, i) => new { outer = o, innerCollection = i },
-                    comparer)
-                .SelectMany(
-                    a => a.innerCollection.DefaultIfEmpty(),
-                    (a, i) => resultSelector(a.outer, i));
-        }
-
         private static IOrderedEnumerable<T> ApplyOrder<T>(this IEnumerable<T> source, string propertyName, string methodName)
         {
             Guard.NotNull(source, nameof(source));
@@ -262,19 +151,5 @@ private static IOrderedEnumerable<T> ThenByDescending<T>(this IOrderedEnumerable
         {
             return ApplyOrder<T>(source, propertyName, nameof(Enumerable.ThenByDescending));
         }
-
-        private class ObjectArrayComparer : IEqualityComparer<object[]>
-        {
-            public bool Equals(object[] x, object[] y)
-            {
-                return x.Length == y.Length && Enumerable.SequenceEqual(x, y);
-            }
-
-            public int GetHashCode(object[] o)
-            {
-                var result = o.Aggregate((a, b) => a.GetHashCode() ^ b.GetHashCode());
-                return result.GetHashCode();
-            }
-        }
     }
 }