feat: GORM O(M+N) scaling — GormRegistry, SessionResolver infrastructure, and core-class tests (consolidates #15779, #15780, #15790)

gradle/test-config.gradle

@@ -33,6 +33,38 @@ dependencies {
     add('testRuntimeOnly', 'org.objenesis:objenesis')
 }
 
+/**
+ * Recursively checks if a project has a direct or transitive dependency on a target project.
+ * Used to detect modules that rely on GORM (grails-datamapping-core), which are prone to
+ * cross-test registry pollution when executed in parallel (maxParallelForks > 1).
+ *
+ * Uses Gradle 9 compatible path lookup (proj.project(pd.getPath())) because
+ * ProjectDependency.getDependencyProject() was removed in Gradle 9.
+ *
+ * @param proj the project to inspect
+ * @param targetProjectName the name of the target dependency project (e.g. 'grails-datamapping-core')
+ * @param visited set of already visited projects to prevent infinite recursion in cyclic dependency configurations
+ * @return true if the project depends on the target project
+ */
+@groovy.transform.CompileStatic
+boolean dependsOnProject(Project proj, String targetProjectName, Set<String> visited = new HashSet<String>()) {
+    if (proj.name == targetProjectName) return true
+    if (visited.contains(proj.name)) return false
+    visited.add(proj.name)
+    for (org.gradle.api.artifacts.Configuration config : proj.configurations) {
+        for (org.gradle.api.artifacts.Dependency dep : config.dependencies) {
+            if (dep instanceof org.gradle.api.artifacts.ProjectDependency) {
+                org.gradle.api.artifacts.ProjectDependency pd = (org.gradle.api.artifacts.ProjectDependency) dep
+                Project depProj = proj.project(pd.getPath())
+                if (dependsOnProject(depProj, targetProjectName, visited)) {
+                    return true
+                }
+            }
+        }
+    }
+    return false
+}
+
 // Disable build cache for Groovy compilation in CI to ensure AST transformations are always applied.
 // AST transformers are applied at compile time, and Gradle's incremental compilation might not detect
 // when a transformer itself changes, leading to stale bytecode.
@@ -83,7 +115,11 @@ tasks.withType(Test).configureEach {
         showStackTraces = true
     }
     excludes = ['**/*TestCase.class', '**/*$*.class']
-    maxParallelForks = configuredTestParallel
+
+    // Selectively isolate GORM (grails-datamapping-core) dependent tests to prevent GormRegistry conflicts
+    def isGormProject = dependsOnProject(project, 'grails-datamapping-core')
+    maxParallelForks = isGormProject ? 1 : configuredTestParallel
+
     maxHeapSize = isCiBuild ? '768m' : '1024m'
     forkEvery = hasProperty('forkEveryUnitTest') ? getProperty('forkEveryUnitTest') as long : (isCiBuild ? 50 : 100)
     if (System.getProperty('debug.tests')) {

grails-core/src/test/groovy/grails/util/GrailsUtilStackFiltererSpec.groovy

@@ -105,8 +105,8 @@ class GrailsUtilStackFiltererSpec extends Specification {
     }
 
     def 'installed DefaultStackTraceFilterer honours logFullStackTraceOnFilter=false'() {
-        given: 'a configured log appender to capture the StackTrace log entry'
-        def logCapture = new LogCapture('StackTrace')
+        given: 'a capture of the dedicated STACK_LOG logger'
+        def logCapture = new LogCapture(DefaultStackTraceFilterer.STACK_LOG_NAME)
 
         and: 'a filterer with the side-effect emission disabled'
         def quietFilterer = new DefaultStackTraceFilterer()
@@ -117,15 +117,15 @@ class GrailsUtilStackFiltererSpec extends Specification {
         GrailsUtil.deepSanitize(exceptionWithApplicationFrame())
 
         then: "no 'Full Stack Trace:' entry is emitted"
-        logCapture.events.count { it.formattedMessage.contains(StackTraceFilterer.FULL_STACK_TRACE_MESSAGE) } == 0
+        logCapture.events.every { !it.formattedMessage.contains(StackTraceFilterer.FULL_STACK_TRACE_MESSAGE) }
 
         cleanup:
         logCapture.close()
     }
 
     def 'installed DefaultStackTraceFilterer emits Full Stack Trace by default'() {
-        given: 'a configured log appender to capture the StackTrace log entry'
-        def logCapture = new LogCapture('StackTrace')
+        given: 'a capture of the dedicated STACK_LOG logger'
+        def logCapture = new LogCapture(DefaultStackTraceFilterer.STACK_LOG_NAME)
 
         and: 'a filterer with the default (enabled) side-effect emission'
         def loudFilterer = new DefaultStackTraceFilterer()

grails-core/src/test/groovy/org/apache/grails/core/GrailsBootstrapRegistryInitializerSpec.groovy

@@ -226,14 +226,14 @@ class GrailsBootstrapRegistryInitializerSpec extends Specification {
         def context = contextWithProperties([
                 (Settings.SETTING_LOG_FULL_STACKTRACE_ON_FILTER): 'false'
         ])
-        def logCapture = new LogCapture('StackTrace')
+        def logCapture = new LogCapture(DefaultStackTraceFilterer.STACK_LOG_NAME)
 
         when:
         closeBootstrapContext(context)
         GrailsUtil.deepSanitize(exceptionWithApplicationFrame())
 
         then: "no 'Full Stack Trace:' entry is emitted"
-        logCapture.events.count { it.formattedMessage.contains(StackTraceFilterer.FULL_STACK_TRACE_MESSAGE) } == 0
+        logCapture.events.every { !it.formattedMessage.contains(StackTraceFilterer.FULL_STACK_TRACE_MESSAGE) }
 
         cleanup:
         logCapture.close()
@@ -242,7 +242,7 @@ class GrailsBootstrapRegistryInitializerSpec extends Specification {
     def 'defaults logFullStackTraceOnFilter to true on the promoted DefaultStackTraceFilterer'() {
         given:
         def context = contextWithProperties([:])
-        def logCapture = new LogCapture('StackTrace')
+        def logCapture = new LogCapture(DefaultStackTraceFilterer.STACK_LOG_NAME)
 
         when:
         closeBootstrapContext(context)

grails-data-graphql/core/src/test/groovy/org/grails/gorm/graphql/fetcher/manager/GraphQLDataFetcherManagerSpec.groovy

@@ -20,9 +20,8 @@
 package org.grails.gorm.graphql.fetcher.manager
 
 import graphql.schema.DataFetchingEnvironment
-import org.grails.datastore.gorm.GormEnhancer
+import org.grails.datastore.gorm.GormRegistry
 import org.grails.datastore.gorm.GormStaticApi
-import org.grails.datastore.mapping.core.connections.ConnectionSource
 import org.grails.datastore.mapping.model.PersistentEntity
 import org.grails.gorm.graphql.binding.GraphQLDataBinder
 import org.grails.gorm.graphql.fetcher.BindingGormDataFetcher
@@ -157,7 +156,7 @@ class GraphQLDataFetcherManagerSpec extends Specification {
 
     void "test registering a binding fetcher"() {
         given:
-        GormEnhancer.STATIC_APIS.put(ConnectionSource.DEFAULT, ['java.lang.String': Mock(GormStaticApi)])
+        GormRegistry.instance.staticApiRegistry.register('java.lang.String', Mock(GormStaticApi))
 
         when:
         manager.registerBindingDataFetcher(String, mockBindingFetcher)

grails-data-hibernate5/core/src/main/groovy/org/grails/orm/hibernate/HibernateGormApiFactory.groovy

@@ -0,0 +1,77 @@
+/*
+ *  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 org.grails.orm.hibernate
+
+import groovy.transform.CompileStatic
+
+import org.grails.datastore.gorm.DatastoreResolver
+import org.grails.datastore.gorm.DefaultGormApiFactory
+import org.grails.datastore.gorm.GormApiFactory
+import org.grails.datastore.gorm.GormInstanceApi
+import org.grails.datastore.gorm.GormRegistry
+import org.grails.datastore.gorm.GormStaticApi
+import org.grails.datastore.gorm.GormValidationApi
+import org.grails.datastore.gorm.finders.FinderMethod
+import org.grails.datastore.mapping.model.MappingContext
+
+/**
+ * {@link GormApiFactory} that produces Hibernate 5-specific API instances, ensuring that
+ * {@code withNewSession} and related lifecycle methods use the Hibernate {@code SessionFactory}
+ * binding rather than the generic GORM {@code DatastoreUtils} path.
+ */
+@CompileStatic
+class HibernateGormApiFactory implements GormApiFactory {
+
+    private final ClassLoader classLoader
+
+    HibernateGormApiFactory(ClassLoader classLoader) {
+        this.classLoader = classLoader
+    }
+
+    @Override
+    <D> GormStaticApi<D> createStaticApi(Class<D> persistentClass, MappingContext mappingContext, DatastoreResolver resolver, String qualifier, GormRegistry registry) {
+        HibernateDatastore hds = (HibernateDatastore) resolver.resolve()
+        List<FinderMethod> finders = new DefaultGormApiFactory().createDynamicFinders(resolver, mappingContext)
+        return new HibernateGormStaticApi<D>(persistentClass, hds, finders, classLoader, hds.getTransactionManager())
+    }
+
+    @Override
+    <D> GormInstanceApi<D> createInstanceApi(Class<D> persistentClass, MappingContext mappingContext, DatastoreResolver resolver, GormRegistry registry, boolean failOnError, boolean markDirty) {
+        HibernateDatastore hds = (HibernateDatastore) resolver.resolve()
+        GormInstanceApi<D> instanceApi = new HibernateGormInstanceApi<D>(persistentClass, hds, classLoader)
+        instanceApi.failOnError = failOnError
+        // The Hibernate datastore is authoritative for dirty marking (resolved from
+        // SETTING_MARK_DIRTY, default false). Hibernate performs its own snapshot dirty checking,
+        // so force-marking every save() dirty would re-update unchanged entities and fire spurious
+        // beforeUpdate/afterUpdate events. The generic enhancer default (true) must not override it.
+        instanceApi.markDirty = hds.markDirty
+        return instanceApi
+    }
+
+    @Override
+    <D> GormValidationApi<D> createValidationApi(Class<D> persistentClass, MappingContext mappingContext, DatastoreResolver resolver, GormRegistry registry) {
+        HibernateDatastore hds = (HibernateDatastore) resolver.resolve()
+        return new HibernateGormValidationApi<D>(persistentClass, hds, classLoader)
+    }
+
+    @Override
+    List<FinderMethod> createDynamicFinders(DatastoreResolver datastoreResolver, MappingContext mappingContext) {
+        new DefaultGormApiFactory().createDynamicFinders(datastoreResolver, mappingContext)
+    }
+}

grails-data-hibernate5/core/src/main/groovy/org/grails/orm/hibernate/HibernateGormEnhancer.groovy

@@ -24,6 +24,7 @@ import org.springframework.transaction.PlatformTransactionManager
 
 import org.grails.datastore.gorm.GormEnhancer
 import org.grails.datastore.gorm.GormInstanceApi
+import org.grails.datastore.gorm.GormRegistry
 import org.grails.datastore.gorm.GormStaticApi
 import org.grails.datastore.gorm.GormValidationApi
 import org.grails.datastore.mapping.core.Datastore
@@ -75,6 +76,6 @@ class HibernateGormEnhancer extends GormEnhancer {
 
     @Override
     protected void registerConstraints(Datastore datastore) {
-        // no-op
+        GormRegistry.instance.registerApiFactory(HibernateDatastore, new HibernateGormApiFactory(Thread.currentThread().contextClassLoader))
     }
 }

grails-data-hibernate5/core/src/main/groovy/org/grails/orm/hibernate/HibernateGormStaticApi.groovy

@@ -39,7 +39,6 @@ import org.springframework.transaction.PlatformTransactionManager
 import org.springframework.transaction.support.TransactionSynchronizationManager
 
 import grails.orm.HibernateCriteriaBuilder
-import org.grails.datastore.gorm.GormEnhancer
 import org.grails.datastore.gorm.finders.DynamicFinder
 import org.grails.datastore.gorm.finders.FinderMethod
 import org.grails.datastore.mapping.query.api.BuildableCriteria as GrailsCriteria
@@ -135,7 +134,11 @@ class HibernateGormStaticApi<D> extends AbstractHibernateGormStaticApi<D> {
 
     @Override
     def propertyMissing(String name) {
-        return GormEnhancer.findStaticApi(persistentClass, name)
+        // Delegate to the base implementation, which resolves dynamic finder property
+        // access to a finder closure before falling back to connection-source qualifier
+        // lookup. Returning a qualifier API unconditionally would break finder calls that
+        // Groovy resolves via the property channel (e.g. Entity.findByName(arg)).
+        return super.propertyMissing(name)
     }
 
     @Override

grails-data-hibernate5/core/src/main/groovy/org/grails/orm/hibernate/HibernateSession.java

@@ -19,9 +19,13 @@
 package org.grails.orm.hibernate;
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import jakarta.persistence.FlushModeType;
 import jakarta.persistence.criteria.CriteriaBuilder;
@@ -34,6 +38,7 @@
 import org.hibernate.proxy.HibernateProxy;
 
 import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.core.convert.ConversionService;
 
 import org.grails.datastore.gorm.timestamp.DefaultTimestampProvider;
 import org.grails.datastore.mapping.model.PersistentEntity;
@@ -163,23 +168,65 @@ public long updateAll(final QueryableCriteria criteria, final Map<String, Object
 
     public List retrieveAll(final Class type, final Iterable keys) {
         final PersistentEntity persistentEntity = getMappingContext().getPersistentEntity(type.getName());
+        final Class idType = persistentEntity.getIdentity().getType();
+        final ConversionService conversionService = getMappingContext().getConversionService();
+
+        // Convert each requested id to the entity's identifier type, preserving order and
+        // duplicates. getAll() must return entities in the supplied id order with a null slot
+        // for any id that does not resolve to a row, so order is driven by the request rather
+        // than the database.
+        final List<Serializable> requestedIds = new ArrayList<>();
+        for (Object key : keys) {
+            requestedIds.add(convertToIdentifierType(key, idType, conversionService));
+        }
+
         return getHibernateTemplate().execute(session -> {
-            final CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
-            CriteriaQuery criteriaQuery = criteriaBuilder.createQuery(type);
-            final Root root = criteriaQuery.from(type);
-            final String id = persistentEntity.getIdentity().getName();
-            criteriaQuery = criteriaQuery.where(
-                criteriaBuilder.in(
-                    root.get(id).in(getIterableAsCollection(keys))
-                )
-            );
-            final org.hibernate.query.Query jpaQuery = session.createQuery(criteriaQuery);
-            getHibernateTemplate().applySettings(jpaQuery);
-
-            return new HibernateHqlQuery(this, persistentEntity, jpaQuery).list();
+            // Query only the distinct, non-null ids; a missing id simply yields no row.
+            final Set<Serializable> distinctIds = new LinkedHashSet<>();
+            for (Serializable requestedId : requestedIds) {
+                if (requestedId != null) {
+                    distinctIds.add(requestedId);
+                }
+            }
+
+            final Map<Object, Object> entitiesById = new HashMap<>();
+            if (!distinctIds.isEmpty()) {
+                final CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
+                CriteriaQuery criteriaQuery = criteriaBuilder.createQuery(type);
+                final Root root = criteriaQuery.from(type);
+                final String id = persistentEntity.getIdentity().getName();
+                // Path.in(Collection) already yields a complete `id IN (...)` predicate; wrapping it
+                // in another criteriaBuilder.in(...) emitted a second empty `IN ()`
+                // (e.g. `id in (1,2) in ()`), which Hibernate rejects with a QuerySyntaxException.
+                criteriaQuery = criteriaQuery.where(root.get(id).in(distinctIds));
+                final org.hibernate.query.Query jpaQuery = session.createQuery(criteriaQuery);
+                getHibernateTemplate().applySettings(jpaQuery);
+
+                final List results = new HibernateHqlQuery(this, persistentEntity, jpaQuery).list();
+                for (Object entity : results) {
+                    entitiesById.put(session.getIdentifier(entity), entity);
+                }
+            }
+
+            // Reassemble in the requested order, leaving a null slot for missing ids.
+            final List ordered = new ArrayList<>(requestedIds.size());
+            for (Serializable requestedId : requestedIds) {
+                ordered.add(requestedId == null ? null : entitiesById.get(requestedId));
+            }
+            return ordered;
         });
     }
 
+    private Serializable convertToIdentifierType(Object key, Class idType, ConversionService conversionService) {
+        if (key == null || idType.isInstance(key)) {
+            return (Serializable) key;
+        }
+        if (conversionService != null && conversionService.canConvert(key.getClass(), idType)) {
+            return (Serializable) conversionService.convert(key, idType);
+        }
+        return (Serializable) key;
+    }
+
     public Query createQuery(Class type) {
         return createQuery(type, null);
     }

grails-data-hibernate5/core/src/test/groovy/org/apache/grails/data/hibernate5/core/GrailsDataHibernate5TckManager.groovy

@@ -53,7 +53,8 @@ class GrailsDataHibernate5TckManager extends GrailsDataTckManager {
     ApplicationContext applicationContext
     HibernateDatastore multiDataSourceDatastore
     HibernateDatastore multiTenantMultiDataSourceDatastore
-    Map grailsConfig
+    ConfigObject grailsConfig = new ConfigObject()
+    boolean isTransactional = true
 
     @Override
     void setup(Class<? extends Specification> spec) {
@@ -63,19 +64,13 @@ class GrailsDataHibernate5TckManager extends GrailsDataTckManager {
 
     @Override
     Session createSession() {
-        ConfigObject config = new ConfigObject()
+        grailsConfig.dataSource.dbCreate = grailsConfig.dataSource.dbCreate ?: "create-drop"
+        grailsApplication = new DefaultGrailsApplication(domainClasses as Class[], new GroovyClassLoader(GrailsDataHibernate5TckManager.getClassLoader()))
         if (grailsConfig) {
-            config.putAll(grailsConfig)
+            grailsApplication.config.putAll(grailsConfig)
         }
-        if (!config.containsKey('dataSource.dbCreate') && !config.dataSource.containsKey('dbCreate')) {
-            config.dataSource.dbCreate = "create-drop"
-        }
-        boolean isTransactional = true
-
-        grailsApplication = new DefaultGrailsApplication(domainClasses, new GroovyClassLoader(GrailsDataHibernate5TckManager.getClassLoader()))
-        grailsApplication.config.putAll(config)
 
-        hibernateDatastore = new HibernateDatastore(DatastoreUtils.createPropertyResolver(config), domainClasses)
+        hibernateDatastore = new HibernateDatastore(DatastoreUtils.createPropertyResolver(grailsConfig), domainClasses as Class[])
         transactionManager = hibernateDatastore.getTransactionManager()
         sessionFactory = hibernateDatastore.sessionFactory
         if (transactionStatus == null && isTransactional) {