remove FluentValidationExtensions.ValidateInstance

src/GraphQL.FluentValidation/ArgumentValidation.cs

@@ -64,4 +64,4 @@ static ValidationContext BuildValidationContext(object? instance, object userCon
         validationContext.RootContextData.Add("UserContext", userContext);
         return validationContext;
     }
-}
+}

src/GraphQL.FluentValidation/FluentValidationExtensions.cs

@@ -1,6 +1,5 @@
 using FluentValidation;
 using GraphQL.FluentValidation;
-using GraphQL.Types;
 
 namespace GraphQL
 {
@@ -9,17 +8,6 @@ namespace GraphQL
     /// </summary>
     public static partial class FluentValidationExtensions
     {
-        /// <summary>
-        /// Validate an instance against the current cached validators defined by <see cref="ValidatorTypeCache"/>.
-        /// </summary>
-        public static void ValidateInstance<TSource, TInstance>(this ResolveFieldContext<TSource> context, TInstance input)
-        {
-            Guard.AgainstNull(context, nameof(context));
-            Guard.AgainstNull(input, nameof(input));
-            var type = input!.GetType();
-            ArgumentValidation.Validate(ArgumentTypeCacheBag.GetCache(context), type, input, context.UserContext);
-        }
-
         /// <summary>
         /// Adds a FieldMiddleware to the GraphQL pipeline that converts a <see cref="ValidationException"/> to <see cref="ExecutionError"/>s./>
         /// </summary>

src/Tests/Arguments/AsyncComplexInput.cs

@@ -0,0 +1,4 @@
+public class AsyncComplexInput
+{
+    public ComplexInputInner? Inner { get; set; }
+}

src/Tests/Arguments/AsyncComplexInputGraph.cs

@@ -0,0 +1,10 @@
+using GraphQL.Types;
+
+public class AsyncComplexInputGraph :
+    InputObjectGraphType
+{
+    public AsyncComplexInputGraph()
+    {
+        Field<ComplexInputInnerGraph>("inner");
+    }
+}

src/Tests/Arguments/AsyncComplexInputValidator.cs

@@ -0,0 +1,16 @@
+using FluentValidation;
+using System.Threading.Tasks;
+
+public class AsyncComplexInputValidator :
+    AbstractValidator<AsyncComplexInput>
+{
+    public AsyncComplexInputValidator()
+    {
+        RuleFor(_ => _.Inner!)
+            .NotEmpty()
+            .MustAsync((o, token) => {
+                return Task.FromResult(o != null && !string.IsNullOrWhiteSpace(o.Content));
+            }).WithMessage("Inner async test failed msg.")
+            .SetValidator(new ComplexInputInnerValidator());
+    }
+}

src/Tests/Arguments/ComplexInput.cs

@@ -1,4 +1,8 @@
-public class ComplexInput
+using System.Collections.Generic;
+
+public class ComplexInput
 {
     public ComplexInputInner? Inner { get; set; }
+
+    public List<ComplexInputListItem>? Items { get; set; }
 }

src/Tests/Arguments/ComplexInputGraph.cs

@@ -6,5 +6,7 @@ public class ComplexInputGraph :
     public ComplexInputGraph()
     {
         Field<ComplexInputInnerGraph>("inner");
+
+        Field<ListGraphType<NonNullGraphType<ComplexInputListItemGraph>>>("items");
     }
 }

src/Tests/Arguments/ComplexInputListItem.cs

@@ -0,0 +1,5 @@
+public class ComplexInputListItem
+{
+    public int Id { get; set; }
+    public string? Content { get; set; }
+}

src/Tests/Arguments/ComplexInputListItemGraph.cs

@@ -0,0 +1,16 @@
+using GraphQL.Types;
+
+public class ComplexInputListItemGraph :
+    InputObjectGraphType<ComplexInputListItem>
+{
+    public ComplexInputListItemGraph()
+    {
+        Field<NonNullGraphType<IntGraphType>>()
+            .Name("id")
+            .Resolve(ctx => ctx.Source.Id);
+
+        Field<StringGraphType, string?>()
+            .Name("content")
+            .Resolve(ctx => ctx.Source.Content);
+    }
+}

src/Tests/Arguments/ComplexInputListItemValidator.cs

@@ -0,0 +1,14 @@
+using FluentValidation;
+
+public class ComplexInputListItemValidator :
+    AbstractValidator<ComplexInputListItem>
+{
+    public ComplexInputListItemValidator()
+    {
+        RuleFor(_ => _.Id)
+            .NotEmpty();
+
+        RuleFor(_ => _.Content)
+            .NotEmpty();
+    }
+}

src/Tests/Arguments/ComplexInputValidator.cs

@@ -8,5 +8,9 @@ public ComplexInputValidator()
         RuleFor(_ => _.Inner!)
             .NotEmpty()
             .SetValidator(new ComplexInputInnerValidator());
+
+        RuleFor(_ => _.Items)
+            .NotEmpty()
+            .ForEach(i => i.SetValidator(new ComplexInputListItemValidator()));
     }
 }

src/Tests/IntegrationTests.AsyncComplexInvalid.approved.txt

@@ -0,0 +1,13 @@
+{
+  data: {
+    asyncComplexInputQuery: null
+  },
+  errors: [
+    {
+      message: 'Inner: Inner async test failed msg.'
+    },
+    {
+      message: 'Inner.Content: \'Content\' must not be empty.'
+    }
+  ]
+}

src/Tests/IntegrationTests.AsyncComplexValid.approved.txt

@@ -0,0 +1,7 @@
+{
+  data: {
+    asyncComplexInputQuery: {
+      data: 'TheContent'
+    }
+  }
+}

src/Tests/IntegrationTests.ComplexInvalid.approved.txt

@@ -5,6 +5,9 @@
   errors: [
     {
       message: 'Inner.Content: \'Content\' must not be empty.'
+    },
+    {
+      message: 'Items: \'Items\' must not be empty.'
     }
   ]
 }

src/Tests/IntegrationTests.ComplexInvalid2.approved.txt

@@ -5,6 +5,9 @@
   errors: [
     {
       message: 'Inner: \'Inner\' must not be empty.'
+    },
+    {
+      message: 'Items: \'Items\' must not be empty.'
     }
   ]
 }

src/Tests/IntegrationTests.ComplexValid.approved.txt

@@ -1,7 +1,7 @@
 {
   data: {
     complexInputQuery: {
-      data: 'TheContent'
+      data: '{"Inner":{"Content":"TheContent"},"Items":[{"Id":1,"Content":"Some content 1"},{"Id":2,"Content":"Some content 2"}]}'
     }
   }
 }

src/Tests/IntegrationTests.cs

@@ -100,7 +100,11 @@ public async Task ComplexValid()
       input: {
         inner: {
           content: ""TheContent""
-        }
+        },
+        items: [
+            { id: 1, content: ""Some content 1"" },
+            { id: 2, content: ""Some content 2"" }
+        ]
       }
     )
   {
@@ -121,7 +125,8 @@ public async Task ComplexInvalid()
       input: {
         inner: {
           content: """"
-        }
+        },
+        items: []
       }
     )
   {
@@ -140,7 +145,8 @@ public async Task ComplexInvalid2()
   complexInputQuery
     (
       input: {
-        inner: null
+        inner: null,
+        items: null
       }
     )
   {
@@ -151,6 +157,54 @@ public async Task ComplexInvalid2()
         ObjectApprover.Verify(result);
     }
 
+    [Fact]
+    public async Task AsyncComplexValid()
+    {
+        var queryString = @"
+{
+  asyncComplexInputQuery
+    (
+      input: {
+        inner: {
+          content: ""TheContent""
+        },
+        items: [
+            { id: 1, content: ""Some content 1"" },
+            { id: 2, content: ""Some content 2"" }
+        ]
+      }
+    )
+  {
+    data
+  }
+}";
+        var result = await QueryExecutor.ExecuteQuery(queryString, null, typeCache);
+        ObjectApprover.Verify(result);
+    }
+
+    [Fact]
+    public async Task AsyncComplexInvalid()
+    {
+        var queryString = @"
+{
+  asyncComplexInputQuery
+    (
+      input: {
+        inner: {
+          content: """"
+        },
+        items: null
+      }
+    )
+  {
+    data
+  }
+}";
+        var result = await QueryExecutor.ExecuteQuery(queryString, null, typeCache);
+        ObjectApprover.Verify(result);
+    }
+
+
     public IntegrationTests(ITestOutputHelper output) :
         base(output)
     {

src/Tests/Query.cs

@@ -1,5 +1,6 @@
-using GraphQL;
+using GraphQL;
 using GraphQL.Types;
+using Newtonsoft.Json;
 
 public class Query :
     ObjectGraphType
@@ -31,7 +32,7 @@ public Query()
                 var input = context.GetValidatedArgument<ComplexInput>("input");
                 return new Result
                 {
-                    Data = input.Inner!.Content
+                    Data = JsonConvert.SerializeObject(input)
                 };
             }
         );
@@ -50,6 +51,21 @@ public Query()
                 };
             }
         );
+
+        FieldAsync<ResultGraph>(
+            "asyncComplexInputQuery",
+            arguments: new QueryArguments(
+                new QueryArgument<ComplexInputGraph> { Name = "input", }
+            ),
+            resolve: async context =>
+            {
+                var input = await context.GetValidatedArgumentAsync<AsyncComplexInput>("input");
+                return new Result
+                {
+                    Data = input.Inner!.Content
+                };
+            }
+        );
     }
 
 }