1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
2
3package graph
4
5import (
6 "bytes"
7 "context"
8 "errors"
9 "fmt"
10 "strconv"
11 "sync"
12 "time"
13
14 "github.com/99designs/gqlgen/graphql"
15 "github.com/99designs/gqlgen/graphql/introspection"
16 "github.com/MichaelMure/git-bug/bug"
17 "github.com/MichaelMure/git-bug/graphql/models"
18 "github.com/MichaelMure/git-bug/util/git"
19 "github.com/vektah/gqlparser"
20 "github.com/vektah/gqlparser/ast"
21)
22
23// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
24func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
25 return &executableSchema{
26 resolvers: cfg.Resolvers,
27 directives: cfg.Directives,
28 complexity: cfg.Complexity,
29 }
30}
31
32type Config struct {
33 Resolvers ResolverRoot
34 Directives DirectiveRoot
35 Complexity ComplexityRoot
36}
37
38type ResolverRoot interface {
39 AddCommentOperation() AddCommentOperationResolver
40 AddCommentTimelineItem() AddCommentTimelineItemResolver
41 Bug() BugResolver
42 CommentHistoryStep() CommentHistoryStepResolver
43 CreateOperation() CreateOperationResolver
44 CreateTimelineItem() CreateTimelineItemResolver
45 EditCommentOperation() EditCommentOperationResolver
46 LabelChangeOperation() LabelChangeOperationResolver
47 LabelChangeTimelineItem() LabelChangeTimelineItemResolver
48 Mutation() MutationResolver
49 Person() PersonResolver
50 Query() QueryResolver
51 Repository() RepositoryResolver
52 SetStatusOperation() SetStatusOperationResolver
53 SetStatusTimelineItem() SetStatusTimelineItemResolver
54 SetTitleOperation() SetTitleOperationResolver
55 SetTitleTimelineItem() SetTitleTimelineItemResolver
56}
57
58type DirectiveRoot struct {
59}
60
61type ComplexityRoot struct {
62 AddCommentOperation struct {
63 Hash func(childComplexity int) int
64 Author func(childComplexity int) int
65 Date func(childComplexity int) int
66 Message func(childComplexity int) int
67 Files func(childComplexity int) int
68 }
69
70 AddCommentTimelineItem struct {
71 Hash func(childComplexity int) int
72 Author func(childComplexity int) int
73 Message func(childComplexity int) int
74 MessageIsEmpty func(childComplexity int) int
75 Files func(childComplexity int) int
76 CreatedAt func(childComplexity int) int
77 LastEdit func(childComplexity int) int
78 Edited func(childComplexity int) int
79 History func(childComplexity int) int
80 }
81
82 Bug struct {
83 Id func(childComplexity int) int
84 HumanId func(childComplexity int) int
85 Status func(childComplexity int) int
86 Title func(childComplexity int) int
87 Labels func(childComplexity int) int
88 Author func(childComplexity int) int
89 CreatedAt func(childComplexity int) int
90 LastEdit func(childComplexity int) int
91 Comments func(childComplexity int, after *string, before *string, first *int, last *int) int
92 Timeline func(childComplexity int, after *string, before *string, first *int, last *int) int
93 Operations func(childComplexity int, after *string, before *string, first *int, last *int) int
94 }
95
96 BugConnection struct {
97 Edges func(childComplexity int) int
98 Nodes func(childComplexity int) int
99 PageInfo func(childComplexity int) int
100 TotalCount func(childComplexity int) int
101 }
102
103 BugEdge struct {
104 Cursor func(childComplexity int) int
105 Node func(childComplexity int) int
106 }
107
108 Comment struct {
109 Author func(childComplexity int) int
110 Message func(childComplexity int) int
111 Files func(childComplexity int) int
112 }
113
114 CommentConnection struct {
115 Edges func(childComplexity int) int
116 Nodes func(childComplexity int) int
117 PageInfo func(childComplexity int) int
118 TotalCount func(childComplexity int) int
119 }
120
121 CommentEdge struct {
122 Cursor func(childComplexity int) int
123 Node func(childComplexity int) int
124 }
125
126 CommentHistoryStep struct {
127 Message func(childComplexity int) int
128 Date func(childComplexity int) int
129 }
130
131 CreateOperation struct {
132 Hash func(childComplexity int) int
133 Author func(childComplexity int) int
134 Date func(childComplexity int) int
135 Title func(childComplexity int) int
136 Message func(childComplexity int) int
137 Files func(childComplexity int) int
138 }
139
140 CreateTimelineItem struct {
141 Hash func(childComplexity int) int
142 Author func(childComplexity int) int
143 Message func(childComplexity int) int
144 MessageIsEmpty func(childComplexity int) int
145 Files func(childComplexity int) int
146 CreatedAt func(childComplexity int) int
147 LastEdit func(childComplexity int) int
148 Edited func(childComplexity int) int
149 History func(childComplexity int) int
150 }
151
152 EditCommentOperation struct {
153 Hash func(childComplexity int) int
154 Author func(childComplexity int) int
155 Date func(childComplexity int) int
156 Target func(childComplexity int) int
157 Message func(childComplexity int) int
158 Files func(childComplexity int) int
159 }
160
161 LabelChangeOperation struct {
162 Hash func(childComplexity int) int
163 Author func(childComplexity int) int
164 Date func(childComplexity int) int
165 Added func(childComplexity int) int
166 Removed func(childComplexity int) int
167 }
168
169 LabelChangeTimelineItem struct {
170 Hash func(childComplexity int) int
171 Author func(childComplexity int) int
172 Date func(childComplexity int) int
173 Added func(childComplexity int) int
174 Removed func(childComplexity int) int
175 }
176
177 Mutation struct {
178 NewBug func(childComplexity int, repoRef *string, title string, message string, files []git.Hash) int
179 AddComment func(childComplexity int, repoRef *string, prefix string, message string, files []git.Hash) int
180 ChangeLabels func(childComplexity int, repoRef *string, prefix string, added []string, removed []string) int
181 Open func(childComplexity int, repoRef *string, prefix string) int
182 Close func(childComplexity int, repoRef *string, prefix string) int
183 SetTitle func(childComplexity int, repoRef *string, prefix string, title string) int
184 Commit func(childComplexity int, repoRef *string, prefix string) int
185 }
186
187 OperationConnection struct {
188 Edges func(childComplexity int) int
189 Nodes func(childComplexity int) int
190 PageInfo func(childComplexity int) int
191 TotalCount func(childComplexity int) int
192 }
193
194 OperationEdge struct {
195 Cursor func(childComplexity int) int
196 Node func(childComplexity int) int
197 }
198
199 PageInfo struct {
200 HasNextPage func(childComplexity int) int
201 HasPreviousPage func(childComplexity int) int
202 StartCursor func(childComplexity int) int
203 EndCursor func(childComplexity int) int
204 }
205
206 Person struct {
207 Name func(childComplexity int) int
208 Email func(childComplexity int) int
209 Login func(childComplexity int) int
210 DisplayName func(childComplexity int) int
211 AvatarUrl func(childComplexity int) int
212 }
213
214 Query struct {
215 DefaultRepository func(childComplexity int) int
216 Repository func(childComplexity int, id string) int
217 }
218
219 Repository struct {
220 AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
221 Bug func(childComplexity int, prefix string) int
222 }
223
224 SetStatusOperation struct {
225 Hash func(childComplexity int) int
226 Author func(childComplexity int) int
227 Date func(childComplexity int) int
228 Status func(childComplexity int) int
229 }
230
231 SetStatusTimelineItem struct {
232 Hash func(childComplexity int) int
233 Author func(childComplexity int) int
234 Date func(childComplexity int) int
235 Status func(childComplexity int) int
236 }
237
238 SetTitleOperation struct {
239 Hash func(childComplexity int) int
240 Author func(childComplexity int) int
241 Date func(childComplexity int) int
242 Title func(childComplexity int) int
243 Was func(childComplexity int) int
244 }
245
246 SetTitleTimelineItem struct {
247 Hash func(childComplexity int) int
248 Author func(childComplexity int) int
249 Date func(childComplexity int) int
250 Title func(childComplexity int) int
251 Was func(childComplexity int) int
252 }
253
254 TimelineItemConnection struct {
255 Edges func(childComplexity int) int
256 Nodes func(childComplexity int) int
257 PageInfo func(childComplexity int) int
258 TotalCount func(childComplexity int) int
259 }
260
261 TimelineItemEdge struct {
262 Cursor func(childComplexity int) int
263 Node func(childComplexity int) int
264 }
265}
266
267type AddCommentOperationResolver interface {
268 Date(ctx context.Context, obj *bug.AddCommentOperation) (time.Time, error)
269}
270type AddCommentTimelineItemResolver interface {
271 CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (time.Time, error)
272 LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (time.Time, error)
273}
274type BugResolver interface {
275 Status(ctx context.Context, obj *bug.Snapshot) (models.Status, error)
276
277 LastEdit(ctx context.Context, obj *bug.Snapshot) (time.Time, error)
278 Comments(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.CommentConnection, error)
279 Timeline(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.TimelineItemConnection, error)
280 Operations(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.OperationConnection, error)
281}
282type CommentHistoryStepResolver interface {
283 Date(ctx context.Context, obj *bug.CommentHistoryStep) (time.Time, error)
284}
285type CreateOperationResolver interface {
286 Date(ctx context.Context, obj *bug.CreateOperation) (time.Time, error)
287}
288type CreateTimelineItemResolver interface {
289 CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (time.Time, error)
290 LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (time.Time, error)
291}
292type EditCommentOperationResolver interface {
293 Date(ctx context.Context, obj *bug.EditCommentOperation) (time.Time, error)
294}
295type LabelChangeOperationResolver interface {
296 Date(ctx context.Context, obj *bug.LabelChangeOperation) (time.Time, error)
297}
298type LabelChangeTimelineItemResolver interface {
299 Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (time.Time, error)
300}
301type MutationResolver interface {
302 NewBug(ctx context.Context, repoRef *string, title string, message string, files []git.Hash) (bug.Snapshot, error)
303 AddComment(ctx context.Context, repoRef *string, prefix string, message string, files []git.Hash) (bug.Snapshot, error)
304 ChangeLabels(ctx context.Context, repoRef *string, prefix string, added []string, removed []string) (bug.Snapshot, error)
305 Open(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
306 Close(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
307 SetTitle(ctx context.Context, repoRef *string, prefix string, title string) (bug.Snapshot, error)
308 Commit(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
309}
310type PersonResolver interface {
311 Name(ctx context.Context, obj *bug.Person) (*string, error)
312 Email(ctx context.Context, obj *bug.Person) (*string, error)
313 Login(ctx context.Context, obj *bug.Person) (*string, error)
314
315 AvatarURL(ctx context.Context, obj *bug.Person) (*string, error)
316}
317type QueryResolver interface {
318 DefaultRepository(ctx context.Context) (*models.Repository, error)
319 Repository(ctx context.Context, id string) (*models.Repository, error)
320}
321type RepositoryResolver interface {
322 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (models.BugConnection, error)
323 Bug(ctx context.Context, obj *models.Repository, prefix string) (*bug.Snapshot, error)
324}
325type SetStatusOperationResolver interface {
326 Date(ctx context.Context, obj *bug.SetStatusOperation) (time.Time, error)
327 Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
328}
329type SetStatusTimelineItemResolver interface {
330 Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (time.Time, error)
331 Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
332}
333type SetTitleOperationResolver interface {
334 Date(ctx context.Context, obj *bug.SetTitleOperation) (time.Time, error)
335}
336type SetTitleTimelineItemResolver interface {
337 Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (time.Time, error)
338}
339
340func field_Bug_comments_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
341 args := map[string]interface{}{}
342 var arg0 *string
343 if tmp, ok := rawArgs["after"]; ok {
344 var err error
345 var ptr1 string
346 if tmp != nil {
347 ptr1, err = graphql.UnmarshalString(tmp)
348 arg0 = &ptr1
349 }
350
351 if err != nil {
352 return nil, err
353 }
354 }
355 args["after"] = arg0
356 var arg1 *string
357 if tmp, ok := rawArgs["before"]; ok {
358 var err error
359 var ptr1 string
360 if tmp != nil {
361 ptr1, err = graphql.UnmarshalString(tmp)
362 arg1 = &ptr1
363 }
364
365 if err != nil {
366 return nil, err
367 }
368 }
369 args["before"] = arg1
370 var arg2 *int
371 if tmp, ok := rawArgs["first"]; ok {
372 var err error
373 var ptr1 int
374 if tmp != nil {
375 ptr1, err = graphql.UnmarshalInt(tmp)
376 arg2 = &ptr1
377 }
378
379 if err != nil {
380 return nil, err
381 }
382 }
383 args["first"] = arg2
384 var arg3 *int
385 if tmp, ok := rawArgs["last"]; ok {
386 var err error
387 var ptr1 int
388 if tmp != nil {
389 ptr1, err = graphql.UnmarshalInt(tmp)
390 arg3 = &ptr1
391 }
392
393 if err != nil {
394 return nil, err
395 }
396 }
397 args["last"] = arg3
398 return args, nil
399
400}
401
402func field_Bug_timeline_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
403 args := map[string]interface{}{}
404 var arg0 *string
405 if tmp, ok := rawArgs["after"]; ok {
406 var err error
407 var ptr1 string
408 if tmp != nil {
409 ptr1, err = graphql.UnmarshalString(tmp)
410 arg0 = &ptr1
411 }
412
413 if err != nil {
414 return nil, err
415 }
416 }
417 args["after"] = arg0
418 var arg1 *string
419 if tmp, ok := rawArgs["before"]; ok {
420 var err error
421 var ptr1 string
422 if tmp != nil {
423 ptr1, err = graphql.UnmarshalString(tmp)
424 arg1 = &ptr1
425 }
426
427 if err != nil {
428 return nil, err
429 }
430 }
431 args["before"] = arg1
432 var arg2 *int
433 if tmp, ok := rawArgs["first"]; ok {
434 var err error
435 var ptr1 int
436 if tmp != nil {
437 ptr1, err = graphql.UnmarshalInt(tmp)
438 arg2 = &ptr1
439 }
440
441 if err != nil {
442 return nil, err
443 }
444 }
445 args["first"] = arg2
446 var arg3 *int
447 if tmp, ok := rawArgs["last"]; ok {
448 var err error
449 var ptr1 int
450 if tmp != nil {
451 ptr1, err = graphql.UnmarshalInt(tmp)
452 arg3 = &ptr1
453 }
454
455 if err != nil {
456 return nil, err
457 }
458 }
459 args["last"] = arg3
460 return args, nil
461
462}
463
464func field_Bug_operations_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
465 args := map[string]interface{}{}
466 var arg0 *string
467 if tmp, ok := rawArgs["after"]; ok {
468 var err error
469 var ptr1 string
470 if tmp != nil {
471 ptr1, err = graphql.UnmarshalString(tmp)
472 arg0 = &ptr1
473 }
474
475 if err != nil {
476 return nil, err
477 }
478 }
479 args["after"] = arg0
480 var arg1 *string
481 if tmp, ok := rawArgs["before"]; ok {
482 var err error
483 var ptr1 string
484 if tmp != nil {
485 ptr1, err = graphql.UnmarshalString(tmp)
486 arg1 = &ptr1
487 }
488
489 if err != nil {
490 return nil, err
491 }
492 }
493 args["before"] = arg1
494 var arg2 *int
495 if tmp, ok := rawArgs["first"]; ok {
496 var err error
497 var ptr1 int
498 if tmp != nil {
499 ptr1, err = graphql.UnmarshalInt(tmp)
500 arg2 = &ptr1
501 }
502
503 if err != nil {
504 return nil, err
505 }
506 }
507 args["first"] = arg2
508 var arg3 *int
509 if tmp, ok := rawArgs["last"]; ok {
510 var err error
511 var ptr1 int
512 if tmp != nil {
513 ptr1, err = graphql.UnmarshalInt(tmp)
514 arg3 = &ptr1
515 }
516
517 if err != nil {
518 return nil, err
519 }
520 }
521 args["last"] = arg3
522 return args, nil
523
524}
525
526func field_Mutation_newBug_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
527 args := map[string]interface{}{}
528 var arg0 *string
529 if tmp, ok := rawArgs["repoRef"]; ok {
530 var err error
531 var ptr1 string
532 if tmp != nil {
533 ptr1, err = graphql.UnmarshalString(tmp)
534 arg0 = &ptr1
535 }
536
537 if err != nil {
538 return nil, err
539 }
540 }
541 args["repoRef"] = arg0
542 var arg1 string
543 if tmp, ok := rawArgs["title"]; ok {
544 var err error
545 arg1, err = graphql.UnmarshalString(tmp)
546 if err != nil {
547 return nil, err
548 }
549 }
550 args["title"] = arg1
551 var arg2 string
552 if tmp, ok := rawArgs["message"]; ok {
553 var err error
554 arg2, err = graphql.UnmarshalString(tmp)
555 if err != nil {
556 return nil, err
557 }
558 }
559 args["message"] = arg2
560 var arg3 []git.Hash
561 if tmp, ok := rawArgs["files"]; ok {
562 var err error
563 var rawIf1 []interface{}
564 if tmp != nil {
565 if tmp1, ok := tmp.([]interface{}); ok {
566 rawIf1 = tmp1
567 } else {
568 rawIf1 = []interface{}{tmp}
569 }
570 }
571 arg3 = make([]git.Hash, len(rawIf1))
572 for idx1 := range rawIf1 {
573 err = (&arg3[idx1]).UnmarshalGQL(rawIf1[idx1])
574 }
575 if err != nil {
576 return nil, err
577 }
578 }
579 args["files"] = arg3
580 return args, nil
581
582}
583
584func field_Mutation_addComment_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
585 args := map[string]interface{}{}
586 var arg0 *string
587 if tmp, ok := rawArgs["repoRef"]; ok {
588 var err error
589 var ptr1 string
590 if tmp != nil {
591 ptr1, err = graphql.UnmarshalString(tmp)
592 arg0 = &ptr1
593 }
594
595 if err != nil {
596 return nil, err
597 }
598 }
599 args["repoRef"] = arg0
600 var arg1 string
601 if tmp, ok := rawArgs["prefix"]; ok {
602 var err error
603 arg1, err = graphql.UnmarshalString(tmp)
604 if err != nil {
605 return nil, err
606 }
607 }
608 args["prefix"] = arg1
609 var arg2 string
610 if tmp, ok := rawArgs["message"]; ok {
611 var err error
612 arg2, err = graphql.UnmarshalString(tmp)
613 if err != nil {
614 return nil, err
615 }
616 }
617 args["message"] = arg2
618 var arg3 []git.Hash
619 if tmp, ok := rawArgs["files"]; ok {
620 var err error
621 var rawIf1 []interface{}
622 if tmp != nil {
623 if tmp1, ok := tmp.([]interface{}); ok {
624 rawIf1 = tmp1
625 } else {
626 rawIf1 = []interface{}{tmp}
627 }
628 }
629 arg3 = make([]git.Hash, len(rawIf1))
630 for idx1 := range rawIf1 {
631 err = (&arg3[idx1]).UnmarshalGQL(rawIf1[idx1])
632 }
633 if err != nil {
634 return nil, err
635 }
636 }
637 args["files"] = arg3
638 return args, nil
639
640}
641
642func field_Mutation_changeLabels_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
643 args := map[string]interface{}{}
644 var arg0 *string
645 if tmp, ok := rawArgs["repoRef"]; ok {
646 var err error
647 var ptr1 string
648 if tmp != nil {
649 ptr1, err = graphql.UnmarshalString(tmp)
650 arg0 = &ptr1
651 }
652
653 if err != nil {
654 return nil, err
655 }
656 }
657 args["repoRef"] = arg0
658 var arg1 string
659 if tmp, ok := rawArgs["prefix"]; ok {
660 var err error
661 arg1, err = graphql.UnmarshalString(tmp)
662 if err != nil {
663 return nil, err
664 }
665 }
666 args["prefix"] = arg1
667 var arg2 []string
668 if tmp, ok := rawArgs["added"]; ok {
669 var err error
670 var rawIf1 []interface{}
671 if tmp != nil {
672 if tmp1, ok := tmp.([]interface{}); ok {
673 rawIf1 = tmp1
674 } else {
675 rawIf1 = []interface{}{tmp}
676 }
677 }
678 arg2 = make([]string, len(rawIf1))
679 for idx1 := range rawIf1 {
680 arg2[idx1], err = graphql.UnmarshalString(rawIf1[idx1])
681 }
682 if err != nil {
683 return nil, err
684 }
685 }
686 args["added"] = arg2
687 var arg3 []string
688 if tmp, ok := rawArgs["removed"]; ok {
689 var err error
690 var rawIf1 []interface{}
691 if tmp != nil {
692 if tmp1, ok := tmp.([]interface{}); ok {
693 rawIf1 = tmp1
694 } else {
695 rawIf1 = []interface{}{tmp}
696 }
697 }
698 arg3 = make([]string, len(rawIf1))
699 for idx1 := range rawIf1 {
700 arg3[idx1], err = graphql.UnmarshalString(rawIf1[idx1])
701 }
702 if err != nil {
703 return nil, err
704 }
705 }
706 args["removed"] = arg3
707 return args, nil
708
709}
710
711func field_Mutation_open_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
712 args := map[string]interface{}{}
713 var arg0 *string
714 if tmp, ok := rawArgs["repoRef"]; ok {
715 var err error
716 var ptr1 string
717 if tmp != nil {
718 ptr1, err = graphql.UnmarshalString(tmp)
719 arg0 = &ptr1
720 }
721
722 if err != nil {
723 return nil, err
724 }
725 }
726 args["repoRef"] = arg0
727 var arg1 string
728 if tmp, ok := rawArgs["prefix"]; ok {
729 var err error
730 arg1, err = graphql.UnmarshalString(tmp)
731 if err != nil {
732 return nil, err
733 }
734 }
735 args["prefix"] = arg1
736 return args, nil
737
738}
739
740func field_Mutation_close_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
741 args := map[string]interface{}{}
742 var arg0 *string
743 if tmp, ok := rawArgs["repoRef"]; ok {
744 var err error
745 var ptr1 string
746 if tmp != nil {
747 ptr1, err = graphql.UnmarshalString(tmp)
748 arg0 = &ptr1
749 }
750
751 if err != nil {
752 return nil, err
753 }
754 }
755 args["repoRef"] = arg0
756 var arg1 string
757 if tmp, ok := rawArgs["prefix"]; ok {
758 var err error
759 arg1, err = graphql.UnmarshalString(tmp)
760 if err != nil {
761 return nil, err
762 }
763 }
764 args["prefix"] = arg1
765 return args, nil
766
767}
768
769func field_Mutation_setTitle_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
770 args := map[string]interface{}{}
771 var arg0 *string
772 if tmp, ok := rawArgs["repoRef"]; ok {
773 var err error
774 var ptr1 string
775 if tmp != nil {
776 ptr1, err = graphql.UnmarshalString(tmp)
777 arg0 = &ptr1
778 }
779
780 if err != nil {
781 return nil, err
782 }
783 }
784 args["repoRef"] = arg0
785 var arg1 string
786 if tmp, ok := rawArgs["prefix"]; ok {
787 var err error
788 arg1, err = graphql.UnmarshalString(tmp)
789 if err != nil {
790 return nil, err
791 }
792 }
793 args["prefix"] = arg1
794 var arg2 string
795 if tmp, ok := rawArgs["title"]; ok {
796 var err error
797 arg2, err = graphql.UnmarshalString(tmp)
798 if err != nil {
799 return nil, err
800 }
801 }
802 args["title"] = arg2
803 return args, nil
804
805}
806
807func field_Mutation_commit_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
808 args := map[string]interface{}{}
809 var arg0 *string
810 if tmp, ok := rawArgs["repoRef"]; ok {
811 var err error
812 var ptr1 string
813 if tmp != nil {
814 ptr1, err = graphql.UnmarshalString(tmp)
815 arg0 = &ptr1
816 }
817
818 if err != nil {
819 return nil, err
820 }
821 }
822 args["repoRef"] = arg0
823 var arg1 string
824 if tmp, ok := rawArgs["prefix"]; ok {
825 var err error
826 arg1, err = graphql.UnmarshalString(tmp)
827 if err != nil {
828 return nil, err
829 }
830 }
831 args["prefix"] = arg1
832 return args, nil
833
834}
835
836func field_Query_repository_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
837 args := map[string]interface{}{}
838 var arg0 string
839 if tmp, ok := rawArgs["id"]; ok {
840 var err error
841 arg0, err = graphql.UnmarshalString(tmp)
842 if err != nil {
843 return nil, err
844 }
845 }
846 args["id"] = arg0
847 return args, nil
848
849}
850
851func field_Query___type_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
852 args := map[string]interface{}{}
853 var arg0 string
854 if tmp, ok := rawArgs["name"]; ok {
855 var err error
856 arg0, err = graphql.UnmarshalString(tmp)
857 if err != nil {
858 return nil, err
859 }
860 }
861 args["name"] = arg0
862 return args, nil
863
864}
865
866func field_Repository_allBugs_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
867 args := map[string]interface{}{}
868 var arg0 *string
869 if tmp, ok := rawArgs["after"]; ok {
870 var err error
871 var ptr1 string
872 if tmp != nil {
873 ptr1, err = graphql.UnmarshalString(tmp)
874 arg0 = &ptr1
875 }
876
877 if err != nil {
878 return nil, err
879 }
880 }
881 args["after"] = arg0
882 var arg1 *string
883 if tmp, ok := rawArgs["before"]; ok {
884 var err error
885 var ptr1 string
886 if tmp != nil {
887 ptr1, err = graphql.UnmarshalString(tmp)
888 arg1 = &ptr1
889 }
890
891 if err != nil {
892 return nil, err
893 }
894 }
895 args["before"] = arg1
896 var arg2 *int
897 if tmp, ok := rawArgs["first"]; ok {
898 var err error
899 var ptr1 int
900 if tmp != nil {
901 ptr1, err = graphql.UnmarshalInt(tmp)
902 arg2 = &ptr1
903 }
904
905 if err != nil {
906 return nil, err
907 }
908 }
909 args["first"] = arg2
910 var arg3 *int
911 if tmp, ok := rawArgs["last"]; ok {
912 var err error
913 var ptr1 int
914 if tmp != nil {
915 ptr1, err = graphql.UnmarshalInt(tmp)
916 arg3 = &ptr1
917 }
918
919 if err != nil {
920 return nil, err
921 }
922 }
923 args["last"] = arg3
924 var arg4 *string
925 if tmp, ok := rawArgs["query"]; ok {
926 var err error
927 var ptr1 string
928 if tmp != nil {
929 ptr1, err = graphql.UnmarshalString(tmp)
930 arg4 = &ptr1
931 }
932
933 if err != nil {
934 return nil, err
935 }
936 }
937 args["query"] = arg4
938 return args, nil
939
940}
941
942func field_Repository_bug_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
943 args := map[string]interface{}{}
944 var arg0 string
945 if tmp, ok := rawArgs["prefix"]; ok {
946 var err error
947 arg0, err = graphql.UnmarshalString(tmp)
948 if err != nil {
949 return nil, err
950 }
951 }
952 args["prefix"] = arg0
953 return args, nil
954
955}
956
957func field___Type_fields_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
958 args := map[string]interface{}{}
959 var arg0 bool
960 if tmp, ok := rawArgs["includeDeprecated"]; ok {
961 var err error
962 arg0, err = graphql.UnmarshalBoolean(tmp)
963 if err != nil {
964 return nil, err
965 }
966 }
967 args["includeDeprecated"] = arg0
968 return args, nil
969
970}
971
972func field___Type_enumValues_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
973 args := map[string]interface{}{}
974 var arg0 bool
975 if tmp, ok := rawArgs["includeDeprecated"]; ok {
976 var err error
977 arg0, err = graphql.UnmarshalBoolean(tmp)
978 if err != nil {
979 return nil, err
980 }
981 }
982 args["includeDeprecated"] = arg0
983 return args, nil
984
985}
986
987type executableSchema struct {
988 resolvers ResolverRoot
989 directives DirectiveRoot
990 complexity ComplexityRoot
991}
992
993func (e *executableSchema) Schema() *ast.Schema {
994 return parsedSchema
995}
996
997func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
998 switch typeName + "." + field {
999
1000 case "AddCommentOperation.hash":
1001 if e.complexity.AddCommentOperation.Hash == nil {
1002 break
1003 }
1004
1005 return e.complexity.AddCommentOperation.Hash(childComplexity), true
1006
1007 case "AddCommentOperation.author":
1008 if e.complexity.AddCommentOperation.Author == nil {
1009 break
1010 }
1011
1012 return e.complexity.AddCommentOperation.Author(childComplexity), true
1013
1014 case "AddCommentOperation.date":
1015 if e.complexity.AddCommentOperation.Date == nil {
1016 break
1017 }
1018
1019 return e.complexity.AddCommentOperation.Date(childComplexity), true
1020
1021 case "AddCommentOperation.message":
1022 if e.complexity.AddCommentOperation.Message == nil {
1023 break
1024 }
1025
1026 return e.complexity.AddCommentOperation.Message(childComplexity), true
1027
1028 case "AddCommentOperation.files":
1029 if e.complexity.AddCommentOperation.Files == nil {
1030 break
1031 }
1032
1033 return e.complexity.AddCommentOperation.Files(childComplexity), true
1034
1035 case "AddCommentTimelineItem.hash":
1036 if e.complexity.AddCommentTimelineItem.Hash == nil {
1037 break
1038 }
1039
1040 return e.complexity.AddCommentTimelineItem.Hash(childComplexity), true
1041
1042 case "AddCommentTimelineItem.author":
1043 if e.complexity.AddCommentTimelineItem.Author == nil {
1044 break
1045 }
1046
1047 return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
1048
1049 case "AddCommentTimelineItem.message":
1050 if e.complexity.AddCommentTimelineItem.Message == nil {
1051 break
1052 }
1053
1054 return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
1055
1056 case "AddCommentTimelineItem.messageIsEmpty":
1057 if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
1058 break
1059 }
1060
1061 return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
1062
1063 case "AddCommentTimelineItem.files":
1064 if e.complexity.AddCommentTimelineItem.Files == nil {
1065 break
1066 }
1067
1068 return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
1069
1070 case "AddCommentTimelineItem.createdAt":
1071 if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
1072 break
1073 }
1074
1075 return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
1076
1077 case "AddCommentTimelineItem.lastEdit":
1078 if e.complexity.AddCommentTimelineItem.LastEdit == nil {
1079 break
1080 }
1081
1082 return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
1083
1084 case "AddCommentTimelineItem.edited":
1085 if e.complexity.AddCommentTimelineItem.Edited == nil {
1086 break
1087 }
1088
1089 return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
1090
1091 case "AddCommentTimelineItem.history":
1092 if e.complexity.AddCommentTimelineItem.History == nil {
1093 break
1094 }
1095
1096 return e.complexity.AddCommentTimelineItem.History(childComplexity), true
1097
1098 case "Bug.id":
1099 if e.complexity.Bug.Id == nil {
1100 break
1101 }
1102
1103 return e.complexity.Bug.Id(childComplexity), true
1104
1105 case "Bug.humanId":
1106 if e.complexity.Bug.HumanId == nil {
1107 break
1108 }
1109
1110 return e.complexity.Bug.HumanId(childComplexity), true
1111
1112 case "Bug.status":
1113 if e.complexity.Bug.Status == nil {
1114 break
1115 }
1116
1117 return e.complexity.Bug.Status(childComplexity), true
1118
1119 case "Bug.title":
1120 if e.complexity.Bug.Title == nil {
1121 break
1122 }
1123
1124 return e.complexity.Bug.Title(childComplexity), true
1125
1126 case "Bug.labels":
1127 if e.complexity.Bug.Labels == nil {
1128 break
1129 }
1130
1131 return e.complexity.Bug.Labels(childComplexity), true
1132
1133 case "Bug.author":
1134 if e.complexity.Bug.Author == nil {
1135 break
1136 }
1137
1138 return e.complexity.Bug.Author(childComplexity), true
1139
1140 case "Bug.createdAt":
1141 if e.complexity.Bug.CreatedAt == nil {
1142 break
1143 }
1144
1145 return e.complexity.Bug.CreatedAt(childComplexity), true
1146
1147 case "Bug.lastEdit":
1148 if e.complexity.Bug.LastEdit == nil {
1149 break
1150 }
1151
1152 return e.complexity.Bug.LastEdit(childComplexity), true
1153
1154 case "Bug.comments":
1155 if e.complexity.Bug.Comments == nil {
1156 break
1157 }
1158
1159 args, err := field_Bug_comments_args(rawArgs)
1160 if err != nil {
1161 return 0, false
1162 }
1163
1164 return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1165
1166 case "Bug.timeline":
1167 if e.complexity.Bug.Timeline == nil {
1168 break
1169 }
1170
1171 args, err := field_Bug_timeline_args(rawArgs)
1172 if err != nil {
1173 return 0, false
1174 }
1175
1176 return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1177
1178 case "Bug.operations":
1179 if e.complexity.Bug.Operations == nil {
1180 break
1181 }
1182
1183 args, err := field_Bug_operations_args(rawArgs)
1184 if err != nil {
1185 return 0, false
1186 }
1187
1188 return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1189
1190 case "BugConnection.edges":
1191 if e.complexity.BugConnection.Edges == nil {
1192 break
1193 }
1194
1195 return e.complexity.BugConnection.Edges(childComplexity), true
1196
1197 case "BugConnection.nodes":
1198 if e.complexity.BugConnection.Nodes == nil {
1199 break
1200 }
1201
1202 return e.complexity.BugConnection.Nodes(childComplexity), true
1203
1204 case "BugConnection.pageInfo":
1205 if e.complexity.BugConnection.PageInfo == nil {
1206 break
1207 }
1208
1209 return e.complexity.BugConnection.PageInfo(childComplexity), true
1210
1211 case "BugConnection.totalCount":
1212 if e.complexity.BugConnection.TotalCount == nil {
1213 break
1214 }
1215
1216 return e.complexity.BugConnection.TotalCount(childComplexity), true
1217
1218 case "BugEdge.cursor":
1219 if e.complexity.BugEdge.Cursor == nil {
1220 break
1221 }
1222
1223 return e.complexity.BugEdge.Cursor(childComplexity), true
1224
1225 case "BugEdge.node":
1226 if e.complexity.BugEdge.Node == nil {
1227 break
1228 }
1229
1230 return e.complexity.BugEdge.Node(childComplexity), true
1231
1232 case "Comment.author":
1233 if e.complexity.Comment.Author == nil {
1234 break
1235 }
1236
1237 return e.complexity.Comment.Author(childComplexity), true
1238
1239 case "Comment.message":
1240 if e.complexity.Comment.Message == nil {
1241 break
1242 }
1243
1244 return e.complexity.Comment.Message(childComplexity), true
1245
1246 case "Comment.files":
1247 if e.complexity.Comment.Files == nil {
1248 break
1249 }
1250
1251 return e.complexity.Comment.Files(childComplexity), true
1252
1253 case "CommentConnection.edges":
1254 if e.complexity.CommentConnection.Edges == nil {
1255 break
1256 }
1257
1258 return e.complexity.CommentConnection.Edges(childComplexity), true
1259
1260 case "CommentConnection.nodes":
1261 if e.complexity.CommentConnection.Nodes == nil {
1262 break
1263 }
1264
1265 return e.complexity.CommentConnection.Nodes(childComplexity), true
1266
1267 case "CommentConnection.pageInfo":
1268 if e.complexity.CommentConnection.PageInfo == nil {
1269 break
1270 }
1271
1272 return e.complexity.CommentConnection.PageInfo(childComplexity), true
1273
1274 case "CommentConnection.totalCount":
1275 if e.complexity.CommentConnection.TotalCount == nil {
1276 break
1277 }
1278
1279 return e.complexity.CommentConnection.TotalCount(childComplexity), true
1280
1281 case "CommentEdge.cursor":
1282 if e.complexity.CommentEdge.Cursor == nil {
1283 break
1284 }
1285
1286 return e.complexity.CommentEdge.Cursor(childComplexity), true
1287
1288 case "CommentEdge.node":
1289 if e.complexity.CommentEdge.Node == nil {
1290 break
1291 }
1292
1293 return e.complexity.CommentEdge.Node(childComplexity), true
1294
1295 case "CommentHistoryStep.message":
1296 if e.complexity.CommentHistoryStep.Message == nil {
1297 break
1298 }
1299
1300 return e.complexity.CommentHistoryStep.Message(childComplexity), true
1301
1302 case "CommentHistoryStep.date":
1303 if e.complexity.CommentHistoryStep.Date == nil {
1304 break
1305 }
1306
1307 return e.complexity.CommentHistoryStep.Date(childComplexity), true
1308
1309 case "CreateOperation.hash":
1310 if e.complexity.CreateOperation.Hash == nil {
1311 break
1312 }
1313
1314 return e.complexity.CreateOperation.Hash(childComplexity), true
1315
1316 case "CreateOperation.author":
1317 if e.complexity.CreateOperation.Author == nil {
1318 break
1319 }
1320
1321 return e.complexity.CreateOperation.Author(childComplexity), true
1322
1323 case "CreateOperation.date":
1324 if e.complexity.CreateOperation.Date == nil {
1325 break
1326 }
1327
1328 return e.complexity.CreateOperation.Date(childComplexity), true
1329
1330 case "CreateOperation.title":
1331 if e.complexity.CreateOperation.Title == nil {
1332 break
1333 }
1334
1335 return e.complexity.CreateOperation.Title(childComplexity), true
1336
1337 case "CreateOperation.message":
1338 if e.complexity.CreateOperation.Message == nil {
1339 break
1340 }
1341
1342 return e.complexity.CreateOperation.Message(childComplexity), true
1343
1344 case "CreateOperation.files":
1345 if e.complexity.CreateOperation.Files == nil {
1346 break
1347 }
1348
1349 return e.complexity.CreateOperation.Files(childComplexity), true
1350
1351 case "CreateTimelineItem.hash":
1352 if e.complexity.CreateTimelineItem.Hash == nil {
1353 break
1354 }
1355
1356 return e.complexity.CreateTimelineItem.Hash(childComplexity), true
1357
1358 case "CreateTimelineItem.author":
1359 if e.complexity.CreateTimelineItem.Author == nil {
1360 break
1361 }
1362
1363 return e.complexity.CreateTimelineItem.Author(childComplexity), true
1364
1365 case "CreateTimelineItem.message":
1366 if e.complexity.CreateTimelineItem.Message == nil {
1367 break
1368 }
1369
1370 return e.complexity.CreateTimelineItem.Message(childComplexity), true
1371
1372 case "CreateTimelineItem.messageIsEmpty":
1373 if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
1374 break
1375 }
1376
1377 return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
1378
1379 case "CreateTimelineItem.files":
1380 if e.complexity.CreateTimelineItem.Files == nil {
1381 break
1382 }
1383
1384 return e.complexity.CreateTimelineItem.Files(childComplexity), true
1385
1386 case "CreateTimelineItem.createdAt":
1387 if e.complexity.CreateTimelineItem.CreatedAt == nil {
1388 break
1389 }
1390
1391 return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
1392
1393 case "CreateTimelineItem.lastEdit":
1394 if e.complexity.CreateTimelineItem.LastEdit == nil {
1395 break
1396 }
1397
1398 return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
1399
1400 case "CreateTimelineItem.edited":
1401 if e.complexity.CreateTimelineItem.Edited == nil {
1402 break
1403 }
1404
1405 return e.complexity.CreateTimelineItem.Edited(childComplexity), true
1406
1407 case "CreateTimelineItem.history":
1408 if e.complexity.CreateTimelineItem.History == nil {
1409 break
1410 }
1411
1412 return e.complexity.CreateTimelineItem.History(childComplexity), true
1413
1414 case "EditCommentOperation.hash":
1415 if e.complexity.EditCommentOperation.Hash == nil {
1416 break
1417 }
1418
1419 return e.complexity.EditCommentOperation.Hash(childComplexity), true
1420
1421 case "EditCommentOperation.author":
1422 if e.complexity.EditCommentOperation.Author == nil {
1423 break
1424 }
1425
1426 return e.complexity.EditCommentOperation.Author(childComplexity), true
1427
1428 case "EditCommentOperation.date":
1429 if e.complexity.EditCommentOperation.Date == nil {
1430 break
1431 }
1432
1433 return e.complexity.EditCommentOperation.Date(childComplexity), true
1434
1435 case "EditCommentOperation.target":
1436 if e.complexity.EditCommentOperation.Target == nil {
1437 break
1438 }
1439
1440 return e.complexity.EditCommentOperation.Target(childComplexity), true
1441
1442 case "EditCommentOperation.message":
1443 if e.complexity.EditCommentOperation.Message == nil {
1444 break
1445 }
1446
1447 return e.complexity.EditCommentOperation.Message(childComplexity), true
1448
1449 case "EditCommentOperation.files":
1450 if e.complexity.EditCommentOperation.Files == nil {
1451 break
1452 }
1453
1454 return e.complexity.EditCommentOperation.Files(childComplexity), true
1455
1456 case "LabelChangeOperation.hash":
1457 if e.complexity.LabelChangeOperation.Hash == nil {
1458 break
1459 }
1460
1461 return e.complexity.LabelChangeOperation.Hash(childComplexity), true
1462
1463 case "LabelChangeOperation.author":
1464 if e.complexity.LabelChangeOperation.Author == nil {
1465 break
1466 }
1467
1468 return e.complexity.LabelChangeOperation.Author(childComplexity), true
1469
1470 case "LabelChangeOperation.date":
1471 if e.complexity.LabelChangeOperation.Date == nil {
1472 break
1473 }
1474
1475 return e.complexity.LabelChangeOperation.Date(childComplexity), true
1476
1477 case "LabelChangeOperation.added":
1478 if e.complexity.LabelChangeOperation.Added == nil {
1479 break
1480 }
1481
1482 return e.complexity.LabelChangeOperation.Added(childComplexity), true
1483
1484 case "LabelChangeOperation.removed":
1485 if e.complexity.LabelChangeOperation.Removed == nil {
1486 break
1487 }
1488
1489 return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1490
1491 case "LabelChangeTimelineItem.hash":
1492 if e.complexity.LabelChangeTimelineItem.Hash == nil {
1493 break
1494 }
1495
1496 return e.complexity.LabelChangeTimelineItem.Hash(childComplexity), true
1497
1498 case "LabelChangeTimelineItem.author":
1499 if e.complexity.LabelChangeTimelineItem.Author == nil {
1500 break
1501 }
1502
1503 return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
1504
1505 case "LabelChangeTimelineItem.date":
1506 if e.complexity.LabelChangeTimelineItem.Date == nil {
1507 break
1508 }
1509
1510 return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
1511
1512 case "LabelChangeTimelineItem.added":
1513 if e.complexity.LabelChangeTimelineItem.Added == nil {
1514 break
1515 }
1516
1517 return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
1518
1519 case "LabelChangeTimelineItem.removed":
1520 if e.complexity.LabelChangeTimelineItem.Removed == nil {
1521 break
1522 }
1523
1524 return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
1525
1526 case "Mutation.newBug":
1527 if e.complexity.Mutation.NewBug == nil {
1528 break
1529 }
1530
1531 args, err := field_Mutation_newBug_args(rawArgs)
1532 if err != nil {
1533 return 0, false
1534 }
1535
1536 return e.complexity.Mutation.NewBug(childComplexity, args["repoRef"].(*string), args["title"].(string), args["message"].(string), args["files"].([]git.Hash)), true
1537
1538 case "Mutation.addComment":
1539 if e.complexity.Mutation.AddComment == nil {
1540 break
1541 }
1542
1543 args, err := field_Mutation_addComment_args(rawArgs)
1544 if err != nil {
1545 return 0, false
1546 }
1547
1548 return e.complexity.Mutation.AddComment(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["message"].(string), args["files"].([]git.Hash)), true
1549
1550 case "Mutation.changeLabels":
1551 if e.complexity.Mutation.ChangeLabels == nil {
1552 break
1553 }
1554
1555 args, err := field_Mutation_changeLabels_args(rawArgs)
1556 if err != nil {
1557 return 0, false
1558 }
1559
1560 return e.complexity.Mutation.ChangeLabels(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["added"].([]string), args["removed"].([]string)), true
1561
1562 case "Mutation.open":
1563 if e.complexity.Mutation.Open == nil {
1564 break
1565 }
1566
1567 args, err := field_Mutation_open_args(rawArgs)
1568 if err != nil {
1569 return 0, false
1570 }
1571
1572 return e.complexity.Mutation.Open(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1573
1574 case "Mutation.close":
1575 if e.complexity.Mutation.Close == nil {
1576 break
1577 }
1578
1579 args, err := field_Mutation_close_args(rawArgs)
1580 if err != nil {
1581 return 0, false
1582 }
1583
1584 return e.complexity.Mutation.Close(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1585
1586 case "Mutation.setTitle":
1587 if e.complexity.Mutation.SetTitle == nil {
1588 break
1589 }
1590
1591 args, err := field_Mutation_setTitle_args(rawArgs)
1592 if err != nil {
1593 return 0, false
1594 }
1595
1596 return e.complexity.Mutation.SetTitle(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["title"].(string)), true
1597
1598 case "Mutation.commit":
1599 if e.complexity.Mutation.Commit == nil {
1600 break
1601 }
1602
1603 args, err := field_Mutation_commit_args(rawArgs)
1604 if err != nil {
1605 return 0, false
1606 }
1607
1608 return e.complexity.Mutation.Commit(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1609
1610 case "OperationConnection.edges":
1611 if e.complexity.OperationConnection.Edges == nil {
1612 break
1613 }
1614
1615 return e.complexity.OperationConnection.Edges(childComplexity), true
1616
1617 case "OperationConnection.nodes":
1618 if e.complexity.OperationConnection.Nodes == nil {
1619 break
1620 }
1621
1622 return e.complexity.OperationConnection.Nodes(childComplexity), true
1623
1624 case "OperationConnection.pageInfo":
1625 if e.complexity.OperationConnection.PageInfo == nil {
1626 break
1627 }
1628
1629 return e.complexity.OperationConnection.PageInfo(childComplexity), true
1630
1631 case "OperationConnection.totalCount":
1632 if e.complexity.OperationConnection.TotalCount == nil {
1633 break
1634 }
1635
1636 return e.complexity.OperationConnection.TotalCount(childComplexity), true
1637
1638 case "OperationEdge.cursor":
1639 if e.complexity.OperationEdge.Cursor == nil {
1640 break
1641 }
1642
1643 return e.complexity.OperationEdge.Cursor(childComplexity), true
1644
1645 case "OperationEdge.node":
1646 if e.complexity.OperationEdge.Node == nil {
1647 break
1648 }
1649
1650 return e.complexity.OperationEdge.Node(childComplexity), true
1651
1652 case "PageInfo.hasNextPage":
1653 if e.complexity.PageInfo.HasNextPage == nil {
1654 break
1655 }
1656
1657 return e.complexity.PageInfo.HasNextPage(childComplexity), true
1658
1659 case "PageInfo.hasPreviousPage":
1660 if e.complexity.PageInfo.HasPreviousPage == nil {
1661 break
1662 }
1663
1664 return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1665
1666 case "PageInfo.startCursor":
1667 if e.complexity.PageInfo.StartCursor == nil {
1668 break
1669 }
1670
1671 return e.complexity.PageInfo.StartCursor(childComplexity), true
1672
1673 case "PageInfo.endCursor":
1674 if e.complexity.PageInfo.EndCursor == nil {
1675 break
1676 }
1677
1678 return e.complexity.PageInfo.EndCursor(childComplexity), true
1679
1680 case "Person.name":
1681 if e.complexity.Person.Name == nil {
1682 break
1683 }
1684
1685 return e.complexity.Person.Name(childComplexity), true
1686
1687 case "Person.email":
1688 if e.complexity.Person.Email == nil {
1689 break
1690 }
1691
1692 return e.complexity.Person.Email(childComplexity), true
1693
1694 case "Person.login":
1695 if e.complexity.Person.Login == nil {
1696 break
1697 }
1698
1699 return e.complexity.Person.Login(childComplexity), true
1700
1701 case "Person.displayName":
1702 if e.complexity.Person.DisplayName == nil {
1703 break
1704 }
1705
1706 return e.complexity.Person.DisplayName(childComplexity), true
1707
1708 case "Person.avatarUrl":
1709 if e.complexity.Person.AvatarUrl == nil {
1710 break
1711 }
1712
1713 return e.complexity.Person.AvatarUrl(childComplexity), true
1714
1715 case "Query.defaultRepository":
1716 if e.complexity.Query.DefaultRepository == nil {
1717 break
1718 }
1719
1720 return e.complexity.Query.DefaultRepository(childComplexity), true
1721
1722 case "Query.repository":
1723 if e.complexity.Query.Repository == nil {
1724 break
1725 }
1726
1727 args, err := field_Query_repository_args(rawArgs)
1728 if err != nil {
1729 return 0, false
1730 }
1731
1732 return e.complexity.Query.Repository(childComplexity, args["id"].(string)), true
1733
1734 case "Repository.allBugs":
1735 if e.complexity.Repository.AllBugs == nil {
1736 break
1737 }
1738
1739 args, err := field_Repository_allBugs_args(rawArgs)
1740 if err != nil {
1741 return 0, false
1742 }
1743
1744 return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1745
1746 case "Repository.bug":
1747 if e.complexity.Repository.Bug == nil {
1748 break
1749 }
1750
1751 args, err := field_Repository_bug_args(rawArgs)
1752 if err != nil {
1753 return 0, false
1754 }
1755
1756 return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1757
1758 case "SetStatusOperation.hash":
1759 if e.complexity.SetStatusOperation.Hash == nil {
1760 break
1761 }
1762
1763 return e.complexity.SetStatusOperation.Hash(childComplexity), true
1764
1765 case "SetStatusOperation.author":
1766 if e.complexity.SetStatusOperation.Author == nil {
1767 break
1768 }
1769
1770 return e.complexity.SetStatusOperation.Author(childComplexity), true
1771
1772 case "SetStatusOperation.date":
1773 if e.complexity.SetStatusOperation.Date == nil {
1774 break
1775 }
1776
1777 return e.complexity.SetStatusOperation.Date(childComplexity), true
1778
1779 case "SetStatusOperation.status":
1780 if e.complexity.SetStatusOperation.Status == nil {
1781 break
1782 }
1783
1784 return e.complexity.SetStatusOperation.Status(childComplexity), true
1785
1786 case "SetStatusTimelineItem.hash":
1787 if e.complexity.SetStatusTimelineItem.Hash == nil {
1788 break
1789 }
1790
1791 return e.complexity.SetStatusTimelineItem.Hash(childComplexity), true
1792
1793 case "SetStatusTimelineItem.author":
1794 if e.complexity.SetStatusTimelineItem.Author == nil {
1795 break
1796 }
1797
1798 return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
1799
1800 case "SetStatusTimelineItem.date":
1801 if e.complexity.SetStatusTimelineItem.Date == nil {
1802 break
1803 }
1804
1805 return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
1806
1807 case "SetStatusTimelineItem.status":
1808 if e.complexity.SetStatusTimelineItem.Status == nil {
1809 break
1810 }
1811
1812 return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
1813
1814 case "SetTitleOperation.hash":
1815 if e.complexity.SetTitleOperation.Hash == nil {
1816 break
1817 }
1818
1819 return e.complexity.SetTitleOperation.Hash(childComplexity), true
1820
1821 case "SetTitleOperation.author":
1822 if e.complexity.SetTitleOperation.Author == nil {
1823 break
1824 }
1825
1826 return e.complexity.SetTitleOperation.Author(childComplexity), true
1827
1828 case "SetTitleOperation.date":
1829 if e.complexity.SetTitleOperation.Date == nil {
1830 break
1831 }
1832
1833 return e.complexity.SetTitleOperation.Date(childComplexity), true
1834
1835 case "SetTitleOperation.title":
1836 if e.complexity.SetTitleOperation.Title == nil {
1837 break
1838 }
1839
1840 return e.complexity.SetTitleOperation.Title(childComplexity), true
1841
1842 case "SetTitleOperation.was":
1843 if e.complexity.SetTitleOperation.Was == nil {
1844 break
1845 }
1846
1847 return e.complexity.SetTitleOperation.Was(childComplexity), true
1848
1849 case "SetTitleTimelineItem.hash":
1850 if e.complexity.SetTitleTimelineItem.Hash == nil {
1851 break
1852 }
1853
1854 return e.complexity.SetTitleTimelineItem.Hash(childComplexity), true
1855
1856 case "SetTitleTimelineItem.author":
1857 if e.complexity.SetTitleTimelineItem.Author == nil {
1858 break
1859 }
1860
1861 return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
1862
1863 case "SetTitleTimelineItem.date":
1864 if e.complexity.SetTitleTimelineItem.Date == nil {
1865 break
1866 }
1867
1868 return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
1869
1870 case "SetTitleTimelineItem.title":
1871 if e.complexity.SetTitleTimelineItem.Title == nil {
1872 break
1873 }
1874
1875 return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
1876
1877 case "SetTitleTimelineItem.was":
1878 if e.complexity.SetTitleTimelineItem.Was == nil {
1879 break
1880 }
1881
1882 return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
1883
1884 case "TimelineItemConnection.edges":
1885 if e.complexity.TimelineItemConnection.Edges == nil {
1886 break
1887 }
1888
1889 return e.complexity.TimelineItemConnection.Edges(childComplexity), true
1890
1891 case "TimelineItemConnection.nodes":
1892 if e.complexity.TimelineItemConnection.Nodes == nil {
1893 break
1894 }
1895
1896 return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
1897
1898 case "TimelineItemConnection.pageInfo":
1899 if e.complexity.TimelineItemConnection.PageInfo == nil {
1900 break
1901 }
1902
1903 return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
1904
1905 case "TimelineItemConnection.totalCount":
1906 if e.complexity.TimelineItemConnection.TotalCount == nil {
1907 break
1908 }
1909
1910 return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
1911
1912 case "TimelineItemEdge.cursor":
1913 if e.complexity.TimelineItemEdge.Cursor == nil {
1914 break
1915 }
1916
1917 return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
1918
1919 case "TimelineItemEdge.node":
1920 if e.complexity.TimelineItemEdge.Node == nil {
1921 break
1922 }
1923
1924 return e.complexity.TimelineItemEdge.Node(childComplexity), true
1925
1926 }
1927 return 0, false
1928}
1929
1930func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
1931 ec := executionContext{graphql.GetRequestContext(ctx), e}
1932
1933 buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
1934 data := ec._Query(ctx, op.SelectionSet)
1935 var buf bytes.Buffer
1936 data.MarshalGQL(&buf)
1937 return buf.Bytes()
1938 })
1939
1940 return &graphql.Response{
1941 Data: buf,
1942 Errors: ec.Errors,
1943 Extensions: ec.Extensions}
1944}
1945
1946func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
1947 ec := executionContext{graphql.GetRequestContext(ctx), e}
1948
1949 buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
1950 data := ec._Mutation(ctx, op.SelectionSet)
1951 var buf bytes.Buffer
1952 data.MarshalGQL(&buf)
1953 return buf.Bytes()
1954 })
1955
1956 return &graphql.Response{
1957 Data: buf,
1958 Errors: ec.Errors,
1959 Extensions: ec.Extensions,
1960 }
1961}
1962
1963func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
1964 return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
1965}
1966
1967type executionContext struct {
1968 *graphql.RequestContext
1969 *executableSchema
1970}
1971
1972var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
1973
1974// nolint: gocyclo, errcheck, gas, goconst
1975func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
1976 fields := graphql.CollectFields(ctx, sel, addCommentOperationImplementors)
1977
1978 var wg sync.WaitGroup
1979 out := graphql.NewOrderedMap(len(fields))
1980 invalid := false
1981 for i, field := range fields {
1982 out.Keys[i] = field.Alias
1983
1984 switch field.Name {
1985 case "__typename":
1986 out.Values[i] = graphql.MarshalString("AddCommentOperation")
1987 case "hash":
1988 out.Values[i] = ec._AddCommentOperation_hash(ctx, field, obj)
1989 if out.Values[i] == graphql.Null {
1990 invalid = true
1991 }
1992 case "author":
1993 out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
1994 if out.Values[i] == graphql.Null {
1995 invalid = true
1996 }
1997 case "date":
1998 wg.Add(1)
1999 go func(i int, field graphql.CollectedField) {
2000 out.Values[i] = ec._AddCommentOperation_date(ctx, field, obj)
2001 if out.Values[i] == graphql.Null {
2002 invalid = true
2003 }
2004 wg.Done()
2005 }(i, field)
2006 case "message":
2007 out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
2008 if out.Values[i] == graphql.Null {
2009 invalid = true
2010 }
2011 case "files":
2012 out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
2013 if out.Values[i] == graphql.Null {
2014 invalid = true
2015 }
2016 default:
2017 panic("unknown field " + strconv.Quote(field.Name))
2018 }
2019 }
2020 wg.Wait()
2021 if invalid {
2022 return graphql.Null
2023 }
2024 return out
2025}
2026
2027// nolint: vetshadow
2028func (ec *executionContext) _AddCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2029 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2030 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2031 rctx := &graphql.ResolverContext{
2032 Object: "AddCommentOperation",
2033 Args: nil,
2034 Field: field,
2035 }
2036 ctx = graphql.WithResolverContext(ctx, rctx)
2037 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2038 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2039 ctx = rctx // use context from middleware stack in children
2040 return obj.Hash()
2041 })
2042 if resTmp == nil {
2043 if !ec.HasError(rctx) {
2044 ec.Errorf(ctx, "must not be null")
2045 }
2046 return graphql.Null
2047 }
2048 res := resTmp.(git.Hash)
2049 rctx.Result = res
2050 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2051 return res
2052}
2053
2054// nolint: vetshadow
2055func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2056 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2057 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2058 rctx := &graphql.ResolverContext{
2059 Object: "AddCommentOperation",
2060 Args: nil,
2061 Field: field,
2062 }
2063 ctx = graphql.WithResolverContext(ctx, rctx)
2064 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2065 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2066 ctx = rctx // use context from middleware stack in children
2067 return obj.Author, nil
2068 })
2069 if resTmp == nil {
2070 if !ec.HasError(rctx) {
2071 ec.Errorf(ctx, "must not be null")
2072 }
2073 return graphql.Null
2074 }
2075 res := resTmp.(bug.Person)
2076 rctx.Result = res
2077 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2078
2079 return ec._Person(ctx, field.Selections, &res)
2080}
2081
2082// nolint: vetshadow
2083func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2084 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2085 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2086 rctx := &graphql.ResolverContext{
2087 Object: "AddCommentOperation",
2088 Args: nil,
2089 Field: field,
2090 }
2091 ctx = graphql.WithResolverContext(ctx, rctx)
2092 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2093 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2094 ctx = rctx // use context from middleware stack in children
2095 return ec.resolvers.AddCommentOperation().Date(rctx, obj)
2096 })
2097 if resTmp == nil {
2098 if !ec.HasError(rctx) {
2099 ec.Errorf(ctx, "must not be null")
2100 }
2101 return graphql.Null
2102 }
2103 res := resTmp.(time.Time)
2104 rctx.Result = res
2105 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2106 return graphql.MarshalTime(res)
2107}
2108
2109// nolint: vetshadow
2110func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2111 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2112 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2113 rctx := &graphql.ResolverContext{
2114 Object: "AddCommentOperation",
2115 Args: nil,
2116 Field: field,
2117 }
2118 ctx = graphql.WithResolverContext(ctx, rctx)
2119 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2120 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2121 ctx = rctx // use context from middleware stack in children
2122 return obj.Message, nil
2123 })
2124 if resTmp == nil {
2125 if !ec.HasError(rctx) {
2126 ec.Errorf(ctx, "must not be null")
2127 }
2128 return graphql.Null
2129 }
2130 res := resTmp.(string)
2131 rctx.Result = res
2132 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2133 return graphql.MarshalString(res)
2134}
2135
2136// nolint: vetshadow
2137func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2138 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2139 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2140 rctx := &graphql.ResolverContext{
2141 Object: "AddCommentOperation",
2142 Args: nil,
2143 Field: field,
2144 }
2145 ctx = graphql.WithResolverContext(ctx, rctx)
2146 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2147 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2148 ctx = rctx // use context from middleware stack in children
2149 return obj.Files, nil
2150 })
2151 if resTmp == nil {
2152 if !ec.HasError(rctx) {
2153 ec.Errorf(ctx, "must not be null")
2154 }
2155 return graphql.Null
2156 }
2157 res := resTmp.([]git.Hash)
2158 rctx.Result = res
2159 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2160
2161 arr1 := make(graphql.Array, len(res))
2162
2163 for idx1 := range res {
2164 arr1[idx1] = func() graphql.Marshaler {
2165 return res[idx1]
2166 }()
2167 }
2168
2169 return arr1
2170}
2171
2172var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem"}
2173
2174// nolint: gocyclo, errcheck, gas, goconst
2175func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2176 fields := graphql.CollectFields(ctx, sel, addCommentTimelineItemImplementors)
2177
2178 var wg sync.WaitGroup
2179 out := graphql.NewOrderedMap(len(fields))
2180 invalid := false
2181 for i, field := range fields {
2182 out.Keys[i] = field.Alias
2183
2184 switch field.Name {
2185 case "__typename":
2186 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
2187 case "hash":
2188 out.Values[i] = ec._AddCommentTimelineItem_hash(ctx, field, obj)
2189 if out.Values[i] == graphql.Null {
2190 invalid = true
2191 }
2192 case "author":
2193 out.Values[i] = ec._AddCommentTimelineItem_author(ctx, field, obj)
2194 if out.Values[i] == graphql.Null {
2195 invalid = true
2196 }
2197 case "message":
2198 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
2199 if out.Values[i] == graphql.Null {
2200 invalid = true
2201 }
2202 case "messageIsEmpty":
2203 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
2204 if out.Values[i] == graphql.Null {
2205 invalid = true
2206 }
2207 case "files":
2208 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
2209 if out.Values[i] == graphql.Null {
2210 invalid = true
2211 }
2212 case "createdAt":
2213 wg.Add(1)
2214 go func(i int, field graphql.CollectedField) {
2215 out.Values[i] = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
2216 if out.Values[i] == graphql.Null {
2217 invalid = true
2218 }
2219 wg.Done()
2220 }(i, field)
2221 case "lastEdit":
2222 wg.Add(1)
2223 go func(i int, field graphql.CollectedField) {
2224 out.Values[i] = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
2225 if out.Values[i] == graphql.Null {
2226 invalid = true
2227 }
2228 wg.Done()
2229 }(i, field)
2230 case "edited":
2231 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
2232 if out.Values[i] == graphql.Null {
2233 invalid = true
2234 }
2235 case "history":
2236 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
2237 if out.Values[i] == graphql.Null {
2238 invalid = true
2239 }
2240 default:
2241 panic("unknown field " + strconv.Quote(field.Name))
2242 }
2243 }
2244 wg.Wait()
2245 if invalid {
2246 return graphql.Null
2247 }
2248 return out
2249}
2250
2251// nolint: vetshadow
2252func (ec *executionContext) _AddCommentTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2253 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2254 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2255 rctx := &graphql.ResolverContext{
2256 Object: "AddCommentTimelineItem",
2257 Args: nil,
2258 Field: field,
2259 }
2260 ctx = graphql.WithResolverContext(ctx, rctx)
2261 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2262 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2263 ctx = rctx // use context from middleware stack in children
2264 return obj.Hash(), nil
2265 })
2266 if resTmp == nil {
2267 if !ec.HasError(rctx) {
2268 ec.Errorf(ctx, "must not be null")
2269 }
2270 return graphql.Null
2271 }
2272 res := resTmp.(git.Hash)
2273 rctx.Result = res
2274 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2275 return res
2276}
2277
2278// nolint: vetshadow
2279func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2280 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2281 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2282 rctx := &graphql.ResolverContext{
2283 Object: "AddCommentTimelineItem",
2284 Args: nil,
2285 Field: field,
2286 }
2287 ctx = graphql.WithResolverContext(ctx, rctx)
2288 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2289 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2290 ctx = rctx // use context from middleware stack in children
2291 return obj.Author, nil
2292 })
2293 if resTmp == nil {
2294 if !ec.HasError(rctx) {
2295 ec.Errorf(ctx, "must not be null")
2296 }
2297 return graphql.Null
2298 }
2299 res := resTmp.(bug.Person)
2300 rctx.Result = res
2301 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2302
2303 return ec._Person(ctx, field.Selections, &res)
2304}
2305
2306// nolint: vetshadow
2307func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2308 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2309 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2310 rctx := &graphql.ResolverContext{
2311 Object: "AddCommentTimelineItem",
2312 Args: nil,
2313 Field: field,
2314 }
2315 ctx = graphql.WithResolverContext(ctx, rctx)
2316 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2317 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2318 ctx = rctx // use context from middleware stack in children
2319 return obj.Message, nil
2320 })
2321 if resTmp == nil {
2322 if !ec.HasError(rctx) {
2323 ec.Errorf(ctx, "must not be null")
2324 }
2325 return graphql.Null
2326 }
2327 res := resTmp.(string)
2328 rctx.Result = res
2329 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2330 return graphql.MarshalString(res)
2331}
2332
2333// nolint: vetshadow
2334func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2335 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2336 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2337 rctx := &graphql.ResolverContext{
2338 Object: "AddCommentTimelineItem",
2339 Args: nil,
2340 Field: field,
2341 }
2342 ctx = graphql.WithResolverContext(ctx, rctx)
2343 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2344 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2345 ctx = rctx // use context from middleware stack in children
2346 return obj.MessageIsEmpty(), nil
2347 })
2348 if resTmp == nil {
2349 if !ec.HasError(rctx) {
2350 ec.Errorf(ctx, "must not be null")
2351 }
2352 return graphql.Null
2353 }
2354 res := resTmp.(bool)
2355 rctx.Result = res
2356 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2357 return graphql.MarshalBoolean(res)
2358}
2359
2360// nolint: vetshadow
2361func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2362 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2363 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2364 rctx := &graphql.ResolverContext{
2365 Object: "AddCommentTimelineItem",
2366 Args: nil,
2367 Field: field,
2368 }
2369 ctx = graphql.WithResolverContext(ctx, rctx)
2370 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2371 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2372 ctx = rctx // use context from middleware stack in children
2373 return obj.Files, nil
2374 })
2375 if resTmp == nil {
2376 if !ec.HasError(rctx) {
2377 ec.Errorf(ctx, "must not be null")
2378 }
2379 return graphql.Null
2380 }
2381 res := resTmp.([]git.Hash)
2382 rctx.Result = res
2383 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2384
2385 arr1 := make(graphql.Array, len(res))
2386
2387 for idx1 := range res {
2388 arr1[idx1] = func() graphql.Marshaler {
2389 return res[idx1]
2390 }()
2391 }
2392
2393 return arr1
2394}
2395
2396// nolint: vetshadow
2397func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2398 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2399 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2400 rctx := &graphql.ResolverContext{
2401 Object: "AddCommentTimelineItem",
2402 Args: nil,
2403 Field: field,
2404 }
2405 ctx = graphql.WithResolverContext(ctx, rctx)
2406 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2407 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2408 ctx = rctx // use context from middleware stack in children
2409 return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
2410 })
2411 if resTmp == nil {
2412 if !ec.HasError(rctx) {
2413 ec.Errorf(ctx, "must not be null")
2414 }
2415 return graphql.Null
2416 }
2417 res := resTmp.(time.Time)
2418 rctx.Result = res
2419 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2420 return graphql.MarshalTime(res)
2421}
2422
2423// nolint: vetshadow
2424func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2425 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2426 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2427 rctx := &graphql.ResolverContext{
2428 Object: "AddCommentTimelineItem",
2429 Args: nil,
2430 Field: field,
2431 }
2432 ctx = graphql.WithResolverContext(ctx, rctx)
2433 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2434 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2435 ctx = rctx // use context from middleware stack in children
2436 return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
2437 })
2438 if resTmp == nil {
2439 if !ec.HasError(rctx) {
2440 ec.Errorf(ctx, "must not be null")
2441 }
2442 return graphql.Null
2443 }
2444 res := resTmp.(time.Time)
2445 rctx.Result = res
2446 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2447 return graphql.MarshalTime(res)
2448}
2449
2450// nolint: vetshadow
2451func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2452 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2453 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2454 rctx := &graphql.ResolverContext{
2455 Object: "AddCommentTimelineItem",
2456 Args: nil,
2457 Field: field,
2458 }
2459 ctx = graphql.WithResolverContext(ctx, rctx)
2460 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2461 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2462 ctx = rctx // use context from middleware stack in children
2463 return obj.Edited(), nil
2464 })
2465 if resTmp == nil {
2466 if !ec.HasError(rctx) {
2467 ec.Errorf(ctx, "must not be null")
2468 }
2469 return graphql.Null
2470 }
2471 res := resTmp.(bool)
2472 rctx.Result = res
2473 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2474 return graphql.MarshalBoolean(res)
2475}
2476
2477// nolint: vetshadow
2478func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2479 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2480 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2481 rctx := &graphql.ResolverContext{
2482 Object: "AddCommentTimelineItem",
2483 Args: nil,
2484 Field: field,
2485 }
2486 ctx = graphql.WithResolverContext(ctx, rctx)
2487 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2488 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2489 ctx = rctx // use context from middleware stack in children
2490 return obj.History, nil
2491 })
2492 if resTmp == nil {
2493 if !ec.HasError(rctx) {
2494 ec.Errorf(ctx, "must not be null")
2495 }
2496 return graphql.Null
2497 }
2498 res := resTmp.([]bug.CommentHistoryStep)
2499 rctx.Result = res
2500 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2501
2502 arr1 := make(graphql.Array, len(res))
2503 var wg sync.WaitGroup
2504
2505 isLen1 := len(res) == 1
2506 if !isLen1 {
2507 wg.Add(len(res))
2508 }
2509
2510 for idx1 := range res {
2511 idx1 := idx1
2512 rctx := &graphql.ResolverContext{
2513 Index: &idx1,
2514 Result: &res[idx1],
2515 }
2516 ctx := graphql.WithResolverContext(ctx, rctx)
2517 f := func(idx1 int) {
2518 if !isLen1 {
2519 defer wg.Done()
2520 }
2521 arr1[idx1] = func() graphql.Marshaler {
2522
2523 return ec._CommentHistoryStep(ctx, field.Selections, &res[idx1])
2524 }()
2525 }
2526 if isLen1 {
2527 f(idx1)
2528 } else {
2529 go f(idx1)
2530 }
2531
2532 }
2533 wg.Wait()
2534 return arr1
2535}
2536
2537var bugImplementors = []string{"Bug"}
2538
2539// nolint: gocyclo, errcheck, gas, goconst
2540func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
2541 fields := graphql.CollectFields(ctx, sel, bugImplementors)
2542
2543 var wg sync.WaitGroup
2544 out := graphql.NewOrderedMap(len(fields))
2545 invalid := false
2546 for i, field := range fields {
2547 out.Keys[i] = field.Alias
2548
2549 switch field.Name {
2550 case "__typename":
2551 out.Values[i] = graphql.MarshalString("Bug")
2552 case "id":
2553 out.Values[i] = ec._Bug_id(ctx, field, obj)
2554 if out.Values[i] == graphql.Null {
2555 invalid = true
2556 }
2557 case "humanId":
2558 out.Values[i] = ec._Bug_humanId(ctx, field, obj)
2559 if out.Values[i] == graphql.Null {
2560 invalid = true
2561 }
2562 case "status":
2563 wg.Add(1)
2564 go func(i int, field graphql.CollectedField) {
2565 out.Values[i] = ec._Bug_status(ctx, field, obj)
2566 if out.Values[i] == graphql.Null {
2567 invalid = true
2568 }
2569 wg.Done()
2570 }(i, field)
2571 case "title":
2572 out.Values[i] = ec._Bug_title(ctx, field, obj)
2573 if out.Values[i] == graphql.Null {
2574 invalid = true
2575 }
2576 case "labels":
2577 out.Values[i] = ec._Bug_labels(ctx, field, obj)
2578 if out.Values[i] == graphql.Null {
2579 invalid = true
2580 }
2581 case "author":
2582 out.Values[i] = ec._Bug_author(ctx, field, obj)
2583 if out.Values[i] == graphql.Null {
2584 invalid = true
2585 }
2586 case "createdAt":
2587 out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
2588 if out.Values[i] == graphql.Null {
2589 invalid = true
2590 }
2591 case "lastEdit":
2592 wg.Add(1)
2593 go func(i int, field graphql.CollectedField) {
2594 out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
2595 if out.Values[i] == graphql.Null {
2596 invalid = true
2597 }
2598 wg.Done()
2599 }(i, field)
2600 case "comments":
2601 wg.Add(1)
2602 go func(i int, field graphql.CollectedField) {
2603 out.Values[i] = ec._Bug_comments(ctx, field, obj)
2604 if out.Values[i] == graphql.Null {
2605 invalid = true
2606 }
2607 wg.Done()
2608 }(i, field)
2609 case "timeline":
2610 wg.Add(1)
2611 go func(i int, field graphql.CollectedField) {
2612 out.Values[i] = ec._Bug_timeline(ctx, field, obj)
2613 if out.Values[i] == graphql.Null {
2614 invalid = true
2615 }
2616 wg.Done()
2617 }(i, field)
2618 case "operations":
2619 wg.Add(1)
2620 go func(i int, field graphql.CollectedField) {
2621 out.Values[i] = ec._Bug_operations(ctx, field, obj)
2622 if out.Values[i] == graphql.Null {
2623 invalid = true
2624 }
2625 wg.Done()
2626 }(i, field)
2627 default:
2628 panic("unknown field " + strconv.Quote(field.Name))
2629 }
2630 }
2631 wg.Wait()
2632 if invalid {
2633 return graphql.Null
2634 }
2635 return out
2636}
2637
2638// nolint: vetshadow
2639func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2640 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2641 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2642 rctx := &graphql.ResolverContext{
2643 Object: "Bug",
2644 Args: nil,
2645 Field: field,
2646 }
2647 ctx = graphql.WithResolverContext(ctx, rctx)
2648 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2649 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2650 ctx = rctx // use context from middleware stack in children
2651 return obj.Id(), nil
2652 })
2653 if resTmp == nil {
2654 if !ec.HasError(rctx) {
2655 ec.Errorf(ctx, "must not be null")
2656 }
2657 return graphql.Null
2658 }
2659 res := resTmp.(string)
2660 rctx.Result = res
2661 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2662 return graphql.MarshalString(res)
2663}
2664
2665// nolint: vetshadow
2666func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2667 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2668 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2669 rctx := &graphql.ResolverContext{
2670 Object: "Bug",
2671 Args: nil,
2672 Field: field,
2673 }
2674 ctx = graphql.WithResolverContext(ctx, rctx)
2675 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2676 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2677 ctx = rctx // use context from middleware stack in children
2678 return obj.HumanId(), nil
2679 })
2680 if resTmp == nil {
2681 if !ec.HasError(rctx) {
2682 ec.Errorf(ctx, "must not be null")
2683 }
2684 return graphql.Null
2685 }
2686 res := resTmp.(string)
2687 rctx.Result = res
2688 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2689 return graphql.MarshalString(res)
2690}
2691
2692// nolint: vetshadow
2693func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2694 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2695 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2696 rctx := &graphql.ResolverContext{
2697 Object: "Bug",
2698 Args: nil,
2699 Field: field,
2700 }
2701 ctx = graphql.WithResolverContext(ctx, rctx)
2702 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2703 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2704 ctx = rctx // use context from middleware stack in children
2705 return ec.resolvers.Bug().Status(rctx, obj)
2706 })
2707 if resTmp == nil {
2708 if !ec.HasError(rctx) {
2709 ec.Errorf(ctx, "must not be null")
2710 }
2711 return graphql.Null
2712 }
2713 res := resTmp.(models.Status)
2714 rctx.Result = res
2715 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2716 return res
2717}
2718
2719// nolint: vetshadow
2720func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2721 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2722 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2723 rctx := &graphql.ResolverContext{
2724 Object: "Bug",
2725 Args: nil,
2726 Field: field,
2727 }
2728 ctx = graphql.WithResolverContext(ctx, rctx)
2729 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2730 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2731 ctx = rctx // use context from middleware stack in children
2732 return obj.Title, nil
2733 })
2734 if resTmp == nil {
2735 if !ec.HasError(rctx) {
2736 ec.Errorf(ctx, "must not be null")
2737 }
2738 return graphql.Null
2739 }
2740 res := resTmp.(string)
2741 rctx.Result = res
2742 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2743 return graphql.MarshalString(res)
2744}
2745
2746// nolint: vetshadow
2747func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2748 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2749 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2750 rctx := &graphql.ResolverContext{
2751 Object: "Bug",
2752 Args: nil,
2753 Field: field,
2754 }
2755 ctx = graphql.WithResolverContext(ctx, rctx)
2756 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2757 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2758 ctx = rctx // use context from middleware stack in children
2759 return obj.Labels, nil
2760 })
2761 if resTmp == nil {
2762 if !ec.HasError(rctx) {
2763 ec.Errorf(ctx, "must not be null")
2764 }
2765 return graphql.Null
2766 }
2767 res := resTmp.([]bug.Label)
2768 rctx.Result = res
2769 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2770
2771 arr1 := make(graphql.Array, len(res))
2772
2773 for idx1 := range res {
2774 arr1[idx1] = func() graphql.Marshaler {
2775 return res[idx1]
2776 }()
2777 }
2778
2779 return arr1
2780}
2781
2782// nolint: vetshadow
2783func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2784 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2785 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2786 rctx := &graphql.ResolverContext{
2787 Object: "Bug",
2788 Args: nil,
2789 Field: field,
2790 }
2791 ctx = graphql.WithResolverContext(ctx, rctx)
2792 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2793 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2794 ctx = rctx // use context from middleware stack in children
2795 return obj.Author, nil
2796 })
2797 if resTmp == nil {
2798 if !ec.HasError(rctx) {
2799 ec.Errorf(ctx, "must not be null")
2800 }
2801 return graphql.Null
2802 }
2803 res := resTmp.(bug.Person)
2804 rctx.Result = res
2805 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2806
2807 return ec._Person(ctx, field.Selections, &res)
2808}
2809
2810// nolint: vetshadow
2811func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2812 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2813 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2814 rctx := &graphql.ResolverContext{
2815 Object: "Bug",
2816 Args: nil,
2817 Field: field,
2818 }
2819 ctx = graphql.WithResolverContext(ctx, rctx)
2820 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2821 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2822 ctx = rctx // use context from middleware stack in children
2823 return obj.CreatedAt, nil
2824 })
2825 if resTmp == nil {
2826 if !ec.HasError(rctx) {
2827 ec.Errorf(ctx, "must not be null")
2828 }
2829 return graphql.Null
2830 }
2831 res := resTmp.(time.Time)
2832 rctx.Result = res
2833 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2834 return graphql.MarshalTime(res)
2835}
2836
2837// nolint: vetshadow
2838func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2839 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2840 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2841 rctx := &graphql.ResolverContext{
2842 Object: "Bug",
2843 Args: nil,
2844 Field: field,
2845 }
2846 ctx = graphql.WithResolverContext(ctx, rctx)
2847 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2848 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2849 ctx = rctx // use context from middleware stack in children
2850 return ec.resolvers.Bug().LastEdit(rctx, obj)
2851 })
2852 if resTmp == nil {
2853 if !ec.HasError(rctx) {
2854 ec.Errorf(ctx, "must not be null")
2855 }
2856 return graphql.Null
2857 }
2858 res := resTmp.(time.Time)
2859 rctx.Result = res
2860 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2861 return graphql.MarshalTime(res)
2862}
2863
2864// nolint: vetshadow
2865func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2866 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2867 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2868 rawArgs := field.ArgumentMap(ec.Variables)
2869 args, err := field_Bug_comments_args(rawArgs)
2870 if err != nil {
2871 ec.Error(ctx, err)
2872 return graphql.Null
2873 }
2874 rctx := &graphql.ResolverContext{
2875 Object: "Bug",
2876 Args: args,
2877 Field: field,
2878 }
2879 ctx = graphql.WithResolverContext(ctx, rctx)
2880 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2881 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2882 ctx = rctx // use context from middleware stack in children
2883 return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
2884 })
2885 if resTmp == nil {
2886 if !ec.HasError(rctx) {
2887 ec.Errorf(ctx, "must not be null")
2888 }
2889 return graphql.Null
2890 }
2891 res := resTmp.(models.CommentConnection)
2892 rctx.Result = res
2893 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2894
2895 return ec._CommentConnection(ctx, field.Selections, &res)
2896}
2897
2898// nolint: vetshadow
2899func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2900 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2901 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2902 rawArgs := field.ArgumentMap(ec.Variables)
2903 args, err := field_Bug_timeline_args(rawArgs)
2904 if err != nil {
2905 ec.Error(ctx, err)
2906 return graphql.Null
2907 }
2908 rctx := &graphql.ResolverContext{
2909 Object: "Bug",
2910 Args: args,
2911 Field: field,
2912 }
2913 ctx = graphql.WithResolverContext(ctx, rctx)
2914 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2915 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2916 ctx = rctx // use context from middleware stack in children
2917 return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
2918 })
2919 if resTmp == nil {
2920 if !ec.HasError(rctx) {
2921 ec.Errorf(ctx, "must not be null")
2922 }
2923 return graphql.Null
2924 }
2925 res := resTmp.(models.TimelineItemConnection)
2926 rctx.Result = res
2927 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2928
2929 return ec._TimelineItemConnection(ctx, field.Selections, &res)
2930}
2931
2932// nolint: vetshadow
2933func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2934 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2935 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2936 rawArgs := field.ArgumentMap(ec.Variables)
2937 args, err := field_Bug_operations_args(rawArgs)
2938 if err != nil {
2939 ec.Error(ctx, err)
2940 return graphql.Null
2941 }
2942 rctx := &graphql.ResolverContext{
2943 Object: "Bug",
2944 Args: args,
2945 Field: field,
2946 }
2947 ctx = graphql.WithResolverContext(ctx, rctx)
2948 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2949 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2950 ctx = rctx // use context from middleware stack in children
2951 return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
2952 })
2953 if resTmp == nil {
2954 if !ec.HasError(rctx) {
2955 ec.Errorf(ctx, "must not be null")
2956 }
2957 return graphql.Null
2958 }
2959 res := resTmp.(models.OperationConnection)
2960 rctx.Result = res
2961 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2962
2963 return ec._OperationConnection(ctx, field.Selections, &res)
2964}
2965
2966var bugConnectionImplementors = []string{"BugConnection"}
2967
2968// nolint: gocyclo, errcheck, gas, goconst
2969func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
2970 fields := graphql.CollectFields(ctx, sel, bugConnectionImplementors)
2971
2972 out := graphql.NewOrderedMap(len(fields))
2973 invalid := false
2974 for i, field := range fields {
2975 out.Keys[i] = field.Alias
2976
2977 switch field.Name {
2978 case "__typename":
2979 out.Values[i] = graphql.MarshalString("BugConnection")
2980 case "edges":
2981 out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
2982 if out.Values[i] == graphql.Null {
2983 invalid = true
2984 }
2985 case "nodes":
2986 out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
2987 if out.Values[i] == graphql.Null {
2988 invalid = true
2989 }
2990 case "pageInfo":
2991 out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
2992 if out.Values[i] == graphql.Null {
2993 invalid = true
2994 }
2995 case "totalCount":
2996 out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
2997 if out.Values[i] == graphql.Null {
2998 invalid = true
2999 }
3000 default:
3001 panic("unknown field " + strconv.Quote(field.Name))
3002 }
3003 }
3004
3005 if invalid {
3006 return graphql.Null
3007 }
3008 return out
3009}
3010
3011// nolint: vetshadow
3012func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3013 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3014 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3015 rctx := &graphql.ResolverContext{
3016 Object: "BugConnection",
3017 Args: nil,
3018 Field: field,
3019 }
3020 ctx = graphql.WithResolverContext(ctx, rctx)
3021 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3022 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3023 ctx = rctx // use context from middleware stack in children
3024 return obj.Edges, nil
3025 })
3026 if resTmp == nil {
3027 if !ec.HasError(rctx) {
3028 ec.Errorf(ctx, "must not be null")
3029 }
3030 return graphql.Null
3031 }
3032 res := resTmp.([]models.BugEdge)
3033 rctx.Result = res
3034 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3035
3036 arr1 := make(graphql.Array, len(res))
3037 var wg sync.WaitGroup
3038
3039 isLen1 := len(res) == 1
3040 if !isLen1 {
3041 wg.Add(len(res))
3042 }
3043
3044 for idx1 := range res {
3045 idx1 := idx1
3046 rctx := &graphql.ResolverContext{
3047 Index: &idx1,
3048 Result: &res[idx1],
3049 }
3050 ctx := graphql.WithResolverContext(ctx, rctx)
3051 f := func(idx1 int) {
3052 if !isLen1 {
3053 defer wg.Done()
3054 }
3055 arr1[idx1] = func() graphql.Marshaler {
3056
3057 return ec._BugEdge(ctx, field.Selections, &res[idx1])
3058 }()
3059 }
3060 if isLen1 {
3061 f(idx1)
3062 } else {
3063 go f(idx1)
3064 }
3065
3066 }
3067 wg.Wait()
3068 return arr1
3069}
3070
3071// nolint: vetshadow
3072func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3073 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3074 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3075 rctx := &graphql.ResolverContext{
3076 Object: "BugConnection",
3077 Args: nil,
3078 Field: field,
3079 }
3080 ctx = graphql.WithResolverContext(ctx, rctx)
3081 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3082 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3083 ctx = rctx // use context from middleware stack in children
3084 return obj.Nodes, nil
3085 })
3086 if resTmp == nil {
3087 if !ec.HasError(rctx) {
3088 ec.Errorf(ctx, "must not be null")
3089 }
3090 return graphql.Null
3091 }
3092 res := resTmp.([]bug.Snapshot)
3093 rctx.Result = res
3094 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3095
3096 arr1 := make(graphql.Array, len(res))
3097 var wg sync.WaitGroup
3098
3099 isLen1 := len(res) == 1
3100 if !isLen1 {
3101 wg.Add(len(res))
3102 }
3103
3104 for idx1 := range res {
3105 idx1 := idx1
3106 rctx := &graphql.ResolverContext{
3107 Index: &idx1,
3108 Result: &res[idx1],
3109 }
3110 ctx := graphql.WithResolverContext(ctx, rctx)
3111 f := func(idx1 int) {
3112 if !isLen1 {
3113 defer wg.Done()
3114 }
3115 arr1[idx1] = func() graphql.Marshaler {
3116
3117 return ec._Bug(ctx, field.Selections, &res[idx1])
3118 }()
3119 }
3120 if isLen1 {
3121 f(idx1)
3122 } else {
3123 go f(idx1)
3124 }
3125
3126 }
3127 wg.Wait()
3128 return arr1
3129}
3130
3131// nolint: vetshadow
3132func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3133 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3134 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3135 rctx := &graphql.ResolverContext{
3136 Object: "BugConnection",
3137 Args: nil,
3138 Field: field,
3139 }
3140 ctx = graphql.WithResolverContext(ctx, rctx)
3141 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3142 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3143 ctx = rctx // use context from middleware stack in children
3144 return obj.PageInfo, nil
3145 })
3146 if resTmp == nil {
3147 if !ec.HasError(rctx) {
3148 ec.Errorf(ctx, "must not be null")
3149 }
3150 return graphql.Null
3151 }
3152 res := resTmp.(models.PageInfo)
3153 rctx.Result = res
3154 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3155
3156 return ec._PageInfo(ctx, field.Selections, &res)
3157}
3158
3159// nolint: vetshadow
3160func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3161 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3162 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3163 rctx := &graphql.ResolverContext{
3164 Object: "BugConnection",
3165 Args: nil,
3166 Field: field,
3167 }
3168 ctx = graphql.WithResolverContext(ctx, rctx)
3169 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3170 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3171 ctx = rctx // use context from middleware stack in children
3172 return obj.TotalCount, nil
3173 })
3174 if resTmp == nil {
3175 if !ec.HasError(rctx) {
3176 ec.Errorf(ctx, "must not be null")
3177 }
3178 return graphql.Null
3179 }
3180 res := resTmp.(int)
3181 rctx.Result = res
3182 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3183 return graphql.MarshalInt(res)
3184}
3185
3186var bugEdgeImplementors = []string{"BugEdge"}
3187
3188// nolint: gocyclo, errcheck, gas, goconst
3189func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
3190 fields := graphql.CollectFields(ctx, sel, bugEdgeImplementors)
3191
3192 out := graphql.NewOrderedMap(len(fields))
3193 invalid := false
3194 for i, field := range fields {
3195 out.Keys[i] = field.Alias
3196
3197 switch field.Name {
3198 case "__typename":
3199 out.Values[i] = graphql.MarshalString("BugEdge")
3200 case "cursor":
3201 out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
3202 if out.Values[i] == graphql.Null {
3203 invalid = true
3204 }
3205 case "node":
3206 out.Values[i] = ec._BugEdge_node(ctx, field, obj)
3207 if out.Values[i] == graphql.Null {
3208 invalid = true
3209 }
3210 default:
3211 panic("unknown field " + strconv.Quote(field.Name))
3212 }
3213 }
3214
3215 if invalid {
3216 return graphql.Null
3217 }
3218 return out
3219}
3220
3221// nolint: vetshadow
3222func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
3223 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3224 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3225 rctx := &graphql.ResolverContext{
3226 Object: "BugEdge",
3227 Args: nil,
3228 Field: field,
3229 }
3230 ctx = graphql.WithResolverContext(ctx, rctx)
3231 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3232 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3233 ctx = rctx // use context from middleware stack in children
3234 return obj.Cursor, nil
3235 })
3236 if resTmp == nil {
3237 if !ec.HasError(rctx) {
3238 ec.Errorf(ctx, "must not be null")
3239 }
3240 return graphql.Null
3241 }
3242 res := resTmp.(string)
3243 rctx.Result = res
3244 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3245 return graphql.MarshalString(res)
3246}
3247
3248// nolint: vetshadow
3249func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
3250 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3251 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3252 rctx := &graphql.ResolverContext{
3253 Object: "BugEdge",
3254 Args: nil,
3255 Field: field,
3256 }
3257 ctx = graphql.WithResolverContext(ctx, rctx)
3258 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3259 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3260 ctx = rctx // use context from middleware stack in children
3261 return obj.Node, nil
3262 })
3263 if resTmp == nil {
3264 if !ec.HasError(rctx) {
3265 ec.Errorf(ctx, "must not be null")
3266 }
3267 return graphql.Null
3268 }
3269 res := resTmp.(bug.Snapshot)
3270 rctx.Result = res
3271 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3272
3273 return ec._Bug(ctx, field.Selections, &res)
3274}
3275
3276var commentImplementors = []string{"Comment", "Authored"}
3277
3278// nolint: gocyclo, errcheck, gas, goconst
3279func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
3280 fields := graphql.CollectFields(ctx, sel, commentImplementors)
3281
3282 out := graphql.NewOrderedMap(len(fields))
3283 invalid := false
3284 for i, field := range fields {
3285 out.Keys[i] = field.Alias
3286
3287 switch field.Name {
3288 case "__typename":
3289 out.Values[i] = graphql.MarshalString("Comment")
3290 case "author":
3291 out.Values[i] = ec._Comment_author(ctx, field, obj)
3292 if out.Values[i] == graphql.Null {
3293 invalid = true
3294 }
3295 case "message":
3296 out.Values[i] = ec._Comment_message(ctx, field, obj)
3297 if out.Values[i] == graphql.Null {
3298 invalid = true
3299 }
3300 case "files":
3301 out.Values[i] = ec._Comment_files(ctx, field, obj)
3302 if out.Values[i] == graphql.Null {
3303 invalid = true
3304 }
3305 default:
3306 panic("unknown field " + strconv.Quote(field.Name))
3307 }
3308 }
3309
3310 if invalid {
3311 return graphql.Null
3312 }
3313 return out
3314}
3315
3316// nolint: vetshadow
3317func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
3318 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3319 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3320 rctx := &graphql.ResolverContext{
3321 Object: "Comment",
3322 Args: nil,
3323 Field: field,
3324 }
3325 ctx = graphql.WithResolverContext(ctx, rctx)
3326 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3327 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3328 ctx = rctx // use context from middleware stack in children
3329 return obj.Author, nil
3330 })
3331 if resTmp == nil {
3332 if !ec.HasError(rctx) {
3333 ec.Errorf(ctx, "must not be null")
3334 }
3335 return graphql.Null
3336 }
3337 res := resTmp.(bug.Person)
3338 rctx.Result = res
3339 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3340
3341 return ec._Person(ctx, field.Selections, &res)
3342}
3343
3344// nolint: vetshadow
3345func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
3346 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3347 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3348 rctx := &graphql.ResolverContext{
3349 Object: "Comment",
3350 Args: nil,
3351 Field: field,
3352 }
3353 ctx = graphql.WithResolverContext(ctx, rctx)
3354 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3355 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3356 ctx = rctx // use context from middleware stack in children
3357 return obj.Message, nil
3358 })
3359 if resTmp == nil {
3360 if !ec.HasError(rctx) {
3361 ec.Errorf(ctx, "must not be null")
3362 }
3363 return graphql.Null
3364 }
3365 res := resTmp.(string)
3366 rctx.Result = res
3367 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3368 return graphql.MarshalString(res)
3369}
3370
3371// nolint: vetshadow
3372func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
3373 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3374 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3375 rctx := &graphql.ResolverContext{
3376 Object: "Comment",
3377 Args: nil,
3378 Field: field,
3379 }
3380 ctx = graphql.WithResolverContext(ctx, rctx)
3381 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3382 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3383 ctx = rctx // use context from middleware stack in children
3384 return obj.Files, nil
3385 })
3386 if resTmp == nil {
3387 if !ec.HasError(rctx) {
3388 ec.Errorf(ctx, "must not be null")
3389 }
3390 return graphql.Null
3391 }
3392 res := resTmp.([]git.Hash)
3393 rctx.Result = res
3394 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3395
3396 arr1 := make(graphql.Array, len(res))
3397
3398 for idx1 := range res {
3399 arr1[idx1] = func() graphql.Marshaler {
3400 return res[idx1]
3401 }()
3402 }
3403
3404 return arr1
3405}
3406
3407var commentConnectionImplementors = []string{"CommentConnection"}
3408
3409// nolint: gocyclo, errcheck, gas, goconst
3410func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
3411 fields := graphql.CollectFields(ctx, sel, commentConnectionImplementors)
3412
3413 out := graphql.NewOrderedMap(len(fields))
3414 invalid := false
3415 for i, field := range fields {
3416 out.Keys[i] = field.Alias
3417
3418 switch field.Name {
3419 case "__typename":
3420 out.Values[i] = graphql.MarshalString("CommentConnection")
3421 case "edges":
3422 out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
3423 if out.Values[i] == graphql.Null {
3424 invalid = true
3425 }
3426 case "nodes":
3427 out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
3428 if out.Values[i] == graphql.Null {
3429 invalid = true
3430 }
3431 case "pageInfo":
3432 out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
3433 if out.Values[i] == graphql.Null {
3434 invalid = true
3435 }
3436 case "totalCount":
3437 out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
3438 if out.Values[i] == graphql.Null {
3439 invalid = true
3440 }
3441 default:
3442 panic("unknown field " + strconv.Quote(field.Name))
3443 }
3444 }
3445
3446 if invalid {
3447 return graphql.Null
3448 }
3449 return out
3450}
3451
3452// nolint: vetshadow
3453func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3454 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3455 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3456 rctx := &graphql.ResolverContext{
3457 Object: "CommentConnection",
3458 Args: nil,
3459 Field: field,
3460 }
3461 ctx = graphql.WithResolverContext(ctx, rctx)
3462 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3463 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3464 ctx = rctx // use context from middleware stack in children
3465 return obj.Edges, nil
3466 })
3467 if resTmp == nil {
3468 if !ec.HasError(rctx) {
3469 ec.Errorf(ctx, "must not be null")
3470 }
3471 return graphql.Null
3472 }
3473 res := resTmp.([]models.CommentEdge)
3474 rctx.Result = res
3475 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3476
3477 arr1 := make(graphql.Array, len(res))
3478 var wg sync.WaitGroup
3479
3480 isLen1 := len(res) == 1
3481 if !isLen1 {
3482 wg.Add(len(res))
3483 }
3484
3485 for idx1 := range res {
3486 idx1 := idx1
3487 rctx := &graphql.ResolverContext{
3488 Index: &idx1,
3489 Result: &res[idx1],
3490 }
3491 ctx := graphql.WithResolverContext(ctx, rctx)
3492 f := func(idx1 int) {
3493 if !isLen1 {
3494 defer wg.Done()
3495 }
3496 arr1[idx1] = func() graphql.Marshaler {
3497
3498 return ec._CommentEdge(ctx, field.Selections, &res[idx1])
3499 }()
3500 }
3501 if isLen1 {
3502 f(idx1)
3503 } else {
3504 go f(idx1)
3505 }
3506
3507 }
3508 wg.Wait()
3509 return arr1
3510}
3511
3512// nolint: vetshadow
3513func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3514 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3515 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3516 rctx := &graphql.ResolverContext{
3517 Object: "CommentConnection",
3518 Args: nil,
3519 Field: field,
3520 }
3521 ctx = graphql.WithResolverContext(ctx, rctx)
3522 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3523 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3524 ctx = rctx // use context from middleware stack in children
3525 return obj.Nodes, nil
3526 })
3527 if resTmp == nil {
3528 if !ec.HasError(rctx) {
3529 ec.Errorf(ctx, "must not be null")
3530 }
3531 return graphql.Null
3532 }
3533 res := resTmp.([]bug.Comment)
3534 rctx.Result = res
3535 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3536
3537 arr1 := make(graphql.Array, len(res))
3538 var wg sync.WaitGroup
3539
3540 isLen1 := len(res) == 1
3541 if !isLen1 {
3542 wg.Add(len(res))
3543 }
3544
3545 for idx1 := range res {
3546 idx1 := idx1
3547 rctx := &graphql.ResolverContext{
3548 Index: &idx1,
3549 Result: &res[idx1],
3550 }
3551 ctx := graphql.WithResolverContext(ctx, rctx)
3552 f := func(idx1 int) {
3553 if !isLen1 {
3554 defer wg.Done()
3555 }
3556 arr1[idx1] = func() graphql.Marshaler {
3557
3558 return ec._Comment(ctx, field.Selections, &res[idx1])
3559 }()
3560 }
3561 if isLen1 {
3562 f(idx1)
3563 } else {
3564 go f(idx1)
3565 }
3566
3567 }
3568 wg.Wait()
3569 return arr1
3570}
3571
3572// nolint: vetshadow
3573func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3574 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3575 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3576 rctx := &graphql.ResolverContext{
3577 Object: "CommentConnection",
3578 Args: nil,
3579 Field: field,
3580 }
3581 ctx = graphql.WithResolverContext(ctx, rctx)
3582 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3583 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3584 ctx = rctx // use context from middleware stack in children
3585 return obj.PageInfo, nil
3586 })
3587 if resTmp == nil {
3588 if !ec.HasError(rctx) {
3589 ec.Errorf(ctx, "must not be null")
3590 }
3591 return graphql.Null
3592 }
3593 res := resTmp.(models.PageInfo)
3594 rctx.Result = res
3595 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3596
3597 return ec._PageInfo(ctx, field.Selections, &res)
3598}
3599
3600// nolint: vetshadow
3601func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3602 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3603 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3604 rctx := &graphql.ResolverContext{
3605 Object: "CommentConnection",
3606 Args: nil,
3607 Field: field,
3608 }
3609 ctx = graphql.WithResolverContext(ctx, rctx)
3610 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3611 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3612 ctx = rctx // use context from middleware stack in children
3613 return obj.TotalCount, nil
3614 })
3615 if resTmp == nil {
3616 if !ec.HasError(rctx) {
3617 ec.Errorf(ctx, "must not be null")
3618 }
3619 return graphql.Null
3620 }
3621 res := resTmp.(int)
3622 rctx.Result = res
3623 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3624 return graphql.MarshalInt(res)
3625}
3626
3627var commentEdgeImplementors = []string{"CommentEdge"}
3628
3629// nolint: gocyclo, errcheck, gas, goconst
3630func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
3631 fields := graphql.CollectFields(ctx, sel, commentEdgeImplementors)
3632
3633 out := graphql.NewOrderedMap(len(fields))
3634 invalid := false
3635 for i, field := range fields {
3636 out.Keys[i] = field.Alias
3637
3638 switch field.Name {
3639 case "__typename":
3640 out.Values[i] = graphql.MarshalString("CommentEdge")
3641 case "cursor":
3642 out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
3643 if out.Values[i] == graphql.Null {
3644 invalid = true
3645 }
3646 case "node":
3647 out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
3648 if out.Values[i] == graphql.Null {
3649 invalid = true
3650 }
3651 default:
3652 panic("unknown field " + strconv.Quote(field.Name))
3653 }
3654 }
3655
3656 if invalid {
3657 return graphql.Null
3658 }
3659 return out
3660}
3661
3662// nolint: vetshadow
3663func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
3664 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3665 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3666 rctx := &graphql.ResolverContext{
3667 Object: "CommentEdge",
3668 Args: nil,
3669 Field: field,
3670 }
3671 ctx = graphql.WithResolverContext(ctx, rctx)
3672 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3673 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3674 ctx = rctx // use context from middleware stack in children
3675 return obj.Cursor, nil
3676 })
3677 if resTmp == nil {
3678 if !ec.HasError(rctx) {
3679 ec.Errorf(ctx, "must not be null")
3680 }
3681 return graphql.Null
3682 }
3683 res := resTmp.(string)
3684 rctx.Result = res
3685 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3686 return graphql.MarshalString(res)
3687}
3688
3689// nolint: vetshadow
3690func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
3691 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3692 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3693 rctx := &graphql.ResolverContext{
3694 Object: "CommentEdge",
3695 Args: nil,
3696 Field: field,
3697 }
3698 ctx = graphql.WithResolverContext(ctx, rctx)
3699 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3700 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3701 ctx = rctx // use context from middleware stack in children
3702 return obj.Node, nil
3703 })
3704 if resTmp == nil {
3705 if !ec.HasError(rctx) {
3706 ec.Errorf(ctx, "must not be null")
3707 }
3708 return graphql.Null
3709 }
3710 res := resTmp.(bug.Comment)
3711 rctx.Result = res
3712 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3713
3714 return ec._Comment(ctx, field.Selections, &res)
3715}
3716
3717var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
3718
3719// nolint: gocyclo, errcheck, gas, goconst
3720func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
3721 fields := graphql.CollectFields(ctx, sel, commentHistoryStepImplementors)
3722
3723 var wg sync.WaitGroup
3724 out := graphql.NewOrderedMap(len(fields))
3725 invalid := false
3726 for i, field := range fields {
3727 out.Keys[i] = field.Alias
3728
3729 switch field.Name {
3730 case "__typename":
3731 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
3732 case "message":
3733 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
3734 if out.Values[i] == graphql.Null {
3735 invalid = true
3736 }
3737 case "date":
3738 wg.Add(1)
3739 go func(i int, field graphql.CollectedField) {
3740 out.Values[i] = ec._CommentHistoryStep_date(ctx, field, obj)
3741 if out.Values[i] == graphql.Null {
3742 invalid = true
3743 }
3744 wg.Done()
3745 }(i, field)
3746 default:
3747 panic("unknown field " + strconv.Quote(field.Name))
3748 }
3749 }
3750 wg.Wait()
3751 if invalid {
3752 return graphql.Null
3753 }
3754 return out
3755}
3756
3757// nolint: vetshadow
3758func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) graphql.Marshaler {
3759 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3760 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3761 rctx := &graphql.ResolverContext{
3762 Object: "CommentHistoryStep",
3763 Args: nil,
3764 Field: field,
3765 }
3766 ctx = graphql.WithResolverContext(ctx, rctx)
3767 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3768 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3769 ctx = rctx // use context from middleware stack in children
3770 return obj.Message, nil
3771 })
3772 if resTmp == nil {
3773 if !ec.HasError(rctx) {
3774 ec.Errorf(ctx, "must not be null")
3775 }
3776 return graphql.Null
3777 }
3778 res := resTmp.(string)
3779 rctx.Result = res
3780 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3781 return graphql.MarshalString(res)
3782}
3783
3784// nolint: vetshadow
3785func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) graphql.Marshaler {
3786 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3787 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3788 rctx := &graphql.ResolverContext{
3789 Object: "CommentHistoryStep",
3790 Args: nil,
3791 Field: field,
3792 }
3793 ctx = graphql.WithResolverContext(ctx, rctx)
3794 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3795 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3796 ctx = rctx // use context from middleware stack in children
3797 return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
3798 })
3799 if resTmp == nil {
3800 if !ec.HasError(rctx) {
3801 ec.Errorf(ctx, "must not be null")
3802 }
3803 return graphql.Null
3804 }
3805 res := resTmp.(time.Time)
3806 rctx.Result = res
3807 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3808 return graphql.MarshalTime(res)
3809}
3810
3811var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
3812
3813// nolint: gocyclo, errcheck, gas, goconst
3814func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
3815 fields := graphql.CollectFields(ctx, sel, createOperationImplementors)
3816
3817 var wg sync.WaitGroup
3818 out := graphql.NewOrderedMap(len(fields))
3819 invalid := false
3820 for i, field := range fields {
3821 out.Keys[i] = field.Alias
3822
3823 switch field.Name {
3824 case "__typename":
3825 out.Values[i] = graphql.MarshalString("CreateOperation")
3826 case "hash":
3827 out.Values[i] = ec._CreateOperation_hash(ctx, field, obj)
3828 if out.Values[i] == graphql.Null {
3829 invalid = true
3830 }
3831 case "author":
3832 out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
3833 if out.Values[i] == graphql.Null {
3834 invalid = true
3835 }
3836 case "date":
3837 wg.Add(1)
3838 go func(i int, field graphql.CollectedField) {
3839 out.Values[i] = ec._CreateOperation_date(ctx, field, obj)
3840 if out.Values[i] == graphql.Null {
3841 invalid = true
3842 }
3843 wg.Done()
3844 }(i, field)
3845 case "title":
3846 out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
3847 if out.Values[i] == graphql.Null {
3848 invalid = true
3849 }
3850 case "message":
3851 out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
3852 if out.Values[i] == graphql.Null {
3853 invalid = true
3854 }
3855 case "files":
3856 out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
3857 if out.Values[i] == graphql.Null {
3858 invalid = true
3859 }
3860 default:
3861 panic("unknown field " + strconv.Quote(field.Name))
3862 }
3863 }
3864 wg.Wait()
3865 if invalid {
3866 return graphql.Null
3867 }
3868 return out
3869}
3870
3871// nolint: vetshadow
3872func (ec *executionContext) _CreateOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
3873 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3874 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3875 rctx := &graphql.ResolverContext{
3876 Object: "CreateOperation",
3877 Args: nil,
3878 Field: field,
3879 }
3880 ctx = graphql.WithResolverContext(ctx, rctx)
3881 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3882 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3883 ctx = rctx // use context from middleware stack in children
3884 return obj.Hash()
3885 })
3886 if resTmp == nil {
3887 if !ec.HasError(rctx) {
3888 ec.Errorf(ctx, "must not be null")
3889 }
3890 return graphql.Null
3891 }
3892 res := resTmp.(git.Hash)
3893 rctx.Result = res
3894 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3895 return res
3896}
3897
3898// nolint: vetshadow
3899func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
3900 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3901 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3902 rctx := &graphql.ResolverContext{
3903 Object: "CreateOperation",
3904 Args: nil,
3905 Field: field,
3906 }
3907 ctx = graphql.WithResolverContext(ctx, rctx)
3908 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3909 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3910 ctx = rctx // use context from middleware stack in children
3911 return obj.Author, nil
3912 })
3913 if resTmp == nil {
3914 if !ec.HasError(rctx) {
3915 ec.Errorf(ctx, "must not be null")
3916 }
3917 return graphql.Null
3918 }
3919 res := resTmp.(bug.Person)
3920 rctx.Result = res
3921 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3922
3923 return ec._Person(ctx, field.Selections, &res)
3924}
3925
3926// nolint: vetshadow
3927func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
3928 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3929 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3930 rctx := &graphql.ResolverContext{
3931 Object: "CreateOperation",
3932 Args: nil,
3933 Field: field,
3934 }
3935 ctx = graphql.WithResolverContext(ctx, rctx)
3936 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3937 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3938 ctx = rctx // use context from middleware stack in children
3939 return ec.resolvers.CreateOperation().Date(rctx, obj)
3940 })
3941 if resTmp == nil {
3942 if !ec.HasError(rctx) {
3943 ec.Errorf(ctx, "must not be null")
3944 }
3945 return graphql.Null
3946 }
3947 res := resTmp.(time.Time)
3948 rctx.Result = res
3949 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3950 return graphql.MarshalTime(res)
3951}
3952
3953// nolint: vetshadow
3954func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
3955 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3956 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3957 rctx := &graphql.ResolverContext{
3958 Object: "CreateOperation",
3959 Args: nil,
3960 Field: field,
3961 }
3962 ctx = graphql.WithResolverContext(ctx, rctx)
3963 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3964 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3965 ctx = rctx // use context from middleware stack in children
3966 return obj.Title, nil
3967 })
3968 if resTmp == nil {
3969 if !ec.HasError(rctx) {
3970 ec.Errorf(ctx, "must not be null")
3971 }
3972 return graphql.Null
3973 }
3974 res := resTmp.(string)
3975 rctx.Result = res
3976 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3977 return graphql.MarshalString(res)
3978}
3979
3980// nolint: vetshadow
3981func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
3982 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3983 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3984 rctx := &graphql.ResolverContext{
3985 Object: "CreateOperation",
3986 Args: nil,
3987 Field: field,
3988 }
3989 ctx = graphql.WithResolverContext(ctx, rctx)
3990 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3991 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3992 ctx = rctx // use context from middleware stack in children
3993 return obj.Message, nil
3994 })
3995 if resTmp == nil {
3996 if !ec.HasError(rctx) {
3997 ec.Errorf(ctx, "must not be null")
3998 }
3999 return graphql.Null
4000 }
4001 res := resTmp.(string)
4002 rctx.Result = res
4003 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4004 return graphql.MarshalString(res)
4005}
4006
4007// nolint: vetshadow
4008func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
4009 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4010 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4011 rctx := &graphql.ResolverContext{
4012 Object: "CreateOperation",
4013 Args: nil,
4014 Field: field,
4015 }
4016 ctx = graphql.WithResolverContext(ctx, rctx)
4017 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4018 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4019 ctx = rctx // use context from middleware stack in children
4020 return obj.Files, nil
4021 })
4022 if resTmp == nil {
4023 if !ec.HasError(rctx) {
4024 ec.Errorf(ctx, "must not be null")
4025 }
4026 return graphql.Null
4027 }
4028 res := resTmp.([]git.Hash)
4029 rctx.Result = res
4030 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4031
4032 arr1 := make(graphql.Array, len(res))
4033
4034 for idx1 := range res {
4035 arr1[idx1] = func() graphql.Marshaler {
4036 return res[idx1]
4037 }()
4038 }
4039
4040 return arr1
4041}
4042
4043var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem"}
4044
4045// nolint: gocyclo, errcheck, gas, goconst
4046func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
4047 fields := graphql.CollectFields(ctx, sel, createTimelineItemImplementors)
4048
4049 var wg sync.WaitGroup
4050 out := graphql.NewOrderedMap(len(fields))
4051 invalid := false
4052 for i, field := range fields {
4053 out.Keys[i] = field.Alias
4054
4055 switch field.Name {
4056 case "__typename":
4057 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
4058 case "hash":
4059 out.Values[i] = ec._CreateTimelineItem_hash(ctx, field, obj)
4060 if out.Values[i] == graphql.Null {
4061 invalid = true
4062 }
4063 case "author":
4064 out.Values[i] = ec._CreateTimelineItem_author(ctx, field, obj)
4065 if out.Values[i] == graphql.Null {
4066 invalid = true
4067 }
4068 case "message":
4069 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
4070 if out.Values[i] == graphql.Null {
4071 invalid = true
4072 }
4073 case "messageIsEmpty":
4074 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
4075 if out.Values[i] == graphql.Null {
4076 invalid = true
4077 }
4078 case "files":
4079 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
4080 if out.Values[i] == graphql.Null {
4081 invalid = true
4082 }
4083 case "createdAt":
4084 wg.Add(1)
4085 go func(i int, field graphql.CollectedField) {
4086 out.Values[i] = ec._CreateTimelineItem_createdAt(ctx, field, obj)
4087 if out.Values[i] == graphql.Null {
4088 invalid = true
4089 }
4090 wg.Done()
4091 }(i, field)
4092 case "lastEdit":
4093 wg.Add(1)
4094 go func(i int, field graphql.CollectedField) {
4095 out.Values[i] = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
4096 if out.Values[i] == graphql.Null {
4097 invalid = true
4098 }
4099 wg.Done()
4100 }(i, field)
4101 case "edited":
4102 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
4103 if out.Values[i] == graphql.Null {
4104 invalid = true
4105 }
4106 case "history":
4107 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
4108 if out.Values[i] == graphql.Null {
4109 invalid = true
4110 }
4111 default:
4112 panic("unknown field " + strconv.Quote(field.Name))
4113 }
4114 }
4115 wg.Wait()
4116 if invalid {
4117 return graphql.Null
4118 }
4119 return out
4120}
4121
4122// nolint: vetshadow
4123func (ec *executionContext) _CreateTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4124 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4125 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4126 rctx := &graphql.ResolverContext{
4127 Object: "CreateTimelineItem",
4128 Args: nil,
4129 Field: field,
4130 }
4131 ctx = graphql.WithResolverContext(ctx, rctx)
4132 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4133 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4134 ctx = rctx // use context from middleware stack in children
4135 return obj.Hash(), nil
4136 })
4137 if resTmp == nil {
4138 if !ec.HasError(rctx) {
4139 ec.Errorf(ctx, "must not be null")
4140 }
4141 return graphql.Null
4142 }
4143 res := resTmp.(git.Hash)
4144 rctx.Result = res
4145 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4146 return res
4147}
4148
4149// nolint: vetshadow
4150func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4151 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4152 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4153 rctx := &graphql.ResolverContext{
4154 Object: "CreateTimelineItem",
4155 Args: nil,
4156 Field: field,
4157 }
4158 ctx = graphql.WithResolverContext(ctx, rctx)
4159 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4160 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4161 ctx = rctx // use context from middleware stack in children
4162 return obj.Author, nil
4163 })
4164 if resTmp == nil {
4165 if !ec.HasError(rctx) {
4166 ec.Errorf(ctx, "must not be null")
4167 }
4168 return graphql.Null
4169 }
4170 res := resTmp.(bug.Person)
4171 rctx.Result = res
4172 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4173
4174 return ec._Person(ctx, field.Selections, &res)
4175}
4176
4177// nolint: vetshadow
4178func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4179 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4180 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4181 rctx := &graphql.ResolverContext{
4182 Object: "CreateTimelineItem",
4183 Args: nil,
4184 Field: field,
4185 }
4186 ctx = graphql.WithResolverContext(ctx, rctx)
4187 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4188 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4189 ctx = rctx // use context from middleware stack in children
4190 return obj.Message, nil
4191 })
4192 if resTmp == nil {
4193 if !ec.HasError(rctx) {
4194 ec.Errorf(ctx, "must not be null")
4195 }
4196 return graphql.Null
4197 }
4198 res := resTmp.(string)
4199 rctx.Result = res
4200 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4201 return graphql.MarshalString(res)
4202}
4203
4204// nolint: vetshadow
4205func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4206 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4207 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4208 rctx := &graphql.ResolverContext{
4209 Object: "CreateTimelineItem",
4210 Args: nil,
4211 Field: field,
4212 }
4213 ctx = graphql.WithResolverContext(ctx, rctx)
4214 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4215 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4216 ctx = rctx // use context from middleware stack in children
4217 return obj.MessageIsEmpty(), nil
4218 })
4219 if resTmp == nil {
4220 if !ec.HasError(rctx) {
4221 ec.Errorf(ctx, "must not be null")
4222 }
4223 return graphql.Null
4224 }
4225 res := resTmp.(bool)
4226 rctx.Result = res
4227 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4228 return graphql.MarshalBoolean(res)
4229}
4230
4231// nolint: vetshadow
4232func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4233 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4234 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4235 rctx := &graphql.ResolverContext{
4236 Object: "CreateTimelineItem",
4237 Args: nil,
4238 Field: field,
4239 }
4240 ctx = graphql.WithResolverContext(ctx, rctx)
4241 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4242 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4243 ctx = rctx // use context from middleware stack in children
4244 return obj.Files, nil
4245 })
4246 if resTmp == nil {
4247 if !ec.HasError(rctx) {
4248 ec.Errorf(ctx, "must not be null")
4249 }
4250 return graphql.Null
4251 }
4252 res := resTmp.([]git.Hash)
4253 rctx.Result = res
4254 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4255
4256 arr1 := make(graphql.Array, len(res))
4257
4258 for idx1 := range res {
4259 arr1[idx1] = func() graphql.Marshaler {
4260 return res[idx1]
4261 }()
4262 }
4263
4264 return arr1
4265}
4266
4267// nolint: vetshadow
4268func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4269 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4270 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4271 rctx := &graphql.ResolverContext{
4272 Object: "CreateTimelineItem",
4273 Args: nil,
4274 Field: field,
4275 }
4276 ctx = graphql.WithResolverContext(ctx, rctx)
4277 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4278 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4279 ctx = rctx // use context from middleware stack in children
4280 return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
4281 })
4282 if resTmp == nil {
4283 if !ec.HasError(rctx) {
4284 ec.Errorf(ctx, "must not be null")
4285 }
4286 return graphql.Null
4287 }
4288 res := resTmp.(time.Time)
4289 rctx.Result = res
4290 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4291 return graphql.MarshalTime(res)
4292}
4293
4294// nolint: vetshadow
4295func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4296 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4297 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4298 rctx := &graphql.ResolverContext{
4299 Object: "CreateTimelineItem",
4300 Args: nil,
4301 Field: field,
4302 }
4303 ctx = graphql.WithResolverContext(ctx, rctx)
4304 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4305 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4306 ctx = rctx // use context from middleware stack in children
4307 return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
4308 })
4309 if resTmp == nil {
4310 if !ec.HasError(rctx) {
4311 ec.Errorf(ctx, "must not be null")
4312 }
4313 return graphql.Null
4314 }
4315 res := resTmp.(time.Time)
4316 rctx.Result = res
4317 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4318 return graphql.MarshalTime(res)
4319}
4320
4321// nolint: vetshadow
4322func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4323 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4324 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4325 rctx := &graphql.ResolverContext{
4326 Object: "CreateTimelineItem",
4327 Args: nil,
4328 Field: field,
4329 }
4330 ctx = graphql.WithResolverContext(ctx, rctx)
4331 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4332 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4333 ctx = rctx // use context from middleware stack in children
4334 return obj.Edited(), nil
4335 })
4336 if resTmp == nil {
4337 if !ec.HasError(rctx) {
4338 ec.Errorf(ctx, "must not be null")
4339 }
4340 return graphql.Null
4341 }
4342 res := resTmp.(bool)
4343 rctx.Result = res
4344 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4345 return graphql.MarshalBoolean(res)
4346}
4347
4348// nolint: vetshadow
4349func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4350 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4351 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4352 rctx := &graphql.ResolverContext{
4353 Object: "CreateTimelineItem",
4354 Args: nil,
4355 Field: field,
4356 }
4357 ctx = graphql.WithResolverContext(ctx, rctx)
4358 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4359 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4360 ctx = rctx // use context from middleware stack in children
4361 return obj.History, nil
4362 })
4363 if resTmp == nil {
4364 if !ec.HasError(rctx) {
4365 ec.Errorf(ctx, "must not be null")
4366 }
4367 return graphql.Null
4368 }
4369 res := resTmp.([]bug.CommentHistoryStep)
4370 rctx.Result = res
4371 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4372
4373 arr1 := make(graphql.Array, len(res))
4374 var wg sync.WaitGroup
4375
4376 isLen1 := len(res) == 1
4377 if !isLen1 {
4378 wg.Add(len(res))
4379 }
4380
4381 for idx1 := range res {
4382 idx1 := idx1
4383 rctx := &graphql.ResolverContext{
4384 Index: &idx1,
4385 Result: &res[idx1],
4386 }
4387 ctx := graphql.WithResolverContext(ctx, rctx)
4388 f := func(idx1 int) {
4389 if !isLen1 {
4390 defer wg.Done()
4391 }
4392 arr1[idx1] = func() graphql.Marshaler {
4393
4394 return ec._CommentHistoryStep(ctx, field.Selections, &res[idx1])
4395 }()
4396 }
4397 if isLen1 {
4398 f(idx1)
4399 } else {
4400 go f(idx1)
4401 }
4402
4403 }
4404 wg.Wait()
4405 return arr1
4406}
4407
4408var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
4409
4410// nolint: gocyclo, errcheck, gas, goconst
4411func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
4412 fields := graphql.CollectFields(ctx, sel, editCommentOperationImplementors)
4413
4414 var wg sync.WaitGroup
4415 out := graphql.NewOrderedMap(len(fields))
4416 invalid := false
4417 for i, field := range fields {
4418 out.Keys[i] = field.Alias
4419
4420 switch field.Name {
4421 case "__typename":
4422 out.Values[i] = graphql.MarshalString("EditCommentOperation")
4423 case "hash":
4424 out.Values[i] = ec._EditCommentOperation_hash(ctx, field, obj)
4425 if out.Values[i] == graphql.Null {
4426 invalid = true
4427 }
4428 case "author":
4429 out.Values[i] = ec._EditCommentOperation_author(ctx, field, obj)
4430 if out.Values[i] == graphql.Null {
4431 invalid = true
4432 }
4433 case "date":
4434 wg.Add(1)
4435 go func(i int, field graphql.CollectedField) {
4436 out.Values[i] = ec._EditCommentOperation_date(ctx, field, obj)
4437 if out.Values[i] == graphql.Null {
4438 invalid = true
4439 }
4440 wg.Done()
4441 }(i, field)
4442 case "target":
4443 out.Values[i] = ec._EditCommentOperation_target(ctx, field, obj)
4444 if out.Values[i] == graphql.Null {
4445 invalid = true
4446 }
4447 case "message":
4448 out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
4449 if out.Values[i] == graphql.Null {
4450 invalid = true
4451 }
4452 case "files":
4453 out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
4454 if out.Values[i] == graphql.Null {
4455 invalid = true
4456 }
4457 default:
4458 panic("unknown field " + strconv.Quote(field.Name))
4459 }
4460 }
4461 wg.Wait()
4462 if invalid {
4463 return graphql.Null
4464 }
4465 return out
4466}
4467
4468// nolint: vetshadow
4469func (ec *executionContext) _EditCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4470 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4471 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4472 rctx := &graphql.ResolverContext{
4473 Object: "EditCommentOperation",
4474 Args: nil,
4475 Field: field,
4476 }
4477 ctx = graphql.WithResolverContext(ctx, rctx)
4478 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4479 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4480 ctx = rctx // use context from middleware stack in children
4481 return obj.Hash()
4482 })
4483 if resTmp == nil {
4484 if !ec.HasError(rctx) {
4485 ec.Errorf(ctx, "must not be null")
4486 }
4487 return graphql.Null
4488 }
4489 res := resTmp.(git.Hash)
4490 rctx.Result = res
4491 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4492 return res
4493}
4494
4495// nolint: vetshadow
4496func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4497 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4498 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4499 rctx := &graphql.ResolverContext{
4500 Object: "EditCommentOperation",
4501 Args: nil,
4502 Field: field,
4503 }
4504 ctx = graphql.WithResolverContext(ctx, rctx)
4505 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4506 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4507 ctx = rctx // use context from middleware stack in children
4508 return obj.Author, nil
4509 })
4510 if resTmp == nil {
4511 if !ec.HasError(rctx) {
4512 ec.Errorf(ctx, "must not be null")
4513 }
4514 return graphql.Null
4515 }
4516 res := resTmp.(bug.Person)
4517 rctx.Result = res
4518 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4519
4520 return ec._Person(ctx, field.Selections, &res)
4521}
4522
4523// nolint: vetshadow
4524func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4525 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4526 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4527 rctx := &graphql.ResolverContext{
4528 Object: "EditCommentOperation",
4529 Args: nil,
4530 Field: field,
4531 }
4532 ctx = graphql.WithResolverContext(ctx, rctx)
4533 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4534 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4535 ctx = rctx // use context from middleware stack in children
4536 return ec.resolvers.EditCommentOperation().Date(rctx, obj)
4537 })
4538 if resTmp == nil {
4539 if !ec.HasError(rctx) {
4540 ec.Errorf(ctx, "must not be null")
4541 }
4542 return graphql.Null
4543 }
4544 res := resTmp.(time.Time)
4545 rctx.Result = res
4546 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4547 return graphql.MarshalTime(res)
4548}
4549
4550// nolint: vetshadow
4551func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4552 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4553 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4554 rctx := &graphql.ResolverContext{
4555 Object: "EditCommentOperation",
4556 Args: nil,
4557 Field: field,
4558 }
4559 ctx = graphql.WithResolverContext(ctx, rctx)
4560 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4561 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4562 ctx = rctx // use context from middleware stack in children
4563 return obj.Target, nil
4564 })
4565 if resTmp == nil {
4566 if !ec.HasError(rctx) {
4567 ec.Errorf(ctx, "must not be null")
4568 }
4569 return graphql.Null
4570 }
4571 res := resTmp.(git.Hash)
4572 rctx.Result = res
4573 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4574 return res
4575}
4576
4577// nolint: vetshadow
4578func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4579 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4580 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4581 rctx := &graphql.ResolverContext{
4582 Object: "EditCommentOperation",
4583 Args: nil,
4584 Field: field,
4585 }
4586 ctx = graphql.WithResolverContext(ctx, rctx)
4587 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4588 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4589 ctx = rctx // use context from middleware stack in children
4590 return obj.Message, nil
4591 })
4592 if resTmp == nil {
4593 if !ec.HasError(rctx) {
4594 ec.Errorf(ctx, "must not be null")
4595 }
4596 return graphql.Null
4597 }
4598 res := resTmp.(string)
4599 rctx.Result = res
4600 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4601 return graphql.MarshalString(res)
4602}
4603
4604// nolint: vetshadow
4605func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4606 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4607 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4608 rctx := &graphql.ResolverContext{
4609 Object: "EditCommentOperation",
4610 Args: nil,
4611 Field: field,
4612 }
4613 ctx = graphql.WithResolverContext(ctx, rctx)
4614 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4615 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4616 ctx = rctx // use context from middleware stack in children
4617 return obj.Files, nil
4618 })
4619 if resTmp == nil {
4620 if !ec.HasError(rctx) {
4621 ec.Errorf(ctx, "must not be null")
4622 }
4623 return graphql.Null
4624 }
4625 res := resTmp.([]git.Hash)
4626 rctx.Result = res
4627 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4628
4629 arr1 := make(graphql.Array, len(res))
4630
4631 for idx1 := range res {
4632 arr1[idx1] = func() graphql.Marshaler {
4633 return res[idx1]
4634 }()
4635 }
4636
4637 return arr1
4638}
4639
4640var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
4641
4642// nolint: gocyclo, errcheck, gas, goconst
4643func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
4644 fields := graphql.CollectFields(ctx, sel, labelChangeOperationImplementors)
4645
4646 var wg sync.WaitGroup
4647 out := graphql.NewOrderedMap(len(fields))
4648 invalid := false
4649 for i, field := range fields {
4650 out.Keys[i] = field.Alias
4651
4652 switch field.Name {
4653 case "__typename":
4654 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
4655 case "hash":
4656 out.Values[i] = ec._LabelChangeOperation_hash(ctx, field, obj)
4657 if out.Values[i] == graphql.Null {
4658 invalid = true
4659 }
4660 case "author":
4661 out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
4662 if out.Values[i] == graphql.Null {
4663 invalid = true
4664 }
4665 case "date":
4666 wg.Add(1)
4667 go func(i int, field graphql.CollectedField) {
4668 out.Values[i] = ec._LabelChangeOperation_date(ctx, field, obj)
4669 if out.Values[i] == graphql.Null {
4670 invalid = true
4671 }
4672 wg.Done()
4673 }(i, field)
4674 case "added":
4675 out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
4676 if out.Values[i] == graphql.Null {
4677 invalid = true
4678 }
4679 case "removed":
4680 out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
4681 if out.Values[i] == graphql.Null {
4682 invalid = true
4683 }
4684 default:
4685 panic("unknown field " + strconv.Quote(field.Name))
4686 }
4687 }
4688 wg.Wait()
4689 if invalid {
4690 return graphql.Null
4691 }
4692 return out
4693}
4694
4695// nolint: vetshadow
4696func (ec *executionContext) _LabelChangeOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
4697 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4698 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4699 rctx := &graphql.ResolverContext{
4700 Object: "LabelChangeOperation",
4701 Args: nil,
4702 Field: field,
4703 }
4704 ctx = graphql.WithResolverContext(ctx, rctx)
4705 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4706 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4707 ctx = rctx // use context from middleware stack in children
4708 return obj.Hash()
4709 })
4710 if resTmp == nil {
4711 if !ec.HasError(rctx) {
4712 ec.Errorf(ctx, "must not be null")
4713 }
4714 return graphql.Null
4715 }
4716 res := resTmp.(git.Hash)
4717 rctx.Result = res
4718 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4719 return res
4720}
4721
4722// nolint: vetshadow
4723func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
4724 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4725 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4726 rctx := &graphql.ResolverContext{
4727 Object: "LabelChangeOperation",
4728 Args: nil,
4729 Field: field,
4730 }
4731 ctx = graphql.WithResolverContext(ctx, rctx)
4732 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4733 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4734 ctx = rctx // use context from middleware stack in children
4735 return obj.Author, nil
4736 })
4737 if resTmp == nil {
4738 if !ec.HasError(rctx) {
4739 ec.Errorf(ctx, "must not be null")
4740 }
4741 return graphql.Null
4742 }
4743 res := resTmp.(bug.Person)
4744 rctx.Result = res
4745 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4746
4747 return ec._Person(ctx, field.Selections, &res)
4748}
4749
4750// nolint: vetshadow
4751func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
4752 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4753 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4754 rctx := &graphql.ResolverContext{
4755 Object: "LabelChangeOperation",
4756 Args: nil,
4757 Field: field,
4758 }
4759 ctx = graphql.WithResolverContext(ctx, rctx)
4760 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4761 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4762 ctx = rctx // use context from middleware stack in children
4763 return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
4764 })
4765 if resTmp == nil {
4766 if !ec.HasError(rctx) {
4767 ec.Errorf(ctx, "must not be null")
4768 }
4769 return graphql.Null
4770 }
4771 res := resTmp.(time.Time)
4772 rctx.Result = res
4773 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4774 return graphql.MarshalTime(res)
4775}
4776
4777// nolint: vetshadow
4778func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
4779 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4780 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4781 rctx := &graphql.ResolverContext{
4782 Object: "LabelChangeOperation",
4783 Args: nil,
4784 Field: field,
4785 }
4786 ctx = graphql.WithResolverContext(ctx, rctx)
4787 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4788 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4789 ctx = rctx // use context from middleware stack in children
4790 return obj.Added, nil
4791 })
4792 if resTmp == nil {
4793 if !ec.HasError(rctx) {
4794 ec.Errorf(ctx, "must not be null")
4795 }
4796 return graphql.Null
4797 }
4798 res := resTmp.([]bug.Label)
4799 rctx.Result = res
4800 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4801
4802 arr1 := make(graphql.Array, len(res))
4803
4804 for idx1 := range res {
4805 arr1[idx1] = func() graphql.Marshaler {
4806 return res[idx1]
4807 }()
4808 }
4809
4810 return arr1
4811}
4812
4813// nolint: vetshadow
4814func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
4815 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4816 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4817 rctx := &graphql.ResolverContext{
4818 Object: "LabelChangeOperation",
4819 Args: nil,
4820 Field: field,
4821 }
4822 ctx = graphql.WithResolverContext(ctx, rctx)
4823 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4824 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4825 ctx = rctx // use context from middleware stack in children
4826 return obj.Removed, nil
4827 })
4828 if resTmp == nil {
4829 if !ec.HasError(rctx) {
4830 ec.Errorf(ctx, "must not be null")
4831 }
4832 return graphql.Null
4833 }
4834 res := resTmp.([]bug.Label)
4835 rctx.Result = res
4836 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4837
4838 arr1 := make(graphql.Array, len(res))
4839
4840 for idx1 := range res {
4841 arr1[idx1] = func() graphql.Marshaler {
4842 return res[idx1]
4843 }()
4844 }
4845
4846 return arr1
4847}
4848
4849var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem"}
4850
4851// nolint: gocyclo, errcheck, gas, goconst
4852func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
4853 fields := graphql.CollectFields(ctx, sel, labelChangeTimelineItemImplementors)
4854
4855 var wg sync.WaitGroup
4856 out := graphql.NewOrderedMap(len(fields))
4857 invalid := false
4858 for i, field := range fields {
4859 out.Keys[i] = field.Alias
4860
4861 switch field.Name {
4862 case "__typename":
4863 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
4864 case "hash":
4865 out.Values[i] = ec._LabelChangeTimelineItem_hash(ctx, field, obj)
4866 if out.Values[i] == graphql.Null {
4867 invalid = true
4868 }
4869 case "author":
4870 out.Values[i] = ec._LabelChangeTimelineItem_author(ctx, field, obj)
4871 if out.Values[i] == graphql.Null {
4872 invalid = true
4873 }
4874 case "date":
4875 wg.Add(1)
4876 go func(i int, field graphql.CollectedField) {
4877 out.Values[i] = ec._LabelChangeTimelineItem_date(ctx, field, obj)
4878 if out.Values[i] == graphql.Null {
4879 invalid = true
4880 }
4881 wg.Done()
4882 }(i, field)
4883 case "added":
4884 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
4885 if out.Values[i] == graphql.Null {
4886 invalid = true
4887 }
4888 case "removed":
4889 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
4890 if out.Values[i] == graphql.Null {
4891 invalid = true
4892 }
4893 default:
4894 panic("unknown field " + strconv.Quote(field.Name))
4895 }
4896 }
4897 wg.Wait()
4898 if invalid {
4899 return graphql.Null
4900 }
4901 return out
4902}
4903
4904// nolint: vetshadow
4905func (ec *executionContext) _LabelChangeTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
4906 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4907 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4908 rctx := &graphql.ResolverContext{
4909 Object: "LabelChangeTimelineItem",
4910 Args: nil,
4911 Field: field,
4912 }
4913 ctx = graphql.WithResolverContext(ctx, rctx)
4914 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4915 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4916 ctx = rctx // use context from middleware stack in children
4917 return obj.Hash(), nil
4918 })
4919 if resTmp == nil {
4920 if !ec.HasError(rctx) {
4921 ec.Errorf(ctx, "must not be null")
4922 }
4923 return graphql.Null
4924 }
4925 res := resTmp.(git.Hash)
4926 rctx.Result = res
4927 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4928 return res
4929}
4930
4931// nolint: vetshadow
4932func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
4933 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4934 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4935 rctx := &graphql.ResolverContext{
4936 Object: "LabelChangeTimelineItem",
4937 Args: nil,
4938 Field: field,
4939 }
4940 ctx = graphql.WithResolverContext(ctx, rctx)
4941 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4942 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4943 ctx = rctx // use context from middleware stack in children
4944 return obj.Author, nil
4945 })
4946 if resTmp == nil {
4947 if !ec.HasError(rctx) {
4948 ec.Errorf(ctx, "must not be null")
4949 }
4950 return graphql.Null
4951 }
4952 res := resTmp.(bug.Person)
4953 rctx.Result = res
4954 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4955
4956 return ec._Person(ctx, field.Selections, &res)
4957}
4958
4959// nolint: vetshadow
4960func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
4961 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4962 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4963 rctx := &graphql.ResolverContext{
4964 Object: "LabelChangeTimelineItem",
4965 Args: nil,
4966 Field: field,
4967 }
4968 ctx = graphql.WithResolverContext(ctx, rctx)
4969 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4970 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4971 ctx = rctx // use context from middleware stack in children
4972 return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
4973 })
4974 if resTmp == nil {
4975 if !ec.HasError(rctx) {
4976 ec.Errorf(ctx, "must not be null")
4977 }
4978 return graphql.Null
4979 }
4980 res := resTmp.(time.Time)
4981 rctx.Result = res
4982 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4983 return graphql.MarshalTime(res)
4984}
4985
4986// nolint: vetshadow
4987func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
4988 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4989 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4990 rctx := &graphql.ResolverContext{
4991 Object: "LabelChangeTimelineItem",
4992 Args: nil,
4993 Field: field,
4994 }
4995 ctx = graphql.WithResolverContext(ctx, rctx)
4996 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4997 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4998 ctx = rctx // use context from middleware stack in children
4999 return obj.Added, nil
5000 })
5001 if resTmp == nil {
5002 if !ec.HasError(rctx) {
5003 ec.Errorf(ctx, "must not be null")
5004 }
5005 return graphql.Null
5006 }
5007 res := resTmp.([]bug.Label)
5008 rctx.Result = res
5009 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5010
5011 arr1 := make(graphql.Array, len(res))
5012
5013 for idx1 := range res {
5014 arr1[idx1] = func() graphql.Marshaler {
5015 return res[idx1]
5016 }()
5017 }
5018
5019 return arr1
5020}
5021
5022// nolint: vetshadow
5023func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5024 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5025 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5026 rctx := &graphql.ResolverContext{
5027 Object: "LabelChangeTimelineItem",
5028 Args: nil,
5029 Field: field,
5030 }
5031 ctx = graphql.WithResolverContext(ctx, rctx)
5032 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5033 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5034 ctx = rctx // use context from middleware stack in children
5035 return obj.Removed, nil
5036 })
5037 if resTmp == nil {
5038 if !ec.HasError(rctx) {
5039 ec.Errorf(ctx, "must not be null")
5040 }
5041 return graphql.Null
5042 }
5043 res := resTmp.([]bug.Label)
5044 rctx.Result = res
5045 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5046
5047 arr1 := make(graphql.Array, len(res))
5048
5049 for idx1 := range res {
5050 arr1[idx1] = func() graphql.Marshaler {
5051 return res[idx1]
5052 }()
5053 }
5054
5055 return arr1
5056}
5057
5058var mutationImplementors = []string{"Mutation"}
5059
5060// nolint: gocyclo, errcheck, gas, goconst
5061func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
5062 fields := graphql.CollectFields(ctx, sel, mutationImplementors)
5063
5064 ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
5065 Object: "Mutation",
5066 })
5067
5068 out := graphql.NewOrderedMap(len(fields))
5069 invalid := false
5070 for i, field := range fields {
5071 out.Keys[i] = field.Alias
5072
5073 switch field.Name {
5074 case "__typename":
5075 out.Values[i] = graphql.MarshalString("Mutation")
5076 case "newBug":
5077 out.Values[i] = ec._Mutation_newBug(ctx, field)
5078 if out.Values[i] == graphql.Null {
5079 invalid = true
5080 }
5081 case "addComment":
5082 out.Values[i] = ec._Mutation_addComment(ctx, field)
5083 if out.Values[i] == graphql.Null {
5084 invalid = true
5085 }
5086 case "changeLabels":
5087 out.Values[i] = ec._Mutation_changeLabels(ctx, field)
5088 if out.Values[i] == graphql.Null {
5089 invalid = true
5090 }
5091 case "open":
5092 out.Values[i] = ec._Mutation_open(ctx, field)
5093 if out.Values[i] == graphql.Null {
5094 invalid = true
5095 }
5096 case "close":
5097 out.Values[i] = ec._Mutation_close(ctx, field)
5098 if out.Values[i] == graphql.Null {
5099 invalid = true
5100 }
5101 case "setTitle":
5102 out.Values[i] = ec._Mutation_setTitle(ctx, field)
5103 if out.Values[i] == graphql.Null {
5104 invalid = true
5105 }
5106 case "commit":
5107 out.Values[i] = ec._Mutation_commit(ctx, field)
5108 if out.Values[i] == graphql.Null {
5109 invalid = true
5110 }
5111 default:
5112 panic("unknown field " + strconv.Quote(field.Name))
5113 }
5114 }
5115
5116 if invalid {
5117 return graphql.Null
5118 }
5119 return out
5120}
5121
5122// nolint: vetshadow
5123func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5124 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5125 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5126 rawArgs := field.ArgumentMap(ec.Variables)
5127 args, err := field_Mutation_newBug_args(rawArgs)
5128 if err != nil {
5129 ec.Error(ctx, err)
5130 return graphql.Null
5131 }
5132 rctx := &graphql.ResolverContext{
5133 Object: "Mutation",
5134 Args: args,
5135 Field: field,
5136 }
5137 ctx = graphql.WithResolverContext(ctx, rctx)
5138 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5139 resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5140 ctx = rctx // use context from middleware stack in children
5141 return ec.resolvers.Mutation().NewBug(rctx, args["repoRef"].(*string), args["title"].(string), args["message"].(string), args["files"].([]git.Hash))
5142 })
5143 if resTmp == nil {
5144 if !ec.HasError(rctx) {
5145 ec.Errorf(ctx, "must not be null")
5146 }
5147 return graphql.Null
5148 }
5149 res := resTmp.(bug.Snapshot)
5150 rctx.Result = res
5151 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5152
5153 return ec._Bug(ctx, field.Selections, &res)
5154}
5155
5156// nolint: vetshadow
5157func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5158 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5159 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5160 rawArgs := field.ArgumentMap(ec.Variables)
5161 args, err := field_Mutation_addComment_args(rawArgs)
5162 if err != nil {
5163 ec.Error(ctx, err)
5164 return graphql.Null
5165 }
5166 rctx := &graphql.ResolverContext{
5167 Object: "Mutation",
5168 Args: args,
5169 Field: field,
5170 }
5171 ctx = graphql.WithResolverContext(ctx, rctx)
5172 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5173 resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5174 ctx = rctx // use context from middleware stack in children
5175 return ec.resolvers.Mutation().AddComment(rctx, args["repoRef"].(*string), args["prefix"].(string), args["message"].(string), args["files"].([]git.Hash))
5176 })
5177 if resTmp == nil {
5178 if !ec.HasError(rctx) {
5179 ec.Errorf(ctx, "must not be null")
5180 }
5181 return graphql.Null
5182 }
5183 res := resTmp.(bug.Snapshot)
5184 rctx.Result = res
5185 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5186
5187 return ec._Bug(ctx, field.Selections, &res)
5188}
5189
5190// nolint: vetshadow
5191func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5192 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5193 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5194 rawArgs := field.ArgumentMap(ec.Variables)
5195 args, err := field_Mutation_changeLabels_args(rawArgs)
5196 if err != nil {
5197 ec.Error(ctx, err)
5198 return graphql.Null
5199 }
5200 rctx := &graphql.ResolverContext{
5201 Object: "Mutation",
5202 Args: args,
5203 Field: field,
5204 }
5205 ctx = graphql.WithResolverContext(ctx, rctx)
5206 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5207 resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5208 ctx = rctx // use context from middleware stack in children
5209 return ec.resolvers.Mutation().ChangeLabels(rctx, args["repoRef"].(*string), args["prefix"].(string), args["added"].([]string), args["removed"].([]string))
5210 })
5211 if resTmp == nil {
5212 if !ec.HasError(rctx) {
5213 ec.Errorf(ctx, "must not be null")
5214 }
5215 return graphql.Null
5216 }
5217 res := resTmp.(bug.Snapshot)
5218 rctx.Result = res
5219 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5220
5221 return ec._Bug(ctx, field.Selections, &res)
5222}
5223
5224// nolint: vetshadow
5225func (ec *executionContext) _Mutation_open(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5226 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5227 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5228 rawArgs := field.ArgumentMap(ec.Variables)
5229 args, err := field_Mutation_open_args(rawArgs)
5230 if err != nil {
5231 ec.Error(ctx, err)
5232 return graphql.Null
5233 }
5234 rctx := &graphql.ResolverContext{
5235 Object: "Mutation",
5236 Args: args,
5237 Field: field,
5238 }
5239 ctx = graphql.WithResolverContext(ctx, rctx)
5240 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5241 resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5242 ctx = rctx // use context from middleware stack in children
5243 return ec.resolvers.Mutation().Open(rctx, args["repoRef"].(*string), args["prefix"].(string))
5244 })
5245 if resTmp == nil {
5246 if !ec.HasError(rctx) {
5247 ec.Errorf(ctx, "must not be null")
5248 }
5249 return graphql.Null
5250 }
5251 res := resTmp.(bug.Snapshot)
5252 rctx.Result = res
5253 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5254
5255 return ec._Bug(ctx, field.Selections, &res)
5256}
5257
5258// nolint: vetshadow
5259func (ec *executionContext) _Mutation_close(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5260 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5261 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5262 rawArgs := field.ArgumentMap(ec.Variables)
5263 args, err := field_Mutation_close_args(rawArgs)
5264 if err != nil {
5265 ec.Error(ctx, err)
5266 return graphql.Null
5267 }
5268 rctx := &graphql.ResolverContext{
5269 Object: "Mutation",
5270 Args: args,
5271 Field: field,
5272 }
5273 ctx = graphql.WithResolverContext(ctx, rctx)
5274 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5275 resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5276 ctx = rctx // use context from middleware stack in children
5277 return ec.resolvers.Mutation().Close(rctx, args["repoRef"].(*string), args["prefix"].(string))
5278 })
5279 if resTmp == nil {
5280 if !ec.HasError(rctx) {
5281 ec.Errorf(ctx, "must not be null")
5282 }
5283 return graphql.Null
5284 }
5285 res := resTmp.(bug.Snapshot)
5286 rctx.Result = res
5287 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5288
5289 return ec._Bug(ctx, field.Selections, &res)
5290}
5291
5292// nolint: vetshadow
5293func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5294 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5295 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5296 rawArgs := field.ArgumentMap(ec.Variables)
5297 args, err := field_Mutation_setTitle_args(rawArgs)
5298 if err != nil {
5299 ec.Error(ctx, err)
5300 return graphql.Null
5301 }
5302 rctx := &graphql.ResolverContext{
5303 Object: "Mutation",
5304 Args: args,
5305 Field: field,
5306 }
5307 ctx = graphql.WithResolverContext(ctx, rctx)
5308 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5309 resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5310 ctx = rctx // use context from middleware stack in children
5311 return ec.resolvers.Mutation().SetTitle(rctx, args["repoRef"].(*string), args["prefix"].(string), args["title"].(string))
5312 })
5313 if resTmp == nil {
5314 if !ec.HasError(rctx) {
5315 ec.Errorf(ctx, "must not be null")
5316 }
5317 return graphql.Null
5318 }
5319 res := resTmp.(bug.Snapshot)
5320 rctx.Result = res
5321 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5322
5323 return ec._Bug(ctx, field.Selections, &res)
5324}
5325
5326// nolint: vetshadow
5327func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5328 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5329 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5330 rawArgs := field.ArgumentMap(ec.Variables)
5331 args, err := field_Mutation_commit_args(rawArgs)
5332 if err != nil {
5333 ec.Error(ctx, err)
5334 return graphql.Null
5335 }
5336 rctx := &graphql.ResolverContext{
5337 Object: "Mutation",
5338 Args: args,
5339 Field: field,
5340 }
5341 ctx = graphql.WithResolverContext(ctx, rctx)
5342 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5343 resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5344 ctx = rctx // use context from middleware stack in children
5345 return ec.resolvers.Mutation().Commit(rctx, args["repoRef"].(*string), args["prefix"].(string))
5346 })
5347 if resTmp == nil {
5348 if !ec.HasError(rctx) {
5349 ec.Errorf(ctx, "must not be null")
5350 }
5351 return graphql.Null
5352 }
5353 res := resTmp.(bug.Snapshot)
5354 rctx.Result = res
5355 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5356
5357 return ec._Bug(ctx, field.Selections, &res)
5358}
5359
5360var operationConnectionImplementors = []string{"OperationConnection"}
5361
5362// nolint: gocyclo, errcheck, gas, goconst
5363func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
5364 fields := graphql.CollectFields(ctx, sel, operationConnectionImplementors)
5365
5366 out := graphql.NewOrderedMap(len(fields))
5367 invalid := false
5368 for i, field := range fields {
5369 out.Keys[i] = field.Alias
5370
5371 switch field.Name {
5372 case "__typename":
5373 out.Values[i] = graphql.MarshalString("OperationConnection")
5374 case "edges":
5375 out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
5376 if out.Values[i] == graphql.Null {
5377 invalid = true
5378 }
5379 case "nodes":
5380 out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
5381 if out.Values[i] == graphql.Null {
5382 invalid = true
5383 }
5384 case "pageInfo":
5385 out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
5386 if out.Values[i] == graphql.Null {
5387 invalid = true
5388 }
5389 case "totalCount":
5390 out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
5391 if out.Values[i] == graphql.Null {
5392 invalid = true
5393 }
5394 default:
5395 panic("unknown field " + strconv.Quote(field.Name))
5396 }
5397 }
5398
5399 if invalid {
5400 return graphql.Null
5401 }
5402 return out
5403}
5404
5405// nolint: vetshadow
5406func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
5407 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5408 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5409 rctx := &graphql.ResolverContext{
5410 Object: "OperationConnection",
5411 Args: nil,
5412 Field: field,
5413 }
5414 ctx = graphql.WithResolverContext(ctx, rctx)
5415 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5416 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5417 ctx = rctx // use context from middleware stack in children
5418 return obj.Edges, nil
5419 })
5420 if resTmp == nil {
5421 if !ec.HasError(rctx) {
5422 ec.Errorf(ctx, "must not be null")
5423 }
5424 return graphql.Null
5425 }
5426 res := resTmp.([]models.OperationEdge)
5427 rctx.Result = res
5428 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5429
5430 arr1 := make(graphql.Array, len(res))
5431 var wg sync.WaitGroup
5432
5433 isLen1 := len(res) == 1
5434 if !isLen1 {
5435 wg.Add(len(res))
5436 }
5437
5438 for idx1 := range res {
5439 idx1 := idx1
5440 rctx := &graphql.ResolverContext{
5441 Index: &idx1,
5442 Result: &res[idx1],
5443 }
5444 ctx := graphql.WithResolverContext(ctx, rctx)
5445 f := func(idx1 int) {
5446 if !isLen1 {
5447 defer wg.Done()
5448 }
5449 arr1[idx1] = func() graphql.Marshaler {
5450
5451 return ec._OperationEdge(ctx, field.Selections, &res[idx1])
5452 }()
5453 }
5454 if isLen1 {
5455 f(idx1)
5456 } else {
5457 go f(idx1)
5458 }
5459
5460 }
5461 wg.Wait()
5462 return arr1
5463}
5464
5465// nolint: vetshadow
5466func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
5467 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5468 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5469 rctx := &graphql.ResolverContext{
5470 Object: "OperationConnection",
5471 Args: nil,
5472 Field: field,
5473 }
5474 ctx = graphql.WithResolverContext(ctx, rctx)
5475 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5476 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5477 ctx = rctx // use context from middleware stack in children
5478 return obj.Nodes, nil
5479 })
5480 if resTmp == nil {
5481 if !ec.HasError(rctx) {
5482 ec.Errorf(ctx, "must not be null")
5483 }
5484 return graphql.Null
5485 }
5486 res := resTmp.([]bug.Operation)
5487 rctx.Result = res
5488 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5489
5490 arr1 := make(graphql.Array, len(res))
5491 var wg sync.WaitGroup
5492
5493 isLen1 := len(res) == 1
5494 if !isLen1 {
5495 wg.Add(len(res))
5496 }
5497
5498 for idx1 := range res {
5499 idx1 := idx1
5500 rctx := &graphql.ResolverContext{
5501 Index: &idx1,
5502 Result: &res[idx1],
5503 }
5504 ctx := graphql.WithResolverContext(ctx, rctx)
5505 f := func(idx1 int) {
5506 if !isLen1 {
5507 defer wg.Done()
5508 }
5509 arr1[idx1] = func() graphql.Marshaler {
5510
5511 return ec._Operation(ctx, field.Selections, &res[idx1])
5512 }()
5513 }
5514 if isLen1 {
5515 f(idx1)
5516 } else {
5517 go f(idx1)
5518 }
5519
5520 }
5521 wg.Wait()
5522 return arr1
5523}
5524
5525// nolint: vetshadow
5526func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
5527 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5528 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5529 rctx := &graphql.ResolverContext{
5530 Object: "OperationConnection",
5531 Args: nil,
5532 Field: field,
5533 }
5534 ctx = graphql.WithResolverContext(ctx, rctx)
5535 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5536 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5537 ctx = rctx // use context from middleware stack in children
5538 return obj.PageInfo, nil
5539 })
5540 if resTmp == nil {
5541 if !ec.HasError(rctx) {
5542 ec.Errorf(ctx, "must not be null")
5543 }
5544 return graphql.Null
5545 }
5546 res := resTmp.(models.PageInfo)
5547 rctx.Result = res
5548 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5549
5550 return ec._PageInfo(ctx, field.Selections, &res)
5551}
5552
5553// nolint: vetshadow
5554func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
5555 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5556 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5557 rctx := &graphql.ResolverContext{
5558 Object: "OperationConnection",
5559 Args: nil,
5560 Field: field,
5561 }
5562 ctx = graphql.WithResolverContext(ctx, rctx)
5563 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5564 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5565 ctx = rctx // use context from middleware stack in children
5566 return obj.TotalCount, nil
5567 })
5568 if resTmp == nil {
5569 if !ec.HasError(rctx) {
5570 ec.Errorf(ctx, "must not be null")
5571 }
5572 return graphql.Null
5573 }
5574 res := resTmp.(int)
5575 rctx.Result = res
5576 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5577 return graphql.MarshalInt(res)
5578}
5579
5580var operationEdgeImplementors = []string{"OperationEdge"}
5581
5582// nolint: gocyclo, errcheck, gas, goconst
5583func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
5584 fields := graphql.CollectFields(ctx, sel, operationEdgeImplementors)
5585
5586 out := graphql.NewOrderedMap(len(fields))
5587 invalid := false
5588 for i, field := range fields {
5589 out.Keys[i] = field.Alias
5590
5591 switch field.Name {
5592 case "__typename":
5593 out.Values[i] = graphql.MarshalString("OperationEdge")
5594 case "cursor":
5595 out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
5596 if out.Values[i] == graphql.Null {
5597 invalid = true
5598 }
5599 case "node":
5600 out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
5601 if out.Values[i] == graphql.Null {
5602 invalid = true
5603 }
5604 default:
5605 panic("unknown field " + strconv.Quote(field.Name))
5606 }
5607 }
5608
5609 if invalid {
5610 return graphql.Null
5611 }
5612 return out
5613}
5614
5615// nolint: vetshadow
5616func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
5617 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5618 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5619 rctx := &graphql.ResolverContext{
5620 Object: "OperationEdge",
5621 Args: nil,
5622 Field: field,
5623 }
5624 ctx = graphql.WithResolverContext(ctx, rctx)
5625 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5626 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5627 ctx = rctx // use context from middleware stack in children
5628 return obj.Cursor, nil
5629 })
5630 if resTmp == nil {
5631 if !ec.HasError(rctx) {
5632 ec.Errorf(ctx, "must not be null")
5633 }
5634 return graphql.Null
5635 }
5636 res := resTmp.(string)
5637 rctx.Result = res
5638 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5639 return graphql.MarshalString(res)
5640}
5641
5642// nolint: vetshadow
5643func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
5644 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5645 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5646 rctx := &graphql.ResolverContext{
5647 Object: "OperationEdge",
5648 Args: nil,
5649 Field: field,
5650 }
5651 ctx = graphql.WithResolverContext(ctx, rctx)
5652 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5653 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5654 ctx = rctx // use context from middleware stack in children
5655 return obj.Node, nil
5656 })
5657 if resTmp == nil {
5658 if !ec.HasError(rctx) {
5659 ec.Errorf(ctx, "must not be null")
5660 }
5661 return graphql.Null
5662 }
5663 res := resTmp.(bug.Operation)
5664 rctx.Result = res
5665 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5666
5667 return ec._Operation(ctx, field.Selections, &res)
5668}
5669
5670var pageInfoImplementors = []string{"PageInfo"}
5671
5672// nolint: gocyclo, errcheck, gas, goconst
5673func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
5674 fields := graphql.CollectFields(ctx, sel, pageInfoImplementors)
5675
5676 out := graphql.NewOrderedMap(len(fields))
5677 invalid := false
5678 for i, field := range fields {
5679 out.Keys[i] = field.Alias
5680
5681 switch field.Name {
5682 case "__typename":
5683 out.Values[i] = graphql.MarshalString("PageInfo")
5684 case "hasNextPage":
5685 out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
5686 if out.Values[i] == graphql.Null {
5687 invalid = true
5688 }
5689 case "hasPreviousPage":
5690 out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
5691 if out.Values[i] == graphql.Null {
5692 invalid = true
5693 }
5694 case "startCursor":
5695 out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
5696 if out.Values[i] == graphql.Null {
5697 invalid = true
5698 }
5699 case "endCursor":
5700 out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
5701 if out.Values[i] == graphql.Null {
5702 invalid = true
5703 }
5704 default:
5705 panic("unknown field " + strconv.Quote(field.Name))
5706 }
5707 }
5708
5709 if invalid {
5710 return graphql.Null
5711 }
5712 return out
5713}
5714
5715// nolint: vetshadow
5716func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
5717 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5718 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5719 rctx := &graphql.ResolverContext{
5720 Object: "PageInfo",
5721 Args: nil,
5722 Field: field,
5723 }
5724 ctx = graphql.WithResolverContext(ctx, rctx)
5725 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5726 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5727 ctx = rctx // use context from middleware stack in children
5728 return obj.HasNextPage, nil
5729 })
5730 if resTmp == nil {
5731 if !ec.HasError(rctx) {
5732 ec.Errorf(ctx, "must not be null")
5733 }
5734 return graphql.Null
5735 }
5736 res := resTmp.(bool)
5737 rctx.Result = res
5738 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5739 return graphql.MarshalBoolean(res)
5740}
5741
5742// nolint: vetshadow
5743func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
5744 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5745 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5746 rctx := &graphql.ResolverContext{
5747 Object: "PageInfo",
5748 Args: nil,
5749 Field: field,
5750 }
5751 ctx = graphql.WithResolverContext(ctx, rctx)
5752 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5753 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5754 ctx = rctx // use context from middleware stack in children
5755 return obj.HasPreviousPage, nil
5756 })
5757 if resTmp == nil {
5758 if !ec.HasError(rctx) {
5759 ec.Errorf(ctx, "must not be null")
5760 }
5761 return graphql.Null
5762 }
5763 res := resTmp.(bool)
5764 rctx.Result = res
5765 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5766 return graphql.MarshalBoolean(res)
5767}
5768
5769// nolint: vetshadow
5770func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
5771 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5772 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5773 rctx := &graphql.ResolverContext{
5774 Object: "PageInfo",
5775 Args: nil,
5776 Field: field,
5777 }
5778 ctx = graphql.WithResolverContext(ctx, rctx)
5779 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5780 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5781 ctx = rctx // use context from middleware stack in children
5782 return obj.StartCursor, nil
5783 })
5784 if resTmp == nil {
5785 if !ec.HasError(rctx) {
5786 ec.Errorf(ctx, "must not be null")
5787 }
5788 return graphql.Null
5789 }
5790 res := resTmp.(string)
5791 rctx.Result = res
5792 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5793 return graphql.MarshalString(res)
5794}
5795
5796// nolint: vetshadow
5797func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
5798 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5799 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5800 rctx := &graphql.ResolverContext{
5801 Object: "PageInfo",
5802 Args: nil,
5803 Field: field,
5804 }
5805 ctx = graphql.WithResolverContext(ctx, rctx)
5806 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5807 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5808 ctx = rctx // use context from middleware stack in children
5809 return obj.EndCursor, nil
5810 })
5811 if resTmp == nil {
5812 if !ec.HasError(rctx) {
5813 ec.Errorf(ctx, "must not be null")
5814 }
5815 return graphql.Null
5816 }
5817 res := resTmp.(string)
5818 rctx.Result = res
5819 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5820 return graphql.MarshalString(res)
5821}
5822
5823var personImplementors = []string{"Person"}
5824
5825// nolint: gocyclo, errcheck, gas, goconst
5826func (ec *executionContext) _Person(ctx context.Context, sel ast.SelectionSet, obj *bug.Person) graphql.Marshaler {
5827 fields := graphql.CollectFields(ctx, sel, personImplementors)
5828
5829 var wg sync.WaitGroup
5830 out := graphql.NewOrderedMap(len(fields))
5831 invalid := false
5832 for i, field := range fields {
5833 out.Keys[i] = field.Alias
5834
5835 switch field.Name {
5836 case "__typename":
5837 out.Values[i] = graphql.MarshalString("Person")
5838 case "name":
5839 wg.Add(1)
5840 go func(i int, field graphql.CollectedField) {
5841 out.Values[i] = ec._Person_name(ctx, field, obj)
5842 wg.Done()
5843 }(i, field)
5844 case "email":
5845 wg.Add(1)
5846 go func(i int, field graphql.CollectedField) {
5847 out.Values[i] = ec._Person_email(ctx, field, obj)
5848 wg.Done()
5849 }(i, field)
5850 case "login":
5851 wg.Add(1)
5852 go func(i int, field graphql.CollectedField) {
5853 out.Values[i] = ec._Person_login(ctx, field, obj)
5854 wg.Done()
5855 }(i, field)
5856 case "displayName":
5857 out.Values[i] = ec._Person_displayName(ctx, field, obj)
5858 if out.Values[i] == graphql.Null {
5859 invalid = true
5860 }
5861 case "avatarUrl":
5862 wg.Add(1)
5863 go func(i int, field graphql.CollectedField) {
5864 out.Values[i] = ec._Person_avatarUrl(ctx, field, obj)
5865 wg.Done()
5866 }(i, field)
5867 default:
5868 panic("unknown field " + strconv.Quote(field.Name))
5869 }
5870 }
5871 wg.Wait()
5872 if invalid {
5873 return graphql.Null
5874 }
5875 return out
5876}
5877
5878// nolint: vetshadow
5879func (ec *executionContext) _Person_name(ctx context.Context, field graphql.CollectedField, obj *bug.Person) graphql.Marshaler {
5880 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5881 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5882 rctx := &graphql.ResolverContext{
5883 Object: "Person",
5884 Args: nil,
5885 Field: field,
5886 }
5887 ctx = graphql.WithResolverContext(ctx, rctx)
5888 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5889 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5890 ctx = rctx // use context from middleware stack in children
5891 return ec.resolvers.Person().Name(rctx, obj)
5892 })
5893 if resTmp == nil {
5894 return graphql.Null
5895 }
5896 res := resTmp.(*string)
5897 rctx.Result = res
5898 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5899
5900 if res == nil {
5901 return graphql.Null
5902 }
5903 return graphql.MarshalString(*res)
5904}
5905
5906// nolint: vetshadow
5907func (ec *executionContext) _Person_email(ctx context.Context, field graphql.CollectedField, obj *bug.Person) graphql.Marshaler {
5908 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5909 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5910 rctx := &graphql.ResolverContext{
5911 Object: "Person",
5912 Args: nil,
5913 Field: field,
5914 }
5915 ctx = graphql.WithResolverContext(ctx, rctx)
5916 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5917 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5918 ctx = rctx // use context from middleware stack in children
5919 return ec.resolvers.Person().Email(rctx, obj)
5920 })
5921 if resTmp == nil {
5922 return graphql.Null
5923 }
5924 res := resTmp.(*string)
5925 rctx.Result = res
5926 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5927
5928 if res == nil {
5929 return graphql.Null
5930 }
5931 return graphql.MarshalString(*res)
5932}
5933
5934// nolint: vetshadow
5935func (ec *executionContext) _Person_login(ctx context.Context, field graphql.CollectedField, obj *bug.Person) graphql.Marshaler {
5936 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5937 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5938 rctx := &graphql.ResolverContext{
5939 Object: "Person",
5940 Args: nil,
5941 Field: field,
5942 }
5943 ctx = graphql.WithResolverContext(ctx, rctx)
5944 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5945 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5946 ctx = rctx // use context from middleware stack in children
5947 return ec.resolvers.Person().Login(rctx, obj)
5948 })
5949 if resTmp == nil {
5950 return graphql.Null
5951 }
5952 res := resTmp.(*string)
5953 rctx.Result = res
5954 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5955
5956 if res == nil {
5957 return graphql.Null
5958 }
5959 return graphql.MarshalString(*res)
5960}
5961
5962// nolint: vetshadow
5963func (ec *executionContext) _Person_displayName(ctx context.Context, field graphql.CollectedField, obj *bug.Person) graphql.Marshaler {
5964 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5965 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5966 rctx := &graphql.ResolverContext{
5967 Object: "Person",
5968 Args: nil,
5969 Field: field,
5970 }
5971 ctx = graphql.WithResolverContext(ctx, rctx)
5972 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5973 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5974 ctx = rctx // use context from middleware stack in children
5975 return obj.DisplayName(), nil
5976 })
5977 if resTmp == nil {
5978 if !ec.HasError(rctx) {
5979 ec.Errorf(ctx, "must not be null")
5980 }
5981 return graphql.Null
5982 }
5983 res := resTmp.(string)
5984 rctx.Result = res
5985 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5986 return graphql.MarshalString(res)
5987}
5988
5989// nolint: vetshadow
5990func (ec *executionContext) _Person_avatarUrl(ctx context.Context, field graphql.CollectedField, obj *bug.Person) graphql.Marshaler {
5991 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5992 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5993 rctx := &graphql.ResolverContext{
5994 Object: "Person",
5995 Args: nil,
5996 Field: field,
5997 }
5998 ctx = graphql.WithResolverContext(ctx, rctx)
5999 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6000 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6001 ctx = rctx // use context from middleware stack in children
6002 return ec.resolvers.Person().AvatarURL(rctx, obj)
6003 })
6004 if resTmp == nil {
6005 return graphql.Null
6006 }
6007 res := resTmp.(*string)
6008 rctx.Result = res
6009 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6010
6011 if res == nil {
6012 return graphql.Null
6013 }
6014 return graphql.MarshalString(*res)
6015}
6016
6017var queryImplementors = []string{"Query"}
6018
6019// nolint: gocyclo, errcheck, gas, goconst
6020func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
6021 fields := graphql.CollectFields(ctx, sel, queryImplementors)
6022
6023 ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
6024 Object: "Query",
6025 })
6026
6027 var wg sync.WaitGroup
6028 out := graphql.NewOrderedMap(len(fields))
6029 invalid := false
6030 for i, field := range fields {
6031 out.Keys[i] = field.Alias
6032
6033 switch field.Name {
6034 case "__typename":
6035 out.Values[i] = graphql.MarshalString("Query")
6036 case "defaultRepository":
6037 wg.Add(1)
6038 go func(i int, field graphql.CollectedField) {
6039 out.Values[i] = ec._Query_defaultRepository(ctx, field)
6040 wg.Done()
6041 }(i, field)
6042 case "repository":
6043 wg.Add(1)
6044 go func(i int, field graphql.CollectedField) {
6045 out.Values[i] = ec._Query_repository(ctx, field)
6046 wg.Done()
6047 }(i, field)
6048 case "__type":
6049 out.Values[i] = ec._Query___type(ctx, field)
6050 case "__schema":
6051 out.Values[i] = ec._Query___schema(ctx, field)
6052 default:
6053 panic("unknown field " + strconv.Quote(field.Name))
6054 }
6055 }
6056 wg.Wait()
6057 if invalid {
6058 return graphql.Null
6059 }
6060 return out
6061}
6062
6063// nolint: vetshadow
6064func (ec *executionContext) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6065 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6066 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6067 rctx := &graphql.ResolverContext{
6068 Object: "Query",
6069 Args: nil,
6070 Field: field,
6071 }
6072 ctx = graphql.WithResolverContext(ctx, rctx)
6073 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6074 resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6075 ctx = rctx // use context from middleware stack in children
6076 return ec.resolvers.Query().DefaultRepository(rctx)
6077 })
6078 if resTmp == nil {
6079 return graphql.Null
6080 }
6081 res := resTmp.(*models.Repository)
6082 rctx.Result = res
6083 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6084
6085 if res == nil {
6086 return graphql.Null
6087 }
6088
6089 return ec._Repository(ctx, field.Selections, res)
6090}
6091
6092// nolint: vetshadow
6093func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6094 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6095 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6096 rawArgs := field.ArgumentMap(ec.Variables)
6097 args, err := field_Query_repository_args(rawArgs)
6098 if err != nil {
6099 ec.Error(ctx, err)
6100 return graphql.Null
6101 }
6102 rctx := &graphql.ResolverContext{
6103 Object: "Query",
6104 Args: args,
6105 Field: field,
6106 }
6107 ctx = graphql.WithResolverContext(ctx, rctx)
6108 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6109 resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6110 ctx = rctx // use context from middleware stack in children
6111 return ec.resolvers.Query().Repository(rctx, args["id"].(string))
6112 })
6113 if resTmp == nil {
6114 return graphql.Null
6115 }
6116 res := resTmp.(*models.Repository)
6117 rctx.Result = res
6118 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6119
6120 if res == nil {
6121 return graphql.Null
6122 }
6123
6124 return ec._Repository(ctx, field.Selections, res)
6125}
6126
6127// nolint: vetshadow
6128func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6129 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6130 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6131 rawArgs := field.ArgumentMap(ec.Variables)
6132 args, err := field_Query___type_args(rawArgs)
6133 if err != nil {
6134 ec.Error(ctx, err)
6135 return graphql.Null
6136 }
6137 rctx := &graphql.ResolverContext{
6138 Object: "Query",
6139 Args: args,
6140 Field: field,
6141 }
6142 ctx = graphql.WithResolverContext(ctx, rctx)
6143 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6144 resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6145 ctx = rctx // use context from middleware stack in children
6146 return ec.introspectType(args["name"].(string))
6147 })
6148 if resTmp == nil {
6149 return graphql.Null
6150 }
6151 res := resTmp.(*introspection.Type)
6152 rctx.Result = res
6153 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6154
6155 if res == nil {
6156 return graphql.Null
6157 }
6158
6159 return ec.___Type(ctx, field.Selections, res)
6160}
6161
6162// nolint: vetshadow
6163func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6164 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6165 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6166 rctx := &graphql.ResolverContext{
6167 Object: "Query",
6168 Args: nil,
6169 Field: field,
6170 }
6171 ctx = graphql.WithResolverContext(ctx, rctx)
6172 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6173 resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6174 ctx = rctx // use context from middleware stack in children
6175 return ec.introspectSchema()
6176 })
6177 if resTmp == nil {
6178 return graphql.Null
6179 }
6180 res := resTmp.(*introspection.Schema)
6181 rctx.Result = res
6182 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6183
6184 if res == nil {
6185 return graphql.Null
6186 }
6187
6188 return ec.___Schema(ctx, field.Selections, res)
6189}
6190
6191var repositoryImplementors = []string{"Repository"}
6192
6193// nolint: gocyclo, errcheck, gas, goconst
6194func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
6195 fields := graphql.CollectFields(ctx, sel, repositoryImplementors)
6196
6197 var wg sync.WaitGroup
6198 out := graphql.NewOrderedMap(len(fields))
6199 invalid := false
6200 for i, field := range fields {
6201 out.Keys[i] = field.Alias
6202
6203 switch field.Name {
6204 case "__typename":
6205 out.Values[i] = graphql.MarshalString("Repository")
6206 case "allBugs":
6207 wg.Add(1)
6208 go func(i int, field graphql.CollectedField) {
6209 out.Values[i] = ec._Repository_allBugs(ctx, field, obj)
6210 if out.Values[i] == graphql.Null {
6211 invalid = true
6212 }
6213 wg.Done()
6214 }(i, field)
6215 case "bug":
6216 wg.Add(1)
6217 go func(i int, field graphql.CollectedField) {
6218 out.Values[i] = ec._Repository_bug(ctx, field, obj)
6219 wg.Done()
6220 }(i, field)
6221 default:
6222 panic("unknown field " + strconv.Quote(field.Name))
6223 }
6224 }
6225 wg.Wait()
6226 if invalid {
6227 return graphql.Null
6228 }
6229 return out
6230}
6231
6232// nolint: vetshadow
6233func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
6234 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6235 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6236 rawArgs := field.ArgumentMap(ec.Variables)
6237 args, err := field_Repository_allBugs_args(rawArgs)
6238 if err != nil {
6239 ec.Error(ctx, err)
6240 return graphql.Null
6241 }
6242 rctx := &graphql.ResolverContext{
6243 Object: "Repository",
6244 Args: args,
6245 Field: field,
6246 }
6247 ctx = graphql.WithResolverContext(ctx, rctx)
6248 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6249 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6250 ctx = rctx // use context from middleware stack in children
6251 return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
6252 })
6253 if resTmp == nil {
6254 if !ec.HasError(rctx) {
6255 ec.Errorf(ctx, "must not be null")
6256 }
6257 return graphql.Null
6258 }
6259 res := resTmp.(models.BugConnection)
6260 rctx.Result = res
6261 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6262
6263 return ec._BugConnection(ctx, field.Selections, &res)
6264}
6265
6266// nolint: vetshadow
6267func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
6268 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6269 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6270 rawArgs := field.ArgumentMap(ec.Variables)
6271 args, err := field_Repository_bug_args(rawArgs)
6272 if err != nil {
6273 ec.Error(ctx, err)
6274 return graphql.Null
6275 }
6276 rctx := &graphql.ResolverContext{
6277 Object: "Repository",
6278 Args: args,
6279 Field: field,
6280 }
6281 ctx = graphql.WithResolverContext(ctx, rctx)
6282 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6283 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6284 ctx = rctx // use context from middleware stack in children
6285 return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
6286 })
6287 if resTmp == nil {
6288 return graphql.Null
6289 }
6290 res := resTmp.(*bug.Snapshot)
6291 rctx.Result = res
6292 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6293
6294 if res == nil {
6295 return graphql.Null
6296 }
6297
6298 return ec._Bug(ctx, field.Selections, res)
6299}
6300
6301var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
6302
6303// nolint: gocyclo, errcheck, gas, goconst
6304func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
6305 fields := graphql.CollectFields(ctx, sel, setStatusOperationImplementors)
6306
6307 var wg sync.WaitGroup
6308 out := graphql.NewOrderedMap(len(fields))
6309 invalid := false
6310 for i, field := range fields {
6311 out.Keys[i] = field.Alias
6312
6313 switch field.Name {
6314 case "__typename":
6315 out.Values[i] = graphql.MarshalString("SetStatusOperation")
6316 case "hash":
6317 out.Values[i] = ec._SetStatusOperation_hash(ctx, field, obj)
6318 if out.Values[i] == graphql.Null {
6319 invalid = true
6320 }
6321 case "author":
6322 out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
6323 if out.Values[i] == graphql.Null {
6324 invalid = true
6325 }
6326 case "date":
6327 wg.Add(1)
6328 go func(i int, field graphql.CollectedField) {
6329 out.Values[i] = ec._SetStatusOperation_date(ctx, field, obj)
6330 if out.Values[i] == graphql.Null {
6331 invalid = true
6332 }
6333 wg.Done()
6334 }(i, field)
6335 case "status":
6336 wg.Add(1)
6337 go func(i int, field graphql.CollectedField) {
6338 out.Values[i] = ec._SetStatusOperation_status(ctx, field, obj)
6339 if out.Values[i] == graphql.Null {
6340 invalid = true
6341 }
6342 wg.Done()
6343 }(i, field)
6344 default:
6345 panic("unknown field " + strconv.Quote(field.Name))
6346 }
6347 }
6348 wg.Wait()
6349 if invalid {
6350 return graphql.Null
6351 }
6352 return out
6353}
6354
6355// nolint: vetshadow
6356func (ec *executionContext) _SetStatusOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
6357 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6358 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6359 rctx := &graphql.ResolverContext{
6360 Object: "SetStatusOperation",
6361 Args: nil,
6362 Field: field,
6363 }
6364 ctx = graphql.WithResolverContext(ctx, rctx)
6365 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6366 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6367 ctx = rctx // use context from middleware stack in children
6368 return obj.Hash()
6369 })
6370 if resTmp == nil {
6371 if !ec.HasError(rctx) {
6372 ec.Errorf(ctx, "must not be null")
6373 }
6374 return graphql.Null
6375 }
6376 res := resTmp.(git.Hash)
6377 rctx.Result = res
6378 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6379 return res
6380}
6381
6382// nolint: vetshadow
6383func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
6384 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6385 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6386 rctx := &graphql.ResolverContext{
6387 Object: "SetStatusOperation",
6388 Args: nil,
6389 Field: field,
6390 }
6391 ctx = graphql.WithResolverContext(ctx, rctx)
6392 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6393 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6394 ctx = rctx // use context from middleware stack in children
6395 return obj.Author, nil
6396 })
6397 if resTmp == nil {
6398 if !ec.HasError(rctx) {
6399 ec.Errorf(ctx, "must not be null")
6400 }
6401 return graphql.Null
6402 }
6403 res := resTmp.(bug.Person)
6404 rctx.Result = res
6405 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6406
6407 return ec._Person(ctx, field.Selections, &res)
6408}
6409
6410// nolint: vetshadow
6411func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
6412 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6413 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6414 rctx := &graphql.ResolverContext{
6415 Object: "SetStatusOperation",
6416 Args: nil,
6417 Field: field,
6418 }
6419 ctx = graphql.WithResolverContext(ctx, rctx)
6420 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6421 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6422 ctx = rctx // use context from middleware stack in children
6423 return ec.resolvers.SetStatusOperation().Date(rctx, obj)
6424 })
6425 if resTmp == nil {
6426 if !ec.HasError(rctx) {
6427 ec.Errorf(ctx, "must not be null")
6428 }
6429 return graphql.Null
6430 }
6431 res := resTmp.(time.Time)
6432 rctx.Result = res
6433 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6434 return graphql.MarshalTime(res)
6435}
6436
6437// nolint: vetshadow
6438func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
6439 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6440 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6441 rctx := &graphql.ResolverContext{
6442 Object: "SetStatusOperation",
6443 Args: nil,
6444 Field: field,
6445 }
6446 ctx = graphql.WithResolverContext(ctx, rctx)
6447 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6448 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6449 ctx = rctx // use context from middleware stack in children
6450 return ec.resolvers.SetStatusOperation().Status(rctx, obj)
6451 })
6452 if resTmp == nil {
6453 if !ec.HasError(rctx) {
6454 ec.Errorf(ctx, "must not be null")
6455 }
6456 return graphql.Null
6457 }
6458 res := resTmp.(models.Status)
6459 rctx.Result = res
6460 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6461 return res
6462}
6463
6464var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem"}
6465
6466// nolint: gocyclo, errcheck, gas, goconst
6467func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
6468 fields := graphql.CollectFields(ctx, sel, setStatusTimelineItemImplementors)
6469
6470 var wg sync.WaitGroup
6471 out := graphql.NewOrderedMap(len(fields))
6472 invalid := false
6473 for i, field := range fields {
6474 out.Keys[i] = field.Alias
6475
6476 switch field.Name {
6477 case "__typename":
6478 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
6479 case "hash":
6480 out.Values[i] = ec._SetStatusTimelineItem_hash(ctx, field, obj)
6481 if out.Values[i] == graphql.Null {
6482 invalid = true
6483 }
6484 case "author":
6485 out.Values[i] = ec._SetStatusTimelineItem_author(ctx, field, obj)
6486 if out.Values[i] == graphql.Null {
6487 invalid = true
6488 }
6489 case "date":
6490 wg.Add(1)
6491 go func(i int, field graphql.CollectedField) {
6492 out.Values[i] = ec._SetStatusTimelineItem_date(ctx, field, obj)
6493 if out.Values[i] == graphql.Null {
6494 invalid = true
6495 }
6496 wg.Done()
6497 }(i, field)
6498 case "status":
6499 wg.Add(1)
6500 go func(i int, field graphql.CollectedField) {
6501 out.Values[i] = ec._SetStatusTimelineItem_status(ctx, field, obj)
6502 if out.Values[i] == graphql.Null {
6503 invalid = true
6504 }
6505 wg.Done()
6506 }(i, field)
6507 default:
6508 panic("unknown field " + strconv.Quote(field.Name))
6509 }
6510 }
6511 wg.Wait()
6512 if invalid {
6513 return graphql.Null
6514 }
6515 return out
6516}
6517
6518// nolint: vetshadow
6519func (ec *executionContext) _SetStatusTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
6520 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6521 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6522 rctx := &graphql.ResolverContext{
6523 Object: "SetStatusTimelineItem",
6524 Args: nil,
6525 Field: field,
6526 }
6527 ctx = graphql.WithResolverContext(ctx, rctx)
6528 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6529 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6530 ctx = rctx // use context from middleware stack in children
6531 return obj.Hash(), nil
6532 })
6533 if resTmp == nil {
6534 if !ec.HasError(rctx) {
6535 ec.Errorf(ctx, "must not be null")
6536 }
6537 return graphql.Null
6538 }
6539 res := resTmp.(git.Hash)
6540 rctx.Result = res
6541 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6542 return res
6543}
6544
6545// nolint: vetshadow
6546func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
6547 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6548 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6549 rctx := &graphql.ResolverContext{
6550 Object: "SetStatusTimelineItem",
6551 Args: nil,
6552 Field: field,
6553 }
6554 ctx = graphql.WithResolverContext(ctx, rctx)
6555 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6556 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6557 ctx = rctx // use context from middleware stack in children
6558 return obj.Author, nil
6559 })
6560 if resTmp == nil {
6561 if !ec.HasError(rctx) {
6562 ec.Errorf(ctx, "must not be null")
6563 }
6564 return graphql.Null
6565 }
6566 res := resTmp.(bug.Person)
6567 rctx.Result = res
6568 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6569
6570 return ec._Person(ctx, field.Selections, &res)
6571}
6572
6573// nolint: vetshadow
6574func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
6575 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6576 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6577 rctx := &graphql.ResolverContext{
6578 Object: "SetStatusTimelineItem",
6579 Args: nil,
6580 Field: field,
6581 }
6582 ctx = graphql.WithResolverContext(ctx, rctx)
6583 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6584 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6585 ctx = rctx // use context from middleware stack in children
6586 return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
6587 })
6588 if resTmp == nil {
6589 if !ec.HasError(rctx) {
6590 ec.Errorf(ctx, "must not be null")
6591 }
6592 return graphql.Null
6593 }
6594 res := resTmp.(time.Time)
6595 rctx.Result = res
6596 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6597 return graphql.MarshalTime(res)
6598}
6599
6600// nolint: vetshadow
6601func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
6602 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6603 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6604 rctx := &graphql.ResolverContext{
6605 Object: "SetStatusTimelineItem",
6606 Args: nil,
6607 Field: field,
6608 }
6609 ctx = graphql.WithResolverContext(ctx, rctx)
6610 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6611 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6612 ctx = rctx // use context from middleware stack in children
6613 return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
6614 })
6615 if resTmp == nil {
6616 if !ec.HasError(rctx) {
6617 ec.Errorf(ctx, "must not be null")
6618 }
6619 return graphql.Null
6620 }
6621 res := resTmp.(models.Status)
6622 rctx.Result = res
6623 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6624 return res
6625}
6626
6627var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
6628
6629// nolint: gocyclo, errcheck, gas, goconst
6630func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
6631 fields := graphql.CollectFields(ctx, sel, setTitleOperationImplementors)
6632
6633 var wg sync.WaitGroup
6634 out := graphql.NewOrderedMap(len(fields))
6635 invalid := false
6636 for i, field := range fields {
6637 out.Keys[i] = field.Alias
6638
6639 switch field.Name {
6640 case "__typename":
6641 out.Values[i] = graphql.MarshalString("SetTitleOperation")
6642 case "hash":
6643 out.Values[i] = ec._SetTitleOperation_hash(ctx, field, obj)
6644 if out.Values[i] == graphql.Null {
6645 invalid = true
6646 }
6647 case "author":
6648 out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
6649 if out.Values[i] == graphql.Null {
6650 invalid = true
6651 }
6652 case "date":
6653 wg.Add(1)
6654 go func(i int, field graphql.CollectedField) {
6655 out.Values[i] = ec._SetTitleOperation_date(ctx, field, obj)
6656 if out.Values[i] == graphql.Null {
6657 invalid = true
6658 }
6659 wg.Done()
6660 }(i, field)
6661 case "title":
6662 out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
6663 if out.Values[i] == graphql.Null {
6664 invalid = true
6665 }
6666 case "was":
6667 out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
6668 if out.Values[i] == graphql.Null {
6669 invalid = true
6670 }
6671 default:
6672 panic("unknown field " + strconv.Quote(field.Name))
6673 }
6674 }
6675 wg.Wait()
6676 if invalid {
6677 return graphql.Null
6678 }
6679 return out
6680}
6681
6682// nolint: vetshadow
6683func (ec *executionContext) _SetTitleOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
6684 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6685 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6686 rctx := &graphql.ResolverContext{
6687 Object: "SetTitleOperation",
6688 Args: nil,
6689 Field: field,
6690 }
6691 ctx = graphql.WithResolverContext(ctx, rctx)
6692 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6693 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6694 ctx = rctx // use context from middleware stack in children
6695 return obj.Hash()
6696 })
6697 if resTmp == nil {
6698 if !ec.HasError(rctx) {
6699 ec.Errorf(ctx, "must not be null")
6700 }
6701 return graphql.Null
6702 }
6703 res := resTmp.(git.Hash)
6704 rctx.Result = res
6705 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6706 return res
6707}
6708
6709// nolint: vetshadow
6710func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
6711 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6712 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6713 rctx := &graphql.ResolverContext{
6714 Object: "SetTitleOperation",
6715 Args: nil,
6716 Field: field,
6717 }
6718 ctx = graphql.WithResolverContext(ctx, rctx)
6719 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6720 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6721 ctx = rctx // use context from middleware stack in children
6722 return obj.Author, nil
6723 })
6724 if resTmp == nil {
6725 if !ec.HasError(rctx) {
6726 ec.Errorf(ctx, "must not be null")
6727 }
6728 return graphql.Null
6729 }
6730 res := resTmp.(bug.Person)
6731 rctx.Result = res
6732 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6733
6734 return ec._Person(ctx, field.Selections, &res)
6735}
6736
6737// nolint: vetshadow
6738func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
6739 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6740 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6741 rctx := &graphql.ResolverContext{
6742 Object: "SetTitleOperation",
6743 Args: nil,
6744 Field: field,
6745 }
6746 ctx = graphql.WithResolverContext(ctx, rctx)
6747 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6748 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6749 ctx = rctx // use context from middleware stack in children
6750 return ec.resolvers.SetTitleOperation().Date(rctx, obj)
6751 })
6752 if resTmp == nil {
6753 if !ec.HasError(rctx) {
6754 ec.Errorf(ctx, "must not be null")
6755 }
6756 return graphql.Null
6757 }
6758 res := resTmp.(time.Time)
6759 rctx.Result = res
6760 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6761 return graphql.MarshalTime(res)
6762}
6763
6764// nolint: vetshadow
6765func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
6766 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6767 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6768 rctx := &graphql.ResolverContext{
6769 Object: "SetTitleOperation",
6770 Args: nil,
6771 Field: field,
6772 }
6773 ctx = graphql.WithResolverContext(ctx, rctx)
6774 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6775 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6776 ctx = rctx // use context from middleware stack in children
6777 return obj.Title, nil
6778 })
6779 if resTmp == nil {
6780 if !ec.HasError(rctx) {
6781 ec.Errorf(ctx, "must not be null")
6782 }
6783 return graphql.Null
6784 }
6785 res := resTmp.(string)
6786 rctx.Result = res
6787 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6788 return graphql.MarshalString(res)
6789}
6790
6791// nolint: vetshadow
6792func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
6793 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6794 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6795 rctx := &graphql.ResolverContext{
6796 Object: "SetTitleOperation",
6797 Args: nil,
6798 Field: field,
6799 }
6800 ctx = graphql.WithResolverContext(ctx, rctx)
6801 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6802 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6803 ctx = rctx // use context from middleware stack in children
6804 return obj.Was, nil
6805 })
6806 if resTmp == nil {
6807 if !ec.HasError(rctx) {
6808 ec.Errorf(ctx, "must not be null")
6809 }
6810 return graphql.Null
6811 }
6812 res := resTmp.(string)
6813 rctx.Result = res
6814 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6815 return graphql.MarshalString(res)
6816}
6817
6818var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem"}
6819
6820// nolint: gocyclo, errcheck, gas, goconst
6821func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6822 fields := graphql.CollectFields(ctx, sel, setTitleTimelineItemImplementors)
6823
6824 var wg sync.WaitGroup
6825 out := graphql.NewOrderedMap(len(fields))
6826 invalid := false
6827 for i, field := range fields {
6828 out.Keys[i] = field.Alias
6829
6830 switch field.Name {
6831 case "__typename":
6832 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
6833 case "hash":
6834 out.Values[i] = ec._SetTitleTimelineItem_hash(ctx, field, obj)
6835 if out.Values[i] == graphql.Null {
6836 invalid = true
6837 }
6838 case "author":
6839 out.Values[i] = ec._SetTitleTimelineItem_author(ctx, field, obj)
6840 if out.Values[i] == graphql.Null {
6841 invalid = true
6842 }
6843 case "date":
6844 wg.Add(1)
6845 go func(i int, field graphql.CollectedField) {
6846 out.Values[i] = ec._SetTitleTimelineItem_date(ctx, field, obj)
6847 if out.Values[i] == graphql.Null {
6848 invalid = true
6849 }
6850 wg.Done()
6851 }(i, field)
6852 case "title":
6853 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
6854 if out.Values[i] == graphql.Null {
6855 invalid = true
6856 }
6857 case "was":
6858 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
6859 if out.Values[i] == graphql.Null {
6860 invalid = true
6861 }
6862 default:
6863 panic("unknown field " + strconv.Quote(field.Name))
6864 }
6865 }
6866 wg.Wait()
6867 if invalid {
6868 return graphql.Null
6869 }
6870 return out
6871}
6872
6873// nolint: vetshadow
6874func (ec *executionContext) _SetTitleTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6875 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6876 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6877 rctx := &graphql.ResolverContext{
6878 Object: "SetTitleTimelineItem",
6879 Args: nil,
6880 Field: field,
6881 }
6882 ctx = graphql.WithResolverContext(ctx, rctx)
6883 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6884 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6885 ctx = rctx // use context from middleware stack in children
6886 return obj.Hash(), nil
6887 })
6888 if resTmp == nil {
6889 if !ec.HasError(rctx) {
6890 ec.Errorf(ctx, "must not be null")
6891 }
6892 return graphql.Null
6893 }
6894 res := resTmp.(git.Hash)
6895 rctx.Result = res
6896 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6897 return res
6898}
6899
6900// nolint: vetshadow
6901func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6902 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6903 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6904 rctx := &graphql.ResolverContext{
6905 Object: "SetTitleTimelineItem",
6906 Args: nil,
6907 Field: field,
6908 }
6909 ctx = graphql.WithResolverContext(ctx, rctx)
6910 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6911 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6912 ctx = rctx // use context from middleware stack in children
6913 return obj.Author, nil
6914 })
6915 if resTmp == nil {
6916 if !ec.HasError(rctx) {
6917 ec.Errorf(ctx, "must not be null")
6918 }
6919 return graphql.Null
6920 }
6921 res := resTmp.(bug.Person)
6922 rctx.Result = res
6923 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6924
6925 return ec._Person(ctx, field.Selections, &res)
6926}
6927
6928// nolint: vetshadow
6929func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6930 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6931 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6932 rctx := &graphql.ResolverContext{
6933 Object: "SetTitleTimelineItem",
6934 Args: nil,
6935 Field: field,
6936 }
6937 ctx = graphql.WithResolverContext(ctx, rctx)
6938 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6939 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6940 ctx = rctx // use context from middleware stack in children
6941 return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
6942 })
6943 if resTmp == nil {
6944 if !ec.HasError(rctx) {
6945 ec.Errorf(ctx, "must not be null")
6946 }
6947 return graphql.Null
6948 }
6949 res := resTmp.(time.Time)
6950 rctx.Result = res
6951 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6952 return graphql.MarshalTime(res)
6953}
6954
6955// nolint: vetshadow
6956func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6957 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6958 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6959 rctx := &graphql.ResolverContext{
6960 Object: "SetTitleTimelineItem",
6961 Args: nil,
6962 Field: field,
6963 }
6964 ctx = graphql.WithResolverContext(ctx, rctx)
6965 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6966 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6967 ctx = rctx // use context from middleware stack in children
6968 return obj.Title, nil
6969 })
6970 if resTmp == nil {
6971 if !ec.HasError(rctx) {
6972 ec.Errorf(ctx, "must not be null")
6973 }
6974 return graphql.Null
6975 }
6976 res := resTmp.(string)
6977 rctx.Result = res
6978 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6979 return graphql.MarshalString(res)
6980}
6981
6982// nolint: vetshadow
6983func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6984 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6985 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6986 rctx := &graphql.ResolverContext{
6987 Object: "SetTitleTimelineItem",
6988 Args: nil,
6989 Field: field,
6990 }
6991 ctx = graphql.WithResolverContext(ctx, rctx)
6992 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6993 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6994 ctx = rctx // use context from middleware stack in children
6995 return obj.Was, nil
6996 })
6997 if resTmp == nil {
6998 if !ec.HasError(rctx) {
6999 ec.Errorf(ctx, "must not be null")
7000 }
7001 return graphql.Null
7002 }
7003 res := resTmp.(string)
7004 rctx.Result = res
7005 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7006 return graphql.MarshalString(res)
7007}
7008
7009var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
7010
7011// nolint: gocyclo, errcheck, gas, goconst
7012func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
7013 fields := graphql.CollectFields(ctx, sel, timelineItemConnectionImplementors)
7014
7015 out := graphql.NewOrderedMap(len(fields))
7016 invalid := false
7017 for i, field := range fields {
7018 out.Keys[i] = field.Alias
7019
7020 switch field.Name {
7021 case "__typename":
7022 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
7023 case "edges":
7024 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
7025 if out.Values[i] == graphql.Null {
7026 invalid = true
7027 }
7028 case "nodes":
7029 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
7030 if out.Values[i] == graphql.Null {
7031 invalid = true
7032 }
7033 case "pageInfo":
7034 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
7035 if out.Values[i] == graphql.Null {
7036 invalid = true
7037 }
7038 case "totalCount":
7039 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
7040 if out.Values[i] == graphql.Null {
7041 invalid = true
7042 }
7043 default:
7044 panic("unknown field " + strconv.Quote(field.Name))
7045 }
7046 }
7047
7048 if invalid {
7049 return graphql.Null
7050 }
7051 return out
7052}
7053
7054// nolint: vetshadow
7055func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7056 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7057 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7058 rctx := &graphql.ResolverContext{
7059 Object: "TimelineItemConnection",
7060 Args: nil,
7061 Field: field,
7062 }
7063 ctx = graphql.WithResolverContext(ctx, rctx)
7064 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7065 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7066 ctx = rctx // use context from middleware stack in children
7067 return obj.Edges, nil
7068 })
7069 if resTmp == nil {
7070 if !ec.HasError(rctx) {
7071 ec.Errorf(ctx, "must not be null")
7072 }
7073 return graphql.Null
7074 }
7075 res := resTmp.([]models.TimelineItemEdge)
7076 rctx.Result = res
7077 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7078
7079 arr1 := make(graphql.Array, len(res))
7080 var wg sync.WaitGroup
7081
7082 isLen1 := len(res) == 1
7083 if !isLen1 {
7084 wg.Add(len(res))
7085 }
7086
7087 for idx1 := range res {
7088 idx1 := idx1
7089 rctx := &graphql.ResolverContext{
7090 Index: &idx1,
7091 Result: &res[idx1],
7092 }
7093 ctx := graphql.WithResolverContext(ctx, rctx)
7094 f := func(idx1 int) {
7095 if !isLen1 {
7096 defer wg.Done()
7097 }
7098 arr1[idx1] = func() graphql.Marshaler {
7099
7100 return ec._TimelineItemEdge(ctx, field.Selections, &res[idx1])
7101 }()
7102 }
7103 if isLen1 {
7104 f(idx1)
7105 } else {
7106 go f(idx1)
7107 }
7108
7109 }
7110 wg.Wait()
7111 return arr1
7112}
7113
7114// nolint: vetshadow
7115func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7116 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7117 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7118 rctx := &graphql.ResolverContext{
7119 Object: "TimelineItemConnection",
7120 Args: nil,
7121 Field: field,
7122 }
7123 ctx = graphql.WithResolverContext(ctx, rctx)
7124 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7125 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7126 ctx = rctx // use context from middleware stack in children
7127 return obj.Nodes, nil
7128 })
7129 if resTmp == nil {
7130 if !ec.HasError(rctx) {
7131 ec.Errorf(ctx, "must not be null")
7132 }
7133 return graphql.Null
7134 }
7135 res := resTmp.([]bug.TimelineItem)
7136 rctx.Result = res
7137 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7138
7139 arr1 := make(graphql.Array, len(res))
7140 var wg sync.WaitGroup
7141
7142 isLen1 := len(res) == 1
7143 if !isLen1 {
7144 wg.Add(len(res))
7145 }
7146
7147 for idx1 := range res {
7148 idx1 := idx1
7149 rctx := &graphql.ResolverContext{
7150 Index: &idx1,
7151 Result: &res[idx1],
7152 }
7153 ctx := graphql.WithResolverContext(ctx, rctx)
7154 f := func(idx1 int) {
7155 if !isLen1 {
7156 defer wg.Done()
7157 }
7158 arr1[idx1] = func() graphql.Marshaler {
7159
7160 return ec._TimelineItem(ctx, field.Selections, &res[idx1])
7161 }()
7162 }
7163 if isLen1 {
7164 f(idx1)
7165 } else {
7166 go f(idx1)
7167 }
7168
7169 }
7170 wg.Wait()
7171 return arr1
7172}
7173
7174// nolint: vetshadow
7175func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7176 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7177 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7178 rctx := &graphql.ResolverContext{
7179 Object: "TimelineItemConnection",
7180 Args: nil,
7181 Field: field,
7182 }
7183 ctx = graphql.WithResolverContext(ctx, rctx)
7184 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7185 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7186 ctx = rctx // use context from middleware stack in children
7187 return obj.PageInfo, nil
7188 })
7189 if resTmp == nil {
7190 if !ec.HasError(rctx) {
7191 ec.Errorf(ctx, "must not be null")
7192 }
7193 return graphql.Null
7194 }
7195 res := resTmp.(models.PageInfo)
7196 rctx.Result = res
7197 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7198
7199 return ec._PageInfo(ctx, field.Selections, &res)
7200}
7201
7202// nolint: vetshadow
7203func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7204 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7205 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7206 rctx := &graphql.ResolverContext{
7207 Object: "TimelineItemConnection",
7208 Args: nil,
7209 Field: field,
7210 }
7211 ctx = graphql.WithResolverContext(ctx, rctx)
7212 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7213 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7214 ctx = rctx // use context from middleware stack in children
7215 return obj.TotalCount, nil
7216 })
7217 if resTmp == nil {
7218 if !ec.HasError(rctx) {
7219 ec.Errorf(ctx, "must not be null")
7220 }
7221 return graphql.Null
7222 }
7223 res := resTmp.(int)
7224 rctx.Result = res
7225 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7226 return graphql.MarshalInt(res)
7227}
7228
7229var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
7230
7231// nolint: gocyclo, errcheck, gas, goconst
7232func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
7233 fields := graphql.CollectFields(ctx, sel, timelineItemEdgeImplementors)
7234
7235 out := graphql.NewOrderedMap(len(fields))
7236 invalid := false
7237 for i, field := range fields {
7238 out.Keys[i] = field.Alias
7239
7240 switch field.Name {
7241 case "__typename":
7242 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
7243 case "cursor":
7244 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
7245 if out.Values[i] == graphql.Null {
7246 invalid = true
7247 }
7248 case "node":
7249 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
7250 if out.Values[i] == graphql.Null {
7251 invalid = true
7252 }
7253 default:
7254 panic("unknown field " + strconv.Quote(field.Name))
7255 }
7256 }
7257
7258 if invalid {
7259 return graphql.Null
7260 }
7261 return out
7262}
7263
7264// nolint: vetshadow
7265func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) graphql.Marshaler {
7266 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7267 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7268 rctx := &graphql.ResolverContext{
7269 Object: "TimelineItemEdge",
7270 Args: nil,
7271 Field: field,
7272 }
7273 ctx = graphql.WithResolverContext(ctx, rctx)
7274 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7275 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7276 ctx = rctx // use context from middleware stack in children
7277 return obj.Cursor, nil
7278 })
7279 if resTmp == nil {
7280 if !ec.HasError(rctx) {
7281 ec.Errorf(ctx, "must not be null")
7282 }
7283 return graphql.Null
7284 }
7285 res := resTmp.(string)
7286 rctx.Result = res
7287 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7288 return graphql.MarshalString(res)
7289}
7290
7291// nolint: vetshadow
7292func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) graphql.Marshaler {
7293 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7294 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7295 rctx := &graphql.ResolverContext{
7296 Object: "TimelineItemEdge",
7297 Args: nil,
7298 Field: field,
7299 }
7300 ctx = graphql.WithResolverContext(ctx, rctx)
7301 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7302 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7303 ctx = rctx // use context from middleware stack in children
7304 return obj.Node, nil
7305 })
7306 if resTmp == nil {
7307 if !ec.HasError(rctx) {
7308 ec.Errorf(ctx, "must not be null")
7309 }
7310 return graphql.Null
7311 }
7312 res := resTmp.(bug.TimelineItem)
7313 rctx.Result = res
7314 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7315
7316 return ec._TimelineItem(ctx, field.Selections, &res)
7317}
7318
7319var __DirectiveImplementors = []string{"__Directive"}
7320
7321// nolint: gocyclo, errcheck, gas, goconst
7322func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
7323 fields := graphql.CollectFields(ctx, sel, __DirectiveImplementors)
7324
7325 out := graphql.NewOrderedMap(len(fields))
7326 invalid := false
7327 for i, field := range fields {
7328 out.Keys[i] = field.Alias
7329
7330 switch field.Name {
7331 case "__typename":
7332 out.Values[i] = graphql.MarshalString("__Directive")
7333 case "name":
7334 out.Values[i] = ec.___Directive_name(ctx, field, obj)
7335 if out.Values[i] == graphql.Null {
7336 invalid = true
7337 }
7338 case "description":
7339 out.Values[i] = ec.___Directive_description(ctx, field, obj)
7340 case "locations":
7341 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
7342 if out.Values[i] == graphql.Null {
7343 invalid = true
7344 }
7345 case "args":
7346 out.Values[i] = ec.___Directive_args(ctx, field, obj)
7347 if out.Values[i] == graphql.Null {
7348 invalid = true
7349 }
7350 default:
7351 panic("unknown field " + strconv.Quote(field.Name))
7352 }
7353 }
7354
7355 if invalid {
7356 return graphql.Null
7357 }
7358 return out
7359}
7360
7361// nolint: vetshadow
7362func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
7363 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7364 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7365 rctx := &graphql.ResolverContext{
7366 Object: "__Directive",
7367 Args: nil,
7368 Field: field,
7369 }
7370 ctx = graphql.WithResolverContext(ctx, rctx)
7371 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7372 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7373 ctx = rctx // use context from middleware stack in children
7374 return obj.Name, nil
7375 })
7376 if resTmp == nil {
7377 if !ec.HasError(rctx) {
7378 ec.Errorf(ctx, "must not be null")
7379 }
7380 return graphql.Null
7381 }
7382 res := resTmp.(string)
7383 rctx.Result = res
7384 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7385 return graphql.MarshalString(res)
7386}
7387
7388// nolint: vetshadow
7389func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
7390 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7391 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7392 rctx := &graphql.ResolverContext{
7393 Object: "__Directive",
7394 Args: nil,
7395 Field: field,
7396 }
7397 ctx = graphql.WithResolverContext(ctx, rctx)
7398 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7399 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7400 ctx = rctx // use context from middleware stack in children
7401 return obj.Description, nil
7402 })
7403 if resTmp == nil {
7404 return graphql.Null
7405 }
7406 res := resTmp.(string)
7407 rctx.Result = res
7408 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7409 return graphql.MarshalString(res)
7410}
7411
7412// nolint: vetshadow
7413func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
7414 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7415 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7416 rctx := &graphql.ResolverContext{
7417 Object: "__Directive",
7418 Args: nil,
7419 Field: field,
7420 }
7421 ctx = graphql.WithResolverContext(ctx, rctx)
7422 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7423 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7424 ctx = rctx // use context from middleware stack in children
7425 return obj.Locations, nil
7426 })
7427 if resTmp == nil {
7428 if !ec.HasError(rctx) {
7429 ec.Errorf(ctx, "must not be null")
7430 }
7431 return graphql.Null
7432 }
7433 res := resTmp.([]string)
7434 rctx.Result = res
7435 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7436
7437 arr1 := make(graphql.Array, len(res))
7438
7439 for idx1 := range res {
7440 arr1[idx1] = func() graphql.Marshaler {
7441 return graphql.MarshalString(res[idx1])
7442 }()
7443 }
7444
7445 return arr1
7446}
7447
7448// nolint: vetshadow
7449func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
7450 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7451 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7452 rctx := &graphql.ResolverContext{
7453 Object: "__Directive",
7454 Args: nil,
7455 Field: field,
7456 }
7457 ctx = graphql.WithResolverContext(ctx, rctx)
7458 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7459 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7460 ctx = rctx // use context from middleware stack in children
7461 return obj.Args, nil
7462 })
7463 if resTmp == nil {
7464 if !ec.HasError(rctx) {
7465 ec.Errorf(ctx, "must not be null")
7466 }
7467 return graphql.Null
7468 }
7469 res := resTmp.([]introspection.InputValue)
7470 rctx.Result = res
7471 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7472
7473 arr1 := make(graphql.Array, len(res))
7474 var wg sync.WaitGroup
7475
7476 isLen1 := len(res) == 1
7477 if !isLen1 {
7478 wg.Add(len(res))
7479 }
7480
7481 for idx1 := range res {
7482 idx1 := idx1
7483 rctx := &graphql.ResolverContext{
7484 Index: &idx1,
7485 Result: &res[idx1],
7486 }
7487 ctx := graphql.WithResolverContext(ctx, rctx)
7488 f := func(idx1 int) {
7489 if !isLen1 {
7490 defer wg.Done()
7491 }
7492 arr1[idx1] = func() graphql.Marshaler {
7493
7494 return ec.___InputValue(ctx, field.Selections, &res[idx1])
7495 }()
7496 }
7497 if isLen1 {
7498 f(idx1)
7499 } else {
7500 go f(idx1)
7501 }
7502
7503 }
7504 wg.Wait()
7505 return arr1
7506}
7507
7508var __EnumValueImplementors = []string{"__EnumValue"}
7509
7510// nolint: gocyclo, errcheck, gas, goconst
7511func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
7512 fields := graphql.CollectFields(ctx, sel, __EnumValueImplementors)
7513
7514 out := graphql.NewOrderedMap(len(fields))
7515 invalid := false
7516 for i, field := range fields {
7517 out.Keys[i] = field.Alias
7518
7519 switch field.Name {
7520 case "__typename":
7521 out.Values[i] = graphql.MarshalString("__EnumValue")
7522 case "name":
7523 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
7524 if out.Values[i] == graphql.Null {
7525 invalid = true
7526 }
7527 case "description":
7528 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
7529 case "isDeprecated":
7530 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
7531 if out.Values[i] == graphql.Null {
7532 invalid = true
7533 }
7534 case "deprecationReason":
7535 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
7536 default:
7537 panic("unknown field " + strconv.Quote(field.Name))
7538 }
7539 }
7540
7541 if invalid {
7542 return graphql.Null
7543 }
7544 return out
7545}
7546
7547// nolint: vetshadow
7548func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
7549 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7550 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7551 rctx := &graphql.ResolverContext{
7552 Object: "__EnumValue",
7553 Args: nil,
7554 Field: field,
7555 }
7556 ctx = graphql.WithResolverContext(ctx, rctx)
7557 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7558 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7559 ctx = rctx // use context from middleware stack in children
7560 return obj.Name, nil
7561 })
7562 if resTmp == nil {
7563 if !ec.HasError(rctx) {
7564 ec.Errorf(ctx, "must not be null")
7565 }
7566 return graphql.Null
7567 }
7568 res := resTmp.(string)
7569 rctx.Result = res
7570 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7571 return graphql.MarshalString(res)
7572}
7573
7574// nolint: vetshadow
7575func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
7576 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7577 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7578 rctx := &graphql.ResolverContext{
7579 Object: "__EnumValue",
7580 Args: nil,
7581 Field: field,
7582 }
7583 ctx = graphql.WithResolverContext(ctx, rctx)
7584 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7585 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7586 ctx = rctx // use context from middleware stack in children
7587 return obj.Description, nil
7588 })
7589 if resTmp == nil {
7590 return graphql.Null
7591 }
7592 res := resTmp.(string)
7593 rctx.Result = res
7594 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7595 return graphql.MarshalString(res)
7596}
7597
7598// nolint: vetshadow
7599func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
7600 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7601 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7602 rctx := &graphql.ResolverContext{
7603 Object: "__EnumValue",
7604 Args: nil,
7605 Field: field,
7606 }
7607 ctx = graphql.WithResolverContext(ctx, rctx)
7608 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7609 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7610 ctx = rctx // use context from middleware stack in children
7611 return obj.IsDeprecated(), nil
7612 })
7613 if resTmp == nil {
7614 if !ec.HasError(rctx) {
7615 ec.Errorf(ctx, "must not be null")
7616 }
7617 return graphql.Null
7618 }
7619 res := resTmp.(bool)
7620 rctx.Result = res
7621 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7622 return graphql.MarshalBoolean(res)
7623}
7624
7625// nolint: vetshadow
7626func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
7627 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7628 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7629 rctx := &graphql.ResolverContext{
7630 Object: "__EnumValue",
7631 Args: nil,
7632 Field: field,
7633 }
7634 ctx = graphql.WithResolverContext(ctx, rctx)
7635 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7636 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7637 ctx = rctx // use context from middleware stack in children
7638 return obj.DeprecationReason(), nil
7639 })
7640 if resTmp == nil {
7641 return graphql.Null
7642 }
7643 res := resTmp.(*string)
7644 rctx.Result = res
7645 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7646
7647 if res == nil {
7648 return graphql.Null
7649 }
7650 return graphql.MarshalString(*res)
7651}
7652
7653var __FieldImplementors = []string{"__Field"}
7654
7655// nolint: gocyclo, errcheck, gas, goconst
7656func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
7657 fields := graphql.CollectFields(ctx, sel, __FieldImplementors)
7658
7659 out := graphql.NewOrderedMap(len(fields))
7660 invalid := false
7661 for i, field := range fields {
7662 out.Keys[i] = field.Alias
7663
7664 switch field.Name {
7665 case "__typename":
7666 out.Values[i] = graphql.MarshalString("__Field")
7667 case "name":
7668 out.Values[i] = ec.___Field_name(ctx, field, obj)
7669 if out.Values[i] == graphql.Null {
7670 invalid = true
7671 }
7672 case "description":
7673 out.Values[i] = ec.___Field_description(ctx, field, obj)
7674 case "args":
7675 out.Values[i] = ec.___Field_args(ctx, field, obj)
7676 if out.Values[i] == graphql.Null {
7677 invalid = true
7678 }
7679 case "type":
7680 out.Values[i] = ec.___Field_type(ctx, field, obj)
7681 if out.Values[i] == graphql.Null {
7682 invalid = true
7683 }
7684 case "isDeprecated":
7685 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
7686 if out.Values[i] == graphql.Null {
7687 invalid = true
7688 }
7689 case "deprecationReason":
7690 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
7691 default:
7692 panic("unknown field " + strconv.Quote(field.Name))
7693 }
7694 }
7695
7696 if invalid {
7697 return graphql.Null
7698 }
7699 return out
7700}
7701
7702// nolint: vetshadow
7703func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7704 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7705 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7706 rctx := &graphql.ResolverContext{
7707 Object: "__Field",
7708 Args: nil,
7709 Field: field,
7710 }
7711 ctx = graphql.WithResolverContext(ctx, rctx)
7712 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7713 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7714 ctx = rctx // use context from middleware stack in children
7715 return obj.Name, nil
7716 })
7717 if resTmp == nil {
7718 if !ec.HasError(rctx) {
7719 ec.Errorf(ctx, "must not be null")
7720 }
7721 return graphql.Null
7722 }
7723 res := resTmp.(string)
7724 rctx.Result = res
7725 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7726 return graphql.MarshalString(res)
7727}
7728
7729// nolint: vetshadow
7730func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7731 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7732 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7733 rctx := &graphql.ResolverContext{
7734 Object: "__Field",
7735 Args: nil,
7736 Field: field,
7737 }
7738 ctx = graphql.WithResolverContext(ctx, rctx)
7739 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7740 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7741 ctx = rctx // use context from middleware stack in children
7742 return obj.Description, nil
7743 })
7744 if resTmp == nil {
7745 return graphql.Null
7746 }
7747 res := resTmp.(string)
7748 rctx.Result = res
7749 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7750 return graphql.MarshalString(res)
7751}
7752
7753// nolint: vetshadow
7754func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7755 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7756 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7757 rctx := &graphql.ResolverContext{
7758 Object: "__Field",
7759 Args: nil,
7760 Field: field,
7761 }
7762 ctx = graphql.WithResolverContext(ctx, rctx)
7763 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7764 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7765 ctx = rctx // use context from middleware stack in children
7766 return obj.Args, nil
7767 })
7768 if resTmp == nil {
7769 if !ec.HasError(rctx) {
7770 ec.Errorf(ctx, "must not be null")
7771 }
7772 return graphql.Null
7773 }
7774 res := resTmp.([]introspection.InputValue)
7775 rctx.Result = res
7776 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7777
7778 arr1 := make(graphql.Array, len(res))
7779 var wg sync.WaitGroup
7780
7781 isLen1 := len(res) == 1
7782 if !isLen1 {
7783 wg.Add(len(res))
7784 }
7785
7786 for idx1 := range res {
7787 idx1 := idx1
7788 rctx := &graphql.ResolverContext{
7789 Index: &idx1,
7790 Result: &res[idx1],
7791 }
7792 ctx := graphql.WithResolverContext(ctx, rctx)
7793 f := func(idx1 int) {
7794 if !isLen1 {
7795 defer wg.Done()
7796 }
7797 arr1[idx1] = func() graphql.Marshaler {
7798
7799 return ec.___InputValue(ctx, field.Selections, &res[idx1])
7800 }()
7801 }
7802 if isLen1 {
7803 f(idx1)
7804 } else {
7805 go f(idx1)
7806 }
7807
7808 }
7809 wg.Wait()
7810 return arr1
7811}
7812
7813// nolint: vetshadow
7814func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7815 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7816 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7817 rctx := &graphql.ResolverContext{
7818 Object: "__Field",
7819 Args: nil,
7820 Field: field,
7821 }
7822 ctx = graphql.WithResolverContext(ctx, rctx)
7823 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7824 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7825 ctx = rctx // use context from middleware stack in children
7826 return obj.Type, nil
7827 })
7828 if resTmp == nil {
7829 if !ec.HasError(rctx) {
7830 ec.Errorf(ctx, "must not be null")
7831 }
7832 return graphql.Null
7833 }
7834 res := resTmp.(*introspection.Type)
7835 rctx.Result = res
7836 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7837
7838 if res == nil {
7839 if !ec.HasError(rctx) {
7840 ec.Errorf(ctx, "must not be null")
7841 }
7842 return graphql.Null
7843 }
7844
7845 return ec.___Type(ctx, field.Selections, res)
7846}
7847
7848// nolint: vetshadow
7849func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7850 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7851 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7852 rctx := &graphql.ResolverContext{
7853 Object: "__Field",
7854 Args: nil,
7855 Field: field,
7856 }
7857 ctx = graphql.WithResolverContext(ctx, rctx)
7858 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7859 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7860 ctx = rctx // use context from middleware stack in children
7861 return obj.IsDeprecated(), nil
7862 })
7863 if resTmp == nil {
7864 if !ec.HasError(rctx) {
7865 ec.Errorf(ctx, "must not be null")
7866 }
7867 return graphql.Null
7868 }
7869 res := resTmp.(bool)
7870 rctx.Result = res
7871 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7872 return graphql.MarshalBoolean(res)
7873}
7874
7875// nolint: vetshadow
7876func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7877 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7878 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7879 rctx := &graphql.ResolverContext{
7880 Object: "__Field",
7881 Args: nil,
7882 Field: field,
7883 }
7884 ctx = graphql.WithResolverContext(ctx, rctx)
7885 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7886 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7887 ctx = rctx // use context from middleware stack in children
7888 return obj.DeprecationReason(), nil
7889 })
7890 if resTmp == nil {
7891 return graphql.Null
7892 }
7893 res := resTmp.(*string)
7894 rctx.Result = res
7895 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7896
7897 if res == nil {
7898 return graphql.Null
7899 }
7900 return graphql.MarshalString(*res)
7901}
7902
7903var __InputValueImplementors = []string{"__InputValue"}
7904
7905// nolint: gocyclo, errcheck, gas, goconst
7906func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
7907 fields := graphql.CollectFields(ctx, sel, __InputValueImplementors)
7908
7909 out := graphql.NewOrderedMap(len(fields))
7910 invalid := false
7911 for i, field := range fields {
7912 out.Keys[i] = field.Alias
7913
7914 switch field.Name {
7915 case "__typename":
7916 out.Values[i] = graphql.MarshalString("__InputValue")
7917 case "name":
7918 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
7919 if out.Values[i] == graphql.Null {
7920 invalid = true
7921 }
7922 case "description":
7923 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
7924 case "type":
7925 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
7926 if out.Values[i] == graphql.Null {
7927 invalid = true
7928 }
7929 case "defaultValue":
7930 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
7931 default:
7932 panic("unknown field " + strconv.Quote(field.Name))
7933 }
7934 }
7935
7936 if invalid {
7937 return graphql.Null
7938 }
7939 return out
7940}
7941
7942// nolint: vetshadow
7943func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
7944 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7945 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7946 rctx := &graphql.ResolverContext{
7947 Object: "__InputValue",
7948 Args: nil,
7949 Field: field,
7950 }
7951 ctx = graphql.WithResolverContext(ctx, rctx)
7952 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7953 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7954 ctx = rctx // use context from middleware stack in children
7955 return obj.Name, nil
7956 })
7957 if resTmp == nil {
7958 if !ec.HasError(rctx) {
7959 ec.Errorf(ctx, "must not be null")
7960 }
7961 return graphql.Null
7962 }
7963 res := resTmp.(string)
7964 rctx.Result = res
7965 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7966 return graphql.MarshalString(res)
7967}
7968
7969// nolint: vetshadow
7970func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
7971 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7972 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7973 rctx := &graphql.ResolverContext{
7974 Object: "__InputValue",
7975 Args: nil,
7976 Field: field,
7977 }
7978 ctx = graphql.WithResolverContext(ctx, rctx)
7979 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7980 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7981 ctx = rctx // use context from middleware stack in children
7982 return obj.Description, nil
7983 })
7984 if resTmp == nil {
7985 return graphql.Null
7986 }
7987 res := resTmp.(string)
7988 rctx.Result = res
7989 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7990 return graphql.MarshalString(res)
7991}
7992
7993// nolint: vetshadow
7994func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
7995 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7996 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7997 rctx := &graphql.ResolverContext{
7998 Object: "__InputValue",
7999 Args: nil,
8000 Field: field,
8001 }
8002 ctx = graphql.WithResolverContext(ctx, rctx)
8003 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8004 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8005 ctx = rctx // use context from middleware stack in children
8006 return obj.Type, nil
8007 })
8008 if resTmp == nil {
8009 if !ec.HasError(rctx) {
8010 ec.Errorf(ctx, "must not be null")
8011 }
8012 return graphql.Null
8013 }
8014 res := resTmp.(*introspection.Type)
8015 rctx.Result = res
8016 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8017
8018 if res == nil {
8019 if !ec.HasError(rctx) {
8020 ec.Errorf(ctx, "must not be null")
8021 }
8022 return graphql.Null
8023 }
8024
8025 return ec.___Type(ctx, field.Selections, res)
8026}
8027
8028// nolint: vetshadow
8029func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
8030 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8031 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8032 rctx := &graphql.ResolverContext{
8033 Object: "__InputValue",
8034 Args: nil,
8035 Field: field,
8036 }
8037 ctx = graphql.WithResolverContext(ctx, rctx)
8038 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8039 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8040 ctx = rctx // use context from middleware stack in children
8041 return obj.DefaultValue, nil
8042 })
8043 if resTmp == nil {
8044 return graphql.Null
8045 }
8046 res := resTmp.(*string)
8047 rctx.Result = res
8048 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8049
8050 if res == nil {
8051 return graphql.Null
8052 }
8053 return graphql.MarshalString(*res)
8054}
8055
8056var __SchemaImplementors = []string{"__Schema"}
8057
8058// nolint: gocyclo, errcheck, gas, goconst
8059func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
8060 fields := graphql.CollectFields(ctx, sel, __SchemaImplementors)
8061
8062 out := graphql.NewOrderedMap(len(fields))
8063 invalid := false
8064 for i, field := range fields {
8065 out.Keys[i] = field.Alias
8066
8067 switch field.Name {
8068 case "__typename":
8069 out.Values[i] = graphql.MarshalString("__Schema")
8070 case "types":
8071 out.Values[i] = ec.___Schema_types(ctx, field, obj)
8072 if out.Values[i] == graphql.Null {
8073 invalid = true
8074 }
8075 case "queryType":
8076 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
8077 if out.Values[i] == graphql.Null {
8078 invalid = true
8079 }
8080 case "mutationType":
8081 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
8082 case "subscriptionType":
8083 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
8084 case "directives":
8085 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
8086 if out.Values[i] == graphql.Null {
8087 invalid = true
8088 }
8089 default:
8090 panic("unknown field " + strconv.Quote(field.Name))
8091 }
8092 }
8093
8094 if invalid {
8095 return graphql.Null
8096 }
8097 return out
8098}
8099
8100// nolint: vetshadow
8101func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8102 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8103 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8104 rctx := &graphql.ResolverContext{
8105 Object: "__Schema",
8106 Args: nil,
8107 Field: field,
8108 }
8109 ctx = graphql.WithResolverContext(ctx, rctx)
8110 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8111 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8112 ctx = rctx // use context from middleware stack in children
8113 return obj.Types(), nil
8114 })
8115 if resTmp == nil {
8116 if !ec.HasError(rctx) {
8117 ec.Errorf(ctx, "must not be null")
8118 }
8119 return graphql.Null
8120 }
8121 res := resTmp.([]introspection.Type)
8122 rctx.Result = res
8123 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8124
8125 arr1 := make(graphql.Array, len(res))
8126 var wg sync.WaitGroup
8127
8128 isLen1 := len(res) == 1
8129 if !isLen1 {
8130 wg.Add(len(res))
8131 }
8132
8133 for idx1 := range res {
8134 idx1 := idx1
8135 rctx := &graphql.ResolverContext{
8136 Index: &idx1,
8137 Result: &res[idx1],
8138 }
8139 ctx := graphql.WithResolverContext(ctx, rctx)
8140 f := func(idx1 int) {
8141 if !isLen1 {
8142 defer wg.Done()
8143 }
8144 arr1[idx1] = func() graphql.Marshaler {
8145
8146 return ec.___Type(ctx, field.Selections, &res[idx1])
8147 }()
8148 }
8149 if isLen1 {
8150 f(idx1)
8151 } else {
8152 go f(idx1)
8153 }
8154
8155 }
8156 wg.Wait()
8157 return arr1
8158}
8159
8160// nolint: vetshadow
8161func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8162 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8163 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8164 rctx := &graphql.ResolverContext{
8165 Object: "__Schema",
8166 Args: nil,
8167 Field: field,
8168 }
8169 ctx = graphql.WithResolverContext(ctx, rctx)
8170 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8171 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8172 ctx = rctx // use context from middleware stack in children
8173 return obj.QueryType(), nil
8174 })
8175 if resTmp == nil {
8176 if !ec.HasError(rctx) {
8177 ec.Errorf(ctx, "must not be null")
8178 }
8179 return graphql.Null
8180 }
8181 res := resTmp.(*introspection.Type)
8182 rctx.Result = res
8183 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8184
8185 if res == nil {
8186 if !ec.HasError(rctx) {
8187 ec.Errorf(ctx, "must not be null")
8188 }
8189 return graphql.Null
8190 }
8191
8192 return ec.___Type(ctx, field.Selections, res)
8193}
8194
8195// nolint: vetshadow
8196func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8197 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8198 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8199 rctx := &graphql.ResolverContext{
8200 Object: "__Schema",
8201 Args: nil,
8202 Field: field,
8203 }
8204 ctx = graphql.WithResolverContext(ctx, rctx)
8205 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8206 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8207 ctx = rctx // use context from middleware stack in children
8208 return obj.MutationType(), nil
8209 })
8210 if resTmp == nil {
8211 return graphql.Null
8212 }
8213 res := resTmp.(*introspection.Type)
8214 rctx.Result = res
8215 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8216
8217 if res == nil {
8218 return graphql.Null
8219 }
8220
8221 return ec.___Type(ctx, field.Selections, res)
8222}
8223
8224// nolint: vetshadow
8225func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8226 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8227 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8228 rctx := &graphql.ResolverContext{
8229 Object: "__Schema",
8230 Args: nil,
8231 Field: field,
8232 }
8233 ctx = graphql.WithResolverContext(ctx, rctx)
8234 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8235 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8236 ctx = rctx // use context from middleware stack in children
8237 return obj.SubscriptionType(), nil
8238 })
8239 if resTmp == nil {
8240 return graphql.Null
8241 }
8242 res := resTmp.(*introspection.Type)
8243 rctx.Result = res
8244 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8245
8246 if res == nil {
8247 return graphql.Null
8248 }
8249
8250 return ec.___Type(ctx, field.Selections, res)
8251}
8252
8253// nolint: vetshadow
8254func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8255 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8256 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8257 rctx := &graphql.ResolverContext{
8258 Object: "__Schema",
8259 Args: nil,
8260 Field: field,
8261 }
8262 ctx = graphql.WithResolverContext(ctx, rctx)
8263 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8264 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8265 ctx = rctx // use context from middleware stack in children
8266 return obj.Directives(), nil
8267 })
8268 if resTmp == nil {
8269 if !ec.HasError(rctx) {
8270 ec.Errorf(ctx, "must not be null")
8271 }
8272 return graphql.Null
8273 }
8274 res := resTmp.([]introspection.Directive)
8275 rctx.Result = res
8276 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8277
8278 arr1 := make(graphql.Array, len(res))
8279 var wg sync.WaitGroup
8280
8281 isLen1 := len(res) == 1
8282 if !isLen1 {
8283 wg.Add(len(res))
8284 }
8285
8286 for idx1 := range res {
8287 idx1 := idx1
8288 rctx := &graphql.ResolverContext{
8289 Index: &idx1,
8290 Result: &res[idx1],
8291 }
8292 ctx := graphql.WithResolverContext(ctx, rctx)
8293 f := func(idx1 int) {
8294 if !isLen1 {
8295 defer wg.Done()
8296 }
8297 arr1[idx1] = func() graphql.Marshaler {
8298
8299 return ec.___Directive(ctx, field.Selections, &res[idx1])
8300 }()
8301 }
8302 if isLen1 {
8303 f(idx1)
8304 } else {
8305 go f(idx1)
8306 }
8307
8308 }
8309 wg.Wait()
8310 return arr1
8311}
8312
8313var __TypeImplementors = []string{"__Type"}
8314
8315// nolint: gocyclo, errcheck, gas, goconst
8316func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
8317 fields := graphql.CollectFields(ctx, sel, __TypeImplementors)
8318
8319 out := graphql.NewOrderedMap(len(fields))
8320 invalid := false
8321 for i, field := range fields {
8322 out.Keys[i] = field.Alias
8323
8324 switch field.Name {
8325 case "__typename":
8326 out.Values[i] = graphql.MarshalString("__Type")
8327 case "kind":
8328 out.Values[i] = ec.___Type_kind(ctx, field, obj)
8329 if out.Values[i] == graphql.Null {
8330 invalid = true
8331 }
8332 case "name":
8333 out.Values[i] = ec.___Type_name(ctx, field, obj)
8334 case "description":
8335 out.Values[i] = ec.___Type_description(ctx, field, obj)
8336 case "fields":
8337 out.Values[i] = ec.___Type_fields(ctx, field, obj)
8338 case "interfaces":
8339 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
8340 case "possibleTypes":
8341 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
8342 case "enumValues":
8343 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
8344 case "inputFields":
8345 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
8346 case "ofType":
8347 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
8348 default:
8349 panic("unknown field " + strconv.Quote(field.Name))
8350 }
8351 }
8352
8353 if invalid {
8354 return graphql.Null
8355 }
8356 return out
8357}
8358
8359// nolint: vetshadow
8360func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8361 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8362 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8363 rctx := &graphql.ResolverContext{
8364 Object: "__Type",
8365 Args: nil,
8366 Field: field,
8367 }
8368 ctx = graphql.WithResolverContext(ctx, rctx)
8369 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8370 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8371 ctx = rctx // use context from middleware stack in children
8372 return obj.Kind(), nil
8373 })
8374 if resTmp == nil {
8375 if !ec.HasError(rctx) {
8376 ec.Errorf(ctx, "must not be null")
8377 }
8378 return graphql.Null
8379 }
8380 res := resTmp.(string)
8381 rctx.Result = res
8382 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8383 return graphql.MarshalString(res)
8384}
8385
8386// nolint: vetshadow
8387func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8388 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8389 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8390 rctx := &graphql.ResolverContext{
8391 Object: "__Type",
8392 Args: nil,
8393 Field: field,
8394 }
8395 ctx = graphql.WithResolverContext(ctx, rctx)
8396 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8397 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8398 ctx = rctx // use context from middleware stack in children
8399 return obj.Name(), nil
8400 })
8401 if resTmp == nil {
8402 return graphql.Null
8403 }
8404 res := resTmp.(*string)
8405 rctx.Result = res
8406 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8407
8408 if res == nil {
8409 return graphql.Null
8410 }
8411 return graphql.MarshalString(*res)
8412}
8413
8414// nolint: vetshadow
8415func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8416 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8417 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8418 rctx := &graphql.ResolverContext{
8419 Object: "__Type",
8420 Args: nil,
8421 Field: field,
8422 }
8423 ctx = graphql.WithResolverContext(ctx, rctx)
8424 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8425 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8426 ctx = rctx // use context from middleware stack in children
8427 return obj.Description(), nil
8428 })
8429 if resTmp == nil {
8430 return graphql.Null
8431 }
8432 res := resTmp.(string)
8433 rctx.Result = res
8434 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8435 return graphql.MarshalString(res)
8436}
8437
8438// nolint: vetshadow
8439func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8440 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8441 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8442 rawArgs := field.ArgumentMap(ec.Variables)
8443 args, err := field___Type_fields_args(rawArgs)
8444 if err != nil {
8445 ec.Error(ctx, err)
8446 return graphql.Null
8447 }
8448 rctx := &graphql.ResolverContext{
8449 Object: "__Type",
8450 Args: args,
8451 Field: field,
8452 }
8453 ctx = graphql.WithResolverContext(ctx, rctx)
8454 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8455 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8456 ctx = rctx // use context from middleware stack in children
8457 return obj.Fields(args["includeDeprecated"].(bool)), nil
8458 })
8459 if resTmp == nil {
8460 return graphql.Null
8461 }
8462 res := resTmp.([]introspection.Field)
8463 rctx.Result = res
8464 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8465
8466 arr1 := make(graphql.Array, len(res))
8467 var wg sync.WaitGroup
8468
8469 isLen1 := len(res) == 1
8470 if !isLen1 {
8471 wg.Add(len(res))
8472 }
8473
8474 for idx1 := range res {
8475 idx1 := idx1
8476 rctx := &graphql.ResolverContext{
8477 Index: &idx1,
8478 Result: &res[idx1],
8479 }
8480 ctx := graphql.WithResolverContext(ctx, rctx)
8481 f := func(idx1 int) {
8482 if !isLen1 {
8483 defer wg.Done()
8484 }
8485 arr1[idx1] = func() graphql.Marshaler {
8486
8487 return ec.___Field(ctx, field.Selections, &res[idx1])
8488 }()
8489 }
8490 if isLen1 {
8491 f(idx1)
8492 } else {
8493 go f(idx1)
8494 }
8495
8496 }
8497 wg.Wait()
8498 return arr1
8499}
8500
8501// nolint: vetshadow
8502func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8503 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8504 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8505 rctx := &graphql.ResolverContext{
8506 Object: "__Type",
8507 Args: nil,
8508 Field: field,
8509 }
8510 ctx = graphql.WithResolverContext(ctx, rctx)
8511 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8512 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8513 ctx = rctx // use context from middleware stack in children
8514 return obj.Interfaces(), nil
8515 })
8516 if resTmp == nil {
8517 return graphql.Null
8518 }
8519 res := resTmp.([]introspection.Type)
8520 rctx.Result = res
8521 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8522
8523 arr1 := make(graphql.Array, len(res))
8524 var wg sync.WaitGroup
8525
8526 isLen1 := len(res) == 1
8527 if !isLen1 {
8528 wg.Add(len(res))
8529 }
8530
8531 for idx1 := range res {
8532 idx1 := idx1
8533 rctx := &graphql.ResolverContext{
8534 Index: &idx1,
8535 Result: &res[idx1],
8536 }
8537 ctx := graphql.WithResolverContext(ctx, rctx)
8538 f := func(idx1 int) {
8539 if !isLen1 {
8540 defer wg.Done()
8541 }
8542 arr1[idx1] = func() graphql.Marshaler {
8543
8544 return ec.___Type(ctx, field.Selections, &res[idx1])
8545 }()
8546 }
8547 if isLen1 {
8548 f(idx1)
8549 } else {
8550 go f(idx1)
8551 }
8552
8553 }
8554 wg.Wait()
8555 return arr1
8556}
8557
8558// nolint: vetshadow
8559func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8560 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8561 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8562 rctx := &graphql.ResolverContext{
8563 Object: "__Type",
8564 Args: nil,
8565 Field: field,
8566 }
8567 ctx = graphql.WithResolverContext(ctx, rctx)
8568 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8569 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8570 ctx = rctx // use context from middleware stack in children
8571 return obj.PossibleTypes(), nil
8572 })
8573 if resTmp == nil {
8574 return graphql.Null
8575 }
8576 res := resTmp.([]introspection.Type)
8577 rctx.Result = res
8578 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8579
8580 arr1 := make(graphql.Array, len(res))
8581 var wg sync.WaitGroup
8582
8583 isLen1 := len(res) == 1
8584 if !isLen1 {
8585 wg.Add(len(res))
8586 }
8587
8588 for idx1 := range res {
8589 idx1 := idx1
8590 rctx := &graphql.ResolverContext{
8591 Index: &idx1,
8592 Result: &res[idx1],
8593 }
8594 ctx := graphql.WithResolverContext(ctx, rctx)
8595 f := func(idx1 int) {
8596 if !isLen1 {
8597 defer wg.Done()
8598 }
8599 arr1[idx1] = func() graphql.Marshaler {
8600
8601 return ec.___Type(ctx, field.Selections, &res[idx1])
8602 }()
8603 }
8604 if isLen1 {
8605 f(idx1)
8606 } else {
8607 go f(idx1)
8608 }
8609
8610 }
8611 wg.Wait()
8612 return arr1
8613}
8614
8615// nolint: vetshadow
8616func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8617 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8618 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8619 rawArgs := field.ArgumentMap(ec.Variables)
8620 args, err := field___Type_enumValues_args(rawArgs)
8621 if err != nil {
8622 ec.Error(ctx, err)
8623 return graphql.Null
8624 }
8625 rctx := &graphql.ResolverContext{
8626 Object: "__Type",
8627 Args: args,
8628 Field: field,
8629 }
8630 ctx = graphql.WithResolverContext(ctx, rctx)
8631 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8632 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8633 ctx = rctx // use context from middleware stack in children
8634 return obj.EnumValues(args["includeDeprecated"].(bool)), nil
8635 })
8636 if resTmp == nil {
8637 return graphql.Null
8638 }
8639 res := resTmp.([]introspection.EnumValue)
8640 rctx.Result = res
8641 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8642
8643 arr1 := make(graphql.Array, len(res))
8644 var wg sync.WaitGroup
8645
8646 isLen1 := len(res) == 1
8647 if !isLen1 {
8648 wg.Add(len(res))
8649 }
8650
8651 for idx1 := range res {
8652 idx1 := idx1
8653 rctx := &graphql.ResolverContext{
8654 Index: &idx1,
8655 Result: &res[idx1],
8656 }
8657 ctx := graphql.WithResolverContext(ctx, rctx)
8658 f := func(idx1 int) {
8659 if !isLen1 {
8660 defer wg.Done()
8661 }
8662 arr1[idx1] = func() graphql.Marshaler {
8663
8664 return ec.___EnumValue(ctx, field.Selections, &res[idx1])
8665 }()
8666 }
8667 if isLen1 {
8668 f(idx1)
8669 } else {
8670 go f(idx1)
8671 }
8672
8673 }
8674 wg.Wait()
8675 return arr1
8676}
8677
8678// nolint: vetshadow
8679func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8680 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8681 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8682 rctx := &graphql.ResolverContext{
8683 Object: "__Type",
8684 Args: nil,
8685 Field: field,
8686 }
8687 ctx = graphql.WithResolverContext(ctx, rctx)
8688 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8689 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8690 ctx = rctx // use context from middleware stack in children
8691 return obj.InputFields(), nil
8692 })
8693 if resTmp == nil {
8694 return graphql.Null
8695 }
8696 res := resTmp.([]introspection.InputValue)
8697 rctx.Result = res
8698 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8699
8700 arr1 := make(graphql.Array, len(res))
8701 var wg sync.WaitGroup
8702
8703 isLen1 := len(res) == 1
8704 if !isLen1 {
8705 wg.Add(len(res))
8706 }
8707
8708 for idx1 := range res {
8709 idx1 := idx1
8710 rctx := &graphql.ResolverContext{
8711 Index: &idx1,
8712 Result: &res[idx1],
8713 }
8714 ctx := graphql.WithResolverContext(ctx, rctx)
8715 f := func(idx1 int) {
8716 if !isLen1 {
8717 defer wg.Done()
8718 }
8719 arr1[idx1] = func() graphql.Marshaler {
8720
8721 return ec.___InputValue(ctx, field.Selections, &res[idx1])
8722 }()
8723 }
8724 if isLen1 {
8725 f(idx1)
8726 } else {
8727 go f(idx1)
8728 }
8729
8730 }
8731 wg.Wait()
8732 return arr1
8733}
8734
8735// nolint: vetshadow
8736func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8737 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8738 defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8739 rctx := &graphql.ResolverContext{
8740 Object: "__Type",
8741 Args: nil,
8742 Field: field,
8743 }
8744 ctx = graphql.WithResolverContext(ctx, rctx)
8745 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8746 resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8747 ctx = rctx // use context from middleware stack in children
8748 return obj.OfType(), nil
8749 })
8750 if resTmp == nil {
8751 return graphql.Null
8752 }
8753 res := resTmp.(*introspection.Type)
8754 rctx.Result = res
8755 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8756
8757 if res == nil {
8758 return graphql.Null
8759 }
8760
8761 return ec.___Type(ctx, field.Selections, res)
8762}
8763
8764func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj *models.Authored) graphql.Marshaler {
8765 switch obj := (*obj).(type) {
8766 case nil:
8767 return graphql.Null
8768 case bug.Comment:
8769 return ec._Comment(ctx, sel, &obj)
8770 case *bug.Comment:
8771 return ec._Comment(ctx, sel, obj)
8772 case *bug.CreateOperation:
8773 return ec._CreateOperation(ctx, sel, obj)
8774 case *bug.SetTitleOperation:
8775 return ec._SetTitleOperation(ctx, sel, obj)
8776 case *bug.AddCommentOperation:
8777 return ec._AddCommentOperation(ctx, sel, obj)
8778 case *bug.EditCommentOperation:
8779 return ec._EditCommentOperation(ctx, sel, obj)
8780 case *bug.SetStatusOperation:
8781 return ec._SetStatusOperation(ctx, sel, obj)
8782 case *bug.LabelChangeOperation:
8783 return ec._LabelChangeOperation(ctx, sel, obj)
8784 default:
8785 panic(fmt.Errorf("unexpected type %T", obj))
8786 }
8787}
8788
8789func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj *bug.Operation) graphql.Marshaler {
8790 switch obj := (*obj).(type) {
8791 case nil:
8792 return graphql.Null
8793 case *bug.CreateOperation:
8794 return ec._CreateOperation(ctx, sel, obj)
8795 case *bug.SetTitleOperation:
8796 return ec._SetTitleOperation(ctx, sel, obj)
8797 case *bug.AddCommentOperation:
8798 return ec._AddCommentOperation(ctx, sel, obj)
8799 case *bug.EditCommentOperation:
8800 return ec._EditCommentOperation(ctx, sel, obj)
8801 case *bug.SetStatusOperation:
8802 return ec._SetStatusOperation(ctx, sel, obj)
8803 case *bug.LabelChangeOperation:
8804 return ec._LabelChangeOperation(ctx, sel, obj)
8805 default:
8806 panic(fmt.Errorf("unexpected type %T", obj))
8807 }
8808}
8809
8810func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.TimelineItem) graphql.Marshaler {
8811 switch obj := (*obj).(type) {
8812 case nil:
8813 return graphql.Null
8814 case *bug.CreateTimelineItem:
8815 return ec._CreateTimelineItem(ctx, sel, obj)
8816 case *bug.AddCommentTimelineItem:
8817 return ec._AddCommentTimelineItem(ctx, sel, obj)
8818 case bug.LabelChangeTimelineItem:
8819 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
8820 case *bug.LabelChangeTimelineItem:
8821 return ec._LabelChangeTimelineItem(ctx, sel, obj)
8822 case bug.SetStatusTimelineItem:
8823 return ec._SetStatusTimelineItem(ctx, sel, &obj)
8824 case *bug.SetStatusTimelineItem:
8825 return ec._SetStatusTimelineItem(ctx, sel, obj)
8826 case bug.SetTitleTimelineItem:
8827 return ec._SetTitleTimelineItem(ctx, sel, &obj)
8828 case *bug.SetTitleTimelineItem:
8829 return ec._SetTitleTimelineItem(ctx, sel, obj)
8830 default:
8831 panic(fmt.Errorf("unexpected type %T", obj))
8832 }
8833}
8834
8835func (ec *executionContext) FieldMiddleware(ctx context.Context, obj interface{}, next graphql.Resolver) (ret interface{}) {
8836 defer func() {
8837 if r := recover(); r != nil {
8838 ec.Error(ctx, ec.Recover(ctx, r))
8839 ret = nil
8840 }
8841 }()
8842 res, err := ec.ResolverMiddleware(ctx, next)
8843 if err != nil {
8844 ec.Error(ctx, err)
8845 return nil
8846 }
8847 return res
8848}
8849
8850func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
8851 if ec.DisableIntrospection {
8852 return nil, errors.New("introspection disabled")
8853 }
8854 return introspection.WrapSchema(parsedSchema), nil
8855}
8856
8857func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
8858 if ec.DisableIntrospection {
8859 return nil, errors.New("introspection disabled")
8860 }
8861 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
8862}
8863
8864var parsedSchema = gqlparser.MustLoadSchema(
8865 &ast.Source{Name: "bug.graphql", Input: `"""Represents an person"""
8866type Person {
8867 """The name of the person, if known."""
8868 name: String
8869 """The email of the person, if known."""
8870 email: String
8871 """The login of the person, if known."""
8872 login: String
8873 """A string containing the either the name of the person, its login or both"""
8874 displayName: String!
8875 """An url to an avatar"""
8876 avatarUrl: String
8877}
8878
8879"""Represents a comment on a bug."""
8880type Comment implements Authored {
8881 """The author of this comment."""
8882 author: Person!
8883
8884 """The message of this comment."""
8885 message: String!
8886
8887 """All media's hash referenced in this comment"""
8888 files: [Hash!]!
8889}
8890
8891type CommentConnection {
8892 edges: [CommentEdge!]!
8893 nodes: [Comment!]!
8894 pageInfo: PageInfo!
8895 totalCount: Int!
8896}
8897
8898type CommentEdge {
8899 cursor: String!
8900 node: Comment!
8901}
8902
8903enum Status {
8904 OPEN
8905 CLOSED
8906}
8907
8908type Bug {
8909 id: String!
8910 humanId: String!
8911 status: Status!
8912 title: String!
8913 labels: [Label!]!
8914 author: Person!
8915 createdAt: Time!
8916 lastEdit: Time!
8917
8918 comments(
8919 """Returns the elements in the list that come after the specified cursor."""
8920 after: String
8921 """Returns the elements in the list that come before the specified cursor."""
8922 before: String
8923 """Returns the first _n_ elements from the list."""
8924 first: Int
8925 """Returns the last _n_ elements from the list."""
8926 last: Int
8927 ): CommentConnection!
8928
8929 timeline(
8930 """Returns the elements in the list that come after the specified cursor."""
8931 after: String
8932 """Returns the elements in the list that come before the specified cursor."""
8933 before: String
8934 """Returns the first _n_ elements from the list."""
8935 first: Int
8936 """Returns the last _n_ elements from the list."""
8937 last: Int
8938 ): TimelineItemConnection!
8939
8940 operations(
8941 """Returns the elements in the list that come after the specified cursor."""
8942 after: String
8943 """Returns the elements in the list that come before the specified cursor."""
8944 before: String
8945 """Returns the first _n_ elements from the list."""
8946 first: Int
8947 """Returns the last _n_ elements from the list."""
8948 last: Int
8949 ): OperationConnection!
8950}
8951
8952"""The connection type for Bug."""
8953type BugConnection {
8954 """A list of edges."""
8955 edges: [BugEdge!]!
8956 nodes: [Bug!]!
8957 """Information to aid in pagination."""
8958 pageInfo: PageInfo!
8959 """Identifies the total count of items in the connection."""
8960 totalCount: Int!
8961}
8962
8963"""An edge in a connection."""
8964type BugEdge {
8965 """A cursor for use in pagination."""
8966 cursor: String!
8967 """The item at the end of the edge."""
8968 node: Bug!
8969}
8970
8971type Repository {
8972 allBugs(
8973 """Returns the elements in the list that come after the specified cursor."""
8974 after: String
8975 """Returns the elements in the list that come before the specified cursor."""
8976 before: String
8977 """Returns the first _n_ elements from the list."""
8978 first: Int
8979 """Returns the last _n_ elements from the list."""
8980 last: Int
8981 """A query to select and order bugs"""
8982 query: String
8983 ): BugConnection!
8984 bug(prefix: String!): Bug
8985}
8986
8987`},
8988 &ast.Source{Name: "operations.graphql", Input: `"""An operation applied to a bug."""
8989interface Operation {
8990 """The hash of the operation"""
8991 hash: Hash!
8992 """The operations author."""
8993 author: Person!
8994 """The datetime when this operation was issued."""
8995 date: Time!
8996}
8997
8998# Connection
8999
9000"""The connection type for an Operation"""
9001type OperationConnection {
9002 edges: [OperationEdge!]!
9003 nodes: [Operation!]!
9004 pageInfo: PageInfo!
9005 totalCount: Int!
9006}
9007
9008"""Represent an Operation"""
9009type OperationEdge {
9010 cursor: String!
9011 node: Operation!
9012}
9013
9014# Operations
9015
9016type CreateOperation implements Operation & Authored {
9017 """The hash of the operation"""
9018 hash: Hash!
9019 """The author of this object."""
9020 author: Person!
9021 """The datetime when this operation was issued."""
9022 date: Time!
9023
9024 title: String!
9025 message: String!
9026 files: [Hash!]!
9027}
9028
9029type SetTitleOperation implements Operation & Authored {
9030 """The hash of the operation"""
9031 hash: Hash!
9032 """The author of this object."""
9033 author: Person!
9034 """The datetime when this operation was issued."""
9035 date: Time!
9036
9037 title: String!
9038 was: String!
9039}
9040
9041type AddCommentOperation implements Operation & Authored {
9042 """The hash of the operation"""
9043 hash: Hash!
9044 """The author of this object."""
9045 author: Person!
9046 """The datetime when this operation was issued."""
9047 date: Time!
9048
9049 message: String!
9050 files: [Hash!]!
9051}
9052
9053type EditCommentOperation implements Operation & Authored {
9054 """The hash of the operation"""
9055 hash: Hash!
9056 """The author of this object."""
9057 author: Person!
9058 """The datetime when this operation was issued."""
9059 date: Time!
9060
9061 target: Hash!
9062 message: String!
9063 files: [Hash!]!
9064}
9065
9066type SetStatusOperation implements Operation & Authored {
9067 """The hash of the operation"""
9068 hash: Hash!
9069 """The author of this object."""
9070 author: Person!
9071 """The datetime when this operation was issued."""
9072 date: Time!
9073
9074 status: Status!
9075}
9076
9077type LabelChangeOperation implements Operation & Authored {
9078 """The hash of the operation"""
9079 hash: Hash!
9080 """The author of this object."""
9081 author: Person!
9082 """The datetime when this operation was issued."""
9083 date: Time!
9084
9085 added: [Label!]!
9086 removed: [Label!]!
9087}`},
9088 &ast.Source{Name: "root.graphql", Input: `scalar Time
9089scalar Label
9090scalar Hash
9091
9092"""Information about pagination in a connection."""
9093type PageInfo {
9094 """When paginating forwards, are there more items?"""
9095 hasNextPage: Boolean!
9096 """When paginating backwards, are there more items?"""
9097 hasPreviousPage: Boolean!
9098 """When paginating backwards, the cursor to continue."""
9099 startCursor: String!
9100 """When paginating forwards, the cursor to continue."""
9101 endCursor: String!
9102}
9103
9104"""An object that has an author."""
9105interface Authored {
9106 """The author of this object."""
9107 author: Person!
9108}
9109
9110type Query {
9111 defaultRepository: Repository
9112 repository(id: String!): Repository
9113}
9114
9115type Mutation {
9116 newBug(repoRef: String, title: String!, message: String!, files: [Hash!]): Bug!
9117
9118 addComment(repoRef: String, prefix: String!, message: String!, files: [Hash!]): Bug!
9119 changeLabels(repoRef: String, prefix: String!, added: [String!], removed: [String!]): Bug!
9120 open(repoRef: String, prefix: String!): Bug!
9121 close(repoRef: String, prefix: String!): Bug!
9122 setTitle(repoRef: String, prefix: String!, title: String!): Bug!
9123
9124 commit(repoRef: String, prefix: String!): Bug!
9125}`},
9126 &ast.Source{Name: "timeline.graphql", Input: `"""An item in the timeline of events"""
9127interface TimelineItem {
9128 """The hash of the source operation"""
9129 hash: Hash!
9130}
9131
9132"""CommentHistoryStep hold one version of a message in the history"""
9133type CommentHistoryStep {
9134 message: String!
9135 date: Time!
9136}
9137
9138# Connection
9139
9140"""The connection type for TimelineItem"""
9141type TimelineItemConnection {
9142 edges: [TimelineItemEdge!]!
9143 nodes: [TimelineItem!]!
9144 pageInfo: PageInfo!
9145 totalCount: Int!
9146}
9147
9148"""Represent a TimelineItem"""
9149type TimelineItemEdge {
9150 cursor: String!
9151 node: TimelineItem!
9152}
9153
9154# Items
9155
9156"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
9157type CreateTimelineItem implements TimelineItem {
9158 """The hash of the source operation"""
9159 hash: Hash!
9160 author: Person!
9161 message: String!
9162 messageIsEmpty: Boolean!
9163 files: [Hash!]!
9164 createdAt: Time!
9165 lastEdit: Time!
9166 edited: Boolean!
9167 history: [CommentHistoryStep!]!
9168}
9169
9170"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
9171type AddCommentTimelineItem implements TimelineItem {
9172 """The hash of the source operation"""
9173 hash: Hash!
9174 author: Person!
9175 message: String!
9176 messageIsEmpty: Boolean!
9177 files: [Hash!]!
9178 createdAt: Time!
9179 lastEdit: Time!
9180 edited: Boolean!
9181 history: [CommentHistoryStep!]!
9182}
9183
9184"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
9185type LabelChangeTimelineItem implements TimelineItem {
9186 """The hash of the source operation"""
9187 hash: Hash!
9188 author: Person!
9189 date: Time!
9190 added: [Label!]!
9191 removed: [Label!]!
9192}
9193
9194"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
9195type SetStatusTimelineItem implements TimelineItem {
9196 """The hash of the source operation"""
9197 hash: Hash!
9198 author: Person!
9199 date: Time!
9200 status: Status!
9201}
9202
9203"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
9204type SetTitleTimelineItem implements TimelineItem {
9205 """The hash of the source operation"""
9206 hash: Hash!
9207 author: Person!
9208 date: Time!
9209 title: String!
9210 was: String!
9211}`},
9212)