Do not rely on JPATraversableResolver / add JPA aware resolver only if ORM is enabled

extensions/hibernate-orm/deployment/pom.xml

@@ -53,6 +53,10 @@
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-vertx-http-dev-ui-spi</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-hibernate-validator-spi</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-hibernate-orm-derby-deployment</artifactId>

extensions/hibernate-orm/deployment/src/main/java/io/quarkus/hibernate/orm/deployment/HibernateOrmProcessor.java

@@ -131,6 +131,7 @@
 import io.quarkus.hibernate.orm.runtime.service.FlatClassLoaderService;
 import io.quarkus.hibernate.orm.runtime.tenant.DataSourceTenantConnectionResolver;
 import io.quarkus.hibernate.orm.runtime.tenant.TenantConnectionResolver;
+import io.quarkus.hibernate.validator.spi.BeanValidationTraversableResolverBuildItem;
 import io.quarkus.panache.hibernate.common.deployment.HibernateEnhancersRegisteredBuildItem;
 import io.quarkus.panache.hibernate.common.deployment.HibernateModelClassCandidatesForFieldAccessBuildItem;
 import io.quarkus.runtime.LaunchMode;
@@ -518,9 +519,11 @@ private boolean hasXmlMappings(List<PersistenceUnitDescriptorBuildItem> persiste
     public void build(RecorderContext recorderContext, HibernateOrmRecorder recorder,
             Capabilities capabilities,
             JpaModelBuildItem jpaModel,
+            HibernateOrmConfig hibernateOrmConfig,
             List<PersistenceUnitDescriptorBuildItem> persistenceUnitDescriptorBuildItems,
             List<HibernateOrmIntegrationStaticConfiguredBuildItem> integrationBuildItems,
             BuildProducer<BeanContainerListenerBuildItem> beanContainerListener,
+            BuildProducer<BeanValidationTraversableResolverBuildItem> beanValidationTraversableResolver,
             LaunchModeBuildItem launchMode) throws Exception {
         validateHibernatePropertiesNotUsed();
 
@@ -578,6 +581,10 @@ public void build(RecorderContext recorderContext, HibernateOrmRecorder recorder
         beanContainerListener
                 .produce(new BeanContainerListenerBuildItem(
                         recorder.initMetadata(finalStagePUDescriptors, scanner, integratorClasses)));
+        if (capabilities.isPresent(Capability.HIBERNATE_VALIDATOR) && hibernateOrmConfig.enabled()) {
+            beanValidationTraversableResolver
+                    .produce(new BeanValidationTraversableResolverBuildItem(recorder.attributeLoadedPredicate()));
+        }
     }
 
     private void validateHibernatePropertiesNotUsed() {

extensions/hibernate-orm/runtime/src/main/java/io/quarkus/hibernate/orm/runtime/HibernateOrmRecorder.java

@@ -6,13 +6,15 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.function.BiPredicate;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
 import jakarta.inject.Inject;
 import jakarta.persistence.Cache;
 import jakarta.persistence.criteria.CriteriaBuilder;
 import jakarta.persistence.metamodel.Metamodel;
+import jakarta.persistence.spi.LoadState;
 
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
@@ -250,4 +252,29 @@ public void run() {
             }
         }, "Hibernate post-boot validation thread for " + puName).start();
     }
+
+    public BiPredicate<Object, String> attributeLoadedPredicate() {
+        return new IsAttributeLoadedPredicate();
+    }
+
+    private static class IsAttributeLoadedPredicate implements BiPredicate<Object, String> {
+        private final ProviderUtil providerUtil = new ProviderUtil();
+
+        @Override
+        public boolean test(Object entity, String attributeName) {
+            LoadState loadstate = providerUtil.isLoadedWithoutReference(entity, attributeName);
+            if (loadstate == LoadState.LOADED) {
+                return true;
+            } else if (loadstate == LoadState.NOT_LOADED) {
+                return false;
+            }
+            loadstate = providerUtil.isLoadedWithReference(entity, attributeName);
+            if (loadstate == LoadState.LOADED) {
+                return true;
+            } else if (loadstate == LoadState.NOT_LOADED) {
+                return false;
+            }
+            return true;
+        }
+    }
 }

extensions/hibernate-validator/deployment/src/main/java/io/quarkus/hibernate/validator/deployment/HibernateValidatorProcessor.java

@@ -120,6 +120,7 @@
 import io.quarkus.hibernate.validator.runtime.locale.LocaleResolversWrapper;
 import io.quarkus.hibernate.validator.spi.AdditionalConstrainedClassBuildItem;
 import io.quarkus.hibernate.validator.spi.BeanValidationAnnotationsBuildItem;
+import io.quarkus.hibernate.validator.spi.BeanValidationTraversableResolverBuildItem;
 import io.quarkus.jaxrs.spi.deployment.AdditionalJaxRsResourceMethodAnnotationsBuildItem;
 import io.quarkus.resteasy.common.spi.ResteasyConfigBuildItem;
 import io.quarkus.resteasy.common.spi.ResteasyDotNames;
@@ -475,7 +476,7 @@ public void build(
             ShutdownContextBuildItem shutdownContext,
             List<ConfigClassBuildItem> configClasses,
             List<AdditionalJaxRsResourceMethodAnnotationsBuildItem> additionalJaxRsResourceMethodAnnotations,
-            Capabilities capabilities,
+            Optional<BeanValidationTraversableResolverBuildItem> beanValidationTraversableResolver,
             LocalesBuildTimeConfig localesBuildTimeConfig,
             HibernateValidatorBuildTimeConfig hibernateValidatorBuildTimeConfig) throws Exception {
 
@@ -607,7 +608,8 @@ public void build(
                 .createWith(recorder.hibernateValidatorFactory(classesToBeValidated, detectedBuiltinConstraints,
                         valueExtractorClassProxies,
                         hasXmlConfiguration(),
-                        capabilities.isPresent(Capability.HIBERNATE_ORM),
+                        beanValidationTraversableResolver
+                                .map(BeanValidationTraversableResolverBuildItem::getAttributeLoadedPredicate),
                         localesBuildTimeConfig,
                         hibernateValidatorBuildTimeConfig))
                 .addQualifier().annotation(DotNames.NAMED).addValue("value", VALIDATOR_FACTORY_NAME).done()

extensions/hibernate-validator/runtime/src/main/java/io/quarkus/hibernate/validator/runtime/HibernateValidatorRecorder.java

@@ -1,11 +1,14 @@
 package io.quarkus.hibernate.validator.runtime;
 
+import java.lang.annotation.ElementType;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
+import java.util.Optional;
 import java.util.Set;
+import java.util.function.BiPredicate;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
@@ -16,6 +19,7 @@
 import jakarta.validation.ConstraintValidatorFactory;
 import jakarta.validation.MessageInterpolator;
 import jakarta.validation.ParameterNameProvider;
+import jakarta.validation.Path;
 import jakarta.validation.TraversableResolver;
 import jakarta.validation.Validation;
 import jakarta.validation.Validator;
@@ -25,7 +29,6 @@
 import org.hibernate.validator.HibernateValidatorFactory;
 import org.hibernate.validator.PredefinedScopeHibernateValidator;
 import org.hibernate.validator.PredefinedScopeHibernateValidatorConfiguration;
-import org.hibernate.validator.internal.engine.resolver.JPATraversableResolver;
 import org.hibernate.validator.spi.messageinterpolation.LocaleResolver;
 import org.hibernate.validator.spi.nodenameprovider.PropertyNodeNameProvider;
 import org.hibernate.validator.spi.properties.GetterPropertySelectionStrategy;
@@ -83,7 +86,8 @@ public void run() {
     public Function<SyntheticCreationalContext<HibernateValidatorFactory>, HibernateValidatorFactory> hibernateValidatorFactory(
             Set<Class<?>> classesToBeValidated,
             Set<String> detectedBuiltinConstraints, Set<Class<?>> valueExtractorClasses,
-            boolean hasXmlConfiguration, boolean jpaInClasspath,
+            boolean hasXmlConfiguration,
+            Optional<BiPredicate<Object, String>> attributeLoadedPredicate,
             LocalesBuildTimeConfig localesBuildTimeConfig,
             HibernateValidatorBuildTimeConfig hibernateValidatorBuildTimeConfig) {
         return new Function<>() {
@@ -141,8 +145,8 @@ public HibernateValidatorFactory apply(SyntheticCreationalContext<HibernateValid
                     configuration.traversableResolver(configuredTraversableResolver.get());
                 } else {
                     // we still define the one we want to use so that we do not rely on runtime automatic detection
-                    if (jpaInClasspath) {
-                        configuration.traversableResolver(new JPATraversableResolver());
+                    if (attributeLoadedPredicate.isPresent()) {
+                        configuration.traversableResolver(new DelegatingTraversableResolver(attributeLoadedPredicate.get()));
                     } else {
                         configuration.traversableResolver(new TraverseAllTraversableResolver());
                     }
@@ -291,4 +295,24 @@ public ResteasyConfigSupport get() {
     public void hibernateValidatorFactoryInit(BeanContainer beanContainer) {
         HibernateValidatorFactory hibernateValidatorFactory = beanContainer.beanInstance(HibernateValidatorFactory.class);
     }
+
+    static final class DelegatingTraversableResolver implements TraversableResolver {
+        private final BiPredicate<Object, String> attributeLoadedPredicate;
+
+        DelegatingTraversableResolver(BiPredicate<Object, String> attributeLoadedPredicate) {
+            this.attributeLoadedPredicate = attributeLoadedPredicate;
+        }
+
+        @Override
+        public boolean isReachable(Object entity, Path.Node traversableProperty, Class<?> rootBeanType,
+                Path pathToTraversableObject, ElementType elementType) {
+            return attributeLoadedPredicate.test(entity, traversableProperty.getName());
+        }
+
+        @Override
+        public boolean isCascadable(Object traversableObject, Path.Node traversableProperty, Class<?> rootBeanType,
+                Path pathToTraversableObject, ElementType elementType) {
+            return true;
+        }
+    }
 }

extensions/hibernate-validator/spi/src/main/java/io/quarkus/hibernate/validator/spi/BeanValidationTraversableResolverBuildItem.java

@@ -0,0 +1,21 @@
+package io.quarkus.hibernate.validator.spi;
+
+import java.util.function.BiPredicate;
+
+import io.quarkus.builder.item.SimpleBuildItem;
+
+/**
+ * BuildItem to replace the default traversable resolver
+ */
+public final class BeanValidationTraversableResolverBuildItem extends SimpleBuildItem {
+
+    private final BiPredicate<Object, String> attributeLoadedPredicate;
+
+    public BeanValidationTraversableResolverBuildItem(BiPredicate<Object, String> attributeLoadedPredicate) {
+        this.attributeLoadedPredicate = attributeLoadedPredicate;
+    }
+
+    public BiPredicate<Object, String> getAttributeLoadedPredicate() {
+        return attributeLoadedPredicate;
+    }
+}

pom.xml

@@ -77,7 +77,7 @@
         <bytebuddy.version>1.15.11</bytebuddy.version> <!-- version controlled by Hibernate ORM's needs -->
         <hibernate-models.version>1.0.0</hibernate-models.version> <!-- version controlled by Hibernate ORM's needs -->
         <hibernate-reactive.version>3.0.0.Final</hibernate-reactive.version> <!-- highly sensitive to Hibernate ORM upgrades -->
-        <hibernate-validator.version>9.0.0.Final</hibernate-validator.version>
+        <hibernate-validator.version>9.0.1.Final</hibernate-validator.version>
         <hibernate-search.version>8.0.0.Final</hibernate-search.version>
 
         <!-- Make sure to check compatibility between these 2 gRPC components before upgrade -->