Use graphql.String for types wrapping a basic string

codegen/config/binder.go

@@ -158,9 +158,11 @@ func (b *Binder) PointerTo(ref *TypeReference) *TypeReference {
 	newRef := &TypeReference{
 		GO:          types.NewPointer(ref.GO),
 		GQL:         ref.GQL,
+		CastType:    ref.CastType,
 		Definition:  ref.Definition,
 		Unmarshaler: ref.Unmarshaler,
 		Marshaler:   ref.Marshaler,
+		IsMarshaler: ref.IsMarshaler,
 	}
 
 	b.References = append(b.References, newRef)
@@ -172,28 +174,34 @@ type TypeReference struct {
 	Definition  *ast.Definition
 	GQL         *ast.Type
 	GO          types.Type
+	CastType    types.Type  // Before calling marshalling functions cast from/to this base type
 	Marshaler   *types.Func // When using external marshalling functions this will point to the Marshal function
 	Unmarshaler *types.Func // When using external marshalling functions this will point to the Unmarshal function
+	IsMarshaler bool        // Does the type implement graphql.Marshaler and graphql.Unmarshaler
 }
 
 func (ref *TypeReference) Elem() *TypeReference {
 	if p, isPtr := ref.GO.(*types.Pointer); isPtr {
 		return &TypeReference{
 			GO:          p.Elem(),
 			GQL:         ref.GQL,
+			CastType:    ref.CastType,
 			Definition:  ref.Definition,
 			Unmarshaler: ref.Unmarshaler,
 			Marshaler:   ref.Marshaler,
+			IsMarshaler: ref.IsMarshaler,
 		}
 	}
 
 	if s, isSlice := ref.GO.(*types.Slice); isSlice {
 		return &TypeReference{
 			GO:          s.Elem(),
 			GQL:         ref.GQL.Elem,
+			CastType:    ref.CastType,
 			Definition:  ref.Definition,
 			Unmarshaler: ref.Unmarshaler,
 			Marshaler:   ref.Marshaler,
+			IsMarshaler: ref.IsMarshaler,
 		}
 	}
 	return nil
@@ -249,44 +257,6 @@ func (t *TypeReference) HasIsZero() bool {
 	return false
 }
 
-func (t *TypeReference) SelfMarshalling() bool {
-	it := t.GO
-	if ptr, isPtr := it.(*types.Pointer); isPtr {
-		it = ptr.Elem()
-	}
-	namedType, ok := it.(*types.Named)
-	if !ok {
-		return false
-	}
-
-	for i := 0; i < namedType.NumMethods(); i++ {
-		switch namedType.Method(i).Name() {
-		case "MarshalGQL":
-			return true
-		}
-	}
-	return false
-}
-
-func (t *TypeReference) SelfUnmarshalling() bool {
-	it := t.GO
-	if ptr, isPtr := it.(*types.Pointer); isPtr {
-		it = ptr.Elem()
-	}
-	namedType, ok := it.(*types.Named)
-	if !ok {
-		return false
-	}
-
-	for i := 0; i < namedType.NumMethods(); i++ {
-		switch namedType.Method(i).Name() {
-		case "UnmarshalGQL":
-			return true
-		}
-	}
-	return false
-}
-
 func (t *TypeReference) UniquenessKey() string {
 	var nullability = "O"
 	if t.GQL.NonNull {
@@ -395,6 +365,22 @@ func (b *Binder) TypeReference(schemaType *ast.Type, bindTarget types.Type) (ret
 			ref.GO = fun.Type().(*types.Signature).Params().At(0).Type()
 			ref.Marshaler = fun
 			ref.Unmarshaler = types.NewFunc(0, fun.Pkg(), "Unmarshal"+typeName, nil)
+		} else if hasMethod(obj.Type(), "MarshalGQL") && hasMethod(obj.Type(), "UnmarshalGQL") {
+			ref.GO = obj.Type()
+			ref.IsMarshaler = true
+		} else if underlying := basicUnderlying(obj.Type()); underlying != nil && underlying.Kind() == types.String {
+			// Special case for named types wrapping strings. Used by default enum implementations.
+
+			ref.GO = obj.Type()
+			ref.CastType = underlying
+
+			underlyingRef, err := b.TypeReference(&ast.Type{NamedType: "String"}, nil)
+			if err != nil {
+				return nil, err
+			}
+
+			ref.Marshaler = underlyingRef.Marshaler
+			ref.Unmarshaler = underlyingRef.Unmarshaler
 		} else {
 			ref.GO = obj.Type()
 		}
@@ -430,3 +416,36 @@ func (b *Binder) CopyModifiersFromAst(t *ast.Type, base types.Type) types.Type {
 
 	return base
 }
+
+func hasMethod(it types.Type, name string) bool {
+	if ptr, isPtr := it.(*types.Pointer); isPtr {
+		it = ptr.Elem()
+	}
+	namedType, ok := it.(*types.Named)
+	if !ok {
+		return false
+	}
+
+	for i := 0; i < namedType.NumMethods(); i++ {
+		if namedType.Method(i).Name() == name {
+			return true
+		}
+	}
+	return false
+}
+
+func basicUnderlying(it types.Type) *types.Basic {
+	if ptr, isPtr := it.(*types.Pointer); isPtr {
+		it = ptr.Elem()
+	}
+	namedType, ok := it.(*types.Named)
+	if !ok {
+		return nil
+	}
+
+	if basic, ok := namedType.Underlying().(*types.Basic); ok {
+		return basic
+	}
+
+	return nil
+}

codegen/testserver/gqlgen.yml

@@ -66,3 +66,5 @@ models:
       oneFoo: { fieldName: foo }
       twoFoo: { fieldName: foo }
       oldFoo: { fieldName: foo, resolver: true }
+  FallbackToStringEncoding:
+    model: "github.com/99designs/gqlgen/codegen/testserver.FallbackToStringEncoding"

codegen/testserver/models.go

@@ -76,3 +76,11 @@ type OverlappingFields struct {
 	Foo    int
 	NewFoo int
 }
+
+type FallbackToStringEncoding string
+
+const (
+	FallbackToStringEncodingA FallbackToStringEncoding = "A"
+	FallbackToStringEncodingB FallbackToStringEncoding = "B"
+	FallbackToStringEncodingC FallbackToStringEncoding = "C"
+)

codegen/testserver/resolver.go

@@ -140,6 +140,9 @@ func (r *queryResolver) DefaultScalar(ctx context.Context, arg string) (string,
 func (r *queryResolver) Slices(ctx context.Context) (*Slices, error) {
 	panic("not implemented")
 }
+func (r *queryResolver) Fallback(ctx context.Context, arg FallbackToStringEncoding) (FallbackToStringEncoding, error) {
+	panic("not implemented")
+}
 func (r *queryResolver) OptionalUnion(ctx context.Context) (TestUnion, error) {
 	panic("not implemented")
 }

codegen/testserver/typefallback.graphql

@@ -0,0 +1,9 @@
+extend type Query {
+    fallback(arg: FallbackToStringEncoding!): FallbackToStringEncoding!
+}
+
+enum FallbackToStringEncoding {
+    A
+    B
+    C
+}

codegen/testserver/typefallback_test.go

@@ -0,0 +1,30 @@
+package testserver
+
+import (
+	"context"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/99designs/gqlgen/client"
+	"github.com/99designs/gqlgen/handler"
+	"github.com/stretchr/testify/require"
+)
+
+func TestTypeFallback(t *testing.T) {
+	resolvers := &Stub{}
+
+	srv := httptest.NewServer(handler.GraphQL(NewExecutableSchema(Config{Resolvers: resolvers})))
+	c := client.New(srv.URL)
+
+	resolvers.QueryResolver.Fallback = func(ctx context.Context, arg FallbackToStringEncoding) (FallbackToStringEncoding, error) {
+		return arg, nil
+	}
+
+	t.Run("fallback to string passthrough", func(t *testing.T) {
+		var resp struct {
+			Fallback string
+		}
+		c.MustPost(`query { fallback(arg: A) }`, &resp)
+		require.Equal(t, "A", resp.Fallback)
+	})
+}