OData AutoMapper translate DTO queries to POCO queries

AddressController.cs

[HttpGet]
public async Task<IEnumerable<AddressModel>> GetAddresses(ODataQueryOptions<AddressModel> queryOptions, CancellationToken cancellationToken)
{
    var repository = new AddressRepository(_context);
    var service = new AddressService(repository);

    var filter = queryOptions.ToModelQueryFilter<AddressModel>();

    return await service.QueryByStreetAsync("StreetName", filter, cancellationToken);
}

AddressRepository.cs

public Task<List<Address>> QueryByStreetAsync(string street, IQueryFilter<Address> filter, CancellationToken cancellationToken)
{
    var query = AsQueryable()
        .Apply(filter);

    return QueryAsync(query, cancellationToken);
}

AddressService.cs

public async Task<IEnumerable<AddressModel>> QueryByStreetAsync(
    string streetName,
    ModelQueryFilter<AddressModel> modelFilter, 
    CancellationToken cancellationToken)
{
    var queryFilter = modelFilter.Map<Address>();

    var addresses = await _addressManager.QueryByStreetAsync(streetName, queryFilter, CancellationToken.None);

    return addresses.Select(Mapper.Map<AddressModel>);
}

IQueryableExtensions.cs

public static class IQueryableExtensions
{
    public static IQueryable<T> Apply<T>(this IQueryable<T> query, IQueryFilter<T> filter)
    {
        if (filter == null) return query;

        var action = filter.FilterExpression.Compile();

        return action(query);
    }
}

ModelQueryFilter.cs

public class ModelQueryFilter<TDto>
{
    public Expression<Func<IQueryable<TDto>, IQueryable<TDto>>> FilterExpression { get; set; }

    public IQueryFilter<TPoco> Map<TPoco>()
    {
        var expression = Mapper.Instance.Map<Expression<Func<IQueryable<TPoco>, IQueryable<TPoco>>>>(FilterExpression);

        return new QueryFilter<TPoco>
        {
            FilterExpression = expression,
        };
    }
}

ODataQueryOptionsExtensions.cs

public static class ODataQueryOptionsExtensions
{
    public static ModelQueryFilter<TDto> ToModelQueryFilter<TDto>(this ODataQueryOptions options)
    {
        Expression<Func<IQueryable<TDto>, IQueryable<TDto>>> expression;

        var query = (IQueryable<TDto>)options.ApplyTo(Enumerable.Empty<TDto>().AsQueryable());

        var param = Expression.Parameter(typeof(IQueryable<TDto>), "x");

        if (query.Expression is MethodCallExpression methodCall)
        {
            var xArg = methodCall.Arguments[1];

            var m = methodCall.Update(methodCall.Object, new List<Expression> {param, xArg});

            expression = Expression.Lambda<Func<IQueryable<TDto>, IQueryable<TDto>>>(m, param);
        }
        else
        {
            expression = x => x;
        }

        var result = new ModelQueryFilter<TDto>
        {
            FilterExpression = expression
        };

        return result;
    }
}