Feature/support continuation token limit property

src/Microsoft.Azure.CosmosRepository/Repositories/DefaultRepository.Paging.cs

@@ -3,6 +3,10 @@
 
 
 // ReSharper disable once CheckNamespace
+using System.Threading;
+using Microsoft.Azure.Cosmos;
+using Microsoft.Extensions.Options;
+
 namespace Microsoft.Azure.CosmosRepository;
 
 internal sealed partial class DefaultRepository<TItem>
@@ -13,19 +17,36 @@ public async ValueTask<IPage<TItem>> PageAsync(
         int pageSize = 25,
         string? continuationToken = null,
         bool returnTotal = false,
-        CancellationToken cancellationToken = default)
-    {
+        CancellationToken cancellationToken = default)
+        => await PageAsync(
+            new QueryRequestOptions() { MaxItemCount = pageSize },
+            predicate,
+            pageSize,
+            continuationToken,
+            returnTotal,
+            cancellationToken);
+
+    /// <inheritdoc/>
+    public async ValueTask<IPage<TItem>> PageAsync(
+        QueryRequestOptions requestOptions,
+        Expression<Func<TItem, bool>>? predicate = null,
+        int pageSize = 25,
+        string? continuationToken = null,
+        bool returnTotal = false,
+        CancellationToken cancellationToken = default)
+    {
         Container container = await containerProvider.GetContainerAsync()
-            .ConfigureAwait(false);
-
-        QueryRequestOptions options = new()
-        {
-            MaxItemCount = pageSize
-        };
+            .ConfigureAwait(false);
+
+        // make sure that if the user hasn't said the value already we take it from the pageSize parameter
+        if (requestOptions.MaxItemCount is null)
+        {
+            requestOptions.MaxItemCount = pageSize;
+        }
 
         IQueryable<TItem> query = container
             .GetItemLinqQueryable<TItem>(
-                requestOptions: options,
+                requestOptions: requestOptions,
                 continuationToken: continuationToken,
                 linqSerializerOptions: optionsMonitor.CurrentValue.SerializationOptions)
             .Where(repositoryExpressionProvider.Build(
@@ -51,7 +72,7 @@ public async ValueTask<IPage<TItem>> PageAsync(
             pageSize,
             items.AsReadOnly(),
             charge + countResponse?.RequestCharge ?? 0,
-            resultingContinuationToken);
+            resultingContinuationToken);
     }
 
     /// <inheritdoc/>
@@ -61,13 +82,30 @@ public async ValueTask<IPageQueryResult<TItem>> PageAsync(
         int pageSize = 25,
         bool returnTotal = false,
         CancellationToken cancellationToken = default)
-    {
+    => await PageAsync(
+            requestOptions: new QueryRequestOptions() { MaxItemCount = pageSize },
+            predicate: predicate,
+            pageNumber: pageNumber,
+            pageSize: pageSize,
+            returnTotal: returnTotal,
+            cancellationToken: cancellationToken);
+
+    /// <inheritdoc/>
+    public async ValueTask<IPageQueryResult<TItem>> PageAsync(
+        QueryRequestOptions requestOptions,
+        Expression<Func<TItem, bool>>? predicate = null,
+        int pageNumber = 1,
+        int pageSize = 25,
+        bool returnTotal = false,
+        CancellationToken cancellationToken = default)
+    {
         Container container = await containerProvider.GetContainerAsync()
             .ConfigureAwait(false);
 
         IQueryable<TItem> query = container
             .GetItemLinqQueryable<TItem>(
-                linqSerializerOptions: optionsMonitor.CurrentValue.SerializationOptions)
+                linqSerializerOptions: optionsMonitor.CurrentValue.SerializationOptions,
+                requestOptions: requestOptions)
             .Where(repositoryExpressionProvider
                 .Build(predicate ?? repositoryExpressionProvider.Default<TItem>()));
 
@@ -94,6 +132,6 @@ public async ValueTask<IPageQueryResult<TItem>> PageAsync(
             pageSize,
             items.AsReadOnly(),
             charge + countResponse?.RequestCharge ?? 0,
-            resultingContinuationToken /* This was missing, is this correct? */);
+            resultingContinuationToken /* This was missing, is this correct? */);
     }
 }

src/Microsoft.Azure.CosmosRepository/Repositories/DefaultRepository.Specs.cs

@@ -11,22 +11,27 @@ internal sealed partial class DefaultRepository<TItem>
     public async ValueTask<TResult> QueryAsync<TResult>(
         ISpecification<TItem, TResult> specification,
         CancellationToken cancellationToken = default)
-        where TResult : IQueryResult<TItem>
-    {
+        where TResult : IQueryResult<TItem>
+        => await QueryAsync(specification, new QueryRequestOptions(), cancellationToken);
+
+    /// <inheritdoc/>
+    public async ValueTask<TResult> QueryAsync<TResult>(
+        ISpecification<TItem, TResult> specification,
+        QueryRequestOptions requestOptions,
+        CancellationToken cancellationToken = default) where TResult : IQueryResult<TItem>
+    {
         Container container = await containerProvider.GetContainerAsync()
             .ConfigureAwait(false);
 
-        QueryRequestOptions options = new();
-
         if (specification.UseContinuationToken)
         {
-            options.MaxItemCount = specification.PageSize;
+            requestOptions.MaxItemCount = specification.PageSize;
         }
 
         IQueryable<TItem> query = container
             .GetItemLinqQueryable<TItem>(
-                requestOptions: options,
-                continuationToken: specification.ContinuationToken, 
+                requestOptions: requestOptions,
+                continuationToken: specification.ContinuationToken,
                 linqSerializerOptions: optionsMonitor.CurrentValue.SerializationOptions)
             .Where(repositoryExpressionProvider.Default<TItem>());
 
@@ -45,6 +50,6 @@ await GetAllItemsAsync(query, specification.PageSize, cancellationToken)
 
         return specification.PostProcessingAction(
             items.AsReadOnly(), count.Resource, charge + count.RequestCharge,
-            continuationToken);
+            continuationToken);
     }
 }

src/Microsoft.Azure.CosmosRepository/Repositories/DefaultRepository.cs

@@ -2,6 +2,8 @@
 // Licensed under the MIT License.
 
 // ReSharper disable once CheckNamespace
+
+
 namespace Microsoft.Azure.CosmosRepository;
 
 /// <inheritdoc/>

src/Microsoft.Azure.CosmosRepository/Repositories/IReadOnlyRepository.cs

@@ -184,6 +184,26 @@ ValueTask<IPage<TItem>> PageAsync(
         bool returnTotal = false,
         CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Offers a load more paging implementation for infinite scroll scenarios.
+    /// Allows for efficient paging making use of cosmos DBs continuation tokens, making this implementation cost effective.
+    /// </summary>
+    /// <param name="requestOptions">An <see cref="QueryRequestOptions"/> to specify query options for Cosmos SDK</param>
+    /// <param name="predicate">A filter criteria for the paging operation, if null it will get all <see cref="IItem"/>s</param>
+    /// <param name="pageSize">The size of the page to return from cosmos db.</param>
+    /// <param name="continuationToken">The token returned from a previous query, if null starts at the beginning of the data</param>
+    /// <param name="returnTotal">Specifies whether or not to return the total number of items that matched the query. This defaults to false as it can be a very expensive operation.</param>
+    /// <param name="cancellationToken">The cancellation token to use when making asynchronous operations.</param>
+    /// <returns>An <see cref="IPage{T}"/> of <see cref="IItem"/>s</returns>
+    /// <remarks>This method makes use of cosmos dbs continuation tokens for efficient, cost effective paging utilising low RUs</remarks>
+    ValueTask<IPage<TItem>> PageAsync(
+        QueryRequestOptions requestOptions,
+        Expression<Func<TItem, bool>>? predicate = null,
+        int pageSize = 25,
+        string? continuationToken = null,
+        bool returnTotal = false,
+        CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Get items based on a specification.
     /// The specification is used to define which filters are used, the order of the search results and how they are paged.
@@ -202,10 +222,49 @@ ValueTask<TResult> QueryAsync<TResult>(
         CancellationToken cancellationToken = default)
         where TResult : IQueryResult<TItem>;
 
+    /// <summary>
+    /// Get items based on a specification.
+    /// The specification is used to define which filters are used, the order of the search results and how they are paged.
+    /// Depending on how results are paged derive specification implementations from different classes:
+    /// For non paged results derive <see cref="DefaultSpecification{TItem}"/>
+    /// For continuation token derive <see cref="ContinuationTokenSpecification{T}"/>
+    /// For page number results derive <see cref="OffsetByPageNumberSpecification{T}"/>
+    /// </summary>
+    /// <typeparam name="TResult">Decides which paging information is retrieved. Use <see cref="ContinuationTokenSpecification{T}"/></typeparam>
+    /// <param name="specification">A specification used to filtering, ordering and paging. A <see cref="ISpecification{T, TResult}"/></param>
+    /// <param name="requestOptions">An <see cref="QueryRequestOptions"/> to specify query options for Cosmos SDK</param>
+    /// <param name="cancellationToken">The cancellation token to use when making asynchronous operations.</param>
+    /// <returns>The selected <typeparamref name="TResult"/> implementation that implements <see cref="IQueryResult{T}"/> of <see cref="IItem"/></returns>
+    /// <remarks>This method makes use of cosmos dbs continuation tokens for efficient, cost effective paging utilising low RUs</remarks>
+    ValueTask<TResult> QueryAsync<TResult>(
+        ISpecification<TItem, TResult> specification,
+        QueryRequestOptions requestOptions,
+        CancellationToken cancellationToken = default)
+        where TResult : IQueryResult<TItem>;
+
+    /// <summary>
+    /// Offers a load more paging implementation for infinite scroll scenarios.
+    /// Allows for efficient paging making use of cosmos DBs continuation tokens, making this implementation cost effective.
+    /// </summary>
+    /// <param name="predicate">A filter criteria for the paging operation, if null it will get all <see cref="IItem"/>s</param>
+    /// <param name="pageNumber">The page number to return from cosmos db.</param>
+    /// <param name="pageSize">The size of the page to return from cosmos db.</param>
+    /// <param name="returnTotal">Specifies whether or not to return the total number of items that matched the query. This defaults to false as it can be a very expensive operation.</param>
+    /// <param name="cancellationToken">The cancellation token to use when making asynchronous operations.</param>
+    /// <returns>An <see cref="IPageQueryResult{T}"/> of <see cref="IItem"/>s</returns>
+    /// <remarks>This method makes use of Cosmos DB's continuation tokens for efficient, cost effective paging utilizing low RUs</remarks>
+    ValueTask<IPageQueryResult<TItem>> PageAsync(
+        Expression<Func<TItem, bool>>? predicate = null,
+        int pageNumber = 1,
+        int pageSize = 25,
+        bool returnTotal = false,
+        CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Offers a load more paging implementation for infinite scroll scenarios.
     /// Allows for efficient paging making use of cosmos DBs continuation tokens, making this implementation cost effective.
     /// </summary>
+    /// <param name="requestOptions">An <see cref="QueryRequestOptions"/> to specify query options for Cosmos SDK</param>
     /// <param name="predicate">A filter criteria for the paging operation, if null it will get all <see cref="IItem"/>s</param>
     /// <param name="pageNumber">The page number to return from cosmos db.</param>
     /// <param name="pageSize">The size of the page to return from cosmos db.</param>
@@ -214,6 +273,7 @@ ValueTask<TResult> QueryAsync<TResult>(
     /// <returns>An <see cref="IPageQueryResult{T}"/> of <see cref="IItem"/>s</returns>
     /// <remarks>This method makes use of Cosmos DB's continuation tokens for efficient, cost effective paging utilizing low RUs</remarks>
     ValueTask<IPageQueryResult<TItem>> PageAsync(
+        QueryRequestOptions requestOptions,
         Expression<Func<TItem, bool>>? predicate = null,
         int pageNumber = 1,
         int pageSize = 25,
@@ -262,5 +322,49 @@ async IAsyncEnumerable<TItem> PageAsync(
             }
         }
     }
+
+    /// <summary>
+    /// Wraps the existing paging support to return an <see cref="IAsyncEnumerable{T}"/>
+    /// where <c>T</c> is <typeparamref name="TItem"/>.
+    /// </summary>
+    /// <param name="predicate">A filter criteria for the paging operation, if null it will get all <see cref="IItem"/>s</param>
+    /// <param name="limit">The limit of how many items to yield. Defaults to <c>1,000</c>.</param>
+    /// <param name="cancellationToken">The optional <see cref="CancellationToken"/> used to </param>
+    /// <returns>An <see cref="IAsyncEnumerable{T}"/> where <c>T</c> is <typeparamref name="TItem"/>.</returns>
+    /// <remarks>This method makes use of Cosmos DB's continuation tokens for efficient, cost effective paging utilizing low RUs</remarks>
+    async IAsyncEnumerable<TItem> PageAsync(
+        QueryRequestOptions requestOptions,
+        Expression<Func<TItem, bool>>? predicate = null,
+        int limit = 1_000,
+        [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        var collected = 0;
+        var currentPage = 0;
+        var hasMoreResults = true;
+
+        while (hasMoreResults && collected < limit
+            && cancellationToken.IsCancellationRequested is false)
+        {
+            IPageQueryResult<TItem> page = await PageAsync(
+                requestOptions,
+                predicate,
+                pageNumber: ++currentPage,
+                25,
+                returnTotal: false,
+                cancellationToken);
+
+            hasMoreResults = page.HasNextPage.GetValueOrDefault();
+
+            foreach (TItem item in page.Items)
+            {
+                if (collected < limit)
+                {
+                    yield return item;
+                }
+
+                collected++;
+            }
+        }
+    }
 #endif
 }

src/Microsoft.Azure.CosmosRepository/Repositories/InMemoryRepository.cs

@@ -3,6 +3,7 @@
 
 
 // ReSharper disable once CheckNamespace
+
 namespace Microsoft.Azure.CosmosRepository;
 
 /// <inheritdoc/>
@@ -22,4 +23,19 @@ public InMemoryRepository(ISpecificationEvaluator specificationEvaluator) =>
 
     private void NotFound() => throw new CosmosException(string.Empty, HttpStatusCode.NotFound, 0, string.Empty, 0);
     private void Conflict() => throw new CosmosException(string.Empty, HttpStatusCode.Conflict, 0, string.Empty, 0);
+
+    public ValueTask<IPage<TItem>> PageAsync(QueryRequestOptions requestOptions, Expression<Func<TItem, bool>>? predicate = null, int pageSize = 25, string? continuationToken = null, bool returnTotal = false, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ValueTask<TResult> QueryAsync<TResult>(ISpecification<TItem, TResult> specification, QueryRequestOptions requestOptions, CancellationToken cancellationToken = default) where TResult : IQueryResult<TItem>
+    {
+        throw new NotImplementedException();
+    }
+
+    public ValueTask<IPageQueryResult<TItem>> PageAsync(QueryRequestOptions requestOptions, Expression<Func<TItem, bool>>? predicate = null, int pageNumber = 1, int pageSize = 25, bool returnTotal = false, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
 }