Fix input array processing

codegen/build.go

@@ -73,7 +73,7 @@ func Bind(schema *schema.Schema, userTypes map[string]string, destDir string) (*
 		NoErr:        true,
 		GoMethodName: "ec.introspectType",
 		Args: []FieldArgument{
-			{GQLName: "name", Type: &Type{namedTypes["String"], []string{}, ""}},
+			{GQLName: "name", Type: &Type{namedTypes["String"], []string{}, ""}, Object: &Object{}},
 		},
 		Object: q,
 	})

codegen/object.go

@@ -35,7 +35,8 @@ type Field struct {
 type FieldArgument struct {
 	*Type
 
-	GQLName string // The name of the argument in graphql
+	GQLName string  // The name of the argument in graphql
+	Object  *Object // A link back to the parent object
 }
 
 type Objects []*Object

codegen/object_build.go

@@ -100,6 +100,7 @@ func buildObject(types NamedTypes, typ *schema.Object) *Object {
 			args = append(args, FieldArgument{
 				GQLName: arg.Name.Name,
 				Type:    types.getType(arg.Type),
+				Object:  obj,
 			})
 		}
 

codegen/templates/args.gotpl

@@ -11,11 +11,15 @@
 			}
 		{{- else}}
 			if tmp, ok := field.Args[{{$arg.GQLName|quote}}]; ok {
-				{{$arg.Unmarshal "tmp2" "tmp" }}
+				var err error
+				{{$arg.Unmarshal (print "arg" $i) "tmp" }}
 				if err != nil {
-					badArgs = true
+					{{- if $arg.Object.Stream }}
+						return nil
+					{{- else }}
+						return graphql.Null
+					{{- end }}
 				}
-				arg{{$i}} = {{if $arg.Type.IsPtr}}&{{end}}tmp2
 			}
 		{{- end}}
 	{{- end -}}

codegen/templates/input.gotpl

@@ -6,11 +6,11 @@
 			switch k {
 			{{- range $field := .Fields }}
 			case {{$field.GQLName|quote}}:
-				{{$field.Unmarshal "val" "v" }}
+				var err error
+				{{ $field.Unmarshal (print "it." $field.GoVarName) "v" }}
 				if err != nil {
 					return it, err
 				}
-				it.{{$field.GoVarName}} = {{if $field.Type.IsPtr}}&{{end}}val
 			{{- end }}
 			}
 		}

codegen/templates/object.gotpl

@@ -17,11 +17,7 @@ func (ec *executionContext) _{{$object.GQLType|lcFirst}}(sel []query.Selection{{
 	switch field.Name {
 	{{- range $field := $object.Fields }}
 	case "{{$field.GQLName}}":
-		badArgs := false
 		{{- template "args.gotpl" $field.Args }}
-		if badArgs {
-			return nil
-		}
 
 		{{- if $field.GoVarName }}
 			results := it.{{$field.GoVarName}}
@@ -73,11 +69,7 @@ func (ec *executionContext) _{{$object.GQLType|lcFirst}}(sel []query.Selection{{
 			out.Values[i] = graphql.MarshalString({{$object.GQLType|quote}})
 		{{- range $field := $object.Fields }}
 		case "{{$field.GQLName}}":
-			badArgs := false
 			{{- template "args.gotpl" $field.Args }}
-			if badArgs {
-				continue
-			}
 
 			{{- if $field.IsConcurrent }}
 				ec.wg.Add(1)

codegen/type.go

@@ -1,6 +1,7 @@
 package codegen
 
 import (
+	"strconv"
 	"strings"
 )
 
@@ -34,10 +35,10 @@ const (
 )
 
 func (t Ref) FullName() string {
-	return t.pkgDot() + t.GoType
+	return t.PkgDot() + t.GoType
 }
 
-func (t Ref) pkgDot() string {
+func (t Ref) PkgDot() string {
 	if t.Import == nil || t.Import.Name == "" {
 		return ""
 	}
@@ -70,25 +71,62 @@ func (t NamedType) IsMarshaled() bool {
 }
 
 func (t Type) Unmarshal(result, raw string) string {
-	realResult := result
-	if t.CastType != "" {
-		result = "castTmp"
-	}
-	ret := tpl(`var {{.result}} {{.type}}
-		err := (&{{.result}}).UnmarshalGQL({{.raw}})`, map[string]interface{}{
-		"result": result,
-		"raw":    raw,
-		"type":   t.FullName(),
-	})
+	return t.unmarshal(result, raw, t.Modifiers, 1)
+}
 
-	if t.Marshaler != nil {
-		ret = result + ", err := " + t.Marshaler.pkgDot() + "Unmarshal" + t.Marshaler.GoType + "(" + raw + ")"
+func (t Type) unmarshal(result, raw string, remainingMods []string, depth int) string {
+	switch {
+	case len(remainingMods) > 0 && remainingMods[0] == modPtr:
+		ptr := "ptr" + strconv.Itoa(depth)
+		return tpl(`var {{.ptr}} {{.t.FullName}}
+			{{.next}}
+			{{.result}} = &{{.ptr -}}
+		`, map[string]interface{}{
+			"ptr":    ptr,
+			"t":      t,
+			"result": result,
+			"next":   t.unmarshal(ptr, raw, remainingMods[1:], depth+1),
+		})
+
+	case len(remainingMods) > 0 && remainingMods[0] == modList:
+		var rawIf = "rawIf" + strconv.Itoa(depth)
+		var index = "idx" + strconv.Itoa(depth)
+
+		return tpl(`{{.rawSlice}} := {{.raw}}.([]interface{})
+			{{.result}} = make({{.type}}, len({{.rawSlice}}))
+			for {{.index}} := range {{.rawSlice}} {
+				{{ .next }}
+			}`, map[string]interface{}{
+			"raw":      raw,
+			"rawSlice": rawIf,
+			"index":    index,
+			"result":   result,
+			"type":     strings.Join(remainingMods, "") + t.NamedType.FullName(),
+			"next":     t.unmarshal(result+"["+index+"]", rawIf+"["+index+"]", remainingMods[1:], depth+1),
+		})
 	}
 
+	realResult := result
 	if t.CastType != "" {
-		ret += "\n" + realResult + " := " + t.CastType + "(castTmp)"
+		result = "castTmp"
 	}
-	return ret
+
+	return tpl(`{{- if .t.CastType }}
+			var castTmp {{.t.FullName}}
+		{{- end }}
+			{{- if .t.Marshaler }}
+				{{ .result }}, err = {{ .t.Marshaler.PkgDot }}Unmarshal{{.t.Marshaler.GoType}}({{.raw}})
+			{{- else }}
+				err = (&{{.result}}).UnmarshalGQL({{.raw}}) 
+			{{- end }}
+		{{- if .t.CastType }}
+			{{ .realResult }} = {{.t.CastType}}(castTmp)
+		{{- end }}`, map[string]interface{}{
+		"realResult": realResult,
+		"result":     result,
+		"raw":        raw,
+		"t":          t,
+	})
 }
 
 func (t Type) Marshal(result, val string) string {
@@ -97,7 +135,7 @@ func (t Type) Marshal(result, val string) string {
 	}
 
 	if t.Marshaler != nil {
-		return result + " = " + t.Marshaler.pkgDot() + "Marshal" + t.Marshaler.GoType + "(" + val + ")"
+		return result + " = " + t.Marshaler.PkgDot() + "Marshal" + t.Marshaler.GoType + "(" + val + ")"
 	}
 
 	return result + " = " + val