Handling opaque types transparently

[jszwedko]

What happened?

I was hoping that gqlgen would transparently handle resolution of a struct field of an opaque slice type:

type StringSlice []string

Which I am using in my models to have them deserialize from a PostgreSQL array column. For example:

type Todo struct {
  tags StringSlice
}

With a schema of:

type Todo {
  tags: [String!]!
}

type Query {
  todos: [Todo!]!
}

However, gqlgen expects a resolver to be generated for this even though the it could transparently handle marshaling and unmarshaling as it supports doing so with the underlying []string.

It appears opaque string types are specifically handed to avoid needing to defining a field resolver.

gqlgen/codegen/config/binder.go

Lines 364 to 377 in 414a4d3

	} else if underlying := basicUnderlying(obj.Type()); def.IsLeafType() && 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 {

So there is some precedence.

I poked around trying to add this to the binder, but couldn't get it working quite right. I figured I'd open this issue at least to track and see if this would be helpful to others.

What did you expect?

gqlgen would generate resolvers to marshal a StringSlice.

Minimal graphql.schema and models to reproduce

type Todo {
  tags: [String!]!
}

type Query {
  todos: [Todo!]!
}

type Todo {
  tags: [String!]!
}

type Query {
  todos: [Todo!]!
}

schema:
- schema.graphql
exec:
  filename: generated.go
model:
  filename: models_gen.go
resolver:
  filename: resolver.go
  type: Resolver
autobind: []
models:
  Todo:
    model: github.com/jszwedko/test-gqlgen.Todo

versions

• gqlgen version 0.9.1
• go version 12.6.1

[jszwedko]

Obviously not optimal, but this worked for specifically handling named []string types:

diff --git a/codegen/config/binder.go b/codegen/config/binder.go
index 72956de..b420ec0 100644
--- a/codegen/config/binder.go
+++ b/codegen/config/binder.go
@@ -206,6 +206,17 @@ func (ref *TypeReference) Elem() *TypeReference {
 	}
 
 	if ref.IsSlice() {
+		if ref.IsNamed() {
+			return &TypeReference{
+				GO:          ref.GO.Underlying().(*types.Slice).Elem(),
+				GQL:         ref.GQL.Elem,
+				CastType:    ref.CastType,
+				Definition:  ref.Definition,
+				Unmarshaler: ref.Unmarshaler,
+				Marshaler:   ref.Marshaler,
+				IsMarshaler: ref.IsMarshaler,
+			}
+		}
 		return &TypeReference{
 			GO:          ref.GO.(*types.Slice).Elem(),
 			GQL:         ref.GQL.Elem,
@@ -232,6 +243,10 @@ func (t *TypeReference) IsNilable() bool {
 }
 
 func (t *TypeReference) IsSlice() bool {
+	if t.IsNamed() {
+		_, isSlice := t.GO.Underlying().(*types.Slice)
+		return t.GQL.Elem != nil && isSlice
+	}
 	_, isSlice := t.GO.(*types.Slice)
 	return t.GQL.Elem != nil && isSlice
 }
diff --git a/codegen/type.gotpl b/codegen/type.gotpl
index cb2782c..4d74abc 100644
--- a/codegen/type.gotpl
+++ b/codegen/type.gotpl
@@ -17,14 +17,25 @@
 					}
 				}
 				var err error
-				res := make([]{{$type.GO.Elem | ref}}, len(vSlice))
-				for i := range vSlice {
-					res[i], err = ec.{{ $type.Elem.UnmarshalFunc }}(ctx, vSlice[i])
-					if err != nil {
-						return nil, err
+				{{- if $type.IsNamed }}
+					res := make([]{{$type.GO.Underlying.Elem | ref}}, len(vSlice))
+					for i := range vSlice {
+						res[i], err = ec.{{ $type.Elem.UnmarshalFunc }}(ctx, vSlice[i])
+						if err != nil {
+							return nil, err
+						}
 					}
-				}
-				return res, nil
+					return res, nil
+				{{- else }}
+					res := make([]{{$type.GO.Elem | ref}}, len(vSlice))
+					for i := range vSlice {
+						res[i], err = ec.{{ $type.Elem.UnmarshalFunc }}(ctx, vSlice[i])
+						if err != nil {
+							return nil, err
+						}
+					}
+					return res, nil
+				{{- end }}
 			{{- else }}
 				{{- if $type.Unmarshaler }}
 					{{- if $type.CastType }}
diff --git a/internal/code/compare.go b/internal/code/compare.go
index dce9aea..9425f39 100644
--- a/internal/code/compare.go
+++ b/internal/code/compare.go
@@ -25,6 +25,14 @@ func CompatibleTypes(expected types.Type, actual types.Type) error {
 		}
 	}
 
+	{
+		if actual, ok := actual.(*types.Named); ok {
+			if actual, ok := actual.Underlying().(*types.Slice); ok {
+				return CompatibleTypes(expected, actual)
+			}
+		}
+	}
+
 	switch expected := expected.(type) {
 	case *types.Slice:
 		if actual, ok := actual.(*types.Slice); ok {

Maybe it'll be useful to someone for ideas.

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[jszwedko]

I can confirm this is still an issue in v0.9.3

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[jszwedko]

Bump

[niondir]

It would be interesting for mapping of pq.StringArray and other pq.Array types.

[truesilver92]

I have a named slice type Permissions []Permission that I am implementing Value() and Scan(value interface{}) on so that it is saved as a json blob in the database (at least that is what I am going for). gqlgen seems to not be handling it at the resolver level. It is asking me to implement resolvers for Permissions everywhere they are used

I think this is related

[oiime]

Any plan on supporting this in some future version?

[simontol]

Temporary solution:

func MarshalStringArray(y pq.StringArray) graphql.Marshaler {
	return graphql.WriterFunc(func(w io.Writer) {
		data, err := json.Marshal(y)
		if err != nil {
			log.Println(err)
		}
		_, err = w.Write(data)
		if err != nil {
			log.Println(err)
		}
	})
}

func UnmarshalStringArray(v interface{}) (pq.StringArray, error) {
	data, ok := v.([]byte)
	var result pq.StringArray
	if !ok {
		return result, fmt.Errorf("StringArray must be a string")
	}
	if err := json.Unmarshal(data, &result); err != nil {
		return result, err
	}

	return result, nil
}