Polishing contribution

Closes gh-737

Author: rstoyanchev

spring-graphql/src/main/java/org/springframework/graphql/data/method/annotation/support/ArgumentValueExtractor.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2002-2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.graphql.data.method.annotation.support;
+
+import jakarta.validation.valueextraction.ExtractedValue;
+import jakarta.validation.valueextraction.UnwrapByDefault;
+import jakarta.validation.valueextraction.ValueExtractor;
+import org.springframework.graphql.data.ArgumentValue;
+
+/**
+ * {@link ValueExtractor} that enables {@code @Valid} with {@link ArgumentValue},
+ * and helps to extract the value from it.
+ *
+ * @since 1.2.2
+ */
+@UnwrapByDefault
+public final class ArgumentValueValueExtractor implements ValueExtractor<ArgumentValue<@ExtractedValue ?>> {
+
+    @Override
+    public void extractValues(ArgumentValue<?> argumentValue, ValueReceiver receiver) {
+        if (argumentValue.isPresent()) {
+            receiver.value(null, argumentValue.value());
+        }
+    }
+
+}

spring-graphql/src/main/java/org/springframework/graphql/data/method/annotation/support/ArgumentValueValueExtractor.java

@@ -1 +1 @@
-org.springframework.graphql.data.method.annotation.support.ArgumentValueExtractor
+org.springframework.graphql.data.method.annotation.support.ArgumentValueValueExtractor

spring-graphql/src/main/resources/META-INF/services/jakarta.validation.valueextraction.ValueExtractor

@@ -26,6 +26,7 @@
 import jakarta.validation.ConstraintViolationException;
 import jakarta.validation.Valid;
 import jakarta.validation.Validation;
+import jakarta.validation.Validator;
 import jakarta.validation.constraints.Max;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
@@ -56,54 +57,54 @@ void shouldFailWithNullValidator() {
 
 	@Test
 	void shouldIgnoreMethodsWithoutAnnotations() {
-		BiConsumer<Object, Object[]> validator = createValidator(MyBean.class, "notValidatedMethod");
-		assertThat(validator).isNull();
+		assertThat(validateFunction(MyBean.class, "notValidatedMethod")).isNull();
 	}
 
 	@Test
 	void shouldRaiseValidationErrorForAnnotatedParams() {
 		MyBean bean = new MyBean();
 
-		BiConsumer<Object, Object[]> validator1 = createValidator(MyBean.class, "myValidMethod");
+		BiConsumer<Object, Object[]> validator1 = validateFunction(MyBean.class, "myValidMethod");
 		assertViolation(() -> validator1.accept(bean, new Object[] {null, 2}), "myValidMethod.arg0");
 		assertViolation(() -> validator1.accept(bean, new Object[] {"test", 12}), "myValidMethod.arg1");
 
-		BiConsumer<Object, Object[]> validator2 = createValidator(MyBean.class, "myValidatedParameterMethod");
+		BiConsumer<Object, Object[]> validator2 = validateFunction(MyBean.class, "myValidatedParameterMethod");
 		assertViolation(() -> validator2.accept(bean, new Object[] {new ConstrainedInput(100)}), "integerValue");
 
-		BiConsumer<Object, Object[]> validator3 = createValidator(MyBean.class, "myValidArgumentValue");
+		BiConsumer<Object, Object[]> validator3 = validateFunction(MyBean.class, "myValidArgumentValue");
 		assertViolation(() -> validator3.accept(bean, new Object[] {ArgumentValue.ofNullable("")}), "myValidArgumentValue.arg0");
 	}
 
 	@Test
 	void shouldRaiseValidationErrorForAnnotatedParamsWithGroups() {
 		MyValidationGroupsBean bean = new MyValidationGroupsBean();
 
-		BiConsumer<Object, Object[]> validator1 = createValidator(MyValidationGroupsBean.class, "myValidMethodWithGroup");
+		BiConsumer<Object, Object[]> validator1 = validateFunction(MyValidationGroupsBean.class, "myValidMethodWithGroup");
 		assertViolation(() -> validator1.accept(bean, new Object[] {null}), "myValidMethodWithGroup.arg0");
 
-		BiConsumer<Object, Object[]> validator2 = createValidator(MyValidationGroupsBean.class, "myValidMethodWithGroupOnType");
+		BiConsumer<Object, Object[]> validator2 = validateFunction(MyValidationGroupsBean.class, "myValidMethodWithGroupOnType");
 		assertViolation(() -> validator2.accept(bean, new Object[] {null}), "myValidMethodWithGroupOnType.arg0");
 	}
 
 	@Test
 	void shouldRecognizeMethodsThatRequireValidation() {
-		BiConsumer<Object, Object[]> validator1 = createValidator(RequiresValidationBean.class, "processConstrainedValue");
+		BiConsumer<Object, Object[]> validator1 = validateFunction(RequiresValidationBean.class, "processConstrainedValue");
 		assertThat(validator1).isNotNull();
 
-		BiConsumer<Object, Object[]> validator2 = createValidator(RequiresValidationBean.class, "processValidInput");
+		BiConsumer<Object, Object[]> validator2 = validateFunction(RequiresValidationBean.class, "processValidInput");
 		assertThat(validator2).isNotNull();
 
-		BiConsumer<Object, Object[]> validator3 = createValidator(RequiresValidationBean.class, "processValidatedInput");
+		BiConsumer<Object, Object[]> validator3 = validateFunction(RequiresValidationBean.class, "processValidatedInput");
 		assertThat(validator3).isNotNull();
 
-		BiConsumer<Object, Object[]> validator4 = createValidator(RequiresValidationBean.class, "processValue");
+		BiConsumer<Object, Object[]> validator4 = validateFunction(RequiresValidationBean.class, "processValue");
 		assertThat(validator4).isNull();
 	}
 
-	private BiConsumer<Object, Object[]> createValidator(Class<?> handlerType, String methodName) {
-		return ValidationHelper.create(Validation.buildDefaultValidatorFactory().getValidator())
-				.getValidationHelperFor(findHandlerMethod(handlerType, methodName));
+	private BiConsumer<Object, Object[]> validateFunction(Class<?> handlerType, String methodName) {
+		Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
+		ValidationHelper helper = ValidationHelper.create(validator);
+		return helper.getValidationHelperFor(findHandlerMethod(handlerType, methodName));
 	}
 
 	private HandlerMethod findHandlerMethod(Class<?> handlerType, String methodName) {