Add test to highlight usecase

codegen/testserver/gqlgen.yml

@@ -14,3 +14,6 @@ autobind:
   - "github.com/99designs/gqlgen/codegen/testserver/introspection"
   - "github.com/99designs/gqlgen/codegen/testserver/invalid-packagename"
 
+models:
+  Email:
+    model: "github.com/99designs/gqlgen/codegen/testserver.Email"

codegen/testserver/mutation_with_custom_scalar.go

@@ -0,0 +1,29 @@
+package testserver
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"regexp"
+)
+
+var re = regexp.MustCompile("^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$")
+
+type Email string
+
+func (value *Email) UnmarshalGQL(v interface{}) error {
+	input, ok := v.(string)
+	if !ok {
+		return fmt.Errorf("email expects a string value")
+	}
+	if !re.MatchString(input) {
+		return fmt.Errorf("invalid email format")
+	}
+	*value = Email(input)
+	return nil
+}
+
+func (value Email) MarshalGQL(w io.Writer) {
+	output, _ := json.Marshal(string(value))
+	w.Write(output)
+}

codegen/testserver/mutation_with_custom_scalar.graphql

@@ -0,0 +1,13 @@
+extend type Mutation {
+    updateSomething(input: SpecialInput!): String!
+}
+
+scalar Email
+
+input SpecialInput {
+    nesting: NestedInput!
+}
+
+input NestedInput {
+    field: Email!
+}

codegen/testserver/mutation_with_custom_scalar_test.go

@@ -0,0 +1,63 @@
+package testserver
+
+import (
+	"context"
+	"encoding/json"
+	"github.com/99designs/gqlgen/client"
+	"github.com/99designs/gqlgen/graphql/handler"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestErrorInsideMutationArgument(t *testing.T) {
+	resolvers := &Stub{}
+	resolvers.MutationResolver.UpdateSomething = func(_ context.Context, input SpecialInput) (s string, err error) {
+		return "Hello world", nil
+	}
+
+	c := client.New(handler.NewDefaultServer(NewExecutableSchema(Config{Resolvers: resolvers})))
+
+	t.Run("mutation with correct input doesn't return error", func(t *testing.T) {
+		var resp map[string]interface{}
+		input := map[string]interface{}{
+			"nesting": map[string]interface{}{
+				"field": "email@example.com",
+			},
+		}
+		err := c.Post(
+			`mutation TestMutation($input: SpecialInput!) { updateSomething(input: $input) }`,
+			&resp,
+			client.Var("input", input),
+		)
+		require.Equal(t, resp["updateSomething"], "Hello world")
+		require.NoError(t, err)
+	})
+
+	t.Run("mutation with incorrect input returns full path", func(t *testing.T) {
+		var resp map[string]interface{}
+		input := map[string]interface{}{
+			"nesting": map[string]interface{}{
+				"field": "not-an-email",
+			},
+		}
+		err := c.Post(
+			`mutation TestMutation($input: SpecialInput!) { updateSomething(input: $input) }`,
+			&resp,
+			client.Var("input", input),
+		)
+		jsonErr, ok := err.(client.RawJsonError)
+		require.True(t, ok)
+		var errDetails []map[string]interface{}
+		err = json.Unmarshal(jsonErr.RawMessage, &errDetails)
+		require.NoError(t, err)
+		require.Len(t, errDetails, 1)
+		firstErr := errDetails[0]
+		path, ok := firstErr["path"].([]interface{})
+		require.Equal(t, path, []interface{}{
+			"updateSomething",
+			"input",
+			"nesting",
+			"field",
+		})
+	})
+}

codegen/testserver/resolver.go

@@ -43,6 +43,10 @@ func (r *modelMethodsResolver) ResolverField(ctx context.Context, obj *ModelMeth
 	panic("not implemented")
 }
 
+func (r *mutationResolver) UpdateSomething(ctx context.Context, input SpecialInput) (string, error) {
+	panic("not implemented")
+}
+
 func (r *overlappingFieldsResolver) OldFoo(ctx context.Context, obj *OverlappingFields) (int, error) {
 	panic("not implemented")
 }
@@ -319,6 +323,9 @@ func (r *Resolver) ForcedResolver() ForcedResolverResolver { return &forcedResol
 // ModelMethods returns ModelMethodsResolver implementation.
 func (r *Resolver) ModelMethods() ModelMethodsResolver { return &modelMethodsResolver{r} }
 
+// Mutation returns MutationResolver implementation.
+func (r *Resolver) Mutation() MutationResolver { return &mutationResolver{r} }
+
 // OverlappingFields returns OverlappingFieldsResolver implementation.
 func (r *Resolver) OverlappingFields() OverlappingFieldsResolver { return &overlappingFieldsResolver{r} }
 
@@ -344,6 +351,7 @@ type backedByInterfaceResolver struct{ *Resolver }
 type errorsResolver struct{ *Resolver }
 type forcedResolverResolver struct{ *Resolver }
 type modelMethodsResolver struct{ *Resolver }
+type mutationResolver struct{ *Resolver }
 type overlappingFieldsResolver struct{ *Resolver }
 type panicsResolver struct{ *Resolver }
 type primitiveResolver struct{ *Resolver }