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