Added page based connection type (#8132)

Author: michaelstaib

src/All.slnx

@@ -89,6 +89,7 @@
     <Project Path="HotChocolate/Core/src/Subscriptions/HotChocolate.Subscriptions.csproj" />
     <Project Path="HotChocolate/Core/src/Types.Analyzers/HotChocolate.Types.Analyzers.csproj" />
     <Project Path="HotChocolate/Core/src/Types.CursorPagination/HotChocolate.Types.CursorPagination.csproj" />
+    <Project Path="HotChocolate/Core/src/Types.CursorPagination.Extensions/HotChocolate.Types.CursorPagination.Extensions.csproj" />
     <Project Path="HotChocolate/Core/src/Types.Errors/HotChocolate.Types.Errors.csproj" />
     <Project Path="HotChocolate/Core/src/Types.Json/HotChocolate.Types.Json.csproj" />
     <Project Path="HotChocolate/Core/src/Types.Mutations/HotChocolate.Types.Mutations.csproj" />

src/GreenDonut/src/GreenDonut.Data.EntityFramework/Extensions/PagingQueryableExtensions.cs

@@ -155,8 +155,7 @@ public static async ValueTask<Page<T>> ToPageAsync<T>(
 
         if (arguments.EnableRelativeCursors && cursor?.IsRelative == true)
         {
-            if ((arguments.Last is not null && cursor.Offset > 0) ||
-                (arguments.First is not null && cursor.Offset < 0))
+            if ((arguments.Last is not null && cursor.Offset > 0) || (arguments.First is not null && cursor.Offset < 0))
             {
                 throw new ArgumentException(
                     "Positive offsets are not allowed with `last`, and negative offsets are not allowed with `first`.",
@@ -237,7 +236,7 @@ public static async ValueTask<Page<T>> ToPageAsync<T>(
         }
 
         var pageIndex = CreateIndex(arguments, cursor, totalCount);
-        return CreatePage(builder.ToImmutable(), arguments, keys, fetchCount, pageIndex, totalCount);
+        return CreatePage(builder.ToImmutable(), arguments, keys, fetchCount, pageIndex, requestedCount, totalCount);
     }
 
     /// <summary>
@@ -433,12 +432,6 @@ public static async ValueTask<Dictionary<TKey, Page<TValue>>> ToBatchPageAsync<T
             includeTotalCount = true;
         }
 
-        Dictionary<TKey, int>? counts = null;
-        if (includeTotalCount)
-        {
-            counts = await GetBatchCountsAsync(source, keySelector, cancellationToken);
-        }
-
         source = QueryHelpers.EnsureOrderPropsAreSelected(source);
         source = QueryHelpers.EnsureGroupPropsAreSelected(source, keySelector);
 
@@ -447,6 +440,12 @@ public static async ValueTask<Dictionary<TKey, Page<TValue>>> ToBatchPageAsync<T
         // and to create a new expression that will not contain it anymore.
         var ordering = ExtractAndRemoveOrder(source.Expression);
 
+        Dictionary<TKey, int>? counts = null;
+        if (includeTotalCount)
+        {
+            counts = await GetBatchCountsAsync(source, keySelector, cancellationToken);
+        }
+
         var forward = arguments.Last is null;
         var requestedCount = int.MaxValue;
         var batchExpression =
@@ -503,6 +502,7 @@ public static async ValueTask<Dictionary<TKey, Page<TValue>>> ToBatchPageAsync<T
                 keys,
                 item.Items.Count,
                 pageIndex,
+                requestedCount,
                 totalCount);
             map.Add(item.Key, page);
         }
@@ -525,8 +525,7 @@ private static async Task<Dictionary<TKey, int>> GetBatchCountsAsync<TElement, T
         return await query.ToDictionaryAsync(t => t.Key, t => t.Count, cancellationToken);
     }
 
-    private static Expression<Func<IGrouping<TKey, TElement>, CountResult<TKey>>> GetOrCreateCountSelector<TElement,
-        TKey>()
+    private static Expression<Func<IGrouping<TKey, TElement>, CountResult<TKey>>> GetOrCreateCountSelector<TElement, TKey>()
     {
         return (Expression<Func<IGrouping<TKey, TElement>, CountResult<TKey>>>)
             _countExpressionCache.GetOrAdd(
@@ -572,6 +571,7 @@ private static Page<T> CreatePage<T>(
         CursorKey[] keys,
         int fetchCount,
         int? index,
+        int? requestedPageSize,
         int? totalCount)
     {
         var hasPrevious = false;
@@ -605,14 +605,15 @@ private static Page<T> CreatePage<T>(
             hasNext = true;
         }
 
-        if (arguments.EnableRelativeCursors && totalCount is not null)
+        if (arguments.EnableRelativeCursors && totalCount is not null && requestedPageSize is not null)
         {
             return new Page<T>(
                 items,
                 hasNext,
                 hasPrevious,
                 (item, o, p, c) => CursorFormatter.Format(item, keys, new CursorPageInfo(o, p, c)),
                 index ?? 1,
+                requestedPageSize.Value,
                 totalCount.Value);
         }
 

src/GreenDonut/src/GreenDonut.Data.Primitives/GreenDonut.Data.Primitives.csproj

@@ -8,6 +8,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <InternalsVisibleTo Include="GreenDonut.Data" />
     <InternalsVisibleTo Include="GreenDonut.Data.EntityFramework" />
   </ItemGroup>
 

src/GreenDonut/src/GreenDonut.Data.Primitives/Page.cs

@@ -15,8 +15,9 @@ public sealed class Page<T> : IEnumerable<T>
     private readonly bool _hasNextPage;
     private readonly bool _hasPreviousPage;
     private readonly Func<T, int, int, int, string> _createCursor;
-    private readonly int? _totalCount;
+    private readonly int? _requestedPageSize;
     private readonly int? _index;
+    private readonly int? _totalCount;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Page{T}"/> class.
@@ -46,7 +47,7 @@ public Page(
         _items = items;
         _hasNextPage = hasNextPage;
         _hasPreviousPage = hasPreviousPage;
-        _createCursor = (item, _, _, _) =>  createCursor(item);
+        _createCursor = (item, _, _, _) => createCursor(item);
         _totalCount = totalCount;
     }
 
@@ -71,20 +72,25 @@ public Page(
     /// <param name="index">
     /// The index number of this page.
     ///</param>
+    /// <param name="requestedPageSize">
+    /// The requested page size.
+    /// </param>
     internal Page(
         ImmutableArray<T> items,
         bool hasNextPage,
         bool hasPreviousPage,
         Func<T, int, int, int, string> createCursor,
         int index,
+        int requestedPageSize,
         int totalCount)
     {
         _items = items;
         _hasNextPage = hasNextPage;
         _hasPreviousPage = hasPreviousPage;
         _createCursor = createCursor;
-        _totalCount = totalCount;
         _index = index;
+        _requestedPageSize = requestedPageSize;
+        _totalCount = totalCount;
     }
 
     /// <summary>
@@ -113,15 +119,21 @@ internal Page(
     public bool HasPreviousPage => _hasPreviousPage;
 
     /// <summary>
-    /// Gets the total count of items in the dataset.
-    /// This value can be null if the total count is unknown.
+    /// Gets the index number of this page.
     /// </summary>
-    public int? TotalCount => _totalCount;
+    public int? Index => _index;
 
     /// <summary>
-    /// Gets the index number of this page.
+    /// Gets the requested page size.
+    /// This value can be null if the page size is unknown.
     /// </summary>
-    public int? Index => _index;
+    internal int? RequestedSize => _requestedPageSize;
+
+    /// <summary>
+    /// Gets the total count of items in the dataset.
+    /// This value can be null if the total count is unknown.
+    /// </summary>
+    public int? TotalCount => _totalCount;
 
     /// <summary>
     /// Creates a cursor for an item of this page.
@@ -136,7 +148,7 @@ internal Page(
 
     public string CreateCursor(T item, int offset)
     {
-        if(_index is null || _totalCount is null)
+        if (_index is null || _totalCount is null)
         {
             throw new InvalidOperationException("This page does not allow relative cursors.");
         }

src/GreenDonut/src/GreenDonut.Data/Extensions/GreenDonutPageExtensions.cs

@@ -0,0 +1,135 @@
+using System.Collections.Immutable;
+
+namespace GreenDonut.Data;
+
+/// <summary>
+/// Extensions for the <see cref="Page{T}"/> class.
+/// </summary>
+public static class GreenDonutPageExtensions
+{
+    /// <summary>
+    /// Creates a relative cursor for backwards pagination.
+    /// </summary>
+    /// <param name="page">
+    /// The page to create cursors for.
+    /// </param>
+    /// <param name="maxCursors">
+    /// The maximum number of cursors to create.
+    /// </param>
+    /// <returns>
+    /// An array of cursors.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// Thrown if the page is null.
+    /// </exception>
+    /// <exception cref="ArgumentOutOfRangeException">
+    /// Thrown if the maximum number of cursors is less than 0.
+    /// </exception>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if the page does not allow relative cursors.
+    /// </exception>
+    /// <remarks>
+    /// This method creates cursors for the previous pages based on the current page.
+    /// The cursors are created using the <see cref="Page{T}.CreateCursor(T, int)"/> method.
+    /// </remarks>
+    public static ImmutableArray<PageCursor> CreateRelativeBackwardCursors<T>(this Page<T> page, int maxCursors = 5)
+    {
+        if (page == null)
+        {
+            throw new ArgumentNullException(nameof(page));
+        }
+
+        if (maxCursors < 0)
+        {
+            throw new ArgumentOutOfRangeException(
+                nameof(maxCursors),
+                "Max cursors must be greater than or equal to 0.");
+        }
+
+        if (page.First is null || page.Index is null || page.Index == 1)
+        {
+            return [];
+        }
+
+        var previousPages = page.Index.Value - 1;
+        var cursors = ImmutableArray.CreateBuilder<PageCursor>();
+
+        maxCursors *= -1;
+
+        for (var i = 0; i > maxCursors && previousPages + i - 1 >= 0; i--)
+        {
+            cursors.Insert(
+                0,
+                new PageCursor(
+                    page.CreateCursor(page.First, i),
+                    previousPages + i));
+        }
+
+        return cursors.ToImmutable();
+    }
+
+    /// <summary>
+    /// Creates a relative cursor for forwards pagination.
+    /// </summary>
+    /// <param name="page">
+    /// The page to create cursors for.
+    /// </param>
+    /// <param name="maxCursors">
+    /// The maximum number of cursors to create.
+    /// </param>
+    /// <returns>
+    /// An array of cursors.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// Thrown if the page is null.
+    /// </exception>
+    /// <exception cref="ArgumentOutOfRangeException">
+    /// Thrown if the maximum number of cursors is less than 0.
+    /// </exception>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if the page does not allow relative cursors.
+    /// </exception>
+    /// <remarks>
+    /// This method creates cursors for the next pages based on the current page.
+    /// The cursors are created using the <see cref="Page{T}.CreateCursor(T, int)"/> method.
+    /// </remarks>
+    public static ImmutableArray<PageCursor> CreateRelativeForwardCursors<T>(this Page<T> page, int maxCursors = 5)
+    {
+        if (page == null)
+        {
+            throw new ArgumentNullException(nameof(page));
+        }
+
+        if (maxCursors < 0)
+        {
+            throw new ArgumentOutOfRangeException(
+                nameof(maxCursors),
+                "Max cursors must be greater than or equal to 0.");
+        }
+
+        if (page.Last is null || page.Index is null)
+        {
+            return [];
+        }
+
+        var totalPages = (page.TotalCount ?? 0) / (page.RequestedSize ?? 10);
+
+        if (page.Index >= totalPages)
+        {
+            return [];
+        }
+
+        var cursors = ImmutableArray.CreateBuilder<PageCursor>();
+        cursors.Add(new PageCursor(page.CreateCursor(page.Last, 0), page.Index.Value + 1));
+
+        for (int i = 1; i < maxCursors && page.Index + i < totalPages; i++)
+        {
+            cursors.Add(
+                new PageCursor(
+                    page.CreateCursor(page.Last, i),
+                    page.Index.Value + i + 1));
+        }
+
+        return cursors.ToImmutable();
+    }
+}

src/GreenDonut/src/GreenDonut.Data/PageCursor.cs

@@ -0,0 +1,3 @@
+namespace GreenDonut.Data;
+
+public record PageCursor(string Cursor, int Page);

src/HotChocolate/Caching/test/Caching.Tests/HotChocolate.Caching.Tests.csproj

@@ -14,6 +14,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\..\Core\src\Types.OffsetPagination\HotChocolate.Types.OffsetPagination.csproj" />
     <ProjectReference Include="..\..\src\Caching\HotChocolate.Caching.csproj" />
     <ProjectReference Include="..\..\..\AspNetCore\src\AspNetCore\HotChocolate.AspNetCore.csproj" />
     <ProjectReference Include="..\..\..\Core\test\Utilities\HotChocolate.Tests.Utilities.csproj" />