10048280495

Committed 22 Jul 2024 09:00PM UTC coverage: 74.714% (+0.04%) from 74.673%

Build # 10048280495

Build Type

push

github

Committed by

web-flow

Commit Message

Revert "feat: allow argument directives to be called even if the argument is …" (#3191)

This reverts commit 0fb31a3ed.

Run Details

5 of 5 new or added lines in 1 file covered. (100.0%)

90 existing lines in 4 files now uncovered.

7195 of 9630 relevant lines covered (74.71%)

657.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.32

/codegen/config/binder.go

package config

import (
        "errors"
        "fmt"
        "go/token"
        "go/types"
        "strings"

        "github.com/vektah/gqlparser/v2/ast"
        "golang.org/x/tools/go/packages"

        "github.com/99designs/gqlgen/codegen/templates"
        "github.com/99designs/gqlgen/internal/code"
)

var ErrTypeNotFound = errors.New("unable to find type")

// Binder connects graphql types to golang types using static analysis
type Binder struct {
        pkgs        *code.Packages
        schema      *ast.Schema
        cfg         *Config
        tctx        *types.Context
        References  []*TypeReference
        SawInvalid  bool
        objectCache map[string]map[string]types.Object
}

func (c *Config) NewBinder() *Binder {
        return &Binder{
                pkgs:   c.Packages,
                schema: c.Schema,
                cfg:    c,
        }
}

func (b *Binder) TypePosition(typ types.Type) token.Position {
        named, isNamed := typ.(*types.Named)
        if !isNamed {
                return token.Position{
                        Filename: "unknown",
                }
        }

        return b.ObjectPosition(named.Obj())
}

func (b *Binder) ObjectPosition(typ types.Object) token.Position {
        if typ == nil {
                return token.Position{
                        Filename: "unknown",
                }
        }
        pkg := b.pkgs.Load(typ.Pkg().Path())
        return pkg.Fset.Position(typ.Pos())
}

func (b *Binder) FindTypeFromName(name string) (types.Type, error) {
        pkgName, typeName := code.PkgAndType(name)
        return b.FindType(pkgName, typeName)
}

func (b *Binder) FindType(pkgName, typeName string) (types.Type, error) {
        if pkgName == "" {
                if typeName == "map[string]interface{}" {
                        return MapType, nil
                }

                if typeName == "interface{}" {
                        return InterfaceType, nil
                }
        }

        obj, err := b.FindObject(pkgName, typeName)
        if err != nil {
                return nil, err
        }

        if fun, isFunc := obj.(*types.Func); isFunc {
                return fun.Type().(*types.Signature).Params().At(0).Type(), nil
        }
        return obj.Type(), nil
}

func (b *Binder) InstantiateType(orig types.Type, targs []types.Type) (types.Type, error) {
        if b.tctx == nil {
                b.tctx = types.NewContext()
        }

        return types.Instantiate(b.tctx, orig, targs, false)
}

var (
        MapType       = types.NewMap(types.Typ[types.String], types.NewInterfaceType(nil, nil).Complete())
        InterfaceType = types.NewInterfaceType(nil, nil)
)

func (b *Binder) DefaultUserObject(name string) (types.Type, error) {
        models := b.cfg.Models[name].Model
        if len(models) == 0 {
                return nil, fmt.Errorf("%s not found in typemap", name)
        }

        if models[0] == "map[string]interface{}" {
                return MapType, nil
        }

        if models[0] == "interface{}" {
                return InterfaceType, nil
        }

        pkgName, typeName := code.PkgAndType(models[0])
        if pkgName == "" {
                return nil, fmt.Errorf("missing package name for %s", name)
        }

        obj, err := b.FindObject(pkgName, typeName)
        if err != nil {
                return nil, err
        }

        return obj.Type(), nil
}

func (b *Binder) FindObject(pkgName, typeName string) (types.Object, error) {
        if pkgName == "" {
                return nil, errors.New("package cannot be nil")
        }

        pkg := b.pkgs.LoadWithTypes(pkgName)
        if pkg == nil {
                err := b.pkgs.Errors()
                if err != nil {
                        return nil, fmt.Errorf("package could not be loaded: %s.%s: %w", pkgName, typeName, err)
                }
                return nil, fmt.Errorf("required package was not loaded: %s.%s", pkgName, typeName)
        }

        if b.objectCache == nil {
                b.objectCache = make(map[string]map[string]types.Object, b.pkgs.Count())
        }

        defsIndex, ok := b.objectCache[pkgName]
        if !ok {
                defsIndex = indexDefs(pkg)
                b.objectCache[pkgName] = defsIndex
        }

        // function based marshalers take precedence
        if val, ok := defsIndex["Marshal"+typeName]; ok {
                return val, nil
        }

        if val, ok := defsIndex[typeName]; ok {
                return val, nil
        }

        return nil, fmt.Errorf("%w: %s.%s", ErrTypeNotFound, pkgName, typeName)
}

func indexDefs(pkg *packages.Package) map[string]types.Object {
        res := make(map[string]types.Object)

        scope := pkg.Types.Scope()
        for astNode, def := range pkg.TypesInfo.Defs {
                // only look at defs in the top scope
                if def == nil {
                        continue
                }
                parent := def.Parent()
                if parent == nil || parent != scope {
                        continue
                }

                if _, ok := res[astNode.Name]; !ok {
                        // The above check may not be really needed, it is only here to have a consistent behavior with
                        // previous implementation of FindObject() function which only honored the first inclusion of a def.
                        // If this is still needed, we can consider something like sync.Map.LoadOrStore() to avoid two lookups.
                        res[astNode.Name] = def
                }
        }

        return res
}

func (b *Binder) PointerTo(ref *TypeReference) *TypeReference {
        newRef := *ref
        newRef.GO = types.NewPointer(ref.GO)
        b.References = append(b.References, &newRef)
        return &newRef
}

// TypeReference is used by args and field types. The Definition can refer to both input and output types.
type TypeReference struct {
        Definition               *ast.Definition
        GQL                      *ast.Type
        GO                       types.Type  // Type of the field being bound. Could be a pointer or a value type of Target.
        Target                   types.Type  // The actual type that we know how to bind to. May require pointer juggling when traversing to fields.
        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
        IsOmittable              bool        // Is the type wrapped with Omittable
        IsContext                bool        // Is the Marshaler/Unmarshaller the context version; applies to either the method or interface variety.
        PointersInUnmarshalInput bool        // Inverse values and pointers in return.
        IsRoot                   bool        // Is the type a root level definition such as Query, Mutation or Subscription
        EnumValues               []EnumValueReference
}

func (ref *TypeReference) Elem() *TypeReference {
        if p, isPtr := ref.GO.(*types.Pointer); isPtr {
                newRef := *ref
                newRef.GO = p.Elem()
                return &newRef
        }

        if ref.IsSlice() {
                newRef := *ref
                newRef.GO = ref.GO.(*types.Slice).Elem()
                newRef.GQL = ref.GQL.Elem
                return &newRef
        }
        return nil
}

func (ref *TypeReference) IsPtr() bool {
        _, isPtr := ref.GO.(*types.Pointer)
        return isPtr
}

// fix for https://github.com/golang/go/issues/31103 may make it possible to remove this (may still be useful)
func (ref *TypeReference) IsPtrToPtr() bool {
        if p, isPtr := ref.GO.(*types.Pointer); isPtr {
                _, isPtr := p.Elem().(*types.Pointer)
                return isPtr
        }
        return false
}

func (ref *TypeReference) IsNilable() bool {
        return IsNilable(ref.GO)
}

func (ref *TypeReference) IsSlice() bool {
        _, isSlice := ref.GO.(*types.Slice)
        return ref.GQL.Elem != nil && isSlice
}

func (ref *TypeReference) IsPtrToSlice() bool {
        if ref.IsPtr() {
                _, isPointerToSlice := ref.GO.(*types.Pointer).Elem().(*types.Slice)
                return isPointerToSlice
        }
        return false
}

func (ref *TypeReference) IsPtrToIntf() bool {
        if ref.IsPtr() {
                _, isPointerToInterface := ref.GO.(*types.Pointer).Elem().(*types.Interface)
                return isPointerToInterface
        }
        return false
}

func (ref *TypeReference) IsNamed() bool {
        _, isSlice := ref.GO.(*types.Named)
        return isSlice
}

func (ref *TypeReference) IsStruct() bool {
        _, isStruct := ref.GO.Underlying().(*types.Struct)
        return isStruct
}

func (ref *TypeReference) IsScalar() bool {
        return ref.Definition.Kind == ast.Scalar
}

func (ref *TypeReference) IsMap() bool {
        return ref.GO == MapType
}

func (ref *TypeReference) UniquenessKey() string {
        nullability := "O"
        if ref.GQL.NonNull {
                nullability = "N"
        }

        elemNullability := ""
        if ref.GQL.Elem != nil && ref.GQL.Elem.NonNull {
                // Fix for #896
                elemNullability = "ᚄ"
        }
        return nullability + ref.Definition.Name + "2" + templates.TypeIdentifier(ref.GO) + elemNullability
}

func (ref *TypeReference) MarshalFunc() string {
        if ref.Definition == nil {
                panic(errors.New("Definition missing for " + ref.GQL.Name()))
        }

        if ref.Definition.Kind == ast.InputObject {
                return ""
        }

        return "marshal" + ref.UniquenessKey()
}

func (ref *TypeReference) UnmarshalFunc() string {
        if ref.Definition == nil {
                panic(errors.New("Definition missing for " + ref.GQL.Name()))
        }

        if !ref.Definition.IsInputType() {
                return ""
        }

        return "unmarshal" + ref.UniquenessKey()
}

func (ref *TypeReference) IsTargetNilable() bool {
        return IsNilable(ref.Target)
}

func (ref *TypeReference) HasEnumValues() bool {
        return len(ref.EnumValues) > 0
}

func (b *Binder) PushRef(ret *TypeReference) {
        b.References = append(b.References, ret)
}

func isMap(t types.Type) bool {
        if t == nil {
                return true
        }
        _, ok := t.(*types.Map)
        return ok
}

func isIntf(t types.Type) bool {
        if t == nil {
                return true
        }
        _, ok := t.(*types.Interface)
        return ok
}

func unwrapOmittable(t types.Type) (types.Type, bool) {
        if t == nil {
                return nil, false
        }
        named, ok := t.(*types.Named)
        if !ok {
                return t, false
        }
        if named.Origin().String() != "github.com/99designs/gqlgen/graphql.Omittable[T any]" {
                return t, false
        }
        return named.TypeArgs().At(0), true
}

func (b *Binder) TypeReference(schemaType *ast.Type, bindTarget types.Type) (ret *TypeReference, err error) {
        if innerType, ok := unwrapOmittable(bindTarget); ok {
                if schemaType.NonNull {
                        return nil, fmt.Errorf("%s is wrapped with Omittable but non-null", schemaType.Name())
                }

                ref, err := b.TypeReference(schemaType, innerType)
                if err != nil {
                        return nil, err
                }

                ref.IsOmittable = true
                return ref, err
        }

        if !isValid(bindTarget) {
                b.SawInvalid = true
                return nil, fmt.Errorf("%s has an invalid type", schemaType.Name())
        }

        var pkgName, typeName string
        def := b.schema.Types[schemaType.Name()]
        defer func() {
                if err == nil && ret != nil {
                        b.PushRef(ret)
                }
        }()

        if len(b.cfg.Models[schemaType.Name()].Model) == 0 {
                return nil, fmt.Errorf("%s was not found", schemaType.Name())
        }

        for _, model := range b.cfg.Models[schemaType.Name()].Model {
                if model == "map[string]interface{}" {
                        if !isMap(bindTarget) {
                                continue
                        }
                        return &TypeReference{
                                Definition: def,
                                GQL:        schemaType,
                                GO:         MapType,
                                IsRoot:     b.cfg.IsRoot(def),
                        }, nil
                }

                if model == "interface{}" {
                        if !isIntf(bindTarget) {
                                continue
                        }
                        return &TypeReference{
                                Definition: def,
                                GQL:        schemaType,
                                GO:         InterfaceType,
                                IsRoot:     b.cfg.IsRoot(def),
                        }, nil
                }

                pkgName, typeName = code.PkgAndType(model)
                if pkgName == "" {
                        return nil, fmt.Errorf("missing package name for %s", schemaType.Name())
                }

                ref := &TypeReference{
                        Definition: def,
                        GQL:        schemaType,
                        IsRoot:     b.cfg.IsRoot(def),
                }

                obj, err := b.FindObject(pkgName, typeName)
                if err != nil {
                        return nil, err
                }

                if values := b.enumValues(def); len(values) > 0 {
                        err = b.enumReference(ref, obj, values)
                        if err != nil {
                                return nil, err
                        }
                } else if fun, isFunc := obj.(*types.Func); isFunc {
                        ref.GO = fun.Type().(*types.Signature).Params().At(0).Type()
                        ref.IsContext = fun.Type().(*types.Signature).Results().At(0).Type().String() == "github.com/99designs/gqlgen/graphql.ContextMarshaler"
                        ref.Marshaler = fun
                        ref.Unmarshaler = types.NewFunc(0, fun.Pkg(), "Unmarshal"+typeName, nil)
                } else if hasMethod(obj.Type(), "MarshalGQLContext") && hasMethod(obj.Type(), "UnmarshalGQLContext") {
                        ref.GO = obj.Type()
                        ref.IsContext = true
                        ref.IsMarshaler = true
                } else if hasMethod(obj.Type(), "MarshalGQL") && hasMethod(obj.Type(), "UnmarshalGQL") {
                        ref.GO = obj.Type()
                        ref.IsMarshaler = true
                } else if underlying := basicUnderlying(obj.Type()); def.IsLeafType() && underlying != nil && underlying.Kind() == types.String {
                        // TODO delete before v1. Backwards compatibility case for named types wrapping strings (see #595)

                        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()
                }

                ref.Target = ref.GO
                ref.GO = b.CopyModifiersFromAst(schemaType, ref.GO)

                if bindTarget != nil {
                        if err = code.CompatibleTypes(ref.GO, bindTarget); err != nil {
                                continue
                        }
                        ref.GO = bindTarget
                }

                ref.PointersInUnmarshalInput = b.cfg.ReturnPointersInUnmarshalInput

                return ref, nil
        }

        return nil, fmt.Errorf("%s is incompatible with %s", schemaType.Name(), bindTarget.String())
}

func isValid(t types.Type) bool {
        basic, isBasic := t.(*types.Basic)
        if !isBasic {
                return true
        }
        return basic.Kind() != types.Invalid
}

func (b *Binder) CopyModifiersFromAst(t *ast.Type, base types.Type) types.Type {
        if t.Elem != nil {
                child := b.CopyModifiersFromAst(t.Elem, base)
                if _, isStruct := child.Underlying().(*types.Struct); isStruct && !b.cfg.OmitSliceElementPointers {
                        child = types.NewPointer(child)
                }
                return types.NewSlice(child)
        }

        var isInterface bool
        if named, ok := base.(*types.Named); ok {
                _, isInterface = named.Underlying().(*types.Interface)
        }

        if !isInterface && !IsNilable(base) && !t.NonNull {
                return types.NewPointer(base)
        }

        return base
}

func IsNilable(t types.Type) bool {
        if namedType, isNamed := t.(*types.Named); isNamed {
                return IsNilable(namedType.Underlying())
        }
        _, isPtr := t.(*types.Pointer)
        _, isMap := t.(*types.Map)
        _, isInterface := t.(*types.Interface)
        _, isSlice := t.(*types.Slice)
        _, isChan := t.(*types.Chan)
        return isPtr || isMap || isInterface || isSlice || isChan
}

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
}

type EnumValueReference struct {
        Definition *ast.EnumValueDefinition
        Object     types.Object
}

func (b *Binder) enumValues(def *ast.Definition) map[string]EnumValue {
        if def.Kind != ast.Enum {
                return nil
        }

        if strings.HasPrefix(def.Name, "__") {
                return nil
        }

        model, ok := b.cfg.Models[def.Name]
        if !ok {
                return nil
        }

        return model.EnumValues
}

func (b *Binder) enumReference(ref *TypeReference, obj types.Object, values map[string]EnumValue) error {
        if len(ref.Definition.EnumValues) != len(values) {
                return fmt.Errorf("not all enum values are binded for %v", ref.Definition.Name)
        }

        if fn, ok := obj.Type().(*types.Signature); ok {
                ref.GO = fn.Params().At(0).Type()
        } else {
                ref.GO = obj.Type()
        }

        str, err := b.TypeReference(&ast.Type{NamedType: "String"}, nil)
        if err != nil {
                return err
        }

        ref.Marshaler = str.Marshaler
        ref.Unmarshaler = str.Unmarshaler
        ref.EnumValues = make([]EnumValueReference, 0, len(values))

        for _, value := range ref.Definition.EnumValues {
                v, ok := values[value.Name]
                if !ok {
                        return fmt.Errorf("enum value not found for: %v, of enum: %v", value.Name, ref.Definition.Name)
                }

                pkgName, typeName := code.PkgAndType(v.Value)
                if pkgName == "" {
                        return fmt.Errorf("missing package name for %v", value.Name)
                }

                valueObj, err := b.FindObject(pkgName, typeName)
                if err != nil {
                        return err
                }

                if !types.AssignableTo(valueObj.Type(), ref.GO) {
                        return fmt.Errorf("wrong type: %v, for enum value: %v, expected type: %v, of enum: %v",
                                valueObj.Type(), value.Name, ref.GO, ref.Definition.Name)
                }

                switch valueObj.(type) {
                case *types.Const, *types.Var:
                        ref.EnumValues = append(ref.EnumValues, EnumValueReference{
                                Definition: value,
                                Object:     valueObj,
                        })
                default:
                        return fmt.Errorf("unsupported enum value for: %v, of enum: %v, only const and var allowed",
                                value.Name, ref.Definition.Name)
                }
        }

        return nil
}

1	package config
2
3	import (
4	"errors"
5	"fmt"
6	"go/token"
7	"go/types"
8	"strings"
9
10	"github.com/vektah/gqlparser/v2/ast"
11	"golang.org/x/tools/go/packages"
12
13	"github.com/99designs/gqlgen/codegen/templates"
14	"github.com/99designs/gqlgen/internal/code"
15	)
16
17	var ErrTypeNotFound = errors.New("unable to find type")
18
19	// Binder connects graphql types to golang types using static analysis
20	type Binder struct {
21	pkgs *code.Packages
22	schema *ast.Schema
23	cfg *Config
24	tctx *types.Context
25	References []*TypeReference
26	SawInvalid bool
27	objectCache map[string]map[string]types.Object
28	}
29
30	func (c Config) NewBinder() Binder {	213✔
31	return &Binder{	213✔
32	pkgs: c.Packages,	213✔
33	schema: c.Schema,	213✔
34	cfg: c,	213✔
35	}	213✔
36	}	213✔
37
38	func (b *Binder) TypePosition(typ types.Type) token.Position {	17✔
39	named, isNamed := typ.(*types.Named)	17✔
40	if !isNamed {	17✔
41	return token.Position{	×
42	Filename: "unknown",	×
43	}	×
44	}	×
45
46	return b.ObjectPosition(named.Obj())	17✔
47	}
48
49	func (b *Binder) ObjectPosition(typ types.Object) token.Position {	445✔
50	if typ == nil {	462✔
51	return token.Position{	17✔
52	Filename: "unknown",	17✔
53	}	17✔
54	}	17✔
55	pkg := b.pkgs.Load(typ.Pkg().Path())	428✔
56	return pkg.Fset.Position(typ.Pos())	428✔
57	}
58
59	func (b *Binder) FindTypeFromName(name string) (types.Type, error) {	306✔
60	pkgName, typeName := code.PkgAndType(name)	306✔
61	return b.FindType(pkgName, typeName)	306✔
62	}	306✔
63
64	func (b *Binder) FindType(pkgName, typeName string) (types.Type, error) {	316✔
65	if pkgName == "" {	316✔
66	if typeName == "map[string]interface{}" {	×
67	return MapType, nil	×
68	}	×
69
70	if typeName == "interface{}" {	×
71	return InterfaceType, nil	×
72	}	×
73	}
74
75	obj, err := b.FindObject(pkgName, typeName)	316✔
76	if err != nil {	316✔
77	return nil, err	×
78	}	×
79
80	if fun, isFunc := obj.(*types.Func); isFunc {	588✔
81	return fun.Type().(*types.Signature).Params().At(0).Type(), nil	272✔
82	}	272✔
83	return obj.Type(), nil	44✔
84	}
85
86	func (b *Binder) InstantiateType(orig types.Type, targs []types.Type) (types.Type, error) {	29✔
87	if b.tctx == nil {	42✔
88	b.tctx = types.NewContext()	13✔
89	}	13✔
90
91	return types.Instantiate(b.tctx, orig, targs, false)	29✔
92	}
93
94	var (
95	MapType = types.NewMap(types.Typ[types.String], types.NewInterfaceType(nil, nil).Complete())
96	InterfaceType = types.NewInterfaceType(nil, nil)
97	)
98
99	func (b *Binder) DefaultUserObject(name string) (types.Type, error) {	104✔
100	models := b.cfg.Models[name].Model	104✔
101	if len(models) == 0 {	104✔
102	return nil, fmt.Errorf("%s not found in typemap", name)	×
103	}	×
104
105	if models[0] == "map[string]interface{}" {	104✔
106	return MapType, nil	×
107	}	×
108
109	if models[0] == "interface{}" {	104✔
110	return InterfaceType, nil	×
111	}	×
112
113	pkgName, typeName := code.PkgAndType(models[0])	104✔
114	if pkgName == "" {	104✔
115	return nil, fmt.Errorf("missing package name for %s", name)	×
116	}	×
117
118	obj, err := b.FindObject(pkgName, typeName)	104✔
119	if err != nil {	104✔
UNCOV 120	return nil, err	×
UNCOV 121	}	×
122
123	return obj.Type(), nil	104✔
124	}
125
126	func (b *Binder) FindObject(pkgName, typeName string) (types.Object, error) {	1,079✔
127	if pkgName == "" {	1,079✔
128	return nil, errors.New("package cannot be nil")	×
129	}	×
130
131	pkg := b.pkgs.LoadWithTypes(pkgName)	1,079✔
132	if pkg == nil {	1,079✔
133	err := b.pkgs.Errors()	×
134	if err != nil {	×
135	return nil, fmt.Errorf("package could not be loaded: %s.%s: %w", pkgName, typeName, err)	×
136	}	×
137	return nil, fmt.Errorf("required package was not loaded: %s.%s", pkgName, typeName)	×
138	}
139
140	if b.objectCache == nil {	1,266✔
141	b.objectCache = make(map[string]map[string]types.Object, b.pkgs.Count())	187✔
142	}	187✔
143
144	defsIndex, ok := b.objectCache[pkgName]	1,079✔
145	if !ok {	1,322✔
146	defsIndex = indexDefs(pkg)	243✔
147	b.objectCache[pkgName] = defsIndex	243✔
148	}	243✔
149
150	// function based marshalers take precedence
151	if val, ok := defsIndex["Marshal"+typeName]; ok {	1,770✔
152	return val, nil	691✔
153	}	691✔
154
155	if val, ok := defsIndex[typeName]; ok {	775✔
156	return val, nil	387✔
157	}	387✔
158
159	return nil, fmt.Errorf("%w: %s.%s", ErrTypeNotFound, pkgName, typeName)	1✔
160	}
161
162	func indexDefs(pkg *packages.Package) map[string]types.Object {	243✔
163	res := make(map[string]types.Object)	243✔
164		243✔
165	scope := pkg.Types.Scope()	243✔
166	for astNode, def := range pkg.TypesInfo.Defs {	174,507✔
167	// only look at defs in the top scope	174,264✔
168	if def == nil {	184,951✔
169	continue	10,687✔
170	}
171	parent := def.Parent()	163,577✔
172	if parent == nil \|\| parent != scope {	294,322✔
173	continue	130,745✔
174	}
175
176	if _, ok := res[astNode.Name]; !ok {	65,664✔
177	// The above check may not be really needed, it is only here to have a consistent behavior with	32,832✔
178	// previous implementation of FindObject() function which only honored the first inclusion of a def.	32,832✔
179	// If this is still needed, we can consider something like sync.Map.LoadOrStore() to avoid two lookups.	32,832✔
180	res[astNode.Name] = def	32,832✔
181	}	32,832✔
182	}
183
184	return res	243✔
185	}
186
187	func (b Binder) PointerTo(ref TypeReference) *TypeReference {	18✔
188	newRef := *ref	18✔
189	newRef.GO = types.NewPointer(ref.GO)	18✔
190	b.References = append(b.References, &newRef)	18✔
191	return &newRef	18✔
192	}	18✔
193
194	// TypeReference is used by args and field types. The Definition can refer to both input and output types.
195	type TypeReference struct {
196	Definition *ast.Definition
197	GQL *ast.Type
198	GO types.Type // Type of the field being bound. Could be a pointer or a value type of Target.
199	Target types.Type // The actual type that we know how to bind to. May require pointer juggling when traversing to fields.
200	CastType types.Type // Before calling marshalling functions cast from/to this base type
201	Marshaler *types.Func // When using external marshalling functions this will point to the Marshal function
202	Unmarshaler *types.Func // When using external marshalling functions this will point to the Unmarshal function
203	IsMarshaler bool // Does the type implement graphql.Marshaler and graphql.Unmarshaler
204	IsOmittable bool // Is the type wrapped with Omittable
205	IsContext bool // Is the Marshaler/Unmarshaller the context version; applies to either the method or interface variety.
206	PointersInUnmarshalInput bool // Inverse values and pointers in return.
207	IsRoot bool // Is the type a root level definition such as Query, Mutation or Subscription
208	EnumValues []EnumValueReference
209	}
210
211	func (ref TypeReference) Elem() TypeReference {	228✔
212	if p, isPtr := ref.GO.(*types.Pointer); isPtr {	228✔
213	newRef := *ref	×
214	newRef.GO = p.Elem()	×
215	return &newRef	×
216	}	×
217
218	if ref.IsSlice() {	456✔
219	newRef := *ref	228✔
220	newRef.GO = ref.GO.(*types.Slice).Elem()	228✔
221	newRef.GQL = ref.GQL.Elem	228✔
222	return &newRef	228✔
223	}	228✔
224	return nil	×
225	}
226
227	func (ref *TypeReference) IsPtr() bool {	1,664✔
228	_, isPtr := ref.GO.(*types.Pointer)	1,664✔
229	return isPtr	1,664✔
230	}	1,664✔
231
232	// fix for https://github.com/golang/go/issues/31103 may make it possible to remove this (may still be useful)
233	func (ref *TypeReference) IsPtrToPtr() bool {	766✔
234	if p, isPtr := ref.GO.(*types.Pointer); isPtr {	1,095✔
235	_, isPtr := p.Elem().(*types.Pointer)	329✔
236	return isPtr	329✔
237	}	329✔
238	return false	437✔
239	}
240
241	func (ref *TypeReference) IsNilable() bool {	278✔
242	return IsNilable(ref.GO)	278✔
243	}	278✔
244
245	func (ref *TypeReference) IsSlice() bool {	1,166✔
246	_, isSlice := ref.GO.(*types.Slice)	1,166✔
247	return ref.GQL.Elem != nil && isSlice	1,166✔
248	}	1,166✔
249
250	func (ref *TypeReference) IsPtrToSlice() bool {	816✔
251	if ref.IsPtr() {	1,137✔
252	_, isPointerToSlice := ref.GO.(types.Pointer).Elem().(types.Slice)	321✔
253	return isPointerToSlice	321✔
254	}	321✔
255	return false	495✔
256	}
257
258	func (ref *TypeReference) IsPtrToIntf() bool {	816✔
259	if ref.IsPtr() {	1,137✔
260	_, isPointerToInterface := ref.GO.(types.Pointer).Elem().(types.Interface)	321✔
261	return isPointerToInterface	321✔
262	}	321✔
263	return false	495✔
264	}
265
266	func (ref *TypeReference) IsNamed() bool {	×
267	_, isSlice := ref.GO.(*types.Named)	×
268	return isSlice	×
269	}	×
270
271	func (ref *TypeReference) IsStruct() bool {	32✔
272	_, isStruct := ref.GO.Underlying().(*types.Struct)	32✔
273	return isStruct	32✔
274	}	32✔
275
276	func (ref *TypeReference) IsScalar() bool {	138✔
277	return ref.Definition.Kind == ast.Scalar	138✔
278	}	138✔
279
280	func (ref *TypeReference) IsMap() bool {	×
281	return ref.GO == MapType	×
282	}	×
283
284	func (ref *TypeReference) UniquenessKey() string {	1,222✔
285	nullability := "O"	1,222✔
286	if ref.GQL.NonNull {	1,981✔
287	nullability = "N"	759✔
288	}	759✔
289
290	elemNullability := ""	1,222✔
291	if ref.GQL.Elem != nil && ref.GQL.Elem.NonNull {	1,448✔
292	// Fix for #896	226✔
293	elemNullability = "ᚄ"	226✔
294	}	226✔
295	return nullability + ref.Definition.Name + "2" + templates.TypeIdentifier(ref.GO) + elemNullability	1,222✔
296	}
297
298	func (ref *TypeReference) MarshalFunc() string {	366✔
299	if ref.Definition == nil {	366✔
300	panic(errors.New("Definition missing for " + ref.GQL.Name()))	×
301	}
302
303	if ref.Definition.Kind == ast.InputObject {	370✔
304	return ""	4✔
305	}	4✔
306
307	return "marshal" + ref.UniquenessKey()	362✔
308	}
309
310	func (ref *TypeReference) UnmarshalFunc() string {	190✔
311	if ref.Definition == nil {	190✔
312	panic(errors.New("Definition missing for " + ref.GQL.Name()))	×
313	}
314
315	if !ref.Definition.IsInputType() {	268✔
316	return ""	78✔
317	}	78✔
318
319	return "unmarshal" + ref.UniquenessKey()	112✔
320	}
321
322	func (ref *TypeReference) IsTargetNilable() bool {	160✔
323	return IsNilable(ref.Target)	160✔
324	}	160✔
325
326	func (ref *TypeReference) HasEnumValues() bool {	218✔
327	return len(ref.EnumValues) > 0	218✔
328	}	218✔
329
330	func (b Binder) PushRef(ret TypeReference) {	648✔
331	b.References = append(b.References, ret)	648✔
332	}	648✔
333
334	func isMap(t types.Type) bool {	×
335	if t == nil {	×
336	return true	×
337	}	×
338	_, ok := t.(*types.Map)	×
339	return ok	×
340	}
341
342	func isIntf(t types.Type) bool {	×
343	if t == nil {	×
344	return true	×
345	}	×
346	_, ok := t.(*types.Interface)	×
347	return ok	×
348	}
349
350	func unwrapOmittable(t types.Type) (types.Type, bool) {	658✔
351	if t == nil {	872✔
352	return nil, false	214✔
353	}	214✔
354	named, ok := t.(*types.Named)	444✔
355	if !ok {	881✔
356	return t, false	437✔
357	}	437✔
358	if named.Origin().String() != "github.com/99designs/gqlgen/graphql.Omittable[T any]" {	8✔
359	return t, false	1✔
360	}	1✔
361	return named.TypeArgs().At(0), true	6✔
362	}
363
364	func (b Binder) TypeReference(schemaType ast.Type, bindTarget types.Type) (ret *TypeReference, err error) {	658✔
365	if innerType, ok := unwrapOmittable(bindTarget); ok {	664✔
366	if schemaType.NonNull {	8✔
367	return nil, fmt.Errorf("%s is wrapped with Omittable but non-null", schemaType.Name())	2✔
368	}	2✔
369
370	ref, err := b.TypeReference(schemaType, innerType)	4✔
371	if err != nil {	4✔
372	return nil, err	×
373	}	×
374
375	ref.IsOmittable = true	4✔
376	return ref, err	4✔
377	}
378
379	if !isValid(bindTarget) {	653✔
380	b.SawInvalid = true	1✔
381	return nil, fmt.Errorf("%s has an invalid type", schemaType.Name())	1✔
382	}	1✔
383
384	var pkgName, typeName string	651✔
385	def := b.schema.Types[schemaType.Name()]	651✔
386	defer func() {	1,302✔
387	if err == nil && ret != nil {	1,299✔
388	b.PushRef(ret)	648✔
389	}	648✔
390	}()
391
392	if len(b.cfg.Models[schemaType.Name()].Model) == 0 {	651✔
393	return nil, fmt.Errorf("%s was not found", schemaType.Name())	×
394	}	×
395
396	for _, model := range b.cfg.Models[schemaType.Name()].Model {	1,302✔
397	if model == "map[string]interface{}" {	651✔
398	if !isMap(bindTarget) {	×
399	continue	×
400	}
401	return &TypeReference{	×
402	Definition: def,	×
403	GQL: schemaType,	×
404	GO: MapType,	×
405	IsRoot: b.cfg.IsRoot(def),	×
406	}, nil	×
407	}
408
409	if model == "interface{}" {	651✔
410	if !isIntf(bindTarget) {	×
411	continue	×
412	}
413	return &TypeReference{	×
414	Definition: def,	×
415	GQL: schemaType,	×
416	GO: InterfaceType,	×
417	IsRoot: b.cfg.IsRoot(def),	×
418	}, nil	×
419	}
420
421	pkgName, typeName = code.PkgAndType(model)	651✔
422	if pkgName == "" {	651✔
423	return nil, fmt.Errorf("missing package name for %s", schemaType.Name())	×
424	}	×
425
426	ref := &TypeReference{	651✔
427	Definition: def,	651✔
428	GQL: schemaType,	651✔
429	IsRoot: b.cfg.IsRoot(def),	651✔
430	}	651✔
431		651✔
432	obj, err := b.FindObject(pkgName, typeName)	651✔
433	if err != nil {	652✔
434	return nil, err	1✔
435	}	1✔
436
437	if values := b.enumValues(def); len(values) > 0 {	652✔
438	err = b.enumReference(ref, obj, values)	2✔
439	if err != nil {	2✔
440	return nil, err	×
441	}	×
442	} else if fun, isFunc := obj.(*types.Func); isFunc {	1,066✔
443	ref.GO = fun.Type().(*types.Signature).Params().At(0).Type()	418✔
444	ref.IsContext = fun.Type().(*types.Signature).Results().At(0).Type().String() == "github.com/99designs/gqlgen/graphql.ContextMarshaler"	418✔
445	ref.Marshaler = fun	418✔
446	ref.Unmarshaler = types.NewFunc(0, fun.Pkg(), "Unmarshal"+typeName, nil)	418✔
447	} else if hasMethod(obj.Type(), "MarshalGQLContext") && hasMethod(obj.Type(), "UnmarshalGQLContext") {	648✔
448	ref.GO = obj.Type()	×
449	ref.IsContext = true	×
450	ref.IsMarshaler = true	×
451	} else if hasMethod(obj.Type(), "MarshalGQL") && hasMethod(obj.Type(), "UnmarshalGQL") {	230✔
452	ref.GO = obj.Type()	×
453	ref.IsMarshaler = true	×
454	} else if underlying := basicUnderlying(obj.Type()); def.IsLeafType() && underlying != nil && underlying.Kind() == types.String {	236✔
455	// TODO delete before v1. Backwards compatibility case for named types wrapping strings (see #595)	6✔
456		6✔
457	ref.GO = obj.Type()	6✔
458	ref.CastType = underlying	6✔
459		6✔
460	underlyingRef, err := b.TypeReference(&ast.Type{NamedType: "String"}, nil)	6✔
461	if err != nil {	6✔
462	return nil, err	×
463	}	×
464
465	ref.Marshaler = underlyingRef.Marshaler	6✔
466	ref.Unmarshaler = underlyingRef.Unmarshaler	6✔
467	} else {	224✔
468	ref.GO = obj.Type()	224✔
469	}	224✔
470
471	ref.Target = ref.GO	650✔
472	ref.GO = b.CopyModifiersFromAst(schemaType, ref.GO)	650✔
473		650✔
474	if bindTarget != nil {	1,087✔
475	if err = code.CompatibleTypes(ref.GO, bindTarget); err != nil {	439✔
476	continue	2✔
477	}
478	ref.GO = bindTarget	435✔
479	}
480
481	ref.PointersInUnmarshalInput = b.cfg.ReturnPointersInUnmarshalInput	648✔
482		648✔
483	return ref, nil	648✔
484	}
485
486	return nil, fmt.Errorf("%s is incompatible with %s", schemaType.Name(), bindTarget.String())	2✔
487	}
488
489	func isValid(t types.Type) bool {	652✔
490	basic, isBasic := t.(*types.Basic)	652✔
491	if !isBasic {	1,164✔
492	return true	512✔
493	}	512✔
494	return basic.Kind() != types.Invalid	140✔
495	}
496
497	func (b Binder) CopyModifiersFromAst(t ast.Type, base types.Type) types.Type {	1,267✔
498	if t.Elem != nil {	1,424✔
499	child := b.CopyModifiersFromAst(t.Elem, base)	157✔
500	if _, isStruct := child.Underlying().(*types.Struct); isStruct && !b.cfg.OmitSliceElementPointers {	263✔
501	child = types.NewPointer(child)	106✔
502	}	106✔
503	return types.NewSlice(child)	157✔
504	}
505
506	var isInterface bool	1,110✔
507	if named, ok := base.(*types.Named); ok {	1,530✔
508	_, isInterface = named.Underlying().(*types.Interface)	420✔
509	}	420✔
510
511	if !isInterface && !IsNilable(base) && !t.NonNull {	1,574✔
512	return types.NewPointer(base)	464✔
513	}	464✔
514
515	return base	646✔
516	}
517
518	func IsNilable(t types.Type) bool {	2,388✔
519	if namedType, isNamed := t.(*types.Named); isNamed {	3,050✔
520	return IsNilable(namedType.Underlying())	662✔
521	}	662✔
522	_, isPtr := t.(*types.Pointer)	1,726✔
523	_, isMap := t.(*types.Map)	1,726✔
524	_, isInterface := t.(*types.Interface)	1,726✔
525	_, isSlice := t.(*types.Slice)	1,726✔
526	_, isChan := t.(*types.Chan)	1,726✔
527	return isPtr \|\| isMap \|\| isInterface \|\| isSlice \|\| isChan	1,726✔
528	}
529
530	func hasMethod(it types.Type, name string) bool {	460✔
531	if ptr, isPtr := it.(*types.Pointer); isPtr {	460✔
532	it = ptr.Elem()	×
533	}	×
534	namedType, ok := it.(*types.Named)	460✔
535	if !ok {	460✔
536	return false	×
537	}	×
538
539	for i := 0; i < namedType.NumMethods(); i++ {	2,938✔
540	if namedType.Method(i).Name() == name {	2,478✔
541	return true	×
542	}	×
543	}
544	return false	460✔
545	}
546
547	func basicUnderlying(it types.Type) *types.Basic {	230✔
548	if ptr, isPtr := it.(*types.Pointer); isPtr {	230✔
549	it = ptr.Elem()	×
550	}	×
551	namedType, ok := it.(*types.Named)	230✔
552	if !ok {	230✔
553	return nil	×
554	}	×
555
556	if basic, ok := namedType.Underlying().(*types.Basic); ok {	236✔
557	return basic	6✔
558	}	6✔
559
560	return nil	224✔
561	}
562
563	type EnumValueReference struct {
564	Definition *ast.EnumValueDefinition
565	Object types.Object
566	}
567
568	func (b Binder) enumValues(def ast.Definition) map[string]EnumValue {	650✔
569	if def.Kind != ast.Enum {	1,277✔
570	return nil	627✔
571	}	627✔
572
573	if strings.HasPrefix(def.Name, "__") {	44✔
574	return nil	21✔
575	}	21✔
576
577	model, ok := b.cfg.Models[def.Name]	2✔
578	if !ok {	2✔
579	return nil	×
580	}	×
581
582	return model.EnumValues	2✔
583	}
584
585	func (b Binder) enumReference(ref TypeReference, obj types.Object, values map[string]EnumValue) error {	2✔
586	if len(ref.Definition.EnumValues) != len(values) {	2✔
587	return fmt.Errorf("not all enum values are binded for %v", ref.Definition.Name)	×
588	}	×
589
590	if fn, ok := obj.Type().(*types.Signature); ok {	3✔
591	ref.GO = fn.Params().At(0).Type()	1✔
592	} else {	2✔
593	ref.GO = obj.Type()	1✔
594	}	1✔
595
596	str, err := b.TypeReference(&ast.Type{NamedType: "String"}, nil)	2✔
597	if err != nil {	2✔
598	return err	×
599	}	×
600
601	ref.Marshaler = str.Marshaler	2✔
602	ref.Unmarshaler = str.Unmarshaler	2✔
603	ref.EnumValues = make([]EnumValueReference, 0, len(values))	2✔
604		2✔
605	for _, value := range ref.Definition.EnumValues {	6✔
606	v, ok := values[value.Name]	4✔
607	if !ok {	4✔
608	return fmt.Errorf("enum value not found for: %v, of enum: %v", value.Name, ref.Definition.Name)	×
609	}	×
610
611	pkgName, typeName := code.PkgAndType(v.Value)	4✔
612	if pkgName == "" {	4✔
613	return fmt.Errorf("missing package name for %v", value.Name)	×
614	}	×
615
616	valueObj, err := b.FindObject(pkgName, typeName)	4✔
617	if err != nil {	4✔
618	return err	×
619	}	×
620
621	if !types.AssignableTo(valueObj.Type(), ref.GO) {	4✔
622	return fmt.Errorf("wrong type: %v, for enum value: %v, expected type: %v, of enum: %v",	×
623	valueObj.Type(), value.Name, ref.GO, ref.Definition.Name)	×
624	}	×
625
626	switch valueObj.(type) {	4✔
627	case types.Const, types.Var:	4✔
628	ref.EnumValues = append(ref.EnumValues, EnumValueReference{	4✔
629	Definition: value,	4✔
630	Object: valueObj,	4✔
631	})	4✔
632	default:	×
633	return fmt.Errorf("unsupported enum value for: %v, of enum: %v, only const and var allowed",	×
634	value.Name, ref.Definition.Name)	×
635	}
636	}
637
638	return nil	2✔
639	}

99designs / gqlgen / 10048280495

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous