Merge pull request #23 from mrahhal/nested

Support nested properties when defining a keyset

Author: mrahhal

README.md

@@ -200,6 +200,38 @@ var admins = await keysetContext.Query
 keysetContext.EnsureCorrectOrder(admins);
 ```
 
+## Nested properties
+
+Nested properties are also supported when defining a keyset. Just make sure the reference contains the same nested chain of properties.
+
+```cs
+// If you're using a loaded entity for the reference.
+var reference = await dbContext.Users
+    // Load it, otherwise you won't get the correct result.
+    .Include(x => x.Nested)
+    .FirstOrDefaultAsync(x => x.Id == id);
+
+// If you're using another type for the reference.
+var reference = new
+{
+    Nested = new
+    {
+        Created = ...,
+    },
+};
+
+var keysetContext = dbContext.Users.KeysetPaginate(
+    // Defining the keyset using a nested property.
+    b => b.Ascending(entity => entity.Nested.Created),
+    direction,
+    reference);
+var result = await keysetContext.Query
+    // You'll want to load it here too if you plan on calling any context methods.
+    .Include(x => x.Nested)
+    .Take(20)
+    .ToListAsync();
+```
+
 ## Avoiding skipping over data
 
 You'll want to make sure the combination of the columns you configure uniquely identify an entity, otherwise you might skip over data while navigating pages. This is a general rule to keep in mind when doing keyset pagination.

samples/Basic/Models/User.cs

@@ -10,5 +10,15 @@ public class User
 		public string Name { get; set; }
 
 		public DateTime Created { get; set; }
+
+		public UserDetails Details { get; set; }
+	}
+
+	[Index(nameof(Created))]
+	public class UserDetails
+	{
+		public int Id { get; set; }
+
+		public DateTime Created { get; set; }
 	}
 }

samples/Basic/Pages/Nested.cshtml

@@ -0,0 +1,31 @@
+@page
+@model NestedModel
+
+<div class="text-center">
+    @if (Model.Users.Any())
+    {
+        <div class="users">
+            @foreach (var user in Model.Users)
+            {
+                <div class="user">
+                    @user.Name (@user.Details.Created.ToLongDateString())
+                </div>
+            }
+        </div>
+
+        <div class="mt-3" style="text-align: center">
+            (@Model.Count items) (@Model.Elapsed | total with prev/next: @Model.ElapsedTotal)
+        </div>
+
+        <div class="pagination mt-3">
+            <a asp-page="/Nested" asp-route-first="@true" disabled="@(!Model.HasPrevious ? "disabled" : null)">First</a>
+            <a asp-page="/Nested" asp-route-before="@Model.Users.First().Id" disabled="@(!Model.HasPrevious ? "disabled" : null)">Previous</a>
+            <a asp-page="/Nested" asp-route-after="@Model.Users.Last().Id" disabled="@(!Model.HasNext ? "disabled" : null)">Next</a>
+            <a asp-page="/Nested" asp-route-last="@true" disabled="@(!Model.HasNext ? "disabled" : null)">Last</a>
+        </div>
+    }
+    else
+    {
+        <div>Nothing</div>
+    }
+</div>

samples/Basic/Pages/Nested.cshtml.cs

@@ -0,0 +1,98 @@
+using System.Diagnostics;
+using Basic.Models;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+using Microsoft.EntityFrameworkCore;
+using MR.EntityFrameworkCore.KeysetPagination;
+
+namespace Basic.Pages
+{
+	public class NestedModel : PageModel
+	{
+		private readonly AppDbContext _dbContext;
+
+		public NestedModel(
+			AppDbContext dbContext)
+		{
+			_dbContext = dbContext;
+		}
+
+		public int Count { get; set; }
+
+		public List<User> Users { get; set; }
+
+		public bool HasPrevious { get; set; }
+
+		public bool HasNext { get; set; }
+
+		public string Elapsed { get; set; }
+
+		public string ElapsedTotal { get; set; }
+
+		public async Task OnGet(int? after, int? before, bool first = false, bool last = false)
+		{
+			var size = 20;
+
+			var keysetBuilderAction = (KeysetPaginationBuilder<User> b) =>
+			{
+				b.Descending(x => x.Details.Created);
+			};
+
+			var sw = Stopwatch.StartNew();
+
+			var query = _dbContext.Users.AsQueryable();
+			Count = await query.CountAsync();
+			KeysetPaginationContext<User> keysetContext;
+			if (first)
+			{
+				keysetContext = query.KeysetPaginate(keysetBuilderAction, KeysetPaginationDirection.Forward);
+				Users = await keysetContext.Query
+					.Include(x => x.Details)
+					.Take(size)
+					.ToListAsync();
+			}
+			else if (last)
+			{
+				keysetContext = query.KeysetPaginate(keysetBuilderAction, KeysetPaginationDirection.Backward);
+				Users = await keysetContext.Query
+					.Include(x => x.Details)
+					.Take(size)
+					.ToListAsync();
+			}
+			else if (after != null)
+			{
+				var reference = await _dbContext.Users.Include(x => x.Details).FirstOrDefaultAsync(x => x.Id == after.Value);
+				keysetContext = query.KeysetPaginate(keysetBuilderAction, KeysetPaginationDirection.Forward, reference);
+				Users = await keysetContext.Query
+					.Include(x => x.Details)
+					.Take(size)
+					.ToListAsync();
+			}
+			else if (before != null)
+			{
+				var reference = await _dbContext.Users.Include(x => x.Details).FirstOrDefaultAsync(x => x.Id == before.Value);
+				keysetContext = query.KeysetPaginate(keysetBuilderAction, KeysetPaginationDirection.Backward, reference);
+				Users = await keysetContext.Query
+					.Include(x => x.Details)
+					.Take(size)
+					.ToListAsync();
+			}
+			else
+			{
+				keysetContext = query.KeysetPaginate(keysetBuilderAction);
+				Users = await keysetContext.Query
+					.Include(x => x.Details)
+					.Take(size)
+					.ToListAsync();
+			}
+
+			keysetContext.EnsureCorrectOrder(Users);
+
+			Elapsed = sw.ElapsedMilliseconds.ToString();
+
+			HasPrevious = await keysetContext.HasPreviousAsync(Users);
+			HasNext = await keysetContext.HasNextAsync(Users);
+
+			ElapsedTotal = sw.ElapsedMilliseconds.ToString();
+		}
+	}
+}

samples/Basic/Pages/Shared/_Layout.cshtml

@@ -24,6 +24,9 @@
                         <li class="nav-item">
                             <a class="nav-link text-dark" asp-area="" asp-page="/Example2">Example 2</a>
                         </li>
+                        <li class="nav-item">
+                            <a class="nav-link text-dark" asp-area="" asp-page="/Nested">Nested</a>
+                        </li>
                     </ul>
                 </div>
             </div>

samples/Basic/Startup.cs

@@ -41,6 +41,10 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
 						Id = i,
 						Name = i.ToString(),
 						Created = created,
+						Details = new UserDetails
+						{
+							Created = created,
+						},
 					});
 				}
 				_dbContext.AddRange(users);

src/MR.EntityFrameworkCore.KeysetPagination/ExpressionHelper.cs

@@ -1,24 +1,74 @@
-using System.Linq.Expressions;
+using System.Diagnostics;
+using System.Linq.Expressions;
 using System.Reflection;
 
 namespace MR.EntityFrameworkCore.KeysetPagination;
 
 internal static class ExpressionHelper
 {
-	public static PropertyInfo GetPropertyInfoFromMemberAccess<T, TProp>(
+	public static Expression UnwrapConvertAndLambda<T, TProp>(
 		Expression<Func<T, TProp>> expression)
 	{
-		MemberExpression memberExpression;
-		if (expression.Body.NodeType == ExpressionType.Convert)
+		if (expression.Body.NodeType != ExpressionType.Convert)
 		{
-			memberExpression = (MemberExpression)((UnaryExpression)expression.Body).Operand;
+			return expression.Body;
 		}
-		else
+
+		return ((UnaryExpression)expression.Body).Operand;
+	}
+
+	public static bool IsSimpleMemberAccess(
+		Expression expression)
+	{
+		ValidateExpressionUnwrapped(expression);
+
+		return expression is MemberExpression memberExpression
+			&& memberExpression.Expression is not MemberExpression;
+	}
+
+	public static PropertyInfo GetSimplePropertyFromMemberAccess(
+		Expression expression)
+	{
+		ValidateExpressionUnwrapped(expression);
+
+		var memberExpression = (MemberExpression)expression;
+		return GetPropertyInfoMember(memberExpression);
+	}
+
+	public static List<PropertyInfo> GetNestedPropertiesFromMemberAccess(
+		Expression expression)
+	{
+		ValidateExpressionUnwrapped(expression);
+
+		var properties = new List<PropertyInfo>();
+
+		var next = expression;
+		while (next is MemberExpression memberExpression)
+		{
+			properties.Add(GetPropertyInfoMember(memberExpression));
+			next = memberExpression.Expression;
+		}
+
+		properties.Reverse();
+		return properties;
+	}
+
+	[Conditional("DEBUG")]
+	private static void ValidateExpressionUnwrapped(Expression expression)
+	{
+		if (expression.NodeType is ExpressionType.Lambda or ExpressionType.Convert)
+		{
+			throw new Exception("Expression should have been unwrapped by now.");
+		}
+	}
+
+	private static PropertyInfo GetPropertyInfoMember(MemberExpression memberExpression)
+	{
+		if (memberExpression.Member is PropertyInfo prop)
 		{
-			memberExpression = (MemberExpression)expression.Body;
+			return prop;
 		}
 
-		var propertyInfo = (PropertyInfo)memberExpression.Member;
-		return propertyInfo;
+		throw new InvalidOperationException($"Expected a property access, got '{memberExpression.Member.MemberType}'.");
 	}
 }

src/MR.EntityFrameworkCore.KeysetPagination/KeysetPaginationBuilder.cs

@@ -25,10 +25,22 @@ private KeysetPaginationBuilder<T> Item<TProp>(
 		Expression<Func<T, TProp>> propertyExpression,
 		bool isDescending)
 	{
-		var property = ExpressionHelper.GetPropertyInfoFromMemberAccess(propertyExpression);
-		_items.Add(new KeysetPaginationItem<T, TProp>(
-			property,
-			isDescending));
+		var unwrapped = ExpressionHelper.UnwrapConvertAndLambda(propertyExpression);
+		if (ExpressionHelper.IsSimpleMemberAccess(unwrapped))
+		{
+			var property = ExpressionHelper.GetSimplePropertyFromMemberAccess(unwrapped);
+			_items.Add(new KeysetPaginationItemSimple<T, TProp>(
+				property,
+				isDescending));
+		}
+		else
+		{
+			var properties = ExpressionHelper.GetNestedPropertiesFromMemberAccess(unwrapped);
+			_items.Add(new KeysetPaginationItemNested<T, TProp>(
+				properties,
+				isDescending));
+		}
+
 		return this;
 	}
 }

src/MR.EntityFrameworkCore.KeysetPagination/KeysetPaginationExtensions.cs

@@ -175,15 +175,10 @@ private static List<object> GetValues<T>(
 		object reference)
 		where T : class
 	{
-		var accessor = Accessor.Obtain(reference.GetType());
 		var referenceValues = new List<object>(capacity: items.Count);
 		foreach (var item in items)
 		{
-			var propertyName = item.Property.Name;
-			if (!accessor.TryGetPropertyValue(reference, propertyName, out var value))
-			{
-				throw new KeysetPaginationIncompatibleObjectException($"Property '{propertyName}' not found on this object.");
-			}
+			var value = item.ObtainValue(reference);
 			referenceValues.Add(value);
 		}
 		return referenceValues;
@@ -272,7 +267,7 @@ private static Expression<Func<T, bool>> BuildKeysetFilterPredicateExpression<T>
 			{
 				var isInnerLastOperation = j + 1 == innerLimit;
 				var item = items[j];
-				var memberAccess = Expression.MakeMemberAccess(param, item.Property);
+				var memberAccess = item.MakeMemberAccessExpression(param);
 				var referenceValue = referenceValues[j];
 				Expression<Func<object>> referenceValueFunc = () => referenceValue;
 				var referenceValueExpression = referenceValueFunc.Body;