From c2bd61b72d5e0f8f6dfc90657c2f1c79e038f64a Mon Sep 17 00:00:00 2001
From: Sergei Calabonga <dev@calabonga.net>
Date: Tue, 3 Dec 2024 11:11:55 +0700
Subject: [PATCH] LastSaveChagesResult renamed

---
 .../Calabonga.UnitOfWork.csproj               |   4 +-
 src/Calabonga.UnitOfWork/IRepository.cs       | 330 +++++++-
 src/Calabonga.UnitOfWork/IRepositoryV2.cs     | 340 --------
 src/Calabonga.UnitOfWork/Repository.cs        | 733 ++++++++++++++++-
 src/Calabonga.UnitOfWork/RepositoryV2.cs      | 746 ------------------
 src/Calabonga.UnitOfWork/SaveChangesResult.cs |   2 +-
 6 files changed, 1060 insertions(+), 1095 deletions(-)
 delete mode 100644 src/Calabonga.UnitOfWork/IRepositoryV2.cs
 delete mode 100644 src/Calabonga.UnitOfWork/RepositoryV2.cs

diff --git a/src/Calabonga.UnitOfWork/Calabonga.UnitOfWork.csproj b/src/Calabonga.UnitOfWork/Calabonga.UnitOfWork.csproj
index 3d53e40..e422b86 100644
--- a/src/Calabonga.UnitOfWork/Calabonga.UnitOfWork.csproj
+++ b/src/Calabonga.UnitOfWork/Calabonga.UnitOfWork.csproj
@@ -2,14 +2,14 @@
 
     <PropertyGroup>
         <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
-        <Version>6.0.0-beta.1</Version>
+        <Version>6.0.0-beta.2</Version>
         <Authors>Calabonga</Authors>
         <Company>Calabonga SOFT</Company>
 	    <Copyright>Calabonga SOFT © 2001-$([System.DateTime]::Now.ToString(yyyy))</Copyright>
         <Description>Unit of Work implementation for EntityFramework Core. For more information please see Calabonga.UnitOfWork package.</Description>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <PackageIcon>logo.png</PackageIcon>
-        <PackageTags>Calabonga EntityFrameworkCore UnitOfWork Repository Extenstion Helper unitofowrk ORM pagination PagedList pattern</PackageTags>
+        <PackageTags>Calabonga EntityFrameworkCore UnitOfWork Repository Extension Helper unitofowrk ORM pagination pattern changes Tracking entites</PackageTags>
         <PackageReleaseNotes>Obsolete methods were removed. Please use TrackingType parameter for DbContext operations: NoTraking, Tracking and NoTrackingWithIdentityResolution.</PackageReleaseNotes>
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
         <PackageProjectUrl>https://www.calabonga.net</PackageProjectUrl>
diff --git a/src/Calabonga.UnitOfWork/IRepository.cs b/src/Calabonga.UnitOfWork/IRepository.cs
index bb0ccbf..434a21f 100644
--- a/src/Calabonga.UnitOfWork/IRepository.cs
+++ b/src/Calabonga.UnitOfWork/IRepository.cs
@@ -1,4 +1,5 @@
-using Microsoft.EntityFrameworkCore;
+using Calabonga.PagedListCore;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.ChangeTracking;
 using Microsoft.EntityFrameworkCore.Query;
 using System;
@@ -14,10 +15,8 @@ namespace Calabonga.UnitOfWork;
 /// Defines the interfaces for generic repository.
 /// </summary>
 /// <typeparam name="TEntity">The type of the entity.</typeparam>
-public partial interface IRepository<TEntity> where TEntity : class
+public interface IRepository<TEntity> where TEntity : class
 {
-
-
     #region Find
 
     /// <summary>
@@ -386,4 +385,327 @@ Task<decimal> SumAsync(
     IQueryable<TEntity> FromSql(string sql, params object[] parameters);
 
     #endregion
+
+    #region GetPagedList
+
+    /// <summary>
+    /// Gets the <see cref="IPagedList{T}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.. This method default no-tracking query.
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="pageIndex">The index of page.</param>
+    /// <param name="pageSize">The size of the page.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>This method default no-tracking query.</remarks>
+    IPagedList<TEntity> GetPagedList(
+    Expression<Func<TEntity, bool>>? predicate = null,
+    Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+    Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+    int pageIndex = 0,
+    int pageSize = 20,
+    TrackingType trackingType = TrackingType.NoTracking,
+    bool ignoreQueryFilters = false,
+    bool ignoreAutoIncludes = false);
+
+    /// <summary>
+    /// Gets the <see cref="IPagedList{TEntity}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="pageIndex">The index of page.</param>
+    /// <param name="pageSize">The size of the page.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="cancellationToken">
+    ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
+    /// </param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>This method default no-tracking query.</remarks>
+    Task<IPagedList<TEntity>> GetPagedListAsync(
+    Expression<Func<TEntity, bool>>? predicate = null,
+    Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+    Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+    int pageIndex = 0,
+    int pageSize = 20,
+    TrackingType trackingType = TrackingType.NoTracking,
+    CancellationToken cancellationToken = default,
+    bool ignoreQueryFilters = false,
+    bool ignoreAutoIncludes = false);
+
+    /// <summary>
+    /// Gets the <see cref="IPagedList{TResult}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="pageIndex">The index of page.</param>
+    /// <param name="pageSize">The size of the page.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TResult}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>This method default no-tracking query.</remarks>
+    IPagedList<TResult> GetPagedList<TResult>(
+    Expression<Func<TEntity, TResult>> selector,
+    Expression<Func<TEntity, bool>>? predicate = null,
+    Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+    Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+    int pageIndex = 0,
+    int pageSize = 20,
+    TrackingType trackingType = TrackingType.NoTracking,
+    bool ignoreQueryFilters = false,
+    bool ignoreAutoIncludes = false) where TResult : class;
+
+    /// <summary>
+    /// Gets the <see cref="IPagedList{TEntity}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="pageIndex">The index of page.</param>
+    /// <param name="pageSize">The size of the page.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="cancellationToken">
+    ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
+    /// </param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>This method default no-tracking query.</remarks>
+    Task<IPagedList<TResult>> GetPagedListAsync<TResult>(
+    Expression<Func<TEntity, TResult>> selector,
+    Expression<Func<TEntity, bool>>? predicate = null,
+    Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+    Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+    int pageIndex = 0,
+    int pageSize = 20,
+    TrackingType trackingType = TrackingType.NoTracking,
+    CancellationToken cancellationToken = default,
+    bool ignoreQueryFilters = false,
+    bool ignoreAutoIncludes = false) where TResult : class;
+
+    #endregion
+
+    #region GetFirstOrDefault
+
+    /// <summary>
+    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>This method defaults to a read-only, no-tracking query.</remarks>
+    TEntity? GetFirstOrDefault(
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false);
+
+    /// <summary>
+    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>This method defaults to a read-only, no-tracking query.</remarks>
+    TResult? GetFirstOrDefault<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false);
+
+    /// <summary>
+    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
+    Task<TResult?> GetFirstOrDefaultAsync<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false);
+
+    /// <summary>
+    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>Ex: This method defaults to a read-only, no-tracking query. </remarks>
+    Task<TEntity?> GetFirstOrDefaultAsync
+    (
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false);
+
+    #endregion
+
+    #region GetAll
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    IQueryable<TEntity> GetAll(TrackingType trackingType = TrackingType.NoTracking);
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
+    IQueryable<TResult> GetAll<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        TrackingType trackingType = TrackingType.NoTracking);
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
+    IQueryable<TResult> GetAll<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        TrackingType trackingType = TrackingType.NoTracking);
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
+    IQueryable<TEntity> GetAll(
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false);
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
+    IQueryable<TResult> GetAll<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false);
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
+    Task<IList<TEntity>> GetAllAsync(TrackingType trackingType = TrackingType.NoTracking);
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
+    Task<IList<TResult>> GetAllAsync<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        TrackingType trackingType = TrackingType.NoTracking);
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
+    Task<IList<TEntity>> GetAllAsync(
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false);
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
+    Task<IList<TResult>> GetAllAsync<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false);
+
+    #endregion
 }
\ No newline at end of file
diff --git a/src/Calabonga.UnitOfWork/IRepositoryV2.cs b/src/Calabonga.UnitOfWork/IRepositoryV2.cs
deleted file mode 100644
index 89a159d..0000000
--- a/src/Calabonga.UnitOfWork/IRepositoryV2.cs
+++ /dev/null
@@ -1,340 +0,0 @@
-using Calabonga.PagedListCore;
-using Microsoft.EntityFrameworkCore.Query;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Calabonga.UnitOfWork;
-
-/// <summary>
-/// Defines the interfaces for generic repository.
-/// </summary>
-/// <typeparam name="TEntity">The type of the entity.</typeparam>
-public partial interface IRepository<TEntity> where TEntity : class
-{
-    #region GetPagedList
-
-    /// <summary>
-    /// Gets the <see cref="IPagedList{T}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.. This method default no-tracking query.
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="pageIndex">The index of page.</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>This method default no-tracking query.</remarks>
-    IPagedList<TEntity> GetPagedList(
-    Expression<Func<TEntity, bool>>? predicate = null,
-    Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-    Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-    int pageIndex = 0,
-    int pageSize = 20,
-    TrackingType trackingType = TrackingType.NoTracking,
-    bool ignoreQueryFilters = false,
-    bool ignoreAutoIncludes = false);
-
-    /// <summary>
-    /// Gets the <see cref="IPagedList{TEntity}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="pageIndex">The index of page.</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="cancellationToken">
-    ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-    /// </param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>This method default no-tracking query.</remarks>
-    Task<IPagedList<TEntity>> GetPagedListAsync(
-    Expression<Func<TEntity, bool>>? predicate = null,
-    Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-    Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-    int pageIndex = 0,
-    int pageSize = 20,
-    TrackingType trackingType = TrackingType.NoTracking,
-    CancellationToken cancellationToken = default,
-    bool ignoreQueryFilters = false,
-    bool ignoreAutoIncludes = false);
-
-    /// <summary>
-    /// Gets the <see cref="IPagedList{TResult}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="pageIndex">The index of page.</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TResult}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>This method default no-tracking query.</remarks>
-    IPagedList<TResult> GetPagedList<TResult>(
-    Expression<Func<TEntity, TResult>> selector,
-    Expression<Func<TEntity, bool>>? predicate = null,
-    Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-    Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-    int pageIndex = 0,
-    int pageSize = 20,
-    TrackingType trackingType = TrackingType.NoTracking,
-    bool ignoreQueryFilters = false,
-    bool ignoreAutoIncludes = false) where TResult : class;
-
-    /// <summary>
-    /// Gets the <see cref="IPagedList{TEntity}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="pageIndex">The index of page.</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="cancellationToken">
-    ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-    /// </param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>This method default no-tracking query.</remarks>
-    Task<IPagedList<TResult>> GetPagedListAsync<TResult>(
-    Expression<Func<TEntity, TResult>> selector,
-    Expression<Func<TEntity, bool>>? predicate = null,
-    Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-    Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-    int pageIndex = 0,
-    int pageSize = 20,
-    TrackingType trackingType = TrackingType.NoTracking,
-    CancellationToken cancellationToken = default,
-    bool ignoreQueryFilters = false,
-    bool ignoreAutoIncludes = false) where TResult : class;
-
-    #endregion
-
-    #region GetFirstOrDefault
-
-    /// <summary>
-    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>This method defaults to a read-only, no-tracking query.</remarks>
-    TEntity? GetFirstOrDefault(
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false);
-
-    /// <summary>
-    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>This method defaults to a read-only, no-tracking query.</remarks>
-    TResult? GetFirstOrDefault<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false);
-
-    /// <summary>
-    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
-    Task<TResult?> GetFirstOrDefaultAsync<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false);
-
-    /// <summary>
-    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>Ex: This method defaults to a read-only, no-tracking query. </remarks>
-    Task<TEntity?> GetFirstOrDefaultAsync
-    (
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false);
-
-    #endregion
-
-    #region GetAll
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    IQueryable<TEntity> GetAll(TrackingType trackingType = TrackingType.NoTracking);
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
-    IQueryable<TResult> GetAll<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        TrackingType trackingType = TrackingType.NoTracking);
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
-    IQueryable<TResult> GetAll<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        TrackingType trackingType = TrackingType.NoTracking);
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
-    IQueryable<TEntity> GetAll(
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false);
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
-    IQueryable<TResult> GetAll<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false);
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
-    Task<IList<TEntity>> GetAllAsync(TrackingType trackingType = TrackingType.NoTracking);
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
-    Task<IList<TResult>> GetAllAsync<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        TrackingType trackingType = TrackingType.NoTracking);
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
-    Task<IList<TEntity>> GetAllAsync(
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false);
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
-    Task<IList<TResult>> GetAllAsync<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false);
-
-    #endregion
-}
\ No newline at end of file
diff --git a/src/Calabonga.UnitOfWork/Repository.cs b/src/Calabonga.UnitOfWork/Repository.cs
index f7ca7f1..af2159c 100644
--- a/src/Calabonga.UnitOfWork/Repository.cs
+++ b/src/Calabonga.UnitOfWork/Repository.cs
@@ -1,4 +1,5 @@
-using Microsoft.EntityFrameworkCore;
+using Calabonga.PagedListCore;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.ChangeTracking;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Query;
@@ -16,7 +17,7 @@ namespace Calabonga.UnitOfWork;
 /// Represents a default generic repository implements the <see cref="IRepository{TEntity}"/> interface.
 /// </summary>
 /// <typeparam name="TEntity">The type of the entity.</typeparam>
-public sealed partial class Repository<TEntity> : IRepository<TEntity> where TEntity : class
+public sealed class Repository<TEntity> : IRepository<TEntity> where TEntity : class
 {
     private readonly DbContext _dbContext;
     private readonly DbSet<TEntity> _dbSet;
@@ -466,4 +467,732 @@ public void Delete(object id)
     public Task<int> ExecuteDeleteAsync(CancellationToken cancellationToken = default) => _dbSet.ExecuteDeleteAsync(cancellationToken);
 
     #endregion
+
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
+    public IQueryable<TEntity> GetAll(TrackingType trackingType = TrackingType.NoTracking) =>
+        trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
+    public IQueryable<TResult> GetAll<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        TrackingType trackingType = TrackingType.NoTracking) =>
+        trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking().Select(selector),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution().Select(selector),
+            TrackingType.Tracking => _dbSet.Select(selector),
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
+    public IQueryable<TResult> GetAll<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        TrackingType trackingType = TrackingType.NoTracking)
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        return query.Select(selector);
+    }
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
+    public IQueryable<TEntity> GetAll(
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+        if (include is not null)
+        {
+            query = include(query);
+        }
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        return orderBy is not null
+            ? orderBy(query)
+            : query;
+    }
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
+    public IQueryable<TResult> GetAll<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+    {
+
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+        if (include is not null)
+        {
+            query = include(query);
+        }
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        return orderBy != null
+            ? orderBy(query).Select(selector)
+            : query.Select(selector);
+    }
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
+    public async Task<IList<TEntity>> GetAllAsync(TrackingType trackingType = TrackingType.NoTracking) =>
+        trackingType switch
+        {
+            TrackingType.NoTracking => await _dbSet.AsNoTracking().ToListAsync(),
+            TrackingType.NoTrackingWithIdentityResolution => await _dbSet.AsNoTrackingWithIdentityResolution().ToListAsync(),
+            TrackingType.Tracking => await _dbSet.ToListAsync(),
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
+    public async Task<IList<TResult>> GetAllAsync<TResult>(Expression<Func<TEntity, TResult>> selector, TrackingType trackingType = TrackingType.NoTracking) =>
+        trackingType switch
+        {
+            TrackingType.NoTracking => await _dbSet.AsNoTracking().Select(selector).ToListAsync(),
+            TrackingType.NoTrackingWithIdentityResolution => await _dbSet.AsNoTrackingWithIdentityResolution().Select(selector).ToListAsync(),
+            TrackingType.Tracking => await _dbSet.Select(selector).ToListAsync(),
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
+    public async Task<IList<TEntity>> GetAllAsync(Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+        if (include is not null)
+        {
+            query = include(query);
+        }
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        if (orderBy is not null)
+        {
+            return await orderBy(query).ToListAsync();
+        }
+
+        return await query.ToListAsync();
+    }
+
+    /// <summary>
+    /// Gets all entities. This method is not recommended
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
+    public async Task<IList<TResult>> GetAllAsync<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+        if (include is not null)
+        {
+            query = include(query);
+        }
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        return orderBy is not null
+            ? await orderBy(query).Select(selector).ToListAsync()
+            : await query.Select(selector).ToListAsync();
+    }
+
+    /// <summary>
+    /// Gets the <see cref="IPagedList{T}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.. This method default no-tracking query.
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="pageIndex">The index of page.</param>
+    /// <param name="pageSize">The size of the page.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>This method default no-tracking query.</remarks>
+    public IPagedList<TEntity> GetPagedList(
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        int pageIndex = 0,
+        int pageSize = 20,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+
+        if (include is not null)
+        {
+            query = include(query);
+        }
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        return orderBy is not null
+            ? orderBy(query).ToPagedList(pageIndex, pageSize)
+            : query.ToPagedList(pageIndex, pageSize);
+    }
+
+    /// <summary>
+    /// Gets the <see cref="IPagedList{TEntity}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="pageIndex">The index of page.</param>
+    /// <param name="pageSize">The size of the page.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="cancellationToken">
+    ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
+    /// </param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>This method default no-tracking query.</remarks>
+    public Task<IPagedList<TEntity>> GetPagedListAsync(
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        int pageIndex = 0,
+        int pageSize = 20,
+        TrackingType trackingType = TrackingType.NoTracking,
+        CancellationToken cancellationToken = default,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+
+        if (include is not null)
+        {
+            query = include(query);
+        }
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        return orderBy is not null
+            ? orderBy(query).ToPagedListAsync(pageIndex, pageSize, 0, cancellationToken)
+            : query.ToPagedListAsync(pageIndex, pageSize, 0, cancellationToken);
+    }
+
+    /// <summary>
+    /// Gets the <see cref="IPagedList{TResult}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="pageIndex">The index of page.</param>
+    /// <param name="pageSize">The size of the page.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TResult}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>This method default no-tracking query.</remarks>
+    public IPagedList<TResult> GetPagedList<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        int pageIndex = 0,
+        int pageSize = 20,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+        where TResult : class
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+        if (include is not null)
+        {
+            query = include(query);
+        }
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        return orderBy is not null
+            ? orderBy(query).Select(selector).ToPagedList(pageIndex, pageSize)
+            : query.Select(selector).ToPagedList(pageIndex, pageSize);
+    }
+
+    /// <summary>
+    /// Gets the <see cref="IPagedList{TEntity}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="pageIndex">The index of page.</param>
+    /// <param name="pageSize">The size of the page.</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="cancellationToken">
+    ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
+    /// </param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>This method default no-tracking query.</remarks>
+    public Task<IPagedList<TResult>> GetPagedListAsync<TResult>(Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        int pageIndex = 0,
+        int pageSize = 20,
+        TrackingType trackingType = TrackingType.NoTracking,
+        CancellationToken cancellationToken = default,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+        where TResult : class
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+        if (include != null)
+        {
+            query = include(query);
+        }
+
+        if (predicate != null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        return orderBy != null
+            ? orderBy(query).Select(selector).ToPagedListAsync(pageIndex, pageSize, 0, cancellationToken)
+            : query.Select(selector).ToPagedListAsync(pageIndex, pageSize, 0, cancellationToken);
+    }
+
+    /// <summary>
+    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
+    /// </summary>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>This method defaults to a read-only, no-tracking query.</remarks>
+    public TEntity? GetFirstOrDefault(Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+        if (include is not null)
+        {
+            query = include(query);
+        }
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        return orderBy is not null
+            ? orderBy(query).FirstOrDefault()
+            : query.FirstOrDefault();
+    }
+
+    public async Task<TEntity?> GetFirstOrDefaultAsync(Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+        if (include is not null)
+        {
+            query = include(query);
+        }
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        return orderBy is not null
+            ? await orderBy(query).FirstOrDefaultAsync()
+            : await query.FirstOrDefaultAsync();
+    }
+
+    public TResult? GetFirstOrDefault<TResult>(
+        Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+        if (include is not null)
+        {
+            query = include(query);
+        }
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        return orderBy is not null
+            ? orderBy(query).Select(selector).FirstOrDefault()
+            : query.Select(selector).FirstOrDefault();
+    }
+
+    /// <summary>
+    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
+    /// </summary>
+    /// <param name="selector">The selector for projection.</param>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <param name="orderBy">A function to order elements.</param>
+    /// <param name="include">A function to include navigation properties</param>
+    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
+    /// <param name="ignoreQueryFilters">Ignore query filters</param>
+    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
+    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
+    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
+    public async Task<TResult?> GetFirstOrDefaultAsync<TResult>(Expression<Func<TEntity, TResult>> selector,
+        Expression<Func<TEntity, bool>>? predicate = null,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
+        TrackingType trackingType = TrackingType.NoTracking,
+        bool ignoreQueryFilters = false,
+        bool ignoreAutoIncludes = false)
+    {
+        var query = trackingType switch
+        {
+            TrackingType.NoTracking => _dbSet.AsNoTracking(),
+            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
+            TrackingType.Tracking => _dbSet,
+            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
+        };
+
+        if (include is not null)
+        {
+            query = include(query);
+        }
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        if (ignoreQueryFilters)
+        {
+            query = query.IgnoreQueryFilters();
+        }
+
+        if (ignoreAutoIncludes)
+        {
+            query = query.IgnoreAutoIncludes();
+        }
+
+        return orderBy is not null
+            ? await orderBy(query).Select(selector).FirstOrDefaultAsync()
+            : await query.Select(selector).FirstOrDefaultAsync();
+    }
 }
\ No newline at end of file
diff --git a/src/Calabonga.UnitOfWork/RepositoryV2.cs b/src/Calabonga.UnitOfWork/RepositoryV2.cs
deleted file mode 100644
index 8f375fb..0000000
--- a/src/Calabonga.UnitOfWork/RepositoryV2.cs
+++ /dev/null
@@ -1,746 +0,0 @@
-using Calabonga.PagedListCore;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Query;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Calabonga.UnitOfWork;
-
-/// <summary>
-/// Represents a default generic repository implements the <see cref="IRepository{TEntity}"/> interface.
-/// </summary>
-/// <typeparam name="TEntity">The type of the entity.</typeparam>
-public sealed partial class Repository<TEntity> : IRepository<TEntity> where TEntity : class
-{
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
-    public IQueryable<TEntity> GetAll(TrackingType trackingType = TrackingType.NoTracking) =>
-        trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
-    public IQueryable<TResult> GetAll<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        TrackingType trackingType = TrackingType.NoTracking) =>
-        trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking().Select(selector),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution().Select(selector),
-            TrackingType.Tracking => _dbSet.Select(selector),
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
-    public IQueryable<TResult> GetAll<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        TrackingType trackingType = TrackingType.NoTracking)
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        return query.Select(selector);
-    }
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
-    public IQueryable<TEntity> GetAll(
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-        if (include is not null)
-        {
-            query = include(query);
-        }
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        return orderBy is not null
-            ? orderBy(query)
-            : query;
-    }
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
-    public IQueryable<TResult> GetAll<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-    {
-
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-        if (include is not null)
-        {
-            query = include(query);
-        }
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        return orderBy != null
-            ? orderBy(query).Select(selector)
-            : query.Select(selector);
-    }
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
-    public async Task<IList<TEntity>> GetAllAsync(TrackingType trackingType = TrackingType.NoTracking) =>
-        trackingType switch
-        {
-            TrackingType.NoTracking => await _dbSet.AsNoTracking().ToListAsync(),
-            TrackingType.NoTrackingWithIdentityResolution => await _dbSet.AsNoTrackingWithIdentityResolution().ToListAsync(),
-            TrackingType.Tracking => await _dbSet.ToListAsync(),
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <returns>The <see cref="IQueryable{TEntity}"/>.</returns>
-    public async Task<IList<TResult>> GetAllAsync<TResult>(Expression<Func<TEntity, TResult>> selector, TrackingType trackingType = TrackingType.NoTracking) =>
-        trackingType switch
-        {
-            TrackingType.NoTracking => await _dbSet.AsNoTracking().Select(selector).ToListAsync(),
-            TrackingType.NoTrackingWithIdentityResolution => await _dbSet.AsNoTrackingWithIdentityResolution().Select(selector).ToListAsync(),
-            TrackingType.Tracking => await _dbSet.Select(selector).ToListAsync(),
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
-    public async Task<IList<TEntity>> GetAllAsync(Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-        if (include is not null)
-        {
-            query = include(query);
-        }
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        if (orderBy is not null)
-        {
-            return await orderBy(query).ToListAsync();
-        }
-
-        return await query.ToListAsync();
-    }
-
-    /// <summary>
-    /// Gets all entities. This method is not recommended
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
-    public async Task<IList<TResult>> GetAllAsync<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-        if (include is not null)
-        {
-            query = include(query);
-        }
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        return orderBy is not null
-            ? await orderBy(query).Select(selector).ToListAsync()
-            : await query.Select(selector).ToListAsync();
-    }
-
-    /// <summary>
-    /// Gets the <see cref="IPagedList{T}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.. This method default no-tracking query.
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="pageIndex">The index of page.</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>This method default no-tracking query.</remarks>
-    public IPagedList<TEntity> GetPagedList(
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        int pageIndex = 0,
-        int pageSize = 20,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-
-        if (include is not null)
-        {
-            query = include(query);
-        }
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        return orderBy is not null
-            ? orderBy(query).ToPagedList(pageIndex, pageSize)
-            : query.ToPagedList(pageIndex, pageSize);
-    }
-
-    /// <summary>
-    /// Gets the <see cref="IPagedList{TEntity}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="pageIndex">The index of page.</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="cancellationToken">
-    ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-    /// </param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>This method default no-tracking query.</remarks>
-    public Task<IPagedList<TEntity>> GetPagedListAsync(
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        int pageIndex = 0,
-        int pageSize = 20,
-        TrackingType trackingType = TrackingType.NoTracking,
-        CancellationToken cancellationToken = default,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-
-        if (include is not null)
-        {
-            query = include(query);
-        }
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        return orderBy is not null
-            ? orderBy(query).ToPagedListAsync(pageIndex, pageSize, 0, cancellationToken)
-            : query.ToPagedListAsync(pageIndex, pageSize, 0, cancellationToken);
-    }
-
-    /// <summary>
-    /// Gets the <see cref="IPagedList{TResult}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="pageIndex">The index of page.</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TResult}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>This method default no-tracking query.</remarks>
-    public IPagedList<TResult> GetPagedList<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        int pageIndex = 0,
-        int pageSize = 20,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-        where TResult : class
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-        if (include is not null)
-        {
-            query = include(query);
-        }
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        return orderBy is not null
-            ? orderBy(query).Select(selector).ToPagedList(pageIndex, pageSize)
-            : query.Select(selector).ToPagedList(pageIndex, pageSize);
-    }
-
-    /// <summary>
-    /// Gets the <see cref="IPagedList{TEntity}"/> based on a predicate, orderBy delegate and page information. This method default no-tracking query.
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="pageIndex">The index of page.</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="cancellationToken">
-    ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-    /// </param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>This method default no-tracking query.</remarks>
-    public Task<IPagedList<TResult>> GetPagedListAsync<TResult>(Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        int pageIndex = 0,
-        int pageSize = 20,
-        TrackingType trackingType = TrackingType.NoTracking,
-        CancellationToken cancellationToken = default,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-        where TResult : class
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-        if (include != null)
-        {
-            query = include(query);
-        }
-
-        if (predicate != null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        return orderBy != null
-            ? orderBy(query).Select(selector).ToPagedListAsync(pageIndex, pageSize, 0, cancellationToken)
-            : query.Select(selector).ToPagedListAsync(pageIndex, pageSize, 0, cancellationToken);
-    }
-
-    /// <summary>
-    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
-    /// </summary>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>This method defaults to a read-only, no-tracking query.</remarks>
-    public TEntity? GetFirstOrDefault(Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-        if (include is not null)
-        {
-            query = include(query);
-        }
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        return orderBy is not null
-            ? orderBy(query).FirstOrDefault()
-            : query.FirstOrDefault();
-    }
-
-    public async Task<TEntity?> GetFirstOrDefaultAsync(Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-        if (include is not null)
-        {
-            query = include(query);
-        }
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        return orderBy is not null
-            ? await orderBy(query).FirstOrDefaultAsync()
-            : await query.FirstOrDefaultAsync();
-    }
-
-    public TResult? GetFirstOrDefault<TResult>(
-        Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-        if (include is not null)
-        {
-            query = include(query);
-        }
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        return orderBy is not null
-            ? orderBy(query).Select(selector).FirstOrDefault()
-            : query.Select(selector).FirstOrDefault();
-    }
-
-    /// <summary>
-    /// Gets the first or default entity based on a predicate, orderBy delegate and include delegate. This method defaults to a read-only, no-tracking query.
-    /// </summary>
-    /// <param name="selector">The selector for projection.</param>
-    /// <param name="predicate">A function to test each element for a condition.</param>
-    /// <param name="orderBy">A function to order elements.</param>
-    /// <param name="include">A function to include navigation properties</param>
-    /// <param name="trackingType"><c>NoTracking</c> to disable changing tracking; <c>Tracking</c> to enable changing tracking; <c>NoTrackingWithIdentityResolution</c> to disable changing tracking but identity resolving. Default to <c>NoTracking</c>.</param>
-    /// <param name="ignoreQueryFilters">Ignore query filters</param>
-    /// <param name="ignoreAutoIncludes">Ignore automatic includes</param>
-    /// <returns>An <see cref="IPagedList{TEntity}"/> that contains elements that satisfy the condition specified by <paramref name="predicate"/>.</returns>
-    /// <remarks>Ex: This method defaults to a read-only, no-tracking query.</remarks>
-    public async Task<TResult?> GetFirstOrDefaultAsync<TResult>(Expression<Func<TEntity, TResult>> selector,
-        Expression<Func<TEntity, bool>>? predicate = null,
-        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null,
-        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>>? include = null,
-        TrackingType trackingType = TrackingType.NoTracking,
-        bool ignoreQueryFilters = false,
-        bool ignoreAutoIncludes = false)
-    {
-        var query = trackingType switch
-        {
-            TrackingType.NoTracking => _dbSet.AsNoTracking(),
-            TrackingType.NoTrackingWithIdentityResolution => _dbSet.AsNoTrackingWithIdentityResolution(),
-            TrackingType.Tracking => _dbSet,
-            _ => throw new ArgumentOutOfRangeException(nameof(trackingType), trackingType, null)
-        };
-
-        if (include is not null)
-        {
-            query = include(query);
-        }
-
-        if (predicate is not null)
-        {
-            query = query.Where(predicate);
-        }
-
-        if (ignoreQueryFilters)
-        {
-            query = query.IgnoreQueryFilters();
-        }
-
-        if (ignoreAutoIncludes)
-        {
-            query = query.IgnoreAutoIncludes();
-        }
-
-        return orderBy is not null
-            ? await orderBy(query).Select(selector).FirstOrDefaultAsync()
-            : await query.Select(selector).FirstOrDefaultAsync();
-    }
-}
\ No newline at end of file
diff --git a/src/Calabonga.UnitOfWork/SaveChangesResult.cs b/src/Calabonga.UnitOfWork/SaveChangesResult.cs
index 3456c0d..10b7432 100644
--- a/src/Calabonga.UnitOfWork/SaveChangesResult.cs
+++ b/src/Calabonga.UnitOfWork/SaveChangesResult.cs
@@ -30,7 +30,7 @@ public sealed class SaveChangesResult
     /// Adds new message to result
     /// </summary>
     /// <param name="message"></param>
-    private void AddMessage(string message) => Messages.Add(message);
+    public void AddMessage(string message) => Messages.Add(message);
 
     /// <summary>
     /// List of the error should appear there