Fix Hibernate 7 eager fetch joins to initialize associations

Under Hibernate 7, `Entity.findById(id, [fetch:[assoc:'join']])` (and dynamic
finders generally) did not eagerly initialize the requested association, while
Hibernate 5 did. The user-visible symptom is that JSON views silently drop
hasMany collections after migration, because the view layer skips uninitialized
lazy collections in non-deep rendering.

Root cause: GORM's shared DynamicFinder translates an EAGER fetch strategy into
`query.join(property)`. In Hibernate 7 that became a plain JPA join that
JpaCriteriaQueryCreator only materialized on demand when referenced in a
predicate - and a fetch-only association is never referenced, so it was never
joined or fetched. JPA requires `root.fetch(...)` for eager initialization, which
the rewritten query layer never emitted (Hibernate 5 used
`criteria.setFetchMode(assoc, JOIN)`).

Fix (Hibernate 7 only):
- HibernateQuery records the association paths requested through join(...) and
  exposes them via getFetchJoinPaths(). createAlias-style filtering joins go
  through detachedCriteria.join directly and are not recorded.
- JpaCriteriaQueryCreator.createQuery() materializes those paths as
  `root.fetch(path, joinType)` for full-entity selects only; projection and count
  queries are skipped (a fetch join is invalid there), dotted paths are skipped,
  and a non-fetchable path falls back to the existing join handling.

Adds FetchJoinSpec to both the Hibernate 5 and Hibernate 7 modules as a
regression test. The full grails-data-hibernate7-core suite passes (2944 tests,
0 failures); Hibernate 5 is unchanged.

Assisted-by: claude-code:claude-4.8-opus

Author: jamesfredley

grails-data-hibernate5/core/src/test/groovy/grails/gorm/tests/FetchJoinSpec.groovy

@@ -0,0 +1,58 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package grails.gorm.tests
+
+import grails.gorm.annotation.Entity
+import org.hibernate.Hibernate
+
+class FetchJoinSpec extends HibernateGormDatastoreSpec {
+
+    void setupSpec() {
+        manager.registerDomainClasses(FetchJoinParent, FetchJoinChild)
+    }
+
+    void "findById with fetch join eagerly initializes the hasMany collection"() {
+        given:
+        def parent = new FetchJoinParent(name: "p")
+        parent.addToChildren(new FetchJoinChild(name: "c1"))
+        parent.addToChildren(new FetchJoinChild(name: "c2"))
+        parent.save(flush: true)
+        manager.session.clear()
+
+        when: "loading by id with an explicit join fetch of the collection"
+        def found = FetchJoinParent.findById(parent.id, [fetch: [children: 'join']])
+
+        then: "the collection is eagerly initialized"
+        found != null
+        Hibernate.isInitialized(found.children)
+        found.children.size() == 2
+    }
+}
+
+@Entity
+class FetchJoinParent {
+    String name
+    static hasMany = [children: FetchJoinChild]
+}
+
+@Entity
+class FetchJoinChild {
+    String name
+    static belongsTo = [parent: FetchJoinParent]
+}

grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQuery.java

@@ -21,9 +21,11 @@
 import java.util.Collections;
 import java.util.Deque;
 import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import groovy.lang.Closure;
 
@@ -73,6 +75,7 @@ public class HibernateQuery extends Query {
     protected static final String ALIAS = "_alias";
     private final Map<String, CriteriaAndAlias> createdAssociationPaths = new HashMap<>();
     private final List<HibernateAlias> aliases = new java.util.ArrayList<>();
+    private final Set<String> fetchJoinPaths = new LinkedHashSet<>();
     protected String alias;
     protected int aliasCount;
     protected Deque<GrailsHibernatePersistentEntity> entityStack = new LinkedList<>();
@@ -403,16 +406,28 @@ public Query clearOrders() {
 
     @Override
     public Query join(String property) {
+        fetchJoinPaths.add(property);
         detachedCriteria.join(property);
         return this;
     }
 
     @Override
     public Query join(String property, JoinType joinType) {
+        fetchJoinPaths.add(property);
         detachedCriteria.join(property, joinType);
         return this;
     }
 
+    /**
+     * The association paths requested as eager join fetches via {@link #join(String)} - for
+     * example by a dynamic finder invoked with {@code [fetch: [assoc: 'join']]}. These are
+     * materialized as JPA {@code root.fetch(...)} joins so the associations are eagerly
+     * initialized, matching the Hibernate 5 behaviour.
+     */
+    public Set<String> getFetchJoinPaths() {
+        return Collections.unmodifiableSet(fetchJoinPaths);
+    }
+
     @Override
     public Query select(String property) {
         detachedCriteria.select(property);

grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaCriteriaQueryCreator.java

@@ -17,12 +17,14 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 
 import jakarta.persistence.criteria.AbstractQuery;
 import jakarta.persistence.criteria.CriteriaBuilder;
 import jakarta.persistence.criteria.CriteriaQuery;
 import jakarta.persistence.criteria.Expression;
+import jakarta.persistence.criteria.JoinType;
 import jakarta.persistence.criteria.Root;
 
 import org.hibernate.query.criteria.HibernateCriteriaBuilder;
@@ -101,7 +103,9 @@ public JpaCriteriaQuery<?> createQuery() {
         var context = JpaQueryContext.forSubquery(parentContext, aliases, root);
         registerDetachedJoins(context);
         discoverAliases(detachedCriteria.getCriteria(), context);
-        
+
+        applyEagerFetchJoins(root, projectionList);
+
         new JpaProjectionAdapter(criteriaBuilder, context).adapt(projections, (AbstractQuery<?>) cq);
         assignGroupBy(cq, context);
 
@@ -110,6 +114,38 @@ public JpaCriteriaQuery<?> createQuery() {
         return cq;
     }
 
+    /**
+     * Eagerly fetch-join the associations requested via {@code fetch:[assoc:'join']} (which a
+     * dynamic finder turns into {@link HibernateQuery#join(String)} calls). Hibernate 5 initializes
+     * these collections; without an explicit JPA {@code root.fetch(...)} they would only be plain
+     * joins (or, when not referenced in a predicate, not materialized at all), leaving the
+     * association uninitialized. Only applied to full-entity selects - a fetch join on a projection
+     * query (for example {@code count}) is invalid.
+     */
+    private void applyEagerFetchJoins(Root<?> root, List<Query.Projection> projectionList) {
+        if (hibernateQuery == null) {
+            return;
+        }
+        boolean entitySelect = projectionList.stream().noneMatch(p -> !(p instanceof Query.DistinctProjection));
+        if (!entitySelect) {
+            return;
+        }
+        Map<String, ?> joinTypes = detachedCriteria.getJoinTypes();
+        for (String fetchPath : hibernateQuery.getFetchJoinPaths()) {
+            if (fetchPath == null || fetchPath.indexOf('.') >= 0) {
+                continue;
+            }
+            Object configured = (joinTypes != null) ? joinTypes.get(fetchPath) : null;
+            JoinType joinType = (configured instanceof JoinType jt) ? jt : JoinType.LEFT;
+            try {
+                root.fetch(fetchPath, joinType);
+            }
+            catch (IllegalArgumentException ignored) {
+                // Not a fetchable association on this root; the plain join handling remains in place.
+            }
+        }
+    }
+
     @SuppressWarnings("unchecked")
     public <T> void populateSubquery(JpaSubQuery<T> subquery) {
         var projectionList = collectProjections();

grails-data-hibernate7/core/src/test/groovy/grails/gorm/tests/FetchJoinSpec.groovy

@@ -0,0 +1,58 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package grails.gorm.tests
+
+import grails.gorm.annotation.Entity
+import org.hibernate.Hibernate
+
+class FetchJoinSpec extends HibernateGormDatastoreSpec {
+
+    void setupSpec() {
+        manager.registerDomainClasses(FetchJoinParent, FetchJoinChild)
+    }
+
+    void "findById with fetch join eagerly initializes the hasMany collection"() {
+        given:
+        def parent = new FetchJoinParent(name: "p")
+        parent.addToChildren(new FetchJoinChild(name: "c1"))
+        parent.addToChildren(new FetchJoinChild(name: "c2"))
+        parent.save(flush: true)
+        manager.session.clear()
+
+        when: "loading by id with an explicit join fetch of the collection"
+        def found = FetchJoinParent.findById(parent.id, [fetch: [children: 'join']])
+
+        then: "the collection is eagerly initialized"
+        found != null
+        Hibernate.isInitialized(found.children)
+        found.children.size() == 2
+    }
+}
+
+@Entity
+class FetchJoinParent {
+    String name
+    static hasMany = [children: FetchJoinChild]
+}
+
+@Entity
+class FetchJoinChild {
+    String name
+    static belongsTo = [parent: FetchJoinParent]
+}