9269963572

Committed 28 May 2024 01:10PM UTC coverage: 74.73% (-0.06%) from 74.793%

Build # 9269963572

Build Type

push

github

Committed by

web-flow

Commit Message

Correct dataloader example (#3110)

Dataloader requires the value and error slice to be of equal length, in order to correctly return the values.

Link: https://github.com/vikstrous/dataloadgen/blob/7de6ebe3d/dataloadgen_test.go#L19-L20

Run Details

7139 of 9553 relevant lines covered (74.73%)

659.92 hits per line

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

64.81

/codegen/object.go

package codegen

import (
        "fmt"
        "go/types"
        "strconv"
        "strings"
        "unicode"

        "github.com/vektah/gqlparser/v2/ast"
        "golang.org/x/text/cases"
        "golang.org/x/text/language"

        "github.com/99designs/gqlgen/codegen/config"
)

type GoFieldType int

const (
        GoFieldUndefined GoFieldType = iota
        GoFieldMethod
        GoFieldVariable
        GoFieldMap
)

type Object struct {
        *ast.Definition

        Type                    types.Type
        ResolverInterface       types.Type
        Root                    bool
        Fields                  []*Field
        Implements              []*ast.Definition
        DisableConcurrency      bool
        Stream                  bool
        Directives              []*Directive
        PointersInUmarshalInput bool
}

func (b *builder) buildObject(typ *ast.Definition) (*Object, error) {
        dirs, err := b.getDirectives(typ.Directives)
        if err != nil {
                return nil, fmt.Errorf("%s: %w", typ.Name, err)
        }
        caser := cases.Title(language.English, cases.NoLower)
        obj := &Object{
                Definition:              typ,
                Root:                    b.Config.IsRoot(typ),
                DisableConcurrency:      typ == b.Schema.Mutation,
                Stream:                  typ == b.Schema.Subscription,
                Directives:              dirs,
                PointersInUmarshalInput: b.Config.ReturnPointersInUmarshalInput,
                ResolverInterface: types.NewNamed(
                        types.NewTypeName(0, b.Config.Exec.Pkg(), caser.String(typ.Name)+"Resolver", nil),
                        nil,
                        nil,
                ),
        }

        if !obj.Root {
                goObject, err := b.Binder.DefaultUserObject(typ.Name)
                if err != nil {
                        return nil, err
                }
                obj.Type = goObject
        }

        for _, intf := range b.Schema.GetImplements(typ) {
                obj.Implements = append(obj.Implements, b.Schema.Types[intf.Name])
        }

        for _, field := range typ.Fields {
                if strings.HasPrefix(field.Name, "__") {
                        continue
                }

                var f *Field
                f, err = b.buildField(obj, field)
                if err != nil {
                        return nil, err
                }

                obj.Fields = append(obj.Fields, f)
        }

        return obj, nil
}

func (o *Object) Reference() types.Type {
        if config.IsNilable(o.Type) {
                return o.Type
        }
        return types.NewPointer(o.Type)
}

type Objects []*Object

func (o *Object) Implementors() string {
        satisfiedBy := strconv.Quote(o.Name)
        for _, s := range o.Implements {
                satisfiedBy += ", " + strconv.Quote(s.Name)
        }
        return "[]string{" + satisfiedBy + "}"
}

func (o *Object) HasResolvers() bool {
        for _, f := range o.Fields {
                if f.IsResolver {
                        return true
                }
        }
        return false
}

func (o *Object) HasUnmarshal() bool {
        if o.IsMap() {
                return false
        }
        for i := 0; i < o.Type.(*types.Named).NumMethods(); i++ {
                if o.Type.(*types.Named).Method(i).Name() == "UnmarshalGQL" {
                        return true
                }
        }
        return false
}

func (o *Object) HasDirectives() bool {
        if len(o.Directives) > 0 {
                return true
        }
        for _, f := range o.Fields {
                if f.HasDirectives() {
                        return true
                }
        }

        return false
}

func (o *Object) IsConcurrent() bool {
        for _, f := range o.Fields {
                if f.IsConcurrent() {
                        return true
                }
        }
        return false
}

func (o *Object) IsReserved() bool {
        return strings.HasPrefix(o.Definition.Name, "__")
}

func (o *Object) IsMap() bool {
        return o.Type == config.MapType
}

func (o *Object) Description() string {
        return o.Definition.Description
}

func (o *Object) HasField(name string) bool {
        for _, f := range o.Fields {
                if f.Name == name {
                        return true
                }
        }

        return false
}

func (os Objects) ByName(name string) *Object {
        for i, o := range os {
                if strings.EqualFold(o.Definition.Name, name) {
                        return os[i]
                }
        }
        return nil
}

func ucFirst(s string) string {
        if s == "" {
                return ""
        }

        r := []rune(s)
        r[0] = unicode.ToUpper(r[0])
        return string(r)
}

1	package codegen
2
3	import (
4	"fmt"
5	"go/types"
6	"strconv"
7	"strings"
8	"unicode"
9
10	"github.com/vektah/gqlparser/v2/ast"
11	"golang.org/x/text/cases"
12	"golang.org/x/text/language"
13
14	"github.com/99designs/gqlgen/codegen/config"
15	)
16
17	type GoFieldType int
18
19	const (
20	GoFieldUndefined GoFieldType = iota
21	GoFieldMethod
22	GoFieldVariable
23	GoFieldMap
24	)
25
26	type Object struct {
27	*ast.Definition
28
29	Type types.Type
30	ResolverInterface types.Type
31	Root bool
32	Fields []*Field
33	Implements []*ast.Definition
34	DisableConcurrency bool
35	Stream bool
36	Directives []*Directive
37	PointersInUmarshalInput bool
38	}
39
40	func (b builder) buildObject(typ ast.Definition) (*Object, error) {	102✔
41	dirs, err := b.getDirectives(typ.Directives)	102✔
42	if err != nil {	102✔
43	return nil, fmt.Errorf("%s: %w", typ.Name, err)	×
44	}	×
45	caser := cases.Title(language.English, cases.NoLower)	102✔
46	obj := &Object{	102✔
47	Definition: typ,	102✔
48	Root: b.Config.IsRoot(typ),	102✔
49	DisableConcurrency: typ == b.Schema.Mutation,	102✔
50	Stream: typ == b.Schema.Subscription,	102✔
51	Directives: dirs,	102✔
52	PointersInUmarshalInput: b.Config.ReturnPointersInUmarshalInput,	102✔
53	ResolverInterface: types.NewNamed(	102✔
54	types.NewTypeName(0, b.Config.Exec.Pkg(), caser.String(typ.Name)+"Resolver", nil),	102✔
55	nil,	102✔
56	nil,	102✔
57	),	102✔
58	}	102✔
59		102✔
60	if !obj.Root {	192✔
61	goObject, err := b.Binder.DefaultUserObject(typ.Name)	90✔
62	if err != nil {	91✔
63	return nil, err	1✔
64	}	1✔
65	obj.Type = goObject	89✔
66	}
67
68	for _, intf := range b.Schema.GetImplements(typ) {	111✔
69	obj.Implements = append(obj.Implements, b.Schema.Types[intf.Name])	10✔
70	}	10✔
71
72	for _, field := range typ.Fields {	547✔
73	if strings.HasPrefix(field.Name, "__") {	466✔
74	continue	20✔
75	}
76
77	var f *Field	426✔
78	f, err = b.buildField(obj, field)	426✔
79	if err != nil {	426✔
80	return nil, err	×
81	}	×
82
83	obj.Fields = append(obj.Fields, f)	426✔
84	}
85
86	return obj, nil	101✔
87	}
88
89	func (o *Object) Reference() types.Type {	206✔
90	if config.IsNilable(o.Type) {	206✔
91	return o.Type	×
92	}	×
93	return types.NewPointer(o.Type)	206✔
94	}
95
96	type Objects []*Object
97
98	func (o *Object) Implementors() string {	42✔
99	satisfiedBy := strconv.Quote(o.Name)	42✔
100	for _, s := range o.Implements {	42✔
101	satisfiedBy += ", " + strconv.Quote(s.Name)	×
102	}	×
103	return "[]string{" + satisfiedBy + "}"	42✔
104	}
105
106	func (o *Object) HasResolvers() bool {	163✔
107	for _, f := range o.Fields {	840✔
108	if f.IsResolver {	709✔
109	return true	32✔
110	}	32✔
111	}
112	return false	131✔
113	}
114
115	func (o *Object) HasUnmarshal() bool {	8✔
116	if o.IsMap() {	8✔
117	return false	×
118	}	×
119	for i := 0; i < o.Type.(*types.Named).NumMethods(); i++ {	8✔
120	if o.Type.(*types.Named).Method(i).Name() == "UnmarshalGQL" {	×
121	return true	×
122	}	×
123	}
124	return false	8✔
125	}
126
127	func (o *Object) HasDirectives() bool {	×
128	if len(o.Directives) > 0 {	×
129	return true	×
130	}	×
131	for _, f := range o.Fields {	×
132	if f.HasDirectives() {	×
133	return true	×
134	}	×
135	}
136
137	return false	×
138	}
139
140	func (o *Object) IsConcurrent() bool {	98✔
141	for _, f := range o.Fields {	540✔
142	if f.IsConcurrent() {	448✔
143	return true	6✔
144	}	6✔
145	}
146	return false	92✔
147	}
148
149	func (o *Object) IsReserved() bool {	84✔
150	return strings.HasPrefix(o.Definition.Name, "__")	84✔
151	}	84✔
152
153	func (o *Object) IsMap() bool {	20✔
154	return o.Type == config.MapType	20✔
155	}	20✔
156
157	func (o *Object) Description() string {	×
158	return o.Definition.Description	×
159	}	×
160
161	func (o *Object) HasField(name string) bool {	×
162	for _, f := range o.Fields {	×
163	if f.Name == name {	×
164	return true	×
165	}	×
166	}
167
168	return false	×
169	}
170
171	func (os Objects) ByName(name string) *Object {	61✔
172	for i, o := range os {	526✔
173	if strings.EqualFold(o.Definition.Name, name) {	510✔
174	return os[i]	45✔
175	}	45✔
176	}
177	return nil	16✔
178	}
179
180	func ucFirst(s string) string {	×
181	if s == "" {	×
182	return ""	×
183	}	×
184
185	r := []rune(s)	×
186	r[0] = unicode.ToUpper(r[0])	×
187	return string(r)	×
188	}

99designs / gqlgen / 9269963572

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