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