Implement HasPreviousPage

Author: Jameak

.editorconfig

@@ -53,6 +53,7 @@ generated_code = true
 
 # C# files
 [*.cs]
+
 # New line preferences
 csharp_new_line_before_open_brace = all
 csharp_new_line_before_else = true

lint-test-and-nuget-test.ps1

@@ -68,7 +68,13 @@ function RunLinterAndStandardTests{
          [string] $AdditionalConfiguration
     )
 
-    Exec { & dotnet format --verify-no-changes }
+    if ($Env -eq 'ci') {
+        Exec { & dotnet format style --verify-no-changes }
+        Exec { & dotnet format analyzers --verify-no-changes }
+    } else {
+        Exec { & dotnet format --verify-no-changes }
+    }
+
     Exec { & dotnet build -c $Configuration $AdditionalConfiguration  '/p:ExtraNoWarn1="JAMCP0007"' '/p:ExtraNoWarn2="JAMCP0018"' }
     Exec { & dotnet test -c $Configuration $AdditionalConfiguration --logger trx --no-build --no-restore }
 }

samples/Jameak.CursorPagination.Sample/Controllers/PaginatedDataController.cs

@@ -39,6 +39,7 @@ public async Task<PaginatedResponse> PaginateByKeySetCursor(string? afterCursor,
             GetDtoQueryable(),
             DelegateMethods.ToListAsyncDelegate(),
             DelegateMethods.CountAsyncDelegate(),
+            DelegateMethods.AnyAsyncDelegate(),
             afterCursor,
             PageSize,
             computeTotalCount: Enums.ComputeTotalCount.Once,
@@ -52,7 +53,8 @@ public async Task<PaginatedResponse> PaginateByKeySetCursor(string? afterCursor,
                 // Entirely up to your use-case how much of this page metadata makes sense to compute and fill out.
                 TotalCount = page.TotalCount!.Value,
                 HasNextPage = page.HasNextPage!.Value,
-                NextPageCursor = page.NextCursor == null ? null : _keySetPaginationStrategy.CursorToString(page.NextCursor)
+                HasPreviousPage = await page.HasPreviousPageAsync(),
+                NextPageCursor = page.NextCursor == null ? null : _keySetPaginationStrategy.CursorToString(page.NextCursor),
             },
             Data = page.Items.Select(item => new DataWithCursor
             {
@@ -85,6 +87,7 @@ public async Task<PaginatedResponse> PaginateByOffsetCursor(string? afterCursor,
             {
                 TotalCount = page.TotalCount!.Value,
                 HasNextPage = page.HasNextPage!.Value,
+                HasPreviousPage = await page.HasPreviousPageAsync(),
                 NextPageCursor = page.NextCursor?.CursorToString()
             },
             Data = page.Items.Select(item => new DataWithCursor
@@ -118,6 +121,7 @@ public async Task<PaginatedResponse> PaginateByPageNumber(int? pageNumber, Cance
             {
                 TotalCount = page.TotalCount!.Value,
                 HasNextPage = page.HasNextPage!.Value,
+                HasPreviousPage = await page.HasPreviousPageAsync(),
                 NextPageCursor = page.NextCursor?.CursorToString()
             },
             Data = page.Items.Select(item => new DataWithCursor

samples/Jameak.CursorPagination.Sample/DelegateMethods.cs

@@ -7,4 +7,5 @@ public static class DelegateMethods
 {
     public static ToListAsync<DtoTypeToPaginate> ToListAsyncDelegate() => (queryable, cancellationToken) => queryable.ToListAsync(cancellationToken);
     public static CountAsync<DtoTypeToPaginate> CountAsyncDelegate() => (queryable, cancellationToken) => queryable.CountAsync(cancellationToken);
+    public static AnyAsync<DtoTypeToPaginate> AnyAsyncDelegate() => (queryable, cancellationToken) => queryable.AnyAsync(cancellationToken);
 }

samples/Jameak.CursorPagination.Sample/PaginatedBatchJob.cs

@@ -57,6 +57,7 @@ private async Task ProcessInBatches(CancellationToken stoppingToken)
                 dtoQueryable,
                 DelegateMethods.ToListAsyncDelegate(),
                 DelegateMethods.CountAsyncDelegate(),
+                DelegateMethods.AnyAsyncDelegate(),
                 null,
                 PageSize,
                 computeTotalCount: Enums.ComputeTotalCount.Once,

samples/Jameak.CursorPagination.Sample/ResponseModels/PageInfo.cs

@@ -4,5 +4,6 @@ public class PageInfo
 {
     public required string? NextPageCursor { get; init; }
     public required bool HasNextPage { get; init; }
+    public required bool HasPreviousPage { get; init; }
     public required int TotalCount { get; init; }
 }

src/Jameak.CursorPagination.Abstractions/Enums/KeySetCursorSerializerGeneration.cs

@@ -21,5 +21,5 @@ public enum KeySetCursorSerializerGeneration
     /// <remarks>
     /// The source-generated implementation uses a <b>JsonNamingPolicy</b> to hide the paginated cursors property names.
     /// </remarks>
-    UseSystemTextJson = 2
+    UseSystemTextJson = 2,
 }

src/Jameak.CursorPagination.Abstractions/Enums/PaginationDirection.cs

@@ -29,5 +29,5 @@ public enum PaginationDirection
     /// <para>Notice that this produces the dataset paginated backwards, but with each page representing the data in the non-reverse order.</para>
     /// <para>If you need the data in reverse order, instead perform a Forward pagination on the opposite sort-order instead (ascending vs. descending)</para>
     /// </remarks>
-    Backward = 2
+    Backward = 2,
 }

src/Jameak.CursorPagination/Delegates.cs

@@ -28,6 +28,18 @@ namespace Jameak.CursorPagination;
 /// </remarks>
 public delegate Task<int> CountAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken);
 
+/// <summary>
+/// Method used to asynchronously determine whether a <see cref="IQueryable{T}"/> contains any elements.
+/// </summary>
+/// <returns>Returns true if any elements exist.</returns>
+/// <remarks>
+/// If using EFCore for async operations you can create this async any method like so:
+/// <code>
+/// (queryable, cancellationToken) => queryable.AnyAsync(cancellationToken)
+/// </code>
+/// </remarks>
+public delegate Task<bool> AnyAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken);
+
 internal delegate PageResult<T, TCursor> NextPage<T, TCursor>() where TCursor : ICursor;
 
 internal delegate Task<PageResultAsync<T, TCursor>> NextPageAsync<T, TCursor>(CancellationToken cancellationToken) where TCursor : ICursor;

src/Jameak.CursorPagination/InternalPaginatorHelper.cs

@@ -1,23 +1,32 @@
 using System.Runtime.CompilerServices;
 using Jameak.CursorPagination.Abstractions;
+using Jameak.CursorPagination.Abstractions.Enums;
 using Jameak.CursorPagination.Enums;
 using Jameak.CursorPagination.Page;
 
 namespace Jameak.CursorPagination;
 internal static class InternalPaginatorHelper
 {
+    internal sealed record EmptyNextPageState(
+        int? TotalCount,
+        Func<bool> HasPreviousPageFunc);
+
+    internal sealed record EmptyNextPageStateAsync(
+        int? TotalCount,
+        Func<Task<bool>> HasPreviousPageAsyncFunc);
+
     internal static NextPage<TData, TCursor> DetermineNextPageFunc<TData, TCursor, TDataEntry>(
         Func<TCursor, NextPage<TData, TCursor>> nextPageFuncGenerator,
         Func<TDataEntry, TCursor> createCursor,
         TDataEntry? nextCursorElement,
-        int? totalCount,
+        EmptyNextPageState emptyNextPageState,
         bool? hasNextPage,
         ComputeNextPage computeNextPage) where TCursor : ICursor
     {
         if (nextCursorElement == null
             || CanSkipNextPageCheck(computeNextPage, hasNextPage))
         {
-            return EmptyNextPage<TData, TCursor>(totalCount);
+            return EmptyNextPage<TData, TCursor>(emptyNextPageState);
         }
 
         return nextPageFuncGenerator(createCursor(nextCursorElement));
@@ -27,14 +36,14 @@ internal static NextPageAsync<TData, TCursor> DetermineNextPageAsyncFunc<TData,
         Func<TCursor, NextPageAsync<TData, TCursor>> nextPageAsyncFuncGenerator,
         Func<TDataEntry, TCursor> createCursor,
         TDataEntry? nextCursorElement,
-        int? totalCount,
+        EmptyNextPageStateAsync emptyNextPageState,
         bool? hasNextPage,
         ComputeNextPage computeNextPage) where TCursor : ICursor
     {
         if (nextCursorElement == null
             || CanSkipNextPageCheck(computeNextPage, hasNextPage))
         {
-            return EmptyNextPageAsync<TData, TCursor>(totalCount);
+            return EmptyNextPageAsync<TData, TCursor>(emptyNextPageState);
         }
 
         return nextPageAsyncFuncGenerator(createCursor(nextCursorElement));
@@ -49,21 +58,36 @@ private static bool CanSkipNextPageCheck(
               && !hasNextPage.Value;
     }
 
-    internal static NextPage<T, TCursor> EmptyNextPage<T, TCursor>(int? totalCount) where TCursor : ICursor
+    private static NextPage<T, TCursor> EmptyNextPage<T, TCursor>(
+        EmptyNextPageState emptyNextPageState) where TCursor : ICursor
     {
-        return () => new PageResult<T, TCursor>([], false, totalCount, EmptyNextPage<T, TCursor>(totalCount), default);
+        return () => new PageResult<T, TCursor>(
+            [],
+            hasNextPage: false,
+            emptyNextPageState.TotalCount,
+            EmptyNextPage<T, TCursor>(emptyNextPageState),
+            nextCursor: default,
+            emptyNextPageState.HasPreviousPageFunc);
     }
 
-    internal static NextPageAsync<T, TCursor> EmptyNextPageAsync<T, TCursor>(int? totalCount) where TCursor : ICursor
+    private static NextPageAsync<T, TCursor> EmptyNextPageAsync<T, TCursor>(
+        EmptyNextPageStateAsync emptyNextPageState) where TCursor : ICursor
     {
-        return (cancellationToken) => Task.FromResult(new PageResultAsync<T, TCursor>([], false, totalCount, EmptyNextPageAsync<T, TCursor>(totalCount), default));
+        return (cancellationToken) => Task.FromResult(
+            new PageResultAsync<T, TCursor>(
+                [],
+                hasNextPage: false,
+                emptyNextPageState.TotalCount,
+                EmptyNextPageAsync<T, TCursor>(emptyNextPageState),
+                nextCursor: default,
+                emptyNextPageState.HasPreviousPageAsyncFunc));
     }
 
     internal static bool ShouldComputeTotalCount(bool hasAlreadyComputedCount, ComputeTotalCount totalEnum)
     {
         return (hasAlreadyComputedCount, totalEnum) switch
         {
-            (false, ComputeTotalCount.Never) => false,
+            (_, ComputeTotalCount.Never) => false,
             (false, ComputeTotalCount.Once) => true,
             (true, ComputeTotalCount.Once) => false,
             (_, ComputeTotalCount.EveryPage) => true,
@@ -78,4 +102,26 @@ internal static void ThrowIfEnumNotDefined<T>(T argument, [CallerArgumentExpress
             throw new ArgumentException($"Parameter '{paramName}' has invalid enum value '{argument}'.", paramName);
         }
     }
+
+    internal static (T? previousCursorElement, T? nextCursorElement) GetCursorElements<T>(
+        List<T> pageData,
+        PaginationDirection paginationDirection)
+    {
+        return paginationDirection switch
+        {
+            PaginationDirection.Forward => (pageData.FirstOrDefault(), pageData.LastOrDefault()),
+            PaginationDirection.Backward => (pageData.LastOrDefault(), pageData.FirstOrDefault()),
+            _ => throw new ArgumentOutOfRangeException(nameof(paginationDirection)),
+        };
+    }
+
+    internal static PaginationDirection InvertDirection(PaginationDirection paginationDirection)
+    {
+        return paginationDirection switch
+        {
+            PaginationDirection.Forward => PaginationDirection.Backward,
+            PaginationDirection.Backward => PaginationDirection.Forward,
+            _ => throw new ArgumentOutOfRangeException(nameof(paginationDirection)),
+        };
+    }
 }