GORM: Shared Mapping Registry O(M+N) Scaling (clean rebuild)

.gitignore

@@ -69,3 +69,8 @@ etc/bin/results
 /local.properties
 local-tasks.gradle
 local-init.gradle
+.junie/
+.antigravitycli/
+.clinerules
+.cursorrules
+.windsurfrules

build.gradle

@@ -84,6 +84,18 @@ subprojects {
             cacheChangingModulesFor(cacheHours, 'hours')
         }
     }
+
+    tasks.withType(Test).configureEach {
+        systemProperty 'logging.level.org.testcontainers', 'WARN'
+        systemProperty 'logging.level.com.github.dockerjava', 'WARN'
+        systemProperty 'logging.level.tc', 'WARN'
+        systemProperty 'logging.level.asset.pipeline', 'WARN'
+        systemProperty 'logging.level.org.springframework', 'WARN'
+        systemProperty 'logging.level.org.hibernate', 'WARN'
+        systemProperty 'logging.level.com.zaxxer.hikari', 'WARN'
+        systemProperty 'logging.level.grails.config.external', 'WARN'
+        systemProperty 'logging.level.org.apache.grails', 'WARN'
+    }
 }
 
 interface ExecSupport {

gradle/hibernate5-test-config.gradle

@@ -28,6 +28,7 @@ tasks.withType(Test).configureEach {
     outputs.cacheIf { !doNotCacheTests }
     outputs.upToDateWhen { !doNotCacheTests }
 
+
     onlyIf {
         ![
                 'onlyFunctionalTests',

gradle/hibernate7-test-config.gradle

@@ -28,6 +28,7 @@ tasks.withType(Test).configureEach {
     outputs.cacheIf { !doNotCacheTests }
     outputs.upToDateWhen { !doNotCacheTests }
 
+
     onlyIf {
         ![
                 'onlyFunctionalTests',

gradle/mongodb-test-config.gradle

@@ -47,6 +47,7 @@ tasks.withType(Test).configureEach {
 
     useJUnitPlatform()
     maxParallelForks = 1
+
     jvmArgs = ['-Xmx1028M']
     afterSuite {
         System.out.print('.')

gradle/rat-root-config.gradle

@@ -134,6 +134,7 @@ tasks.named('rat') {
             'node_modules/**', // exclude node_modules
             '**/*.log', // exclude log files
             'local-tasks.gradle', // exclude local helper scripts
+            '**/ISSUES.md', // exclude local issue tracking files (no license header)
     ] + rootProject.subprojects.collect{"${rootProject.projectDir.relativePath(it.layout.buildDirectory.get().asFile).toString()}/**/*" }
     // logger.lifecycle("Excludes for RAT task: ${allExcludes.join(', \n')}")
     excludes = allExcludes

gradle/test-config.gradle

@@ -31,6 +31,38 @@ dependencies {
     add('testRuntimeOnly', 'org.junit.platform:junit-platform-launcher')
 }
 
+/**
+ * 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.
@@ -79,7 +111,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-converters/src/main/groovy/org/grails/web/converters/marshaller/ByDatasourceDomainClassFetcher.java

@@ -19,7 +19,7 @@
 
 package org.grails.web.converters.marshaller;
 
-import org.grails.datastore.gorm.GormEnhancer;
+import org.grails.datastore.gorm.GormRegistry;
 import org.grails.datastore.mapping.core.Datastore;
 import org.grails.datastore.mapping.model.MappingContext;
 import org.grails.datastore.mapping.model.PersistentEntity;
@@ -29,7 +29,7 @@ public class ByDatasourceDomainClassFetcher implements DomainClassFetcher {
     @Override
     public PersistentEntity findDomainClass(Object instance) {
         Class clazz = instance.getClass();
-        Datastore datastore = GormEnhancer.findDatastore(clazz);
+        Datastore datastore = GormRegistry.getInstance().getApiResolver().findDatastore(clazz);
         if (datastore != null) {
             MappingContext mappingContext = datastore.getMappingContext();
             if (mappingContext != null) {

grails-data-graphql/ISSUES.md

@@ -0,0 +1,17 @@
+# GraphQL O(M+N) Scaling and Performance
+
+## Context
+GraphQL GORM integration maps GORM entities to a GraphQL schema. In multi-tenant environments, the schema resolution and data fetching layers must handle tenant context switches efficiently to avoid the O(M+N) performance trap.
+
+## Identified Issues
+- **Fetcher Overhead**: GORM Data Fetchers may perform redundant tenant resolution for each field in a deeply nested GraphQL query.
+- **Schema Duplication**: If schemas are being re-generated or re-validated per-tenant without caching, it leads to significant CPU and memory pressure.
+
+## Fix Strategy
+1. **Context-Aware Fetchers**: Ensure `DataFetcher` implementations capture the tenant ID from the initial execution context and propagate it to GORM static API calls (e.g., using `withTenant(id)` or passing the ID directly to refactored static methods).
+2. **Profile Execution**: Use `GraphqlTenantContextProfilingSpec` to measure the cost of fetching data across multiple tenants.
+
+## Targets for B.2 Refactoring
+- `org.grails.gorm.graphql.fetcher.PogoDataFetcher`
+- `org.grails.gorm.graphql.fetcher.GormEntityDataFetcher`
+- `org.grails.gorm.graphql.interceptor.GraphQLInterceptor`

grails-data-graphql/core/src/main/groovy/org/grails/gorm/graphql/entity/EntityFetchOptions.java

@@ -32,7 +32,7 @@
 import graphql.language.SelectionSet;
 import graphql.schema.DataFetchingEnvironment;
 
-import org.grails.datastore.gorm.GormEnhancer;
+import org.grails.datastore.gorm.GormRegistry;
 import org.grails.datastore.mapping.model.PersistentEntity;
 import org.grails.datastore.mapping.model.types.Association;
 import org.grails.datastore.mapping.model.types.ToMany;
@@ -60,7 +60,7 @@ public EntityFetchOptions(Class<?> entityClass) {
     }
 
     public EntityFetchOptions(Class<?> entityClass, String projectionName) {
-        this(GormEnhancer.findStaticApi(entityClass).getGormPersistentEntity(), projectionName);
+        this(GormRegistry.getInstance().findStaticApi(entityClass).getGormPersistentEntity(), projectionName);
     }
 
     public EntityFetchOptions(PersistentEntity entity) {

grails-data-graphql/core/src/main/groovy/org/grails/gorm/graphql/fetcher/DefaultGormDataFetcher.groovy

@@ -19,15 +19,17 @@
 
 package org.grails.gorm.graphql.fetcher
 
+import groovy.transform.CompileStatic
+import groovy.util.logging.Slf4j
+
+import graphql.schema.DataFetcher
+import graphql.schema.DataFetchingEnvironment
+
 import grails.gorm.DetachedCriteria
 import grails.gorm.multitenancy.Tenants
 import grails.gorm.transactions.TransactionService
-import graphql.schema.DataFetcher
-import graphql.schema.DataFetchingEnvironment
-import groovy.transform.CompileStatic
-import groovy.util.logging.Slf4j
-import org.grails.datastore.gorm.GormEnhancer
 import org.grails.datastore.gorm.GormEntity
+import org.grails.datastore.gorm.GormRegistry
 import org.grails.datastore.gorm.GormStaticApi
 import org.grails.datastore.mapping.core.Datastore
 import org.grails.datastore.mapping.model.PersistentEntity
@@ -79,7 +81,7 @@ abstract class DefaultGormDataFetcher<T> implements DataFetcher<T> {
     }
 
     protected Object loadEntity(PersistentEntity entity, Object argument) {
-        GormEnhancer.findStaticApi(entity.javaClass).load((Serializable)argument)
+        GormRegistry.instance.findStaticApi(entity.javaClass).load((Serializable)argument)
     }
 
     protected Map<String, Object> getIdentifierValues(DataFetchingEnvironment environment) {
@@ -141,7 +143,7 @@ abstract class DefaultGormDataFetcher<T> implements DataFetcher<T> {
     }
 
     protected GormStaticApi getStaticApi() {
-        GormEnhancer.findStaticApi(entity.javaClass)
+        GormRegistry.instance.findStaticApi(entity.javaClass)
     }
 
     abstract T get(DataFetchingEnvironment environment)