Handle nested context-only constructors

Author: oschwald

src/main/java/com/maxmind/db/Decoder.java

@@ -555,6 +555,20 @@ private <T> CachedConstructor<T> loadConstructorMetadata(Class<T> cls) {
             parameterIndexes.put(name, i);
         }
 
+        // Check for transitive context requirements: if any non-injection parameter type
+        // itself requires context (e.g., nested objects with @MaxMindDbIpAddress annotations),
+        // then this parent class also requires context to avoid incorrect caching.
+        if (!requiresContext) {
+            for (int i = 0; i < parameterTypes.length; i++) {
+                if (parameterInjections[i] == ParameterInjection.NONE) {
+                    if (shouldInstantiateFromContext(parameterTypes[i])) {
+                        requiresContext = true;
+                        break;
+                    }
+                }
+            }
+        }
+
         var cachedConstructor = new CachedConstructor<>(
             constructor,
             parameterTypes,
@@ -602,8 +616,15 @@ private <T> Object decodeMapIntoObject(int size, Class<T> cls)
                 parameters[i] = injectParameter(parameterInjections[i], parameterTypes[i]);
                 continue;
             }
-            if (parameters[i] == null && parameterDefaults[i] != null) {
+            if (parameters[i] != null) {
+                continue;
+            }
+            if (parameterDefaults[i] != null) {
                 parameters[i] = parameterDefaults[i];
+                continue;
+            }
+            if (shouldInstantiateFromContext(parameterTypes[i])) {
+                parameters[i] = instantiateWithLookupContext(parameterTypes[i]);
             }
         }
 
@@ -629,6 +650,77 @@ private <T> Object decodeMapIntoObject(int size, Class<T> cls)
         }
     }
 
+    private boolean shouldInstantiateFromContext(Class<?> parameterType) {
+        if (parameterType == null
+            || parameterType.isPrimitive()
+            || isSimpleType(parameterType)
+            || Map.class.isAssignableFrom(parameterType)
+            || List.class.isAssignableFrom(parameterType)) {
+            return false;
+        }
+        return requiresLookupContext(parameterType);
+    }
+
+    private Object instantiateWithLookupContext(Class<?> parameterType) {
+        var metadata = loadConstructorMetadata(parameterType);
+        if (metadata == null || !metadata.requiresLookupContext()) {
+            return null;
+        }
+
+        var ctor = metadata.constructor();
+        var types = metadata.parameterTypes();
+        var defaults = metadata.parameterDefaults();
+        var injections = metadata.parameterInjections();
+        var args = new Object[types.length];
+
+        for (int i = 0; i < args.length; i++) {
+            if (injections[i] != ParameterInjection.NONE) {
+                args[i] = injectParameter(injections[i], types[i]);
+            } else if (defaults[i] != null) {
+                args[i] = defaults[i];
+            } else if (types[i].isPrimitive()) {
+                args[i] = primitiveDefault(types[i]);
+            } else {
+                args[i] = null;
+            }
+        }
+
+        try {
+            return ctor.newInstance(args);
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+            throw new DeserializationException(
+                "Error creating object of type: " + parameterType.getName(), e);
+        }
+    }
+
+    private static Object primitiveDefault(Class<?> type) {
+        if (type.equals(Boolean.TYPE)) {
+            return false;
+        }
+        if (type.equals(Byte.TYPE)) {
+            return (byte) 0;
+        }
+        if (type.equals(Short.TYPE)) {
+            return (short) 0;
+        }
+        if (type.equals(Integer.TYPE)) {
+            return 0;
+        }
+        if (type.equals(Long.TYPE)) {
+            return 0L;
+        }
+        if (type.equals(Float.TYPE)) {
+            return 0.0f;
+        }
+        if (type.equals(Double.TYPE)) {
+            return 0.0d;
+        }
+        if (type.equals(Character.TYPE)) {
+            return '\0';
+        }
+        return null;
+    }
+
     private Object injectParameter(ParameterInjection injection, Class<?> parameterType) {
         return switch (injection) {
             case IP_ADDRESS -> getLookupIpValue(parameterType);

src/test/java/com/maxmind/db/ReaderTest.java

@@ -552,6 +552,49 @@ public void testContextAnnotations(int chunkSize) throws IOException {
         }
     }
 
+    @ParameterizedTest
+    @MethodSource("chunkSizes")
+    public void testNestedContextAnnotations(int chunkSize) throws IOException {
+        try (var reader = new Reader(getFile("MaxMind-DB-test-decoder.mmdb"), chunkSize)) {
+            var firstIp = InetAddress.getByName("1.1.1.1");
+            var secondIp = InetAddress.getByName("1.1.1.3");
+            var expectedNetwork = reader.getRecord(firstIp, Map.class).network().toString();
+
+            var first = reader.get(firstIp, WrapperContextOnlyModel.class);
+            var second = reader.get(secondIp, WrapperContextOnlyModel.class);
+
+            assertNotNull(first.context);
+            assertEquals(firstIp, first.context.lookupIp);
+            assertEquals(expectedNetwork, first.context.lookupNetwork.toString());
+
+            assertNotNull(second.context);
+            assertEquals(secondIp, second.context.lookupIp);
+            assertEquals(expectedNetwork, second.context.lookupNetwork.toString());
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("chunkSizes")
+    public void testNestedContextAnnotationsWithCache(int chunkSize) throws IOException {
+        var cache = new CHMCache();
+        try (var reader = new Reader(getFile("MaxMind-DB-test-decoder.mmdb"), cache, chunkSize)) {
+            var firstIp = InetAddress.getByName("1.1.1.1");
+            var secondIp = InetAddress.getByName("1.1.1.3");
+            var expectedNetwork = reader.getRecord(firstIp, Map.class).network().toString();
+
+            var first = reader.get(firstIp, WrapperContextOnlyModel.class);
+            var second = reader.get(secondIp, WrapperContextOnlyModel.class);
+
+            assertNotNull(first.context);
+            assertEquals(firstIp, first.context.lookupIp);
+            assertEquals(expectedNetwork, first.context.lookupNetwork.toString());
+
+            assertNotNull(second.context);
+            assertEquals(secondIp, second.context.lookupIp);
+            assertEquals(expectedNetwork, second.context.lookupNetwork.toString());
+        }
+    }
+
     @ParameterizedTest
     @MethodSource("chunkSizes")
     public void testDecodingTypesPointerDecoderFile(int chunkSize) throws IOException {
@@ -842,6 +885,32 @@ public TestModelBoxed(
         }
     }
 
+    static class ContextOnlyModel {
+        InetAddress lookupIp;
+        Network lookupNetwork;
+
+        @MaxMindDbConstructor
+        public ContextOnlyModel(
+            @MaxMindDbIpAddress InetAddress lookupIp,
+            @MaxMindDbNetwork Network lookupNetwork
+        ) {
+            this.lookupIp = lookupIp;
+            this.lookupNetwork = lookupNetwork;
+        }
+    }
+
+    static class WrapperContextOnlyModel {
+        ContextOnlyModel context;
+
+        @MaxMindDbConstructor
+        public WrapperContextOnlyModel(
+            @MaxMindDbParameter(name = "missing_context")
+            ContextOnlyModel context
+        ) {
+            this.context = context;
+        }
+    }
+
     static class MapModelBoxed {
         MapXModelBoxed mapXField;