src/Coscine.ApiClient.Core.Test/Coscine.ApiClient.Core.Test.csproj

@@ -6,7 +6,7 @@
     <TargetFramework>net7.0</TargetFramework>
     <IsPackable>false</IsPackable>
     <Nullable>annotations</Nullable>
-  <Version>1.5.0</Version></PropertyGroup>
+  <Version>1.6.0</Version></PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.3" />

src/Coscine.ApiClient.Core/Coscine.ApiClient.Core.csproj

@@ -12,7 +12,7 @@
     <Description>A library generated from a OpenAPI doc</Description>
     <Copyright>No Copyright</Copyright>
     <RootNamespace>Coscine.ApiClient.Core</RootNamespace>
-    <Version>1.5.0</Version>
+    <Version>1.6.0</Version>
     <DocumentationFile>bin\$(Configuration)\$(TargetFramework)\Coscine.ApiClient.Core.xml</DocumentationFile>
     <RepositoryUrl>https://github.com/GIT_USER_ID/GIT_REPO_ID.git</RepositoryUrl>
     <RepositoryType>git</RepositoryType>

src/Coscine.ApiClient/Coscine.ApiClient.csproj

@@ -4,7 +4,7 @@
 		<RootNamespace>Coscine.ApiClient</RootNamespace>
 		<AssemblyName>Coscine.ApiClient</AssemblyName>
 		<TargetFramework>net7.0</TargetFramework>
-		<Version>1.5.0</Version>
+		<Version>1.6.0</Version>
 	</PropertyGroup>
 
 	<PropertyGroup>

src/Coscine.ApiClient/PaginationHelper.cs

+using Coscine.ApiClient.Core.Model;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Coscine.ApiClient;
+
+/// <summary>
+/// Provides helper methods to work with paginated data.
+/// </summary>
+public static class PaginationHelper
+{
+    /// <summary>
+    /// Asynchronously retrieves all items of type <typeparamref name="T"/> across all pages.
+    /// </summary>
+    /// <remarks>
+    /// This method repeatedly calls the provided <paramref name="pageRequest"/> function to fetch items from multiple pages.
+    /// It lazily generates an asynchronous sequence of items, yielding each item as it becomes available. The method employs reflection
+    /// to dynamically interact with the response object of type <typeparamref name="S"/>, enabling a flexible approach to handle various types of paginated data.
+    /// Ensure that the <typeparamref name="S"/> type has "Data" and "Pagination" properties, with "Data" being an <see cref="IEnumerable{T}"/>.
+    /// </remarks>
+    /// <typeparam name="S">The type of the paginated response object. This object must have "Data" and "Pagination" properties.</typeparam>
+    /// <typeparam name="T">The type of the items in the paginated collection. This type must be a class.</typeparam>
+    /// <param name="pageRequest">
+    /// A function that takes an integer (representing the page number) and returns a <see cref="Task{TResult}"/> where <c>TResult</c> is <typeparamref name="S"/>.
+    /// This function should encapsulate the logic to retrieve items for the specified page number.
+    /// </param>
+    /// <returns>
+    /// An asynchronous enumerable <see cref="IAsyncEnumerable{T}"/> that represents the sequence of items.
+    /// The sequence is lazily generated, yielding items as they are retrieved from each page.
+    /// </returns>
+    /// <example>
+    /// <para>
+    /// Usage example:
+    /// </para>
+    /// <code>
+    /// var allItems = PaginationHelper.GetAllAsync&lt;ProjectAdminDtoPagedResponse, ProjectAdminDto&gt;(pageNumber => FetchItemsPageAsync(pageNumber));
+    /// </code>
+    /// <para>
+    /// This asynchronously retrieves all items across all pages using the provided function <c>FetchItemsPageAsync</c>,
+    /// which is expected to return a paginated response object with "Data" and "Pagination" properties.
+    /// </para>
+    /// </example>
+    public static async IAsyncEnumerable<T> GetAllAsync<S, T>(Func<int, Task<S>> pageRequest) where T : class
+    {
+        var currentPage = 1;
+        bool hasNext = true;
+
+        while (hasNext)
+        {
+            var iteration = await pageRequest(currentPage);
+
+            // Using reflection to dynamically access "Data" and "Pagination" properties
+            var dataProperty = iteration?.GetType().GetProperty("Data");
+            var paginationProperty = iteration?.GetType().GetProperty("Pagination");
+
+            if (dataProperty?.GetValue(iteration) is IEnumerable<T> data &&
+                paginationProperty?.GetValue(iteration) is Pagination pagination)
+            {
+                foreach (var item in data)
+                {
+                    yield return item;
+                }
+                hasNext = pagination.HasNext;
+            }
+            else
+            {
+                // Break the loop if properties are not found or cast fails
+                hasNext = false;
+            }
+
+            currentPage++;
+        }
+    }
+}
\ No newline at end of file

src/Coscine.ApiClient/RequestUtil.cs

-using Coscine.ApiClient.Core.Model;
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Threading.Tasks;
-
-namespace Coscine.ApiClient;
-
-/// <summary>
-/// Provides utility methods for handling web requests that return paged responses.
-/// </summary>
-public class RequestUtil
-{
-    /// <summary>
-    /// Wraps a paged request into an asynchronous enumerable. This method utilizes reflection to handle various types of paged responses since they do not implement a common interface.
-    /// </summary>
-    /// <remarks>
-    /// The method is generic and uses reflection to access 'Data', 'Pagination', and 'IsSuccess' properties of the paged response.
-    /// This approach is not ideal in terms of performance and type safety, but it allows for handling different paged response types.
-    /// </remarks>
-    /// <typeparam name="S">The type of the paged response expected from the retrieval function.</typeparam>
-    /// <typeparam name="T">The type of the data transfer object (DTO) contained within the paged response.</typeparam>
-    /// <param name="RetrieveRequest">
-    /// A function that takes an integer representing the current page number and returns a Task that resolves to a paged response of type <typeparamref name="S"/>.
-    /// </param>
-    /// <returns>
-    /// A task representing the asynchronous operation. The task result contains an <see cref="IEnumerable{T}"/> that iterates over the retrieved DTOs.
-    /// </returns>
-    public static async Task<IEnumerable<T>> WrapPagedRequest<S, T>(
-        Func<int, Task<S>> RetrieveRequest
-    )
-    {
-        var returnArray = new List<T>();
-        var hasNext = true;
-        var currentPageNumber = 1;
-        while (hasNext)
-        {
-            var iteration = await RetrieveRequest(currentPageNumber);
-
-            PropertyInfo? dataProperty = iteration?.GetType().GetProperty("Data");
-            PropertyInfo? paginationProperty = iteration?.GetType().GetProperty("Pagination");
-            PropertyInfo? isSuccessProperty = iteration?.GetType().GetProperty("IsSuccess");
-
-            if (isSuccessProperty != null &&
-                (bool?)isSuccessProperty.GetValue(iteration) == true &&
-                dataProperty != null &&
-                paginationProperty != null)
-            {
-                var data = (List<T>?)dataProperty.GetValue(iteration);
-
-                if (data != null)
-                {
-                    returnArray.AddRange(data);
-                }
-
-                var pagination = paginationProperty.GetValue(iteration);
-                hasNext = pagination != null && ((Pagination)pagination).HasNext;
-            }
-            else
-            {
-                break;
-            }
-
-            currentPageNumber++;
-        }
-
-        return returnArray;
-    }
-}