diff --git a/src/AutSoft.Linq/AutSoft.Linq.csproj b/src/AutSoft.Linq/AutSoft.Linq.csproj
index 6c7848f..2cf09f5 100644
--- a/src/AutSoft.Linq/AutSoft.Linq.csproj
+++ b/src/AutSoft.Linq/AutSoft.Linq.csproj
@@ -5,9 +5,6 @@
     <Nullable>enable</Nullable>
     <ErrorReport>send</ErrorReport>
   </PropertyGroup>
-  <ItemGroup>
-    <PackageReference Include="AutoMapper" />
-  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\AutSoft.Core\AutSoft.Common.csproj" />
   </ItemGroup>
diff --git a/src/AutSoft.Linq/Queryable/OrderByExtensions.cs b/src/AutSoft.Linq/Queryable/OrderByExtensions.cs
index 8ca4424..f0d986a 100644
--- a/src/AutSoft.Linq/Queryable/OrderByExtensions.cs
+++ b/src/AutSoft.Linq/Queryable/OrderByExtensions.cs
@@ -1,7 +1,3 @@
-using AutoMapper;
-using AutoMapper.Internal;
-
-using AutSoft.Common.Exceptions;
 using AutSoft.Linq.Models;
 
 using Microsoft.EntityFrameworkCore;
@@ -75,7 +71,6 @@ public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(
     /// <returns><see cref="IQueryable{T}" /> with ordering information</returns>
     /// <remarks>
     /// This overload fits if the page request contains ordering information in entity model level.
-    /// If you use AutoMapper's <see cref="IMapper.ProjectTo"/> consider to use overloads with TDto type parameters
     /// </remarks>
     public static IOrderedQueryable<TSource> OrderBy<TSource>(
         this IQueryable<TSource> source,
@@ -88,83 +83,4 @@ public static IOrderedQueryable<TSource> OrderBy<TSource>(
                 : e => EF.Property<object>(e!, pageRequest.OrderBy),
             pageRequest.OrderDirection);
     }
-
-    /// <summary>
-    /// OrderBy where the desired ordering is coming from a <see cref="PageRequest"/>
-    /// and mapping expression calculated based on the provided mapping configuration
-    /// </summary>
-    /// <typeparam name="TSource">Element's type</typeparam>
-    /// <typeparam name="TDto">Target DTO's type to find mapping information</typeparam>
-    /// <param name="source">An <see cref="IQueryable{T}" /> to order</param>
-    /// <param name="pageRequest">A page request which contains the desired column's name to order.</param>
-    /// <param name="defaultOrderingSelector">If the page request does not define any ordering information</param>
-    /// <param name="mappings">AutoMapper mapping configuration which contains mapping expressions for TSource -> TDto type conversion</param>
-    /// <returns><see cref="IQueryable{T}" /> with ordering information</returns>
-    public static IOrderedQueryable<TSource> OrderBy<TSource, TDto>(
-        this IQueryable<TSource> source,
-        PageRequest pageRequest,
-        Expression<Func<TSource, object?>> defaultOrderingSelector,
-        IConfigurationProvider mappings)
-    {
-        var orderKeySelector = GetOrderKeySelector<TSource, TDto>(pageRequest, defaultOrderingSelector, mappings);
-
-        return source.OrderBy(orderKeySelector, pageRequest.OrderDirection);
-    }
-
-    /// <summary>
-    /// OrderBy where the desired ordering is coming from a <see cref="PageRequest"/>
-    /// and mapping expression calculated based on the provided mapping configuration
-    /// </summary>
-    /// <typeparam name="TSource">Element's type</typeparam>
-    /// <typeparam name="TDto">Target DTO's type to find mapping information</typeparam>
-    /// <param name="source">An <see cref="IQueryable{T}" /> to order</param>
-    /// <param name="pageRequest">A page request which contains the desired column's name to order.</param>
-    /// <param name="defaultOrderingSelector">If the page request does not define any ordering information</param>
-    /// <param name="defaultOrderDirection">Ordering direction for <paramref name="defaultOrderingSelector"/></param>
-    /// <param name="mappings">AutoMapper mapping configuration which contains mapping expressions for TSource -> TDto type conversion</param>
-    /// <returns><see cref="IQueryable{T}" /> with ordering information</returns>
-    public static IOrderedQueryable<TSource> OrderBy<TSource, TDto>(
-       this IQueryable<TSource> source,
-       PageRequest pageRequest,
-       Expression<Func<TSource, object?>> defaultOrderingSelector,
-       OrderDirection defaultOrderDirection,
-       IConfigurationProvider mappings)
-    {
-        var orderKeySelector = GetOrderKeySelector<TSource, TDto>(pageRequest, defaultOrderingSelector, mappings);
-
-        if (orderKeySelector == defaultOrderingSelector)
-            return source.OrderBy(orderKeySelector, defaultOrderDirection);
-
-        return source.OrderBy(orderKeySelector, pageRequest.OrderDirection);
-    }
-
-    private static Expression<Func<TSource, object?>> GetOrderKeySelector<TSource, TDto>(
-        PageRequest pageRequest,
-        Expression<Func<TSource, object?>> defaultOrderingSelector,
-        IConfigurationProvider mappings)
-    {
-        if (!string.IsNullOrEmpty(pageRequest.OrderBy))
-        {
-            // The caller want to order based on a not existed or an unsortable property
-            var pi = typeof(TDto).GetProperty(pageRequest.OrderBy);
-            if (pi?.IsSortable() != true)
-                throw new ValidationException(pageRequest.OrderBy, "Cannot sort based on this property!");
-        }
-
-        var orderKeySelector = defaultOrderingSelector;
-
-        if (!string.IsNullOrEmpty(pageRequest.OrderBy))
-        {
-            var expression = mappings.Internal().FindTypeMapFor<TSource, TDto>()
-                ?.PropertyMaps
-                ?.FirstOrDefault(m => m.CustomMapExpression != null && m.DestinationName == pageRequest.OrderBy)
-                ?.CustomMapExpression;
-
-            orderKeySelector = expression != null
-                ? Expression.Lambda<Func<TSource, object?>>(Expression.Convert(expression.Body, typeof(object)), expression.Parameters)
-                : e => EF.Property<object>(e!, pageRequest.OrderBy);
-        }
-
-        return orderKeySelector;
-    }
 }
diff --git a/test/AutSoft.Linq.Tests/Queryable/OrderByExtensions/OrderByExtensionsTests.OrderByFromMappings.cs b/test/AutSoft.Linq.Tests/Queryable/OrderByExtensions/OrderByExtensionsTests.OrderByFromMappings.cs
deleted file mode 100644
index 70a447c..0000000
--- a/test/AutSoft.Linq.Tests/Queryable/OrderByExtensions/OrderByExtensionsTests.OrderByFromMappings.cs
+++ /dev/null
@@ -1,145 +0,0 @@
-using AutoMapper.QueryableExtensions;
-
-using AutSoft.Common.Exceptions;
-using AutSoft.Linq.Models;
-using AutSoft.Linq.Queryable;
-
-using FluentAssertions;
-
-using System.Linq.Expressions;
-
-namespace AutSoft.Linq.Tests.Queryable.OrderByExtensions;
-
-public partial class OrderByExtensionsTests
-{
-    public class OrderByFromMappings : OrderByExtensionsTests
-    {
-        public static List<(string orderColumn, Expression<Func<PersonDto, object?>> expectedOrderExpression)> OrderExpression() => new()
-        {
-            (nameof(PersonDto.Id), p => p.Id),
-            (nameof(PersonDto.Name), p => p.Name),
-            (nameof(PersonDto.Age), p => p.Age),
-        };
-
-        [Theory]
-        [CombinatorialData]
-        public void Should_ReturnOrdered(
-            [CombinatorialMemberData(nameof(OrderExpression))] (string orderColumn, Expression<Func<PersonDto, object?>> expectedOrderExpression) ordering,
-            OrderDirection orderDirection)
-        {
-            // Act
-            var ordered = Subject
-                .OrderBy<Person, PersonDto>(
-                    new PageRequest { OrderBy = ordering.orderColumn, OrderDirection = orderDirection },
-                    p => p.Id,
-                    Mapper.ConfigurationProvider)
-                .ProjectTo<PersonDto>(Mapper.ConfigurationProvider)
-                .ToList();
-
-            // Assert
-            ordered.Should().HaveCount(Subject.Count()).And.HaveCountGreaterThan(0);
-            if (orderDirection is OrderDirection.Ascending)
-            {
-                ordered.Should().BeInAscendingOrder(ordering.expectedOrderExpression);
-            }
-            else if (orderDirection is OrderDirection.Descending)
-            {
-                ordered.Should().BeInDescendingOrder(ordering.expectedOrderExpression);
-            }
-            else
-            {
-                throw new NotSupportedException("Not valid test case input");
-            }
-        }
-
-        public static List<(Expression<Func<Person, object?>> defaultOrderExpression, Expression<Func<PersonDto, object?>> expectedOrderExpression)> DefaultOrderExpression() => new()
-        {
-            (p => p.Id, p => p.Id),
-            (p => p.Name, p => p.Name),
-            (p => p.Address, p => p.Address),
-        };
-
-        [Theory]
-        [CombinatorialData]
-        public void Should_ReturnDefaultOrdered_WithoutOrderingInfo(
-            [CombinatorialMemberData(nameof(DefaultOrderExpression))]
-            (Expression<Func<Person, object?>> defaultOrderExpression, Expression<Func<PersonDto, object?>> expectedOrderExpression) expressions,
-            OrderDirection orderDirection)
-        {
-            // Act
-            var ordered = Subject
-                .OrderBy<Person, PersonDto>(
-                    new PageRequest() { OrderDirection = orderDirection },
-                    expressions.defaultOrderExpression,
-                    Mapper.ConfigurationProvider)
-                .ProjectTo<PersonDto>(Mapper.ConfigurationProvider)
-                .ToList();
-
-            // Assert
-            ordered.Should().HaveCount(Subject.Count()).And.HaveCountGreaterThan(0);
-            if (orderDirection is OrderDirection.Ascending)
-            {
-                ordered.Should().BeInAscendingOrder(expressions.expectedOrderExpression);
-            }
-            else if (orderDirection is OrderDirection.Descending)
-            {
-                ordered.Should().BeInDescendingOrder(expressions.expectedOrderExpression);
-            }
-            else
-            {
-                throw new NotSupportedException("Not valid test case input");
-            }
-        }
-
-        [Theory]
-        [CombinatorialData]
-        public void Should_ReturnDefaultOrdered_WithDefaultOrderDirection(
-            [CombinatorialMemberData(nameof(DefaultOrderExpression))]
-            (Expression<Func<Person, object?>> defaultOrderExpression, Expression<Func<PersonDto, object?>> expectedOrderExpression) expressions,
-            OrderDirection defaultOrderDirection)
-        {
-            // Act
-            var ordered = Subject
-                .OrderBy<Person, PersonDto>(new PageRequest(), expressions.defaultOrderExpression, defaultOrderDirection, Mapper.ConfigurationProvider)
-                .ProjectTo<PersonDto>(Mapper.ConfigurationProvider)
-                .ToList();
-
-            // Assert
-            ordered.Should().HaveCount(Subject.Count()).And.HaveCountGreaterThan(0);
-            if (defaultOrderDirection is OrderDirection.Ascending)
-            {
-                ordered.Should().BeInAscendingOrder(expressions.expectedOrderExpression);
-            }
-            else if (defaultOrderDirection is OrderDirection.Descending)
-            {
-                ordered.Should().BeInDescendingOrder(expressions.expectedOrderExpression);
-            }
-            else
-            {
-                throw new NotSupportedException("Not valid test case input");
-            }
-        }
-
-        [Fact]
-        public void Should_ThrowOnNotSortableColumn()
-        {
-            // Act
-            var func = () => Subject
-                .OrderBy<Person, PersonDto>(new PageRequest { OrderBy = nameof(PersonDto.Address) }, p => p.Id, Mapper.ConfigurationProvider);
-
-            // Assert
-            func.Should().Throw<ValidationException>();
-        }
-
-        [Fact]
-        public void Should_ThrowOnNotExistedColumn()
-        {
-            // Act
-            var func = () => Subject
-                .OrderBy<Person, PersonDto>(new PageRequest { OrderBy = "TEST" }, p => p.Id, Mapper.ConfigurationProvider);
-
-            // Assert
-            func.Should().Throw<ValidationException>();
-        }
-    }
-}