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 AllBoards(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BoardConnection, error)
22 Board(ctx context.Context, obj *models.Repository, prefix string) (models.BoardWrapper, error)
23 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
24 Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
25 AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
26 Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
27 UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
28 ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
29}
30
31// endregion ************************** generated!.gotpl **************************
32
33// region ***************************** args.gotpl *****************************
34
35func (ec *executionContext) field_Repository_allBoards_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
36 var err error
37 args := map[string]any{}
38 arg0, err := ec.field_Repository_allBoards_argsAfter(ctx, rawArgs)
39 if err != nil {
40 return nil, err
41 }
42 args["after"] = arg0
43 arg1, err := ec.field_Repository_allBoards_argsBefore(ctx, rawArgs)
44 if err != nil {
45 return nil, err
46 }
47 args["before"] = arg1
48 arg2, err := ec.field_Repository_allBoards_argsFirst(ctx, rawArgs)
49 if err != nil {
50 return nil, err
51 }
52 args["first"] = arg2
53 arg3, err := ec.field_Repository_allBoards_argsLast(ctx, rawArgs)
54 if err != nil {
55 return nil, err
56 }
57 args["last"] = arg3
58 arg4, err := ec.field_Repository_allBoards_argsQuery(ctx, rawArgs)
59 if err != nil {
60 return nil, err
61 }
62 args["query"] = arg4
63 return args, nil
64}
65func (ec *executionContext) field_Repository_allBoards_argsAfter(
66 ctx context.Context,
67 rawArgs map[string]any,
68) (*string, error) {
69 if _, ok := rawArgs["after"]; !ok {
70 var zeroVal *string
71 return zeroVal, nil
72 }
73
74 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
75 if tmp, ok := rawArgs["after"]; ok {
76 return ec.unmarshalOString2ᚖstring(ctx, tmp)
77 }
78
79 var zeroVal *string
80 return zeroVal, nil
81}
82
83func (ec *executionContext) field_Repository_allBoards_argsBefore(
84 ctx context.Context,
85 rawArgs map[string]any,
86) (*string, error) {
87 if _, ok := rawArgs["before"]; !ok {
88 var zeroVal *string
89 return zeroVal, nil
90 }
91
92 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
93 if tmp, ok := rawArgs["before"]; ok {
94 return ec.unmarshalOString2ᚖstring(ctx, tmp)
95 }
96
97 var zeroVal *string
98 return zeroVal, nil
99}
100
101func (ec *executionContext) field_Repository_allBoards_argsFirst(
102 ctx context.Context,
103 rawArgs map[string]any,
104) (*int, error) {
105 if _, ok := rawArgs["first"]; !ok {
106 var zeroVal *int
107 return zeroVal, nil
108 }
109
110 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
111 if tmp, ok := rawArgs["first"]; ok {
112 return ec.unmarshalOInt2ᚖint(ctx, tmp)
113 }
114
115 var zeroVal *int
116 return zeroVal, nil
117}
118
119func (ec *executionContext) field_Repository_allBoards_argsLast(
120 ctx context.Context,
121 rawArgs map[string]any,
122) (*int, error) {
123 if _, ok := rawArgs["last"]; !ok {
124 var zeroVal *int
125 return zeroVal, nil
126 }
127
128 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
129 if tmp, ok := rawArgs["last"]; ok {
130 return ec.unmarshalOInt2ᚖint(ctx, tmp)
131 }
132
133 var zeroVal *int
134 return zeroVal, nil
135}
136
137func (ec *executionContext) field_Repository_allBoards_argsQuery(
138 ctx context.Context,
139 rawArgs map[string]any,
140) (*string, error) {
141 if _, ok := rawArgs["query"]; !ok {
142 var zeroVal *string
143 return zeroVal, nil
144 }
145
146 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query"))
147 if tmp, ok := rawArgs["query"]; ok {
148 return ec.unmarshalOString2ᚖstring(ctx, tmp)
149 }
150
151 var zeroVal *string
152 return zeroVal, nil
153}
154
155func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
156 var err error
157 args := map[string]any{}
158 arg0, err := ec.field_Repository_allBugs_argsAfter(ctx, rawArgs)
159 if err != nil {
160 return nil, err
161 }
162 args["after"] = arg0
163 arg1, err := ec.field_Repository_allBugs_argsBefore(ctx, rawArgs)
164 if err != nil {
165 return nil, err
166 }
167 args["before"] = arg1
168 arg2, err := ec.field_Repository_allBugs_argsFirst(ctx, rawArgs)
169 if err != nil {
170 return nil, err
171 }
172 args["first"] = arg2
173 arg3, err := ec.field_Repository_allBugs_argsLast(ctx, rawArgs)
174 if err != nil {
175 return nil, err
176 }
177 args["last"] = arg3
178 arg4, err := ec.field_Repository_allBugs_argsQuery(ctx, rawArgs)
179 if err != nil {
180 return nil, err
181 }
182 args["query"] = arg4
183 return args, nil
184}
185func (ec *executionContext) field_Repository_allBugs_argsAfter(
186 ctx context.Context,
187 rawArgs map[string]any,
188) (*string, error) {
189 if _, ok := rawArgs["after"]; !ok {
190 var zeroVal *string
191 return zeroVal, nil
192 }
193
194 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
195 if tmp, ok := rawArgs["after"]; ok {
196 return ec.unmarshalOString2ᚖstring(ctx, tmp)
197 }
198
199 var zeroVal *string
200 return zeroVal, nil
201}
202
203func (ec *executionContext) field_Repository_allBugs_argsBefore(
204 ctx context.Context,
205 rawArgs map[string]any,
206) (*string, error) {
207 if _, ok := rawArgs["before"]; !ok {
208 var zeroVal *string
209 return zeroVal, nil
210 }
211
212 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
213 if tmp, ok := rawArgs["before"]; ok {
214 return ec.unmarshalOString2ᚖstring(ctx, tmp)
215 }
216
217 var zeroVal *string
218 return zeroVal, nil
219}
220
221func (ec *executionContext) field_Repository_allBugs_argsFirst(
222 ctx context.Context,
223 rawArgs map[string]any,
224) (*int, error) {
225 if _, ok := rawArgs["first"]; !ok {
226 var zeroVal *int
227 return zeroVal, nil
228 }
229
230 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
231 if tmp, ok := rawArgs["first"]; ok {
232 return ec.unmarshalOInt2ᚖint(ctx, tmp)
233 }
234
235 var zeroVal *int
236 return zeroVal, nil
237}
238
239func (ec *executionContext) field_Repository_allBugs_argsLast(
240 ctx context.Context,
241 rawArgs map[string]any,
242) (*int, error) {
243 if _, ok := rawArgs["last"]; !ok {
244 var zeroVal *int
245 return zeroVal, nil
246 }
247
248 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
249 if tmp, ok := rawArgs["last"]; ok {
250 return ec.unmarshalOInt2ᚖint(ctx, tmp)
251 }
252
253 var zeroVal *int
254 return zeroVal, nil
255}
256
257func (ec *executionContext) field_Repository_allBugs_argsQuery(
258 ctx context.Context,
259 rawArgs map[string]any,
260) (*string, error) {
261 if _, ok := rawArgs["query"]; !ok {
262 var zeroVal *string
263 return zeroVal, nil
264 }
265
266 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query"))
267 if tmp, ok := rawArgs["query"]; ok {
268 return ec.unmarshalOString2ᚖstring(ctx, tmp)
269 }
270
271 var zeroVal *string
272 return zeroVal, nil
273}
274
275func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
276 var err error
277 args := map[string]any{}
278 arg0, err := ec.field_Repository_allIdentities_argsAfter(ctx, rawArgs)
279 if err != nil {
280 return nil, err
281 }
282 args["after"] = arg0
283 arg1, err := ec.field_Repository_allIdentities_argsBefore(ctx, rawArgs)
284 if err != nil {
285 return nil, err
286 }
287 args["before"] = arg1
288 arg2, err := ec.field_Repository_allIdentities_argsFirst(ctx, rawArgs)
289 if err != nil {
290 return nil, err
291 }
292 args["first"] = arg2
293 arg3, err := ec.field_Repository_allIdentities_argsLast(ctx, rawArgs)
294 if err != nil {
295 return nil, err
296 }
297 args["last"] = arg3
298 return args, nil
299}
300func (ec *executionContext) field_Repository_allIdentities_argsAfter(
301 ctx context.Context,
302 rawArgs map[string]any,
303) (*string, error) {
304 if _, ok := rawArgs["after"]; !ok {
305 var zeroVal *string
306 return zeroVal, nil
307 }
308
309 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
310 if tmp, ok := rawArgs["after"]; ok {
311 return ec.unmarshalOString2ᚖstring(ctx, tmp)
312 }
313
314 var zeroVal *string
315 return zeroVal, nil
316}
317
318func (ec *executionContext) field_Repository_allIdentities_argsBefore(
319 ctx context.Context,
320 rawArgs map[string]any,
321) (*string, error) {
322 if _, ok := rawArgs["before"]; !ok {
323 var zeroVal *string
324 return zeroVal, nil
325 }
326
327 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
328 if tmp, ok := rawArgs["before"]; ok {
329 return ec.unmarshalOString2ᚖstring(ctx, tmp)
330 }
331
332 var zeroVal *string
333 return zeroVal, nil
334}
335
336func (ec *executionContext) field_Repository_allIdentities_argsFirst(
337 ctx context.Context,
338 rawArgs map[string]any,
339) (*int, error) {
340 if _, ok := rawArgs["first"]; !ok {
341 var zeroVal *int
342 return zeroVal, nil
343 }
344
345 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
346 if tmp, ok := rawArgs["first"]; ok {
347 return ec.unmarshalOInt2ᚖint(ctx, tmp)
348 }
349
350 var zeroVal *int
351 return zeroVal, nil
352}
353
354func (ec *executionContext) field_Repository_allIdentities_argsLast(
355 ctx context.Context,
356 rawArgs map[string]any,
357) (*int, error) {
358 if _, ok := rawArgs["last"]; !ok {
359 var zeroVal *int
360 return zeroVal, nil
361 }
362
363 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
364 if tmp, ok := rawArgs["last"]; ok {
365 return ec.unmarshalOInt2ᚖint(ctx, tmp)
366 }
367
368 var zeroVal *int
369 return zeroVal, nil
370}
371
372func (ec *executionContext) field_Repository_board_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
373 var err error
374 args := map[string]any{}
375 arg0, err := ec.field_Repository_board_argsPrefix(ctx, rawArgs)
376 if err != nil {
377 return nil, err
378 }
379 args["prefix"] = arg0
380 return args, nil
381}
382func (ec *executionContext) field_Repository_board_argsPrefix(
383 ctx context.Context,
384 rawArgs map[string]any,
385) (string, error) {
386 if _, ok := rawArgs["prefix"]; !ok {
387 var zeroVal string
388 return zeroVal, nil
389 }
390
391 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
392 if tmp, ok := rawArgs["prefix"]; ok {
393 return ec.unmarshalNString2string(ctx, tmp)
394 }
395
396 var zeroVal string
397 return zeroVal, nil
398}
399
400func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
401 var err error
402 args := map[string]any{}
403 arg0, err := ec.field_Repository_bug_argsPrefix(ctx, rawArgs)
404 if err != nil {
405 return nil, err
406 }
407 args["prefix"] = arg0
408 return args, nil
409}
410func (ec *executionContext) field_Repository_bug_argsPrefix(
411 ctx context.Context,
412 rawArgs map[string]any,
413) (string, error) {
414 if _, ok := rawArgs["prefix"]; !ok {
415 var zeroVal string
416 return zeroVal, nil
417 }
418
419 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
420 if tmp, ok := rawArgs["prefix"]; ok {
421 return ec.unmarshalNString2string(ctx, tmp)
422 }
423
424 var zeroVal string
425 return zeroVal, nil
426}
427
428func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
429 var err error
430 args := map[string]any{}
431 arg0, err := ec.field_Repository_identity_argsPrefix(ctx, rawArgs)
432 if err != nil {
433 return nil, err
434 }
435 args["prefix"] = arg0
436 return args, nil
437}
438func (ec *executionContext) field_Repository_identity_argsPrefix(
439 ctx context.Context,
440 rawArgs map[string]any,
441) (string, error) {
442 if _, ok := rawArgs["prefix"]; !ok {
443 var zeroVal string
444 return zeroVal, nil
445 }
446
447 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
448 if tmp, ok := rawArgs["prefix"]; ok {
449 return ec.unmarshalNString2string(ctx, tmp)
450 }
451
452 var zeroVal string
453 return zeroVal, nil
454}
455
456func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
457 var err error
458 args := map[string]any{}
459 arg0, err := ec.field_Repository_validLabels_argsAfter(ctx, rawArgs)
460 if err != nil {
461 return nil, err
462 }
463 args["after"] = arg0
464 arg1, err := ec.field_Repository_validLabels_argsBefore(ctx, rawArgs)
465 if err != nil {
466 return nil, err
467 }
468 args["before"] = arg1
469 arg2, err := ec.field_Repository_validLabels_argsFirst(ctx, rawArgs)
470 if err != nil {
471 return nil, err
472 }
473 args["first"] = arg2
474 arg3, err := ec.field_Repository_validLabels_argsLast(ctx, rawArgs)
475 if err != nil {
476 return nil, err
477 }
478 args["last"] = arg3
479 return args, nil
480}
481func (ec *executionContext) field_Repository_validLabels_argsAfter(
482 ctx context.Context,
483 rawArgs map[string]any,
484) (*string, error) {
485 if _, ok := rawArgs["after"]; !ok {
486 var zeroVal *string
487 return zeroVal, nil
488 }
489
490 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
491 if tmp, ok := rawArgs["after"]; ok {
492 return ec.unmarshalOString2ᚖstring(ctx, tmp)
493 }
494
495 var zeroVal *string
496 return zeroVal, nil
497}
498
499func (ec *executionContext) field_Repository_validLabels_argsBefore(
500 ctx context.Context,
501 rawArgs map[string]any,
502) (*string, error) {
503 if _, ok := rawArgs["before"]; !ok {
504 var zeroVal *string
505 return zeroVal, nil
506 }
507
508 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
509 if tmp, ok := rawArgs["before"]; ok {
510 return ec.unmarshalOString2ᚖstring(ctx, tmp)
511 }
512
513 var zeroVal *string
514 return zeroVal, nil
515}
516
517func (ec *executionContext) field_Repository_validLabels_argsFirst(
518 ctx context.Context,
519 rawArgs map[string]any,
520) (*int, error) {
521 if _, ok := rawArgs["first"]; !ok {
522 var zeroVal *int
523 return zeroVal, nil
524 }
525
526 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
527 if tmp, ok := rawArgs["first"]; ok {
528 return ec.unmarshalOInt2ᚖint(ctx, tmp)
529 }
530
531 var zeroVal *int
532 return zeroVal, nil
533}
534
535func (ec *executionContext) field_Repository_validLabels_argsLast(
536 ctx context.Context,
537 rawArgs map[string]any,
538) (*int, error) {
539 if _, ok := rawArgs["last"]; !ok {
540 var zeroVal *int
541 return zeroVal, nil
542 }
543
544 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
545 if tmp, ok := rawArgs["last"]; ok {
546 return ec.unmarshalOInt2ᚖint(ctx, tmp)
547 }
548
549 var zeroVal *int
550 return zeroVal, nil
551}
552
553// endregion ***************************** args.gotpl *****************************
554
555// region ************************** directives.gotpl **************************
556
557// endregion ************************** directives.gotpl **************************
558
559// region **************************** field.gotpl *****************************
560
561func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
562 fc, err := ec.fieldContext_Repository_name(ctx, field)
563 if err != nil {
564 return graphql.Null
565 }
566 ctx = graphql.WithFieldContext(ctx, fc)
567 defer func() {
568 if r := recover(); r != nil {
569 ec.Error(ctx, ec.Recover(ctx, r))
570 ret = graphql.Null
571 }
572 }()
573 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
574 ctx = rctx // use context from middleware stack in children
575 return ec.resolvers.Repository().Name(rctx, obj)
576 })
577 if err != nil {
578 ec.Error(ctx, err)
579 return graphql.Null
580 }
581 if resTmp == nil {
582 return graphql.Null
583 }
584 res := resTmp.(*string)
585 fc.Result = res
586 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
587}
588
589func (ec *executionContext) fieldContext_Repository_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
590 fc = &graphql.FieldContext{
591 Object: "Repository",
592 Field: field,
593 IsMethod: true,
594 IsResolver: true,
595 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
596 return nil, errors.New("field of type String does not have child fields")
597 },
598 }
599 return fc, nil
600}
601
602func (ec *executionContext) _Repository_allBoards(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
603 fc, err := ec.fieldContext_Repository_allBoards(ctx, field)
604 if err != nil {
605 return graphql.Null
606 }
607 ctx = graphql.WithFieldContext(ctx, fc)
608 defer func() {
609 if r := recover(); r != nil {
610 ec.Error(ctx, ec.Recover(ctx, r))
611 ret = graphql.Null
612 }
613 }()
614 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
615 ctx = rctx // use context from middleware stack in children
616 return ec.resolvers.Repository().AllBoards(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int), fc.Args["query"].(*string))
617 })
618 if err != nil {
619 ec.Error(ctx, err)
620 return graphql.Null
621 }
622 if resTmp == nil {
623 if !graphql.HasFieldError(ctx, fc) {
624 ec.Errorf(ctx, "must not be null")
625 }
626 return graphql.Null
627 }
628 res := resTmp.(*models.BoardConnection)
629 fc.Result = res
630 return ec.marshalNBoardConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardConnection(ctx, field.Selections, res)
631}
632
633func (ec *executionContext) fieldContext_Repository_allBoards(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
634 fc = &graphql.FieldContext{
635 Object: "Repository",
636 Field: field,
637 IsMethod: true,
638 IsResolver: true,
639 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
640 switch field.Name {
641 case "edges":
642 return ec.fieldContext_BoardConnection_edges(ctx, field)
643 case "nodes":
644 return ec.fieldContext_BoardConnection_nodes(ctx, field)
645 case "pageInfo":
646 return ec.fieldContext_BoardConnection_pageInfo(ctx, field)
647 case "totalCount":
648 return ec.fieldContext_BoardConnection_totalCount(ctx, field)
649 }
650 return nil, fmt.Errorf("no field named %q was found under type BoardConnection", field.Name)
651 },
652 }
653 defer func() {
654 if r := recover(); r != nil {
655 err = ec.Recover(ctx, r)
656 ec.Error(ctx, err)
657 }
658 }()
659 ctx = graphql.WithFieldContext(ctx, fc)
660 if fc.Args, err = ec.field_Repository_allBoards_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
661 ec.Error(ctx, err)
662 return fc, err
663 }
664 return fc, nil
665}
666
667func (ec *executionContext) _Repository_board(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
668 fc, err := ec.fieldContext_Repository_board(ctx, field)
669 if err != nil {
670 return graphql.Null
671 }
672 ctx = graphql.WithFieldContext(ctx, fc)
673 defer func() {
674 if r := recover(); r != nil {
675 ec.Error(ctx, ec.Recover(ctx, r))
676 ret = graphql.Null
677 }
678 }()
679 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
680 ctx = rctx // use context from middleware stack in children
681 return ec.resolvers.Repository().Board(rctx, obj, fc.Args["prefix"].(string))
682 })
683 if err != nil {
684 ec.Error(ctx, err)
685 return graphql.Null
686 }
687 if resTmp == nil {
688 return graphql.Null
689 }
690 res := resTmp.(models.BoardWrapper)
691 fc.Result = res
692 return ec.marshalOBoard2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardWrapper(ctx, field.Selections, res)
693}
694
695func (ec *executionContext) fieldContext_Repository_board(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
696 fc = &graphql.FieldContext{
697 Object: "Repository",
698 Field: field,
699 IsMethod: true,
700 IsResolver: true,
701 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
702 switch field.Name {
703 case "id":
704 return ec.fieldContext_Board_id(ctx, field)
705 case "humanId":
706 return ec.fieldContext_Board_humanId(ctx, field)
707 case "createdAt":
708 return ec.fieldContext_Board_createdAt(ctx, field)
709 case "lastEdit":
710 return ec.fieldContext_Board_lastEdit(ctx, field)
711 case "title":
712 return ec.fieldContext_Board_title(ctx, field)
713 case "description":
714 return ec.fieldContext_Board_description(ctx, field)
715 case "columns":
716 return ec.fieldContext_Board_columns(ctx, field)
717 case "actors":
718 return ec.fieldContext_Board_actors(ctx, field)
719 case "operations":
720 return ec.fieldContext_Board_operations(ctx, field)
721 }
722 return nil, fmt.Errorf("no field named %q was found under type Board", field.Name)
723 },
724 }
725 defer func() {
726 if r := recover(); r != nil {
727 err = ec.Recover(ctx, r)
728 ec.Error(ctx, err)
729 }
730 }()
731 ctx = graphql.WithFieldContext(ctx, fc)
732 if fc.Args, err = ec.field_Repository_board_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
733 ec.Error(ctx, err)
734 return fc, err
735 }
736 return fc, nil
737}
738
739func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
740 fc, err := ec.fieldContext_Repository_allBugs(ctx, field)
741 if err != nil {
742 return graphql.Null
743 }
744 ctx = graphql.WithFieldContext(ctx, fc)
745 defer func() {
746 if r := recover(); r != nil {
747 ec.Error(ctx, ec.Recover(ctx, r))
748 ret = graphql.Null
749 }
750 }()
751 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
752 ctx = rctx // use context from middleware stack in children
753 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))
754 })
755 if err != nil {
756 ec.Error(ctx, err)
757 return graphql.Null
758 }
759 if resTmp == nil {
760 if !graphql.HasFieldError(ctx, fc) {
761 ec.Errorf(ctx, "must not be null")
762 }
763 return graphql.Null
764 }
765 res := resTmp.(*models.BugConnection)
766 fc.Result = res
767 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
768}
769
770func (ec *executionContext) fieldContext_Repository_allBugs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
771 fc = &graphql.FieldContext{
772 Object: "Repository",
773 Field: field,
774 IsMethod: true,
775 IsResolver: true,
776 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
777 switch field.Name {
778 case "edges":
779 return ec.fieldContext_BugConnection_edges(ctx, field)
780 case "nodes":
781 return ec.fieldContext_BugConnection_nodes(ctx, field)
782 case "pageInfo":
783 return ec.fieldContext_BugConnection_pageInfo(ctx, field)
784 case "totalCount":
785 return ec.fieldContext_BugConnection_totalCount(ctx, field)
786 }
787 return nil, fmt.Errorf("no field named %q was found under type BugConnection", field.Name)
788 },
789 }
790 defer func() {
791 if r := recover(); r != nil {
792 err = ec.Recover(ctx, r)
793 ec.Error(ctx, err)
794 }
795 }()
796 ctx = graphql.WithFieldContext(ctx, fc)
797 if fc.Args, err = ec.field_Repository_allBugs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
798 ec.Error(ctx, err)
799 return fc, err
800 }
801 return fc, nil
802}
803
804func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
805 fc, err := ec.fieldContext_Repository_bug(ctx, field)
806 if err != nil {
807 return graphql.Null
808 }
809 ctx = graphql.WithFieldContext(ctx, fc)
810 defer func() {
811 if r := recover(); r != nil {
812 ec.Error(ctx, ec.Recover(ctx, r))
813 ret = graphql.Null
814 }
815 }()
816 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
817 ctx = rctx // use context from middleware stack in children
818 return ec.resolvers.Repository().Bug(rctx, obj, fc.Args["prefix"].(string))
819 })
820 if err != nil {
821 ec.Error(ctx, err)
822 return graphql.Null
823 }
824 if resTmp == nil {
825 return graphql.Null
826 }
827 res := resTmp.(models.BugWrapper)
828 fc.Result = res
829 return ec.marshalOBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
830}
831
832func (ec *executionContext) fieldContext_Repository_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
833 fc = &graphql.FieldContext{
834 Object: "Repository",
835 Field: field,
836 IsMethod: true,
837 IsResolver: true,
838 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
839 switch field.Name {
840 case "id":
841 return ec.fieldContext_Bug_id(ctx, field)
842 case "humanId":
843 return ec.fieldContext_Bug_humanId(ctx, field)
844 case "createdAt":
845 return ec.fieldContext_Bug_createdAt(ctx, field)
846 case "lastEdit":
847 return ec.fieldContext_Bug_lastEdit(ctx, field)
848 case "status":
849 return ec.fieldContext_Bug_status(ctx, field)
850 case "title":
851 return ec.fieldContext_Bug_title(ctx, field)
852 case "labels":
853 return ec.fieldContext_Bug_labels(ctx, field)
854 case "author":
855 return ec.fieldContext_Bug_author(ctx, field)
856 case "actors":
857 return ec.fieldContext_Bug_actors(ctx, field)
858 case "participants":
859 return ec.fieldContext_Bug_participants(ctx, field)
860 case "comments":
861 return ec.fieldContext_Bug_comments(ctx, field)
862 case "timeline":
863 return ec.fieldContext_Bug_timeline(ctx, field)
864 case "operations":
865 return ec.fieldContext_Bug_operations(ctx, field)
866 }
867 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
868 },
869 }
870 defer func() {
871 if r := recover(); r != nil {
872 err = ec.Recover(ctx, r)
873 ec.Error(ctx, err)
874 }
875 }()
876 ctx = graphql.WithFieldContext(ctx, fc)
877 if fc.Args, err = ec.field_Repository_bug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
878 ec.Error(ctx, err)
879 return fc, err
880 }
881 return fc, nil
882}
883
884func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
885 fc, err := ec.fieldContext_Repository_allIdentities(ctx, field)
886 if err != nil {
887 return graphql.Null
888 }
889 ctx = graphql.WithFieldContext(ctx, fc)
890 defer func() {
891 if r := recover(); r != nil {
892 ec.Error(ctx, ec.Recover(ctx, r))
893 ret = graphql.Null
894 }
895 }()
896 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
897 ctx = rctx // use context from middleware stack in children
898 return ec.resolvers.Repository().AllIdentities(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
899 })
900 if err != nil {
901 ec.Error(ctx, err)
902 return graphql.Null
903 }
904 if resTmp == nil {
905 if !graphql.HasFieldError(ctx, fc) {
906 ec.Errorf(ctx, "must not be null")
907 }
908 return graphql.Null
909 }
910 res := resTmp.(*models.IdentityConnection)
911 fc.Result = res
912 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
913}
914
915func (ec *executionContext) fieldContext_Repository_allIdentities(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
916 fc = &graphql.FieldContext{
917 Object: "Repository",
918 Field: field,
919 IsMethod: true,
920 IsResolver: true,
921 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
922 switch field.Name {
923 case "edges":
924 return ec.fieldContext_IdentityConnection_edges(ctx, field)
925 case "nodes":
926 return ec.fieldContext_IdentityConnection_nodes(ctx, field)
927 case "pageInfo":
928 return ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
929 case "totalCount":
930 return ec.fieldContext_IdentityConnection_totalCount(ctx, field)
931 }
932 return nil, fmt.Errorf("no field named %q was found under type IdentityConnection", field.Name)
933 },
934 }
935 defer func() {
936 if r := recover(); r != nil {
937 err = ec.Recover(ctx, r)
938 ec.Error(ctx, err)
939 }
940 }()
941 ctx = graphql.WithFieldContext(ctx, fc)
942 if fc.Args, err = ec.field_Repository_allIdentities_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
943 ec.Error(ctx, err)
944 return fc, err
945 }
946 return fc, nil
947}
948
949func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
950 fc, err := ec.fieldContext_Repository_identity(ctx, field)
951 if err != nil {
952 return graphql.Null
953 }
954 ctx = graphql.WithFieldContext(ctx, fc)
955 defer func() {
956 if r := recover(); r != nil {
957 ec.Error(ctx, ec.Recover(ctx, r))
958 ret = graphql.Null
959 }
960 }()
961 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
962 ctx = rctx // use context from middleware stack in children
963 return ec.resolvers.Repository().Identity(rctx, obj, fc.Args["prefix"].(string))
964 })
965 if err != nil {
966 ec.Error(ctx, err)
967 return graphql.Null
968 }
969 if resTmp == nil {
970 return graphql.Null
971 }
972 res := resTmp.(models.IdentityWrapper)
973 fc.Result = res
974 return ec.marshalOIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
975}
976
977func (ec *executionContext) fieldContext_Repository_identity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
978 fc = &graphql.FieldContext{
979 Object: "Repository",
980 Field: field,
981 IsMethod: true,
982 IsResolver: true,
983 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
984 switch field.Name {
985 case "id":
986 return ec.fieldContext_Identity_id(ctx, field)
987 case "humanId":
988 return ec.fieldContext_Identity_humanId(ctx, field)
989 case "name":
990 return ec.fieldContext_Identity_name(ctx, field)
991 case "email":
992 return ec.fieldContext_Identity_email(ctx, field)
993 case "login":
994 return ec.fieldContext_Identity_login(ctx, field)
995 case "displayName":
996 return ec.fieldContext_Identity_displayName(ctx, field)
997 case "avatarUrl":
998 return ec.fieldContext_Identity_avatarUrl(ctx, field)
999 case "isProtected":
1000 return ec.fieldContext_Identity_isProtected(ctx, field)
1001 }
1002 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
1003 },
1004 }
1005 defer func() {
1006 if r := recover(); r != nil {
1007 err = ec.Recover(ctx, r)
1008 ec.Error(ctx, err)
1009 }
1010 }()
1011 ctx = graphql.WithFieldContext(ctx, fc)
1012 if fc.Args, err = ec.field_Repository_identity_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1013 ec.Error(ctx, err)
1014 return fc, err
1015 }
1016 return fc, nil
1017}
1018
1019func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1020 fc, err := ec.fieldContext_Repository_userIdentity(ctx, field)
1021 if err != nil {
1022 return graphql.Null
1023 }
1024 ctx = graphql.WithFieldContext(ctx, fc)
1025 defer func() {
1026 if r := recover(); r != nil {
1027 ec.Error(ctx, ec.Recover(ctx, r))
1028 ret = graphql.Null
1029 }
1030 }()
1031 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1032 ctx = rctx // use context from middleware stack in children
1033 return ec.resolvers.Repository().UserIdentity(rctx, obj)
1034 })
1035 if err != nil {
1036 ec.Error(ctx, err)
1037 return graphql.Null
1038 }
1039 if resTmp == nil {
1040 return graphql.Null
1041 }
1042 res := resTmp.(models.IdentityWrapper)
1043 fc.Result = res
1044 return ec.marshalOIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
1045}
1046
1047func (ec *executionContext) fieldContext_Repository_userIdentity(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1048 fc = &graphql.FieldContext{
1049 Object: "Repository",
1050 Field: field,
1051 IsMethod: true,
1052 IsResolver: true,
1053 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1054 switch field.Name {
1055 case "id":
1056 return ec.fieldContext_Identity_id(ctx, field)
1057 case "humanId":
1058 return ec.fieldContext_Identity_humanId(ctx, field)
1059 case "name":
1060 return ec.fieldContext_Identity_name(ctx, field)
1061 case "email":
1062 return ec.fieldContext_Identity_email(ctx, field)
1063 case "login":
1064 return ec.fieldContext_Identity_login(ctx, field)
1065 case "displayName":
1066 return ec.fieldContext_Identity_displayName(ctx, field)
1067 case "avatarUrl":
1068 return ec.fieldContext_Identity_avatarUrl(ctx, field)
1069 case "isProtected":
1070 return ec.fieldContext_Identity_isProtected(ctx, field)
1071 }
1072 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
1073 },
1074 }
1075 return fc, nil
1076}
1077
1078func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1079 fc, err := ec.fieldContext_Repository_validLabels(ctx, field)
1080 if err != nil {
1081 return graphql.Null
1082 }
1083 ctx = graphql.WithFieldContext(ctx, fc)
1084 defer func() {
1085 if r := recover(); r != nil {
1086 ec.Error(ctx, ec.Recover(ctx, r))
1087 ret = graphql.Null
1088 }
1089 }()
1090 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1091 ctx = rctx // use context from middleware stack in children
1092 return ec.resolvers.Repository().ValidLabels(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
1093 })
1094 if err != nil {
1095 ec.Error(ctx, err)
1096 return graphql.Null
1097 }
1098 if resTmp == nil {
1099 if !graphql.HasFieldError(ctx, fc) {
1100 ec.Errorf(ctx, "must not be null")
1101 }
1102 return graphql.Null
1103 }
1104 res := resTmp.(*models.LabelConnection)
1105 fc.Result = res
1106 return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
1107}
1108
1109func (ec *executionContext) fieldContext_Repository_validLabels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1110 fc = &graphql.FieldContext{
1111 Object: "Repository",
1112 Field: field,
1113 IsMethod: true,
1114 IsResolver: true,
1115 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1116 switch field.Name {
1117 case "edges":
1118 return ec.fieldContext_LabelConnection_edges(ctx, field)
1119 case "nodes":
1120 return ec.fieldContext_LabelConnection_nodes(ctx, field)
1121 case "pageInfo":
1122 return ec.fieldContext_LabelConnection_pageInfo(ctx, field)
1123 case "totalCount":
1124 return ec.fieldContext_LabelConnection_totalCount(ctx, field)
1125 }
1126 return nil, fmt.Errorf("no field named %q was found under type LabelConnection", field.Name)
1127 },
1128 }
1129 defer func() {
1130 if r := recover(); r != nil {
1131 err = ec.Recover(ctx, r)
1132 ec.Error(ctx, err)
1133 }
1134 }()
1135 ctx = graphql.WithFieldContext(ctx, fc)
1136 if fc.Args, err = ec.field_Repository_validLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1137 ec.Error(ctx, err)
1138 return fc, err
1139 }
1140 return fc, nil
1141}
1142
1143// endregion **************************** field.gotpl *****************************
1144
1145// region **************************** input.gotpl *****************************
1146
1147// endregion **************************** input.gotpl *****************************
1148
1149// region ************************** interface.gotpl ***************************
1150
1151// endregion ************************** interface.gotpl ***************************
1152
1153// region **************************** object.gotpl ****************************
1154
1155var repositoryImplementors = []string{"Repository"}
1156
1157func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
1158 fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
1159
1160 out := graphql.NewFieldSet(fields)
1161 deferred := make(map[string]*graphql.FieldSet)
1162 for i, field := range fields {
1163 switch field.Name {
1164 case "__typename":
1165 out.Values[i] = graphql.MarshalString("Repository")
1166 case "name":
1167 field := field
1168
1169 innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1170 defer func() {
1171 if r := recover(); r != nil {
1172 ec.Error(ctx, ec.Recover(ctx, r))
1173 }
1174 }()
1175 res = ec._Repository_name(ctx, field, obj)
1176 return res
1177 }
1178
1179 if field.Deferrable != nil {
1180 dfs, ok := deferred[field.Deferrable.Label]
1181 di := 0
1182 if ok {
1183 dfs.AddField(field)
1184 di = len(dfs.Values) - 1
1185 } else {
1186 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1187 deferred[field.Deferrable.Label] = dfs
1188 }
1189 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1190 return innerFunc(ctx, dfs)
1191 })
1192
1193 // don't run the out.Concurrently() call below
1194 out.Values[i] = graphql.Null
1195 continue
1196 }
1197
1198 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1199 case "allBoards":
1200 field := field
1201
1202 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1203 defer func() {
1204 if r := recover(); r != nil {
1205 ec.Error(ctx, ec.Recover(ctx, r))
1206 }
1207 }()
1208 res = ec._Repository_allBoards(ctx, field, obj)
1209 if res == graphql.Null {
1210 atomic.AddUint32(&fs.Invalids, 1)
1211 }
1212 return res
1213 }
1214
1215 if field.Deferrable != nil {
1216 dfs, ok := deferred[field.Deferrable.Label]
1217 di := 0
1218 if ok {
1219 dfs.AddField(field)
1220 di = len(dfs.Values) - 1
1221 } else {
1222 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1223 deferred[field.Deferrable.Label] = dfs
1224 }
1225 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1226 return innerFunc(ctx, dfs)
1227 })
1228
1229 // don't run the out.Concurrently() call below
1230 out.Values[i] = graphql.Null
1231 continue
1232 }
1233
1234 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1235 case "board":
1236 field := field
1237
1238 innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1239 defer func() {
1240 if r := recover(); r != nil {
1241 ec.Error(ctx, ec.Recover(ctx, r))
1242 }
1243 }()
1244 res = ec._Repository_board(ctx, field, obj)
1245 return res
1246 }
1247
1248 if field.Deferrable != nil {
1249 dfs, ok := deferred[field.Deferrable.Label]
1250 di := 0
1251 if ok {
1252 dfs.AddField(field)
1253 di = len(dfs.Values) - 1
1254 } else {
1255 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1256 deferred[field.Deferrable.Label] = dfs
1257 }
1258 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1259 return innerFunc(ctx, dfs)
1260 })
1261
1262 // don't run the out.Concurrently() call below
1263 out.Values[i] = graphql.Null
1264 continue
1265 }
1266
1267 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1268 case "allBugs":
1269 field := field
1270
1271 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1272 defer func() {
1273 if r := recover(); r != nil {
1274 ec.Error(ctx, ec.Recover(ctx, r))
1275 }
1276 }()
1277 res = ec._Repository_allBugs(ctx, field, obj)
1278 if res == graphql.Null {
1279 atomic.AddUint32(&fs.Invalids, 1)
1280 }
1281 return res
1282 }
1283
1284 if field.Deferrable != nil {
1285 dfs, ok := deferred[field.Deferrable.Label]
1286 di := 0
1287 if ok {
1288 dfs.AddField(field)
1289 di = len(dfs.Values) - 1
1290 } else {
1291 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1292 deferred[field.Deferrable.Label] = dfs
1293 }
1294 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1295 return innerFunc(ctx, dfs)
1296 })
1297
1298 // don't run the out.Concurrently() call below
1299 out.Values[i] = graphql.Null
1300 continue
1301 }
1302
1303 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1304 case "bug":
1305 field := field
1306
1307 innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1308 defer func() {
1309 if r := recover(); r != nil {
1310 ec.Error(ctx, ec.Recover(ctx, r))
1311 }
1312 }()
1313 res = ec._Repository_bug(ctx, field, obj)
1314 return res
1315 }
1316
1317 if field.Deferrable != nil {
1318 dfs, ok := deferred[field.Deferrable.Label]
1319 di := 0
1320 if ok {
1321 dfs.AddField(field)
1322 di = len(dfs.Values) - 1
1323 } else {
1324 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1325 deferred[field.Deferrable.Label] = dfs
1326 }
1327 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1328 return innerFunc(ctx, dfs)
1329 })
1330
1331 // don't run the out.Concurrently() call below
1332 out.Values[i] = graphql.Null
1333 continue
1334 }
1335
1336 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1337 case "allIdentities":
1338 field := field
1339
1340 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1341 defer func() {
1342 if r := recover(); r != nil {
1343 ec.Error(ctx, ec.Recover(ctx, r))
1344 }
1345 }()
1346 res = ec._Repository_allIdentities(ctx, field, obj)
1347 if res == graphql.Null {
1348 atomic.AddUint32(&fs.Invalids, 1)
1349 }
1350 return res
1351 }
1352
1353 if field.Deferrable != nil {
1354 dfs, ok := deferred[field.Deferrable.Label]
1355 di := 0
1356 if ok {
1357 dfs.AddField(field)
1358 di = len(dfs.Values) - 1
1359 } else {
1360 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1361 deferred[field.Deferrable.Label] = dfs
1362 }
1363 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1364 return innerFunc(ctx, dfs)
1365 })
1366
1367 // don't run the out.Concurrently() call below
1368 out.Values[i] = graphql.Null
1369 continue
1370 }
1371
1372 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1373 case "identity":
1374 field := field
1375
1376 innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1377 defer func() {
1378 if r := recover(); r != nil {
1379 ec.Error(ctx, ec.Recover(ctx, r))
1380 }
1381 }()
1382 res = ec._Repository_identity(ctx, field, obj)
1383 return res
1384 }
1385
1386 if field.Deferrable != nil {
1387 dfs, ok := deferred[field.Deferrable.Label]
1388 di := 0
1389 if ok {
1390 dfs.AddField(field)
1391 di = len(dfs.Values) - 1
1392 } else {
1393 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1394 deferred[field.Deferrable.Label] = dfs
1395 }
1396 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1397 return innerFunc(ctx, dfs)
1398 })
1399
1400 // don't run the out.Concurrently() call below
1401 out.Values[i] = graphql.Null
1402 continue
1403 }
1404
1405 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1406 case "userIdentity":
1407 field := field
1408
1409 innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1410 defer func() {
1411 if r := recover(); r != nil {
1412 ec.Error(ctx, ec.Recover(ctx, r))
1413 }
1414 }()
1415 res = ec._Repository_userIdentity(ctx, field, obj)
1416 return res
1417 }
1418
1419 if field.Deferrable != nil {
1420 dfs, ok := deferred[field.Deferrable.Label]
1421 di := 0
1422 if ok {
1423 dfs.AddField(field)
1424 di = len(dfs.Values) - 1
1425 } else {
1426 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1427 deferred[field.Deferrable.Label] = dfs
1428 }
1429 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1430 return innerFunc(ctx, dfs)
1431 })
1432
1433 // don't run the out.Concurrently() call below
1434 out.Values[i] = graphql.Null
1435 continue
1436 }
1437
1438 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1439 case "validLabels":
1440 field := field
1441
1442 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1443 defer func() {
1444 if r := recover(); r != nil {
1445 ec.Error(ctx, ec.Recover(ctx, r))
1446 }
1447 }()
1448 res = ec._Repository_validLabels(ctx, field, obj)
1449 if res == graphql.Null {
1450 atomic.AddUint32(&fs.Invalids, 1)
1451 }
1452 return res
1453 }
1454
1455 if field.Deferrable != nil {
1456 dfs, ok := deferred[field.Deferrable.Label]
1457 di := 0
1458 if ok {
1459 dfs.AddField(field)
1460 di = len(dfs.Values) - 1
1461 } else {
1462 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1463 deferred[field.Deferrable.Label] = dfs
1464 }
1465 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1466 return innerFunc(ctx, dfs)
1467 })
1468
1469 // don't run the out.Concurrently() call below
1470 out.Values[i] = graphql.Null
1471 continue
1472 }
1473
1474 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1475 default:
1476 panic("unknown field " + strconv.Quote(field.Name))
1477 }
1478 }
1479 out.Dispatch(ctx)
1480 if out.Invalids > 0 {
1481 return graphql.Null
1482 }
1483
1484 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1485
1486 for label, dfs := range deferred {
1487 ec.processDeferredGroup(graphql.DeferredGroup{
1488 Label: label,
1489 Path: graphql.GetPath(ctx),
1490 FieldSet: dfs,
1491 Context: ctx,
1492 })
1493 }
1494
1495 return out
1496}
1497
1498// endregion **************************** object.gotpl ****************************
1499
1500// region ***************************** type.gotpl *****************************
1501
1502func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
1503 if v == nil {
1504 return graphql.Null
1505 }
1506 return ec._Repository(ctx, sel, v)
1507}
1508
1509// endregion ***************************** type.gotpl *****************************