1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
2
3package graph
4
5import (
6 "context"
7 "errors"
8 "fmt"
9 "strconv"
10 "sync/atomic"
11
12 "github.com/99designs/gqlgen/graphql"
13 "github.com/git-bug/git-bug/api/graphql/models"
14 "github.com/vektah/gqlparser/v2/ast"
15)
16
17// region ************************** generated!.gotpl **************************
18
19type RepositoryResolver interface {
20 Name(ctx context.Context, obj *models.Repository) (*string, error)
21 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
22 Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
23 AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
24 Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
25 UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
26 ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
27}
28
29// endregion ************************** generated!.gotpl **************************
30
31// region ***************************** args.gotpl *****************************
32
33func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
34 var err error
35 args := map[string]interface{}{}
36 var arg0 *string
37 if tmp, ok := rawArgs["after"]; ok {
38 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
39 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
40 if err != nil {
41 return nil, err
42 }
43 }
44 args["after"] = arg0
45 var arg1 *string
46 if tmp, ok := rawArgs["before"]; ok {
47 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
48 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
49 if err != nil {
50 return nil, err
51 }
52 }
53 args["before"] = arg1
54 var arg2 *int
55 if tmp, ok := rawArgs["first"]; ok {
56 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
57 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
58 if err != nil {
59 return nil, err
60 }
61 }
62 args["first"] = arg2
63 var arg3 *int
64 if tmp, ok := rawArgs["last"]; ok {
65 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
66 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
67 if err != nil {
68 return nil, err
69 }
70 }
71 args["last"] = arg3
72 var arg4 *string
73 if tmp, ok := rawArgs["query"]; ok {
74 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("query"))
75 arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
76 if err != nil {
77 return nil, err
78 }
79 }
80 args["query"] = arg4
81 return args, nil
82}
83
84func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
85 var err error
86 args := map[string]interface{}{}
87 var arg0 *string
88 if tmp, ok := rawArgs["after"]; ok {
89 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
90 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
91 if err != nil {
92 return nil, err
93 }
94 }
95 args["after"] = arg0
96 var arg1 *string
97 if tmp, ok := rawArgs["before"]; ok {
98 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
99 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
100 if err != nil {
101 return nil, err
102 }
103 }
104 args["before"] = arg1
105 var arg2 *int
106 if tmp, ok := rawArgs["first"]; ok {
107 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
108 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
109 if err != nil {
110 return nil, err
111 }
112 }
113 args["first"] = arg2
114 var arg3 *int
115 if tmp, ok := rawArgs["last"]; ok {
116 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
117 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
118 if err != nil {
119 return nil, err
120 }
121 }
122 args["last"] = arg3
123 return args, nil
124}
125
126func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
127 var err error
128 args := map[string]interface{}{}
129 var arg0 string
130 if tmp, ok := rawArgs["prefix"]; ok {
131 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
132 arg0, err = ec.unmarshalNString2string(ctx, tmp)
133 if err != nil {
134 return nil, err
135 }
136 }
137 args["prefix"] = arg0
138 return args, nil
139}
140
141func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
142 var err error
143 args := map[string]interface{}{}
144 var arg0 string
145 if tmp, ok := rawArgs["prefix"]; ok {
146 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
147 arg0, err = ec.unmarshalNString2string(ctx, tmp)
148 if err != nil {
149 return nil, err
150 }
151 }
152 args["prefix"] = arg0
153 return args, nil
154}
155
156func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
157 var err error
158 args := map[string]interface{}{}
159 var arg0 *string
160 if tmp, ok := rawArgs["after"]; ok {
161 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
162 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
163 if err != nil {
164 return nil, err
165 }
166 }
167 args["after"] = arg0
168 var arg1 *string
169 if tmp, ok := rawArgs["before"]; ok {
170 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
171 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
172 if err != nil {
173 return nil, err
174 }
175 }
176 args["before"] = arg1
177 var arg2 *int
178 if tmp, ok := rawArgs["first"]; ok {
179 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
180 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
181 if err != nil {
182 return nil, err
183 }
184 }
185 args["first"] = arg2
186 var arg3 *int
187 if tmp, ok := rawArgs["last"]; ok {
188 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
189 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
190 if err != nil {
191 return nil, err
192 }
193 }
194 args["last"] = arg3
195 return args, nil
196}
197
198// endregion ***************************** args.gotpl *****************************
199
200// region ************************** directives.gotpl **************************
201
202// endregion ************************** directives.gotpl **************************
203
204// region **************************** field.gotpl *****************************
205
206func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
207 fc, err := ec.fieldContext_Repository_name(ctx, field)
208 if err != nil {
209 return graphql.Null
210 }
211 ctx = graphql.WithFieldContext(ctx, fc)
212 defer func() {
213 if r := recover(); r != nil {
214 ec.Error(ctx, ec.Recover(ctx, r))
215 ret = graphql.Null
216 }
217 }()
218 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
219 ctx = rctx // use context from middleware stack in children
220 return ec.resolvers.Repository().Name(rctx, obj)
221 })
222 if err != nil {
223 ec.Error(ctx, err)
224 return graphql.Null
225 }
226 if resTmp == nil {
227 return graphql.Null
228 }
229 res := resTmp.(*string)
230 fc.Result = res
231 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
232}
233
234func (ec *executionContext) fieldContext_Repository_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
235 fc = &graphql.FieldContext{
236 Object: "Repository",
237 Field: field,
238 IsMethod: true,
239 IsResolver: true,
240 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
241 return nil, errors.New("field of type String does not have child fields")
242 },
243 }
244 return fc, nil
245}
246
247func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
248 fc, err := ec.fieldContext_Repository_allBugs(ctx, field)
249 if err != nil {
250 return graphql.Null
251 }
252 ctx = graphql.WithFieldContext(ctx, fc)
253 defer func() {
254 if r := recover(); r != nil {
255 ec.Error(ctx, ec.Recover(ctx, r))
256 ret = graphql.Null
257 }
258 }()
259 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
260 ctx = rctx // use context from middleware stack in children
261 return ec.resolvers.Repository().AllBugs(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int), fc.Args["query"].(*string))
262 })
263 if err != nil {
264 ec.Error(ctx, err)
265 return graphql.Null
266 }
267 if resTmp == nil {
268 if !graphql.HasFieldError(ctx, fc) {
269 ec.Errorf(ctx, "must not be null")
270 }
271 return graphql.Null
272 }
273 res := resTmp.(*models.BugConnection)
274 fc.Result = res
275 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
276}
277
278func (ec *executionContext) fieldContext_Repository_allBugs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
279 fc = &graphql.FieldContext{
280 Object: "Repository",
281 Field: field,
282 IsMethod: true,
283 IsResolver: true,
284 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
285 switch field.Name {
286 case "edges":
287 return ec.fieldContext_BugConnection_edges(ctx, field)
288 case "nodes":
289 return ec.fieldContext_BugConnection_nodes(ctx, field)
290 case "pageInfo":
291 return ec.fieldContext_BugConnection_pageInfo(ctx, field)
292 case "totalCount":
293 return ec.fieldContext_BugConnection_totalCount(ctx, field)
294 }
295 return nil, fmt.Errorf("no field named %q was found under type BugConnection", field.Name)
296 },
297 }
298 defer func() {
299 if r := recover(); r != nil {
300 err = ec.Recover(ctx, r)
301 ec.Error(ctx, err)
302 }
303 }()
304 ctx = graphql.WithFieldContext(ctx, fc)
305 if fc.Args, err = ec.field_Repository_allBugs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
306 ec.Error(ctx, err)
307 return fc, err
308 }
309 return fc, nil
310}
311
312func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
313 fc, err := ec.fieldContext_Repository_bug(ctx, field)
314 if err != nil {
315 return graphql.Null
316 }
317 ctx = graphql.WithFieldContext(ctx, fc)
318 defer func() {
319 if r := recover(); r != nil {
320 ec.Error(ctx, ec.Recover(ctx, r))
321 ret = graphql.Null
322 }
323 }()
324 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
325 ctx = rctx // use context from middleware stack in children
326 return ec.resolvers.Repository().Bug(rctx, obj, fc.Args["prefix"].(string))
327 })
328 if err != nil {
329 ec.Error(ctx, err)
330 return graphql.Null
331 }
332 if resTmp == nil {
333 return graphql.Null
334 }
335 res := resTmp.(models.BugWrapper)
336 fc.Result = res
337 return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
338}
339
340func (ec *executionContext) fieldContext_Repository_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
341 fc = &graphql.FieldContext{
342 Object: "Repository",
343 Field: field,
344 IsMethod: true,
345 IsResolver: true,
346 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
347 switch field.Name {
348 case "id":
349 return ec.fieldContext_Bug_id(ctx, field)
350 case "humanId":
351 return ec.fieldContext_Bug_humanId(ctx, field)
352 case "status":
353 return ec.fieldContext_Bug_status(ctx, field)
354 case "title":
355 return ec.fieldContext_Bug_title(ctx, field)
356 case "labels":
357 return ec.fieldContext_Bug_labels(ctx, field)
358 case "author":
359 return ec.fieldContext_Bug_author(ctx, field)
360 case "createdAt":
361 return ec.fieldContext_Bug_createdAt(ctx, field)
362 case "lastEdit":
363 return ec.fieldContext_Bug_lastEdit(ctx, field)
364 case "actors":
365 return ec.fieldContext_Bug_actors(ctx, field)
366 case "participants":
367 return ec.fieldContext_Bug_participants(ctx, field)
368 case "comments":
369 return ec.fieldContext_Bug_comments(ctx, field)
370 case "timeline":
371 return ec.fieldContext_Bug_timeline(ctx, field)
372 case "operations":
373 return ec.fieldContext_Bug_operations(ctx, field)
374 }
375 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
376 },
377 }
378 defer func() {
379 if r := recover(); r != nil {
380 err = ec.Recover(ctx, r)
381 ec.Error(ctx, err)
382 }
383 }()
384 ctx = graphql.WithFieldContext(ctx, fc)
385 if fc.Args, err = ec.field_Repository_bug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
386 ec.Error(ctx, err)
387 return fc, err
388 }
389 return fc, nil
390}
391
392func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
393 fc, err := ec.fieldContext_Repository_allIdentities(ctx, field)
394 if err != nil {
395 return graphql.Null
396 }
397 ctx = graphql.WithFieldContext(ctx, fc)
398 defer func() {
399 if r := recover(); r != nil {
400 ec.Error(ctx, ec.Recover(ctx, r))
401 ret = graphql.Null
402 }
403 }()
404 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
405 ctx = rctx // use context from middleware stack in children
406 return ec.resolvers.Repository().AllIdentities(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
407 })
408 if err != nil {
409 ec.Error(ctx, err)
410 return graphql.Null
411 }
412 if resTmp == nil {
413 if !graphql.HasFieldError(ctx, fc) {
414 ec.Errorf(ctx, "must not be null")
415 }
416 return graphql.Null
417 }
418 res := resTmp.(*models.IdentityConnection)
419 fc.Result = res
420 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
421}
422
423func (ec *executionContext) fieldContext_Repository_allIdentities(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
424 fc = &graphql.FieldContext{
425 Object: "Repository",
426 Field: field,
427 IsMethod: true,
428 IsResolver: true,
429 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
430 switch field.Name {
431 case "edges":
432 return ec.fieldContext_IdentityConnection_edges(ctx, field)
433 case "nodes":
434 return ec.fieldContext_IdentityConnection_nodes(ctx, field)
435 case "pageInfo":
436 return ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
437 case "totalCount":
438 return ec.fieldContext_IdentityConnection_totalCount(ctx, field)
439 }
440 return nil, fmt.Errorf("no field named %q was found under type IdentityConnection", field.Name)
441 },
442 }
443 defer func() {
444 if r := recover(); r != nil {
445 err = ec.Recover(ctx, r)
446 ec.Error(ctx, err)
447 }
448 }()
449 ctx = graphql.WithFieldContext(ctx, fc)
450 if fc.Args, err = ec.field_Repository_allIdentities_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
451 ec.Error(ctx, err)
452 return fc, err
453 }
454 return fc, nil
455}
456
457func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
458 fc, err := ec.fieldContext_Repository_identity(ctx, field)
459 if err != nil {
460 return graphql.Null
461 }
462 ctx = graphql.WithFieldContext(ctx, fc)
463 defer func() {
464 if r := recover(); r != nil {
465 ec.Error(ctx, ec.Recover(ctx, r))
466 ret = graphql.Null
467 }
468 }()
469 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
470 ctx = rctx // use context from middleware stack in children
471 return ec.resolvers.Repository().Identity(rctx, obj, fc.Args["prefix"].(string))
472 })
473 if err != nil {
474 ec.Error(ctx, err)
475 return graphql.Null
476 }
477 if resTmp == nil {
478 return graphql.Null
479 }
480 res := resTmp.(models.IdentityWrapper)
481 fc.Result = res
482 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
483}
484
485func (ec *executionContext) fieldContext_Repository_identity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
486 fc = &graphql.FieldContext{
487 Object: "Repository",
488 Field: field,
489 IsMethod: true,
490 IsResolver: true,
491 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
492 switch field.Name {
493 case "id":
494 return ec.fieldContext_Identity_id(ctx, field)
495 case "humanId":
496 return ec.fieldContext_Identity_humanId(ctx, field)
497 case "name":
498 return ec.fieldContext_Identity_name(ctx, field)
499 case "email":
500 return ec.fieldContext_Identity_email(ctx, field)
501 case "login":
502 return ec.fieldContext_Identity_login(ctx, field)
503 case "displayName":
504 return ec.fieldContext_Identity_displayName(ctx, field)
505 case "avatarUrl":
506 return ec.fieldContext_Identity_avatarUrl(ctx, field)
507 case "isProtected":
508 return ec.fieldContext_Identity_isProtected(ctx, field)
509 }
510 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
511 },
512 }
513 defer func() {
514 if r := recover(); r != nil {
515 err = ec.Recover(ctx, r)
516 ec.Error(ctx, err)
517 }
518 }()
519 ctx = graphql.WithFieldContext(ctx, fc)
520 if fc.Args, err = ec.field_Repository_identity_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
521 ec.Error(ctx, err)
522 return fc, err
523 }
524 return fc, nil
525}
526
527func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
528 fc, err := ec.fieldContext_Repository_userIdentity(ctx, field)
529 if err != nil {
530 return graphql.Null
531 }
532 ctx = graphql.WithFieldContext(ctx, fc)
533 defer func() {
534 if r := recover(); r != nil {
535 ec.Error(ctx, ec.Recover(ctx, r))
536 ret = graphql.Null
537 }
538 }()
539 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
540 ctx = rctx // use context from middleware stack in children
541 return ec.resolvers.Repository().UserIdentity(rctx, obj)
542 })
543 if err != nil {
544 ec.Error(ctx, err)
545 return graphql.Null
546 }
547 if resTmp == nil {
548 return graphql.Null
549 }
550 res := resTmp.(models.IdentityWrapper)
551 fc.Result = res
552 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
553}
554
555func (ec *executionContext) fieldContext_Repository_userIdentity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
556 fc = &graphql.FieldContext{
557 Object: "Repository",
558 Field: field,
559 IsMethod: true,
560 IsResolver: true,
561 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
562 switch field.Name {
563 case "id":
564 return ec.fieldContext_Identity_id(ctx, field)
565 case "humanId":
566 return ec.fieldContext_Identity_humanId(ctx, field)
567 case "name":
568 return ec.fieldContext_Identity_name(ctx, field)
569 case "email":
570 return ec.fieldContext_Identity_email(ctx, field)
571 case "login":
572 return ec.fieldContext_Identity_login(ctx, field)
573 case "displayName":
574 return ec.fieldContext_Identity_displayName(ctx, field)
575 case "avatarUrl":
576 return ec.fieldContext_Identity_avatarUrl(ctx, field)
577 case "isProtected":
578 return ec.fieldContext_Identity_isProtected(ctx, field)
579 }
580 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
581 },
582 }
583 return fc, nil
584}
585
586func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
587 fc, err := ec.fieldContext_Repository_validLabels(ctx, field)
588 if err != nil {
589 return graphql.Null
590 }
591 ctx = graphql.WithFieldContext(ctx, fc)
592 defer func() {
593 if r := recover(); r != nil {
594 ec.Error(ctx, ec.Recover(ctx, r))
595 ret = graphql.Null
596 }
597 }()
598 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
599 ctx = rctx // use context from middleware stack in children
600 return ec.resolvers.Repository().ValidLabels(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
601 })
602 if err != nil {
603 ec.Error(ctx, err)
604 return graphql.Null
605 }
606 if resTmp == nil {
607 if !graphql.HasFieldError(ctx, fc) {
608 ec.Errorf(ctx, "must not be null")
609 }
610 return graphql.Null
611 }
612 res := resTmp.(*models.LabelConnection)
613 fc.Result = res
614 return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
615}
616
617func (ec *executionContext) fieldContext_Repository_validLabels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
618 fc = &graphql.FieldContext{
619 Object: "Repository",
620 Field: field,
621 IsMethod: true,
622 IsResolver: true,
623 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
624 switch field.Name {
625 case "edges":
626 return ec.fieldContext_LabelConnection_edges(ctx, field)
627 case "nodes":
628 return ec.fieldContext_LabelConnection_nodes(ctx, field)
629 case "pageInfo":
630 return ec.fieldContext_LabelConnection_pageInfo(ctx, field)
631 case "totalCount":
632 return ec.fieldContext_LabelConnection_totalCount(ctx, field)
633 }
634 return nil, fmt.Errorf("no field named %q was found under type LabelConnection", field.Name)
635 },
636 }
637 defer func() {
638 if r := recover(); r != nil {
639 err = ec.Recover(ctx, r)
640 ec.Error(ctx, err)
641 }
642 }()
643 ctx = graphql.WithFieldContext(ctx, fc)
644 if fc.Args, err = ec.field_Repository_validLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
645 ec.Error(ctx, err)
646 return fc, err
647 }
648 return fc, nil
649}
650
651// endregion **************************** field.gotpl *****************************
652
653// region **************************** input.gotpl *****************************
654
655// endregion **************************** input.gotpl *****************************
656
657// region ************************** interface.gotpl ***************************
658
659// endregion ************************** interface.gotpl ***************************
660
661// region **************************** object.gotpl ****************************
662
663var repositoryImplementors = []string{"Repository"}
664
665func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
666 fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
667
668 out := graphql.NewFieldSet(fields)
669 deferred := make(map[string]*graphql.FieldSet)
670 for i, field := range fields {
671 switch field.Name {
672 case "__typename":
673 out.Values[i] = graphql.MarshalString("Repository")
674 case "name":
675 field := field
676
677 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
678 defer func() {
679 if r := recover(); r != nil {
680 ec.Error(ctx, ec.Recover(ctx, r))
681 }
682 }()
683 res = ec._Repository_name(ctx, field, obj)
684 return res
685 }
686
687 if field.Deferrable != nil {
688 dfs, ok := deferred[field.Deferrable.Label]
689 di := 0
690 if ok {
691 dfs.AddField(field)
692 di = len(dfs.Values) - 1
693 } else {
694 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
695 deferred[field.Deferrable.Label] = dfs
696 }
697 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
698 return innerFunc(ctx, dfs)
699 })
700
701 // don't run the out.Concurrently() call below
702 out.Values[i] = graphql.Null
703 continue
704 }
705
706 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
707 case "allBugs":
708 field := field
709
710 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
711 defer func() {
712 if r := recover(); r != nil {
713 ec.Error(ctx, ec.Recover(ctx, r))
714 }
715 }()
716 res = ec._Repository_allBugs(ctx, field, obj)
717 if res == graphql.Null {
718 atomic.AddUint32(&fs.Invalids, 1)
719 }
720 return res
721 }
722
723 if field.Deferrable != nil {
724 dfs, ok := deferred[field.Deferrable.Label]
725 di := 0
726 if ok {
727 dfs.AddField(field)
728 di = len(dfs.Values) - 1
729 } else {
730 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
731 deferred[field.Deferrable.Label] = dfs
732 }
733 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
734 return innerFunc(ctx, dfs)
735 })
736
737 // don't run the out.Concurrently() call below
738 out.Values[i] = graphql.Null
739 continue
740 }
741
742 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
743 case "bug":
744 field := field
745
746 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
747 defer func() {
748 if r := recover(); r != nil {
749 ec.Error(ctx, ec.Recover(ctx, r))
750 }
751 }()
752 res = ec._Repository_bug(ctx, field, obj)
753 return res
754 }
755
756 if field.Deferrable != nil {
757 dfs, ok := deferred[field.Deferrable.Label]
758 di := 0
759 if ok {
760 dfs.AddField(field)
761 di = len(dfs.Values) - 1
762 } else {
763 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
764 deferred[field.Deferrable.Label] = dfs
765 }
766 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
767 return innerFunc(ctx, dfs)
768 })
769
770 // don't run the out.Concurrently() call below
771 out.Values[i] = graphql.Null
772 continue
773 }
774
775 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
776 case "allIdentities":
777 field := field
778
779 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
780 defer func() {
781 if r := recover(); r != nil {
782 ec.Error(ctx, ec.Recover(ctx, r))
783 }
784 }()
785 res = ec._Repository_allIdentities(ctx, field, obj)
786 if res == graphql.Null {
787 atomic.AddUint32(&fs.Invalids, 1)
788 }
789 return res
790 }
791
792 if field.Deferrable != nil {
793 dfs, ok := deferred[field.Deferrable.Label]
794 di := 0
795 if ok {
796 dfs.AddField(field)
797 di = len(dfs.Values) - 1
798 } else {
799 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
800 deferred[field.Deferrable.Label] = dfs
801 }
802 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
803 return innerFunc(ctx, dfs)
804 })
805
806 // don't run the out.Concurrently() call below
807 out.Values[i] = graphql.Null
808 continue
809 }
810
811 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
812 case "identity":
813 field := field
814
815 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
816 defer func() {
817 if r := recover(); r != nil {
818 ec.Error(ctx, ec.Recover(ctx, r))
819 }
820 }()
821 res = ec._Repository_identity(ctx, field, obj)
822 return res
823 }
824
825 if field.Deferrable != nil {
826 dfs, ok := deferred[field.Deferrable.Label]
827 di := 0
828 if ok {
829 dfs.AddField(field)
830 di = len(dfs.Values) - 1
831 } else {
832 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
833 deferred[field.Deferrable.Label] = dfs
834 }
835 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
836 return innerFunc(ctx, dfs)
837 })
838
839 // don't run the out.Concurrently() call below
840 out.Values[i] = graphql.Null
841 continue
842 }
843
844 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
845 case "userIdentity":
846 field := field
847
848 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
849 defer func() {
850 if r := recover(); r != nil {
851 ec.Error(ctx, ec.Recover(ctx, r))
852 }
853 }()
854 res = ec._Repository_userIdentity(ctx, field, obj)
855 return res
856 }
857
858 if field.Deferrable != nil {
859 dfs, ok := deferred[field.Deferrable.Label]
860 di := 0
861 if ok {
862 dfs.AddField(field)
863 di = len(dfs.Values) - 1
864 } else {
865 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
866 deferred[field.Deferrable.Label] = dfs
867 }
868 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
869 return innerFunc(ctx, dfs)
870 })
871
872 // don't run the out.Concurrently() call below
873 out.Values[i] = graphql.Null
874 continue
875 }
876
877 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
878 case "validLabels":
879 field := field
880
881 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
882 defer func() {
883 if r := recover(); r != nil {
884 ec.Error(ctx, ec.Recover(ctx, r))
885 }
886 }()
887 res = ec._Repository_validLabels(ctx, field, obj)
888 if res == graphql.Null {
889 atomic.AddUint32(&fs.Invalids, 1)
890 }
891 return res
892 }
893
894 if field.Deferrable != nil {
895 dfs, ok := deferred[field.Deferrable.Label]
896 di := 0
897 if ok {
898 dfs.AddField(field)
899 di = len(dfs.Values) - 1
900 } else {
901 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
902 deferred[field.Deferrable.Label] = dfs
903 }
904 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
905 return innerFunc(ctx, dfs)
906 })
907
908 // don't run the out.Concurrently() call below
909 out.Values[i] = graphql.Null
910 continue
911 }
912
913 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
914 default:
915 panic("unknown field " + strconv.Quote(field.Name))
916 }
917 }
918 out.Dispatch(ctx)
919 if out.Invalids > 0 {
920 return graphql.Null
921 }
922
923 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
924
925 for label, dfs := range deferred {
926 ec.processDeferredGroup(graphql.DeferredGroup{
927 Label: label,
928 Path: graphql.GetPath(ctx),
929 FieldSet: dfs,
930 Context: ctx,
931 })
932 }
933
934 return out
935}
936
937// endregion **************************** object.gotpl ****************************
938
939// region ***************************** type.gotpl *****************************
940
941func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
942 if v == nil {
943 return graphql.Null
944 }
945 return ec._Repository(ctx, sel, v)
946}
947
948// endregion ***************************** type.gotpl *****************************