Validate required GraphQL variables at compile time

graphql-apt/src/main/java/feign/graphql/apt/GraphqlSchemaProcessor.java

@@ -234,6 +234,8 @@ private void processMethod(
       return;
     }
 
+    validator.validateVariableBindings(operation, method);
+
     var returnTypeName = getSimpleTypeName(method.getReturnType());
     if (returnTypeName != null && !isExistingExternalType(method.getReturnType(), targetPackage)) {
       var rootType = getRootType(operation, registry);

graphql-apt/src/main/java/feign/graphql/apt/QueryValidator.java

@@ -15,13 +15,21 @@
  */
 package feign.graphql.apt;
 
+import feign.Param;
 import graphql.GraphQLError;
 import graphql.language.Document;
+import graphql.language.ListType;
+import graphql.language.NonNullType;
+import graphql.language.OperationDefinition;
+import graphql.language.Type;
+import graphql.language.VariableDefinition;
 import graphql.schema.GraphQLSchema;
 import graphql.validation.Validator;
+import java.util.HashSet;
 import java.util.Locale;
 import javax.annotation.processing.Messager;
 import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
 import javax.tools.Diagnostic;
 
 public class QueryValidator {
@@ -58,4 +66,39 @@ public boolean validate(GraphQLSchema schema, Document document, Element methodE
     }
     return false;
   }
+
+  public void validateVariableBindings(OperationDefinition operation, ExecutableElement method) {
+    var paramNames = new HashSet<String>();
+    for (var param : method.getParameters()) {
+      if (param.getAnnotation(Param.class) == null) {
+        paramNames.add(param.getSimpleName().toString());
+      }
+    }
+
+    for (VariableDefinition varDef : operation.getVariableDefinitions()) {
+      if (varDef.getType() instanceof NonNullType && varDef.getDefaultValue() == null) {
+        var varName = varDef.getName();
+        if (!paramNames.contains(varName)) {
+          messager.printMessage(
+              Diagnostic.Kind.ERROR,
+              "Required GraphQL variable '$%s' (%s) has no corresponding method parameter. Add a parameter named '%s' or provide a default value in the query."
+                  .formatted(varName, typeToString(varDef.getType()), varName),
+              method);
+        }
+      }
+    }
+  }
+
+  private String typeToString(Type<?> type) {
+    if (type instanceof NonNullType nonNullType) {
+      return typeToString(nonNullType.getType()) + "!";
+    }
+    if (type instanceof ListType listType) {
+      return "[" + typeToString(listType.getType()) + "]";
+    }
+    if (type instanceof graphql.language.TypeName typeName) {
+      return typeName.getName();
+    }
+    return type.toString();
+  }
 }

graphql-apt/src/test/java/feign/graphql/apt/GraphqlSchemaProcessorTest.java

@@ -672,4 +672,180 @@ interface DiffNestedApi {
         .contentsAsUtf8String()
         .contains("public record Location(String sector, String region) {}");
   }
+
+  @Test
+  void missingRequiredVariableReportsError() {
+    var source =
+        JavaFileObjects.forSourceString(
+            "test.MissingVarApi",
+            """
+            package test;
+
+            import feign.graphql.GraphqlSchema;
+            import feign.graphql.GraphqlQuery;
+
+            @GraphqlSchema("test-schema.graphql")
+            interface MissingVarApi {
+              @GraphqlQuery("query getChar($id: ID!) { character(id: $id) { id name } }")
+              CharResult getCharacter();
+            }
+            """);
+
+    var compilation = javac().withProcessors(new GraphqlSchemaProcessor()).compile(source);
+
+    assertThat(compilation).failed();
+    assertThat(compilation).hadErrorContaining("Required GraphQL variable '$id'");
+  }
+
+  @Test
+  void requiredVariableWithDefaultValueIsOptional() {
+    var source =
+        JavaFileObjects.forSourceString(
+            "test.DefaultVarApi",
+            """
+            package test;
+
+            import feign.graphql.GraphqlSchema;
+            import feign.graphql.GraphqlQuery;
+
+            @GraphqlSchema("test-schema.graphql")
+            interface DefaultVarApi {
+              @GraphqlQuery("query getChar($id: ID! = \\"1\\") { character(id: $id) { id name } }")
+              CharResult getCharacter();
+            }
+            """);
+
+    var compilation = javac().withProcessors(new GraphqlSchemaProcessor()).compile(source);
+
+    assertThat(compilation).succeeded();
+  }
+
+  @Test
+  void nullableVariableIsOptional() {
+    var source =
+        JavaFileObjects.forSourceString(
+            "test.NullableVarApi",
+            """
+            package test;
+
+            import feign.graphql.GraphqlSchema;
+            import feign.graphql.GraphqlQuery;
+
+            @GraphqlSchema("test-schema.graphql")
+            interface NullableVarApi {
+              @GraphqlQuery(\"""
+                  query listChars($filter: CharacterFilter) {
+                    characters(filter: $filter) { id name }
+                  }\""")
+              CharResult listCharacters();
+            }
+            """);
+
+    var compilation = javac().withProcessors(new GraphqlSchemaProcessor()).compile(source);
+
+    assertThat(compilation).succeeded();
+  }
+
+  @Test
+  void paramAnnotationNotCountedAsVariable() {
+    var source =
+        JavaFileObjects.forSourceString(
+            "test.ParamApi",
+            """
+            package test;
+
+            import feign.Param;
+            import feign.graphql.GraphqlSchema;
+            import feign.graphql.GraphqlQuery;
+
+            @GraphqlSchema("test-schema.graphql")
+            interface ParamApi {
+              @GraphqlQuery("query getChar($id: ID!) { character(id: $id) { id name } }")
+              CharResult getCharacter(@Param("auth") String token);
+            }
+            """);
+
+    var compilation = javac().withProcessors(new GraphqlSchemaProcessor()).compile(source);
+
+    assertThat(compilation).failed();
+    assertThat(compilation).hadErrorContaining("Required GraphQL variable '$id'");
+  }
+
+  @Test
+  void requiredVariableWithMatchingParameterSucceeds() {
+    var source =
+        JavaFileObjects.forSourceString(
+            "test.MatchApi",
+            """
+            package test;
+
+            import feign.graphql.GraphqlSchema;
+            import feign.graphql.GraphqlQuery;
+
+            @GraphqlSchema("test-schema.graphql")
+            interface MatchApi {
+              @GraphqlQuery("query getChar($id: ID!) { character(id: $id) { id name } }")
+              CharResult getCharacter(String id);
+            }
+            """);
+
+    var compilation = javac().withProcessors(new GraphqlSchemaProcessor()).compile(source);
+
+    assertThat(compilation).succeeded();
+  }
+
+  @Test
+  void multipleRequiredVariablesMissing() {
+    var source =
+        JavaFileObjects.forSourceString(
+            "test.MultiMissingApi",
+            """
+            package test;
+
+            import feign.graphql.GraphqlSchema;
+            import feign.graphql.GraphqlQuery;
+
+            @GraphqlSchema("test-schema.graphql")
+            interface MultiMissingApi {
+              @GraphqlQuery(\"""
+                  mutation updateEpisode($id: ID!, $episode: Episode!) {
+                    updateEpisode(id: $id, episode: $episode) { id appearsIn }
+                  }\""")
+              EpisodeResult updateEpisode();
+            }
+            """);
+
+    var compilation = javac().withProcessors(new GraphqlSchemaProcessor()).compile(source);
+
+    assertThat(compilation).failed();
+    assertThat(compilation).hadErrorContaining("Required GraphQL variable '$id'");
+    assertThat(compilation).hadErrorContaining("Required GraphQL variable '$episode'");
+  }
+
+  @Test
+  void inlineInputMissingRequiredFieldReportsError() {
+    var source =
+        JavaFileObjects.forSourceString(
+            "test.InlineApi",
+            """
+            package test;
+
+            import feign.graphql.GraphqlSchema;
+            import feign.graphql.GraphqlQuery;
+
+            @GraphqlSchema("test-schema.graphql")
+            interface InlineApi {
+              @GraphqlQuery(\"""
+                  mutation create($name: String!) {
+                    createCharacter(input: { name: $name }) { id }
+                  }\""")
+              Object create(String name);
+            }
+            """);
+
+    var compilation = javac().withProcessors(new GraphqlSchemaProcessor()).compile(source);
+
+    assertThat(compilation).failed();
+    assertThat(compilation).hadErrorContaining("email");
+  }
 }