Fix list null

Author: xxlv

executor_test.go

@@ -403,6 +403,82 @@ func TestThreadsSourceCorrectly(t *testing.T) {
 	}
 }
 
+func TestCorrectlyListArgumentsWithNull(t *testing.T) {
+	query := `
+      query Example {
+        b(listStringArg: null, listBoolArg: [true,false,null],listIntArg:[123,null,12],listStringNonNullArg:[null])
+      }
+    `
+	var resolvedArgs map[string]interface{}
+	schema, err := graphql.NewSchema(graphql.SchemaConfig{
+		Query: graphql.NewObject(graphql.ObjectConfig{
+			Name: "Type",
+			Fields: graphql.Fields{
+				"b": &graphql.Field{
+					Args: graphql.FieldConfigArgument{
+						"listStringArg": &graphql.ArgumentConfig{
+							Type: graphql.NewList(graphql.String),
+						},
+						"listStringNonNullArg": &graphql.ArgumentConfig{
+							Type: graphql.NewNonNull(graphql.NewList(graphql.String)),
+						},
+						"listBoolArg": &graphql.ArgumentConfig{
+							Type: graphql.NewList(graphql.Boolean),
+						},
+						"listIntArg": &graphql.ArgumentConfig{
+							Type: graphql.NewList(graphql.Int),
+						},
+					},
+					Type: graphql.String,
+					Resolve: func(p graphql.ResolveParams) (interface{}, error) {
+						resolvedArgs = p.Args
+						return resolvedArgs, nil
+					},
+				},
+			},
+		}),
+	})
+	if err != nil {
+		t.Fatalf("Error in schema %v", err.Error())
+	}
+	ast := testutil.TestParse(t, query)
+
+	ep := graphql.ExecuteParams{
+		Schema: schema,
+		AST:    ast,
+	}
+	result := testutil.TestExecute(t, ep)
+	if len(result.Errors) > 0 {
+		t.Fatalf("wrong result, unexpected errors: %v", result.Errors)
+	}
+	tests := []struct {
+		key      string
+		expected interface{}
+	}{
+		{
+			"listStringArg", nil,
+		},
+
+		{
+			"listStringNonNullArg", []interface{}{nil},
+		},
+
+		{
+			"listBoolArg", []interface{}{true, false, nil},
+		},
+
+		{
+			"listIntArg", []interface{}{123, nil, 12},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(fmt.Sprintf("TestCorrectlyListArgumentsWithNull_%s", tt.key), func(t *testing.T) {
+			if !reflect.DeepEqual(resolvedArgs[tt.key], tt.expected) {
+				t.Fatalf("Expected args.%s to equal `%v`, got `%v`", tt.key, tt.expected, resolvedArgs[tt.key])
+			}
+		})
+	}
+}
 func TestCorrectlyThreadsArguments(t *testing.T) {
 
 	query := `

values.go

@@ -57,16 +57,34 @@ func getArgumentValues(
 		if tmpValue, ok := argASTMap[argDef.PrivateName]; ok {
 			value = tmpValue.Value
 		}
-		if tmp = valueFromAST(value, argDef.Type, variableValues); isNullish(tmp) {
-			tmp = argDef.DefaultValue
-		}
-		if !isNullish(tmp) {
-			results[argDef.PrivateName] = tmp
+		// if ast value is NullValue, and keep args's key
+		if value != nil && value.GetKind() == kinds.NullValue {
+			results[argDef.PrivateName] = nil
+		} else {
+			if tmp = valueFromAST(value, argDef.Type, variableValues); isNullish(tmp) {
+				tmp = argDef.DefaultValue
+			}
+			if !isNullish(tmp) {
+				results[argDef.PrivateName] = tmp
+			} else {
+				if nullValueWithVairableProvided(value, argDef.PrivateName, variableValues) {
+					results[argDef.PrivateName] = nil
+				}
+			}
 		}
 	}
 	return results
 }
 
+func nullValueWithVairableProvided(valueAST ast.Value, key string, variables map[string]interface{}) bool {
+	if valueAST != nil && valueAST.GetKind() == kinds.Variable {
+		if _, ok := variables[key]; ok {
+			return true
+		}
+	}
+	return false
+}
+
 // Given a variable definition, and any value of input, return a value which
 // adheres to the variable definition, or throw an error.
 func getVariableValue(schema Schema, definitionAST *ast.VariableDefinition, input interface{}) (interface{}, error) {
@@ -349,7 +367,7 @@ func isIterable(src interface{}) bool {
  *
  */
 func valueFromAST(valueAST ast.Value, ttype Input, variables map[string]interface{}) interface{} {
-	if valueAST == nil {
+	if valueAST == nil || valueAST.GetKind() == kinds.NullValue {
 		return nil
 	}
 	// precedence: value > type

variables_test.go

@@ -70,6 +70,9 @@ func inputResolved(p graphql.ResolveParams) (interface{}, error) {
 	if !ok {
 		return nil, nil
 	}
+	if input == nil {
+		return nil, nil
+	}
 	b, err := json.Marshal(input)
 	if err != nil {
 		return nil, nil
@@ -960,6 +963,36 @@ func TestVariables_ListsAndNullability_AllowsListsToBeNull(t *testing.T) {
 		t.Fatalf("Unexpected result, Diff: %v", testutil.Diff(expected, result))
 	}
 }
+
+func TestVariables_ListsAndNullability_AllowsListsToBeNullWithMoreListValues(t *testing.T) {
+	doc := `
+        query q($input: [String]) {
+          list(input: $input)
+        }
+	`
+	params := map[string]interface{}{
+		"input": []interface{}{nil, "ok", nil},
+	}
+
+	expected := &graphql.Result{
+		Data: map[string]interface{}{
+			"list": `[null,"ok",null]`,
+		},
+	}
+	ast := testutil.TestParse(t, doc)
+	ep := graphql.ExecuteParams{
+		Schema: variablesTestSchema,
+		AST:    ast,
+		Args:   params,
+	}
+	result := testutil.TestExecute(t, ep)
+	if len(result.Errors) > 0 {
+		t.Fatalf("wrong result, unexpected errors: %v", result.Errors)
+	}
+	if !reflect.DeepEqual(expected, result) {
+		t.Fatalf("Unexpected result, Diff: %v", testutil.Diff(expected, result))
+	}
+}
 func TestVariables_ListsAndNullability_AllowsListsToContainValues(t *testing.T) {
 	doc := `
         query q($input: [String]) {