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