feat(sdk): support indirect DurableHandler inheritance

Author: nvasiu

sdk/src/main/java/software/amazon/lambda/durable/DurableHandler.java

@@ -31,7 +31,7 @@ public abstract class DurableHandler<I, O> implements RequestStreamHandler {
     private static final Logger logger = LoggerFactory.getLogger(DurableHandler.class);
 
     protected DurableHandler() {
-        this.inputType = TypeToken.fromGenericSuperClass(getClass(), 0);
+        this.inputType = TypeToken.fromGenericSuperClass(getClass(), DurableHandler.class, 0);
         this.config = createConfiguration();
     }
 

sdk/src/main/java/software/amazon/lambda/durable/TypeToken.java

@@ -4,6 +4,7 @@
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
 
 /**
  * Framework-agnostic type token for capturing generic type information at runtime.
@@ -60,22 +61,40 @@ public static <U> TypeToken<U> get(Class<U> clazz) {
     }
 
     /**
-     * Creates a TypeToken by extracting a type parameter from a generic superclass.
+     * Creates a TypeToken by extracting a type parameter from a target ancestor class, walking up the class hierarchy.
      *
-     * @param clazz the subclass to extract the type from
-     * @param typeParameterPosition the position of the type parameter in the superclass declaration (0-based)
+     * @param clazz the subclass to start from
+     * @param targetClass the ancestor class to extract the type parameter from
+     * @param typeParameterPosition the position of the type parameter in the target class declaration (0-based)
      * @param <U> the type to extract
-     * @param <V> the superclass type
+     * @param <V> the starting class type
      * @return a TypeToken representing the extracted type
      */
-    static <U, V> TypeToken<U> fromGenericSuperClass(Class<V> clazz, int typeParameterPosition) {
-        // Extract input type from generic superclass
-        var superClass = clazz.getGenericSuperclass();
-        if (superClass instanceof ParameterizedType paramType) {
-            return new TypeToken<>(paramType.getActualTypeArguments()[typeParameterPosition]) {};
-        } else {
-            throw new IllegalArgumentException("Cannot determine type from base class: " + clazz);
+    static <U, V> TypeToken<U> fromGenericSuperClass(Class<V> clazz, Class<?> targetClass, int typeParameterPosition) {
+        Class<?> current = clazz;
+
+        while (current != null && current != Object.class) {
+            var genericSuper = current.getGenericSuperclass();
+            if (!(genericSuper instanceof ParameterizedType paramType)) {
+                current = current.getSuperclass();
+                continue;
+            }
+
+            Class<?> rawSuper = (Class<?>) paramType.getRawType();
+            if (rawSuper == targetClass) {
+                Type typeArgument = paramType.getActualTypeArguments()[typeParameterPosition];
+                if (typeArgument instanceof TypeVariable) {
+                    throw new IllegalArgumentException(
+                            "Cannot determine type from base class, the type is left unresolved by an intermediate class: "
+                                    + clazz);
+                }
+                return new TypeToken<>(typeArgument) {};
+            }
+
+            current = rawSuper;
         }
+
+        throw new IllegalArgumentException("Cannot determine type from base class: " + clazz);
     }
 
     /**

sdk/src/test/java/software/amazon/lambda/durable/DurableHandlerTest.java

@@ -65,11 +65,53 @@ void testNonDurableFunctionThrowsUserFriendlyError() throws Exception {
         assertTrue(exception.getMessage().contains("Unexpected payload provided to start the durable execution"));
     }
 
+    @Test
+    void testIndirectDurableHandlerInheritance() {
+        // Verifies a handler that reaches DurableHandler through an intermediate
+        // abstract class still resolves its input type correctly.
+        var handler = new ConcreteIndirectHandler();
+
+        assertNotNull(handler);
+
+        var result = handler.handleRequest("test-input", null);
+        assertEquals("indirect: test-input", result);
+    }
+
+    @Test
+    void testUnresolvedInputTypeThrowsException() {
+        // The input type is left as a type variable by the intermediate class, so it
+        // cannot be resolved and must fail loudly rather than producing a broken token.
+        var exception = assertThrows(IllegalArgumentException.class, UnresolvedInputHandler::new);
+        assertTrue(exception.getMessage().contains("unresolved"));
+    }
+
     // Test handler implementation
     private static class TestDurableHandler extends DurableHandler<String, String> {
         @Override
         public String handleRequest(String input, DurableContext context) {
             return "processed: " + input;
         }
     }
+
+    // Intermediate abstract handler that fixes the input type
+    private abstract static class AbstractIndirectHandler<O> extends DurableHandler<String, O> {}
+
+    // Concrete handler that inherits DurableHandler indirectly
+    private static class ConcreteIndirectHandler extends AbstractIndirectHandler<String> {
+        @Override
+        public String handleRequest(String input, DurableContext context) {
+            return "indirect: " + input;
+        }
+    }
+
+    // Intermediate handler that leaves the input type as a type variable
+    private abstract static class UnresolvedInputBase<I> extends DurableHandler<I, String> {}
+
+    // Concrete handler whose input type is not resolvable by walking superclasses
+    private static class UnresolvedInputHandler extends UnresolvedInputBase<String> {
+        @Override
+        public String handleRequest(String input, DurableContext context) {
+            return input;
+        }
+    }
 }