Collect nested ConfigMappingClass entries in getConfigMappingsMetadata (#1551)

Author: radcortez

implementation/src/main/java/io/smallrye/config/ConfigMappingInterface.java

@@ -188,7 +188,7 @@ String getClassInternalName() {
         return className.replace('.', '/');
     }
 
-    List<ConfigMappingInterface> getNested() {
+    public List<ConfigMappingInterface> getNested() {
         Set<ConfigMappingInterface> nested = new LinkedHashSet<>();
         getNested(properties, nested);
         return new ArrayList<>(nested);

implementation/src/main/java/io/smallrye/config/ConfigMappingLoader.java

@@ -4,8 +4,10 @@
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.UndeclaredThrowableException;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -43,6 +45,7 @@ public static List<ConfigMappingMetadata> getConfigMappingsMetadata(final Class<
         ConfigMappingClass configMappingClass = ConfigMappingClass.getConfigurationClass(type);
         if (configMappingClass != null) {
             mappings.add(configMappingClass);
+            mappings.addAll(configMappingClass.getNested());
             mappings.addAll(getConfigMappingsMetadata(getConfigMapping(type).getInterfaceType()));
         }
         return List.copyOf(mappings);
@@ -336,5 +339,37 @@ public String getClassName() {
         public byte[] getClassBytes() {
             return ConfigMappingGenerator.generate(classType, interfaceName);
         }
+
+        public List<ConfigMappingClass> getNested() {
+            List<ConfigMappingClass> nested = new ArrayList<>();
+            collectNested(classType, nested);
+            return nested;
+        }
+
+        private static void collectNested(final Class<?> type, final List<ConfigMappingClass> nested) {
+            for (Field field : type.getDeclaredFields()) {
+                Class<?> fieldType = field.getType();
+                if (Collection.class.isAssignableFrom(fieldType) || Map.class.isAssignableFrom(fieldType)) {
+                    java.lang.reflect.Type genericType = field.getGenericType();
+                    if (genericType instanceof ParameterizedType parameterizedType) {
+                        for (java.lang.reflect.Type typeArg : parameterizedType.getActualTypeArguments()) {
+                            if (typeArg instanceof Class<?> argClass) {
+                                addNested(argClass, nested);
+                            }
+                        }
+                    }
+                } else {
+                    addNested(fieldType, nested);
+                }
+            }
+        }
+
+        private static void addNested(final Class<?> type, final List<ConfigMappingClass> nested) {
+            ConfigMappingClass configClass = getConfigurationClass(type);
+            if (configClass != null) {
+                nested.add(configClass);
+                collectNested(type, nested);
+            }
+        }
     }
 }

implementation/src/main/java/io/smallrye/config/ConfigMappingMetadata.java

@@ -1,9 +1,15 @@
 package io.smallrye.config;
 
+import java.util.List;
+
 public interface ConfigMappingMetadata {
     Class<?> getInterfaceType();
 
     String getClassName();
 
     byte[] getClassBytes();
+
+    default List<? extends ConfigMappingMetadata> getNested() {
+        return List.of();
+    }
 }

implementation/src/test/java/io/smallrye/config/ConfigMappingClassTest.java

@@ -5,9 +5,12 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.OptionalInt;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.eclipse.microprofile.config.spi.Converter;
 import org.junit.jupiter.api.Assertions;
@@ -259,6 +262,25 @@ void mapNestedWithFieldInitializerIgnored() {
         assertEquals(8080, mapping.servers.get("one").port);
     }
 
+    @Test
+    void nestedMetadataCollection() {
+        List<ConfigMappingMetadata> metadata = ConfigMappingLoader.getConfigMappingsMetadata(MapNestedClass.class);
+        Set<String> names = metadata.stream()
+                .map(ConfigMappingMetadata::getClassName)
+                .collect(Collectors.toSet());
+
+        // ConfigMappingClass entries (generated interface names)
+        assertTrue(names
+                .contains(ConfigMappingLoader.ConfigMappingClass.getConfigurationClass(MapNestedClass.class).getClassName()));
+        assertTrue(names.contains(
+                ConfigMappingLoader.ConfigMappingClass.getConfigurationClass(MapNestedClass.ServerEntry.class).getClassName()));
+        // ConfigMappingInterface entries (implementation class names)
+        assertTrue(names.contains(ConfigMappingInterface.getImplementationClassName(
+                ConfigMappingLoader.getConfigMapping(MapNestedClass.class).getInterfaceType())));
+        assertTrue(names.contains(ConfigMappingInterface.getImplementationClassName(
+                ConfigMappingLoader.getConfigMapping(MapNestedClass.ServerEntry.class).getInterfaceType())));
+    }
+
     static class MapNestedClass {
         Map<String, ServerEntry> servers = new HashMap<>();