Spring @QuerydslPredicate and QuerydslBinderCustomizer: is it possible to infuse default criteria into predicate generated from request params?

Question

I am using Spring Data JPA and QueryDsl (v.4.2.2), Java 8. I can explicitly construct search predicates and pass them to the repository methods. However, I like the idea of using the @QuerydslPredicate annotation on a web/REST controller's method argument when the queried entities have more than a few properties, and I want the flexibility of filtering the search by any of them. So, something like this, generally, works very well:

    @GetMapping("/accounts/summaries")
    public PageDto<AccountSummaryDto> getAccountSummaries(@QuerydslPredicate(root = AccountSummary.class) Predicate accountSearchPredicate,
            @RequestParam(name = "pageIndex", defaultValue = "0") int pageIndex,
            @RequestParam(name = "pageSize", defaultValue = "25") int pageSize,
            @RequestParam(name = "sortBy", defaultValue = "id") String sortBy,
            @RequestParam(name = "sortOrder", defaultValue = "desc") String sortOrder) {

         // delegating to web-agnostic service that:
         // - creates Pageable pageRequest,     
         // - calls accountSummaryRepository.findAll(predicate, pageRequest), 
         // - constructs custom PageDto wrapper, etc. 
         return accountService.retrieveAccountSummaries(accountSearchPredicate, pageIndex, pageSize, sortBy, sortOrder); 
    }

My Spring Data JPA repository interface looks similar to this:

    public interface AccountSummarySearchRepository
        extends JpaRepository<AccountSummary, Integer>, QuerydslPredicateExecutor<AccountSummary>, QuerydslBinderCustomizer<QAccountSummary > {

    @Override
    default void customize(QuerydslBindings bindings, QAccountSummary acctSummary) {
        bindings.bind(acctSummary.customer.firstName).first((path, value) -> path.isNull().or(path.startsWithIgnoreCase(value))) ;
        bindings.bind(acctSummary.customer.lastName).first((path, value) -> path.isNull().or(path.startsWithIgnoreCase(value))) ;
        
        // etc.

        // default binding for String properties to be case insensitive "contains" match
        bindings.bind(String.class).first(
                (StringPath path, String value) -> path.isNull().or(path.containsIgnoreCase(value)));
    }

My question:

The bindings in the customize method are set using the entity field paths and the values of the request parameters that match those paths. If the parameter is not specified, is there a way to bind the path to some constant value or a value obtained dynamically?

For example, I want to always ONLY retrieve the entities where property deleted is set to false - without forcing the client to pass that as a query parameter? Similarly, I may want to set other default lookup values dynamically for each query. For example, I may want to "retrieve only those accounts where assignedTo == [current user ID available on a ThreadLocal]...

The following will not work

        bindings.bind(acctSummary.deleted).first((path, value) -> path.eq(false));

because it, obviously, expects the first occurrence of the path/value pair for deleted=... in the Predicate (mapped from the incoming request params via the @QuerydslPredicate annotation. I don't want to pass that as a parameter because the requester does not even need to know about the existence of such field.

Is there a simple way to infuse the Predicate instance that is auto-populated via the @QuerydslPredicate annotation with any additional implicit/default criteria that are not explicitly passed in the web request? Could this be done in the customize method? I suppose, one (very ugly) way would be to intercept the HTTP request in a filter - before it is processed by the Spring-QueryDsl framework - and replace it with a new request with added parameters? That would be a horrible solution, and I feel there has to be a better way to do it via some hook/capability provided by the framework itself.

Unfortunately, there seem to be no comprehensive documentation for Spring QueryDsl support - other than some very simplistic examples.

Thanks for your help!

Answer 1

Answering my own question... I was hoping to find a hook in the framework where I could add the code to enhance the auto-generated predicate with criteria common for all my queries - before it arrives in the controller method, but wasn’t able to figure that out. Overriding QuerydslPredicateArgumentResolver doesn't seem a good or necessary option. And, quite frankly, I've come to the conclusion that this wasn't such a great idea to begin with. It seems that any modifications to the search criteria should be done in a more obvious way - in the business tier. So I decided to simply update the predicate in the service method:

public PageDto<AccountSummaryDto> retrieveByPredicate(Predicate predicate, int pageIndex, int pageSize, String sortBy, String sortOrder) {
     Pageable pageRequest = PageRequest.of(pageIndex, pageSize, Sort.Direction.fromString(sortOrder), sortBy);

     QAccountSummary accountSummary = QAccountSummary.accountSummary; //QueryDsl auto-generated query type for AccountSummary (path root)
     
     // construct new enhanced search predicate w/added criteria common for all queries 
     // using original predicate generated by framework from request params as base
     BooleanBuilder updatedPredicate = new BooleanBuilder(predicate)
        .and(accountSummary.somethingNested.id.eq(SomeThreadContext.getSomethingId()))
        .and(accountSummary.deleted.eq(false))
        .and(accountSummary.someProperty.eq("xyz"));

     Page<accountSummary> page = summarySearchRepository.findAll(updatedPredicate, pageRequest);
     return toAccountSummaryPageDto(page); // custom method that converts results to page DTO w/entity dots and page stats
}

The construction of the updated predicate may be extracted into a separate private method on the service should it be desirable to use it in multiple search methods and/or if more logic is required to dynamically generate additional search criteria.