Ignore implicit default persistence units if there is no datasource and no entity

... instead of failing as soon as there is a managed class, even if that
class is not an entity.

The previous behavior was particularly problematic when Panache was in the
classpath, because then there will always be a managed class (Panache's
mappedsuperclasses) in the default persistence unit, so we would end up
failing with default configuration.

Now we will just ignore such a persistence unit.

Author: yrodiere

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

@@ -892,33 +892,39 @@ private void handleHibernateORMWithNoPersistenceXml(
                 && hibernateOrmConfig.namedPersistenceUnits().isEmpty())
                 || hibernateOrmConfig.defaultPersistenceUnit().isAnyPropertySet();
 
-        Map<String, Set<String>> modelClassesAndPackagesPerPersistencesUnits = getModelClassesAndPackagesPerPersistenceUnits(
+        var modelPerPersistencesUnit = getModelPerPersistenceUnit(
                 hibernateOrmConfig, additionalJpaModelBuildItems, jpaModel, index.getIndex(), enableDefaultPersistenceUnit);
-        Set<String> modelClassesAndPackagesForDefaultPersistenceUnit = modelClassesAndPackagesPerPersistencesUnits
-                .getOrDefault(PersistenceUnitUtil.DEFAULT_PERSISTENCE_UNIT_NAME, Collections.emptySet());
+        var modelForDefaultPersistenceUnit = modelPerPersistencesUnit.get(PersistenceUnitUtil.DEFAULT_PERSISTENCE_UNIT_NAME);
+        if (modelForDefaultPersistenceUnit == null) {
+            modelForDefaultPersistenceUnit = new JpaPersistenceUnitModel();
+        }
 
         Set<String> storageEngineCollector = new HashSet<>();
 
         if (enableDefaultPersistenceUnit) {
             producePersistenceUnitDescriptorFromConfig(
                     hibernateOrmConfig, jpaModel, PersistenceUnitUtil.DEFAULT_PERSISTENCE_UNIT_NAME,
                     hibernateOrmConfig.defaultPersistenceUnit(),
-                    modelClassesAndPackagesForDefaultPersistenceUnit,
+                    modelForDefaultPersistenceUnit.allModelClassAndPackageNames(),
                     jpaModel.getXmlMappings(PersistenceUnitUtil.DEFAULT_PERSISTENCE_UNIT_NAME),
                     jdbcDataSources, applicationArchivesBuildItem, launchMode, capabilities,
                     systemProperties, nativeImageResources, hotDeploymentWatchedFiles, persistenceUnitDescriptors,
                     reflectiveMethods, unremovableBeans, storageEngineCollector, dbKindMetadataBuildItems);
-        } else if (!modelClassesAndPackagesForDefaultPersistenceUnit.isEmpty()
+        } else if (!modelForDefaultPersistenceUnit.entityClassNames().isEmpty()
                 && (!hibernateOrmConfig.defaultPersistenceUnit().datasource().isPresent()
                         || DataSourceUtil.isDefault(hibernateOrmConfig.defaultPersistenceUnit().datasource().get()))
                 && !defaultJdbcDataSource.isPresent()) {
+            // We're not enable the default PU, meaning there is no explicit configuration for it,
+            // and we couldn't find a default datasource.
+            // But there are entities assigned to it, meaning these entities can never work properly.
+            // This looks like a mistake, so we'll error out.
             String persistenceUnitName = PersistenceUnitUtil.DEFAULT_PERSISTENCE_UNIT_NAME;
             String dataSourceName = DataSourceUtil.DEFAULT_DATASOURCE_NAME;
             var cause = DataSourceUtil.dataSourceNotConfigured(dataSourceName);
             throw new ConfigurationException(String.format(Locale.ROOT,
                     "Persistence unit '%s' defines entities %s, but its datasource '%s' cannot be found: %s"
                             + " Alternatively, disable Hibernate ORM by setting '%s=false', and the entities will be ignored.",
-                    persistenceUnitName, modelClassesAndPackagesForDefaultPersistenceUnit,
+                    persistenceUnitName, modelForDefaultPersistenceUnit.entityClassNames(),
                     dataSourceName,
                     cause.getMessage(),
                     HibernateOrmRuntimeConfig.extensionPropertyKey("enabled")),
@@ -927,11 +933,12 @@ private void handleHibernateORMWithNoPersistenceXml(
 
         for (Entry<String, HibernateOrmConfigPersistenceUnit> persistenceUnitEntry : hibernateOrmConfig.namedPersistenceUnits()
                 .entrySet()) {
+            var persistenceUnitName = persistenceUnitEntry.getKey();
+            var model = modelPerPersistencesUnit.get(persistenceUnitEntry.getKey());
             producePersistenceUnitDescriptorFromConfig(
-                    hibernateOrmConfig, jpaModel, persistenceUnitEntry.getKey(), persistenceUnitEntry.getValue(),
-                    modelClassesAndPackagesPerPersistencesUnits.getOrDefault(persistenceUnitEntry.getKey(),
-                            Collections.emptySet()),
-                    jpaModel.getXmlMappings(persistenceUnitEntry.getKey()),
+                    hibernateOrmConfig, jpaModel, persistenceUnitName, persistenceUnitEntry.getValue(),
+                    model == null ? Collections.emptySet() : model.allModelClassAndPackageNames(),
+                    jpaModel.getXmlMappings(persistenceUnitName),
                     jdbcDataSources, applicationArchivesBuildItem, launchMode, capabilities,
                     systemProperties, nativeImageResources, hotDeploymentWatchedFiles, persistenceUnitDescriptors,
                     reflectiveMethods, unremovableBeans, storageEngineCollector, dbKindMetadataBuildItems);
@@ -1143,10 +1150,10 @@ private void enhanceEntities(final JpaModelBuildItem jpaModel,
         }
     }
 
-    public static Map<String, Set<String>> getModelClassesAndPackagesPerPersistenceUnits(HibernateOrmConfig hibernateOrmConfig,
+    public static Map<String, JpaPersistenceUnitModel> getModelPerPersistenceUnit(HibernateOrmConfig hibernateOrmConfig,
             List<AdditionalJpaModelBuildItem> additionalJpaModelBuildItems, JpaModelBuildItem jpaModel,
             IndexView index, boolean enableDefaultPersistenceUnit) {
-        Map<String, Set<String>> modelClassesAndPackagesPerPersistenceUnits = new HashMap<>();
+        Map<String, JpaPersistenceUnitModel> modelPerPersistenceUnit = new HashMap<>();
 
         boolean hasPackagesInQuarkusConfig = hasPackagesInQuarkusConfig(hibernateOrmConfig);
         Collection<AnnotationInstance> packageLevelPersistenceUnitAnnotations = getPackageLevelPersistenceUnitAnnotations(
@@ -1212,9 +1219,11 @@ public static Map<String, Set<String>> getModelClassesAndPackagesPerPersistenceU
             // No .packages configuration, no package-level persistence unit annotations,
             // and no named persistence units: all the entities will be associated with the default one
             // so we don't need to split them
-            Set<String> allModelClassesAndPackages = new HashSet<>(jpaModel.getAllModelClassNames());
-            allModelClassesAndPackages.addAll(jpaModel.getAllModelPackageNames());
-            return Collections.singletonMap(PersistenceUnitUtil.DEFAULT_PERSISTENCE_UNIT_NAME, allModelClassesAndPackages);
+            var model = new JpaPersistenceUnitModel();
+            model.entityClassNames().addAll(jpaModel.getEntityClassNames());
+            model.allModelClassAndPackageNames().addAll(jpaModel.getAllModelClassNames());
+            model.allModelClassAndPackageNames().addAll(jpaModel.getAllModelPackageNames());
+            return Map.of(PersistenceUnitUtil.DEFAULT_PERSISTENCE_UNIT_NAME, model);
         }
 
         Set<String> modelClassesWithPersistenceUnitAnnotations = new TreeSet<>();
@@ -1232,13 +1241,18 @@ public static Map<String, Set<String>> getModelClassesAndPackagesPerPersistenceU
             for (Entry<String, Set<String>> packageRuleEntry : packageRules.entrySet()) {
                 if (modelClassName.startsWith(packageRuleEntry.getKey())) {
                     for (String persistenceUnitName : packageRuleEntry.getValue()) {
-                        modelClassesAndPackagesPerPersistenceUnits.putIfAbsent(persistenceUnitName, new HashSet<>());
-                        modelClassesAndPackagesPerPersistenceUnits.get(persistenceUnitName).add(modelClassName);
+                        var model = modelPerPersistenceUnit.computeIfAbsent(persistenceUnitName,
+                                ignored -> new JpaPersistenceUnitModel());
+
+                        if (jpaModel.getEntityClassNames().contains(modelClassName)) {
+                            model.entityClassNames().add(modelClassName);
+                        }
+                        model.allModelClassAndPackageNames().add(modelClassName);
 
                         // also add the hierarchy to the persistence unit
                         // we would need to add all the underlying model to it but adding the hierarchy
                         // is necessary for Panache as we need to add PanacheEntity to the PU
-                        modelClassesAndPackagesPerPersistenceUnits.get(persistenceUnitName).addAll(relatedModelClassNames);
+                        model.allModelClassAndPackageNames().addAll(relatedModelClassNames);
                     }
                 }
             }
@@ -1254,8 +1268,13 @@ public static Map<String, Set<String>> getModelClassesAndPackagesPerPersistenceU
             }
             assignedModelClasses.add(className); // Even if persistenceUnits is empty, the class is still assigned (to nothing)
             for (String persistenceUnitName : persistenceUnits) {
-                modelClassesAndPackagesPerPersistenceUnits.putIfAbsent(persistenceUnitName, new HashSet<>());
-                modelClassesAndPackagesPerPersistenceUnits.get(persistenceUnitName).add(className);
+                var model = modelPerPersistenceUnit.computeIfAbsent(persistenceUnitName,
+                        ignored -> new JpaPersistenceUnitModel());
+
+                if (jpaModel.getEntityClassNames().contains(className)) {
+                    model.entityClassNames().add(className);
+                }
+                model.allModelClassAndPackageNames().add(className);
             }
         }
 
@@ -1265,7 +1284,8 @@ public static Map<String, Set<String>> getModelClassesAndPackagesPerPersistenceU
                     String.join("\n\t- ", modelClassesWithPersistenceUnitAnnotations)));
         }
 
-        assignedModelClasses.addAll(modelClassesAndPackagesPerPersistenceUnits.values().stream().flatMap(Set::stream).toList());
+        assignedModelClasses.addAll(modelPerPersistenceUnit.values().stream()
+                .map(JpaPersistenceUnitModel::allModelClassAndPackageNames).flatMap(Set::stream).toList());
         Set<String> unaffectedModelClasses = jpaModel.getAllModelClassNames().stream()
                 .filter(c -> !assignedModelClasses.contains(c))
                 .collect(Collectors.toCollection(TreeSet::new));
@@ -1281,12 +1301,13 @@ public static Map<String, Set<String>> getModelClassesAndPackagesPerPersistenceU
                 continue;
             }
             for (String persistenceUnitName : persistenceUnitNames) {
-                modelClassesAndPackagesPerPersistenceUnits.putIfAbsent(persistenceUnitName, new HashSet<>());
-                modelClassesAndPackagesPerPersistenceUnits.get(persistenceUnitName).add(modelPackageName);
+                var model = modelPerPersistenceUnit.computeIfAbsent(persistenceUnitName,
+                        ignored -> new JpaPersistenceUnitModel());
+                model.allModelClassAndPackageNames().add(modelPackageName);
             }
         }
 
-        return modelClassesAndPackagesPerPersistenceUnits;
+        return modelPerPersistenceUnit;
     }
 
     private static Set<String> getRelatedModelClassNames(IndexView index, Set<String> knownModelClassNames,

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

@@ -0,0 +1,11 @@
+package io.quarkus.hibernate.orm.deployment;
+
+import java.util.Set;
+import java.util.TreeSet;
+
+public record JpaPersistenceUnitModel(Set<String> entityClassNames,
+        Set<String> allModelClassAndPackageNames) {
+    public JpaPersistenceUnitModel() {
+        this(new TreeSet<>(), new TreeSet<>());
+    }
+}

extensions/hibernate-reactive/deployment/src/main/java/io/quarkus/hibernate/reactive/deployment/HibernateReactiveProcessor.java

@@ -355,19 +355,18 @@ private static QuarkusPersistenceUnitDescriptorWithSupportedDBKind generateReact
             BuildProducer<HotDeploymentWatchedFileBuildItem> hotDeploymentWatchedFiles,
             List<DatabaseKindDialectBuildItem> dbKindDialectBuildItems, boolean enableDefaultPersistenceUnit) {
 
-        Map<String, Set<String>> modelClassesAndPackagesPerPersistencesUnits = HibernateOrmProcessor
-                .getModelClassesAndPackagesPerPersistenceUnits(hibernateOrmConfig, additionalJpaModelBuildItems, jpaModel,
+        var modelPerPersistencesUnit = HibernateOrmProcessor
+                .getModelPerPersistenceUnit(hibernateOrmConfig, additionalJpaModelBuildItems, jpaModel,
                         index.getIndex(),
                         enableDefaultPersistenceUnit);
 
-        Set<String> modelClassesAndPackages = modelClassesAndPackagesPerPersistencesUnits
-                .getOrDefault(persistenceUnitName, Collections.emptySet());
+        var model = modelPerPersistencesUnit.get(persistenceUnitName);
 
         QuarkusPersistenceUnitDescriptor descriptor = new QuarkusPersistenceUnitDescriptor(
                 persistenceUnitName,
                 new HibernateReactivePersistenceUnitProviderHelper(),
                 PersistenceUnitTransactionType.RESOURCE_LOCAL,
-                new ArrayList<>(modelClassesAndPackages),
+                new ArrayList<>(model == null ? Collections.emptySet() : model.allModelClassAndPackageNames()),
                 new Properties(),
                 true);
 

extensions/panache/hibernate-orm-panache/deployment/src/test/java/io/quarkus/hibernate/orm/panache/deployment/test/ErroneousConfigHotReloadTestCase.java

@@ -21,6 +21,21 @@ public class ErroneousConfigHotReloadTestCase {
 
     @Test
     public void test() {
+        // Because there is no entity, the fact that there is no datasource will not trigger an error:
+        // the persistence unit will simply be automatically deactivated.
+        // Panache will however raise an exception on first attempt to use a class that is not, in fact, an entity.
+        RestAssured.when().get("/unannotatedEntity").then().statusCode(500).body(containsString("@Entity"))
+                .body(not(containsString("NullPointer")));
+
+        TEST.modifySourceFile(UnAnnotatedEntity.class, new Function<String, String>() {
+            @Override
+            public String apply(String s) {
+                return s.replace("//", "");
+            }
+        });
+
+        // Once we do have entities, the persistence unit will be active,
+        // but will fail to start since there is no datasource.
         RestAssured.when()
                 .get("/unannotatedEntity").then().statusCode(500)
                 // Weirdly, in case of build errors, Quarkus will return the error as HTML, even if we set the content type to JSON...
@@ -36,16 +51,6 @@ public String apply(String s) {
             }
         });
 
-        RestAssured.when().get("/unannotatedEntity").then().statusCode(500).body(containsString("@Entity"))
-                .body(not(containsString("NullPointer")));
-
-        TEST.modifySourceFile(UnAnnotatedEntity.class, new Function<String, String>() {
-            @Override
-            public String apply(String s) {
-                return s.replace("//", "");
-            }
-        });
-
         RestAssured.when().get("/unannotatedEntity").then().statusCode(200);
     }