Specification<T>.toPredicate(...) Change type of first parameter to From<?, T>

[jobayle]

Dear spring devs,

I'd like to suggest the following change in interface Specification<T>:

Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder);

to

Predicate toPredicate(From<?, T> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder);

Because From<T, U> is the supertype of both Root<T> and Join<T, U>, it would allow better reuse of specifications when joining tables.

---

Our use case is the following, we have a OneToMany relation
Table CarMaker <>---> Table Car

We have already made Specification factory methods from Request DTOs for entities CarMaker and Car.
We would like to reuse these 2 methods when filtering on both CarMaker and Car:

Specification<CarMaker> filterCarMakers(CarMakerRequestDTO request) { ... }

Specification<Car> filterCars(CarRequestDTO request) { ... }

Specification<CarMaker> filterCarMakersAndCars(CarMakerAndCarAggregatedRequestDTO  request) {
    return filterCarMakers(request.getCarMakerRequest())
            .and((r, q, c) -> filterCars(request.getCarRequest()).toPredicate(r.join("cars", JoinType.INNER), q, c));
}

see also: https://stackoverflow.com/a/46955740/6705221

[mp911de]

From an API perspective, Root declares one method more than From does, and it denotes a more specific type. Generally speaking, From could be a better alternative than Root to improve reuse of specifications. However, specifications weren't designed with reuse in mind and we have no way to introduce a non-breaking change considering the amount of existing specification implementations.

This could be a topic worth revisiting for Spring Data JPA 4.0.

[mp911de]

Another approach here could be the introduction of a functional-style composition API to build and reuse specification-like fragments. Anyone willing to experiment with that kind of approach can take a spike and we're happy to keep the discussion going.

[bukajsytlos]

when we are at it, why not Path<X>?

[svenmeier]

With a Path you would not be able to join or correlate, so From<T,T> seems to be a nice fit.

[svenmeier]

I've put together a possible implementation based on how we handle it in our project. Due to limitations with modifying Spring classes, our local solution includes a bit more code duplication.

We make extensive use of NestableSpecification and JoinSpecification, often nesting them across multiple relations. Our specifications always implement NestableSpecification instead of Specification, since our predicates do not need access to the Root and From is always sufficient.

If you're interested, I'm happy to flesh out the implementation further with documentation and tests.