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 {
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`},
1695 &ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
1696type Identity {
1697 """The identifier for this identity"""
1698 id: String!
1699 """The human version (truncated) identifier for this identity"""
1700 humanId: String!
1701 """The name of the person, if known."""
1702 name: String
1703 """The email of the person, if known."""
1704 email: String
1705 """The login of the person, if known."""
1706 login: String
1707 """A string containing the either the name of the person, its login or both"""
1708 displayName: String!
1709 """An url to an avatar"""
1710 avatarUrl: String
1711 """isProtected is true if the chain of git commits started to be signed.
1712 If that's the case, only signed commit with a valid key for this identity can be added."""
1713 isProtected: Boolean!
1714}
1715
1716type IdentityConnection {
1717 edges: [IdentityEdge!]!
1718 nodes: [Identity!]!
1719 pageInfo: PageInfo!
1720 totalCount: Int!
1721}
1722
1723type IdentityEdge {
1724 cursor: String!
1725 node: Identity!
1726}`},
1727 &ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
1728interface Operation {
1729 """The hash of the operation"""
1730 hash: Hash!
1731 """The operations author."""
1732 author: Identity!
1733 """The datetime when this operation was issued."""
1734 date: Time!
1735}
1736
1737# Connection
1738
1739"""The connection type for an Operation"""
1740type OperationConnection {
1741 edges: [OperationEdge!]!
1742 nodes: [Operation!]!
1743 pageInfo: PageInfo!
1744 totalCount: Int!
1745}
1746
1747"""Represent an Operation"""
1748type OperationEdge {
1749 cursor: String!
1750 node: Operation!
1751}
1752
1753# Operations
1754
1755type CreateOperation implements Operation & Authored {
1756 """The hash of the operation"""
1757 hash: Hash!
1758 """The author of this object."""
1759 author: Identity!
1760 """The datetime when this operation was issued."""
1761 date: Time!
1762
1763 title: String!
1764 message: String!
1765 files: [Hash!]!
1766}
1767
1768type SetTitleOperation implements Operation & Authored {
1769 """The hash of the operation"""
1770 hash: Hash!
1771 """The author of this object."""
1772 author: Identity!
1773 """The datetime when this operation was issued."""
1774 date: Time!
1775
1776 title: String!
1777 was: String!
1778}
1779
1780type AddCommentOperation implements Operation & Authored {
1781 """The hash of the operation"""
1782 hash: Hash!
1783 """The author of this object."""
1784 author: Identity!
1785 """The datetime when this operation was issued."""
1786 date: Time!
1787
1788 message: String!
1789 files: [Hash!]!
1790}
1791
1792type EditCommentOperation implements Operation & Authored {
1793 """The hash of the operation"""
1794 hash: Hash!
1795 """The author of this object."""
1796 author: Identity!
1797 """The datetime when this operation was issued."""
1798 date: Time!
1799
1800 target: Hash!
1801 message: String!
1802 files: [Hash!]!
1803}
1804
1805type SetStatusOperation implements Operation & Authored {
1806 """The hash of the operation"""
1807 hash: Hash!
1808 """The author of this object."""
1809 author: Identity!
1810 """The datetime when this operation was issued."""
1811 date: Time!
1812
1813 status: Status!
1814}
1815
1816type LabelChangeOperation implements Operation & Authored {
1817 """The hash of the operation"""
1818 hash: Hash!
1819 """The author of this object."""
1820 author: Identity!
1821 """The datetime when this operation was issued."""
1822 date: Time!
1823
1824 added: [Label!]!
1825 removed: [Label!]!
1826}
1827`},
1828 &ast.Source{Name: "schema/repository.graphql", Input: `
1829type Repository {
1830 """All the bugs"""
1831 allBugs(
1832 """Returns the elements in the list that come after the specified cursor."""
1833 after: String
1834 """Returns the elements in the list that come before the specified cursor."""
1835 before: String
1836 """Returns the first _n_ elements from the list."""
1837 first: Int
1838 """Returns the last _n_ elements from the list."""
1839 last: Int
1840 """A query to select and order bugs"""
1841 query: String
1842 ): BugConnection!
1843
1844 bug(prefix: String!): Bug
1845
1846 """All the identities"""
1847 allIdentities(
1848 """Returns the elements in the list that come after the specified cursor."""
1849 after: String
1850 """Returns the elements in the list that come before the specified cursor."""
1851 before: String
1852 """Returns the first _n_ elements from the list."""
1853 first: Int
1854 """Returns the last _n_ elements from the list."""
1855 last: Int
1856 ): IdentityConnection!
1857
1858 identity(prefix: String!): Identity
1859
1860 """The identity created or selected by the user as its own"""
1861 userIdentity: Identity
1862
1863 """List of valid labels."""
1864 validLabels: [Label!]!
1865}`},
1866 &ast.Source{Name: "schema/root.graphql", Input: `type Query {
1867 defaultRepository: Repository
1868 repository(id: String!): Repository
1869}
1870
1871type Mutation {
1872 newBug(repoRef: String, title: String!, message: String!, files: [Hash!]): Bug!
1873
1874 addComment(repoRef: String, prefix: String!, message: String!, files: [Hash!]): Bug!
1875 changeLabels(repoRef: String, prefix: String!, added: [String!], removed: [String!]): Bug!
1876 open(repoRef: String, prefix: String!): Bug!
1877 close(repoRef: String, prefix: String!): Bug!
1878 setTitle(repoRef: String, prefix: String!, title: String!): Bug!
1879
1880 commit(repoRef: String, prefix: String!): Bug!
1881}
1882`},
1883 &ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
1884interface TimelineItem {
1885 """The hash of the source operation"""
1886 hash: Hash!
1887}
1888
1889"""CommentHistoryStep hold one version of a message in the history"""
1890type CommentHistoryStep {
1891 message: String!
1892 date: Time!
1893}
1894
1895# Connection
1896
1897"""The connection type for TimelineItem"""
1898type TimelineItemConnection {
1899 edges: [TimelineItemEdge!]!
1900 nodes: [TimelineItem!]!
1901 pageInfo: PageInfo!
1902 totalCount: Int!
1903}
1904
1905"""Represent a TimelineItem"""
1906type TimelineItemEdge {
1907 cursor: String!
1908 node: TimelineItem!
1909}
1910
1911# Items
1912
1913"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
1914type CreateTimelineItem implements TimelineItem {
1915 """The hash of the source operation"""
1916 hash: Hash!
1917 author: Identity!
1918 message: String!
1919 messageIsEmpty: Boolean!
1920 files: [Hash!]!
1921 createdAt: Time!
1922 lastEdit: Time!
1923 edited: Boolean!
1924 history: [CommentHistoryStep!]!
1925}
1926
1927"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
1928type AddCommentTimelineItem implements TimelineItem {
1929 """The hash of the source operation"""
1930 hash: Hash!
1931 author: Identity!
1932 message: String!
1933 messageIsEmpty: Boolean!
1934 files: [Hash!]!
1935 createdAt: Time!
1936 lastEdit: Time!
1937 edited: Boolean!
1938 history: [CommentHistoryStep!]!
1939}
1940
1941"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
1942type LabelChangeTimelineItem implements TimelineItem {
1943 """The hash of the source operation"""
1944 hash: Hash!
1945 author: Identity!
1946 date: Time!
1947 added: [Label!]!
1948 removed: [Label!]!
1949}
1950
1951"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
1952type SetStatusTimelineItem implements TimelineItem {
1953 """The hash of the source operation"""
1954 hash: Hash!
1955 author: Identity!
1956 date: Time!
1957 status: Status!
1958}
1959
1960"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
1961type SetTitleTimelineItem implements TimelineItem {
1962 """The hash of the source operation"""
1963 hash: Hash!
1964 author: Identity!
1965 date: Time!
1966 title: String!
1967 was: String!
1968}
1969`},
1970 &ast.Source{Name: "schema/types.graphql", Input: `scalar Time
1971scalar Hash
1972
1973"""Defines a color by red, green and blue components."""
1974type Color {
1975 """Red component of the color."""
1976 R: Int!
1977 """Green component of the color."""
1978 G: Int!
1979 """Blue component of the color."""
1980 B: Int!
1981}
1982
1983"""Label for a bug."""
1984type Label {
1985 """The name of the label."""
1986 name: String!
1987 """Color of the label."""
1988 color: Color!
1989}
1990
1991"""Information about pagination in a connection."""
1992type PageInfo {
1993 """When paginating forwards, are there more items?"""
1994 hasNextPage: Boolean!
1995 """When paginating backwards, are there more items?"""
1996 hasPreviousPage: Boolean!
1997 """When paginating backwards, the cursor to continue."""
1998 startCursor: String!
1999 """When paginating forwards, the cursor to continue."""
2000 endCursor: String!
2001}
2002
2003"""An object that has an author."""
2004interface Authored {
2005 """The author of this object."""
2006 author: Identity!
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.CreateOperation:
7438 return ec._CreateOperation(ctx, sel, obj)
7439 case *bug.SetTitleOperation:
7440 return ec._SetTitleOperation(ctx, sel, obj)
7441 case *bug.AddCommentOperation:
7442 return ec._AddCommentOperation(ctx, sel, obj)
7443 case *bug.EditCommentOperation:
7444 return ec._EditCommentOperation(ctx, sel, obj)
7445 case *bug.SetStatusOperation:
7446 return ec._SetStatusOperation(ctx, sel, obj)
7447 case *bug.LabelChangeOperation:
7448 return ec._LabelChangeOperation(ctx, sel, obj)
7449 default:
7450 panic(fmt.Errorf("unexpected type %T", obj))
7451 }
7452}
7453
7454func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj *bug.Operation) graphql.Marshaler {
7455 switch obj := (*obj).(type) {
7456 case nil:
7457 return graphql.Null
7458 case *bug.CreateOperation:
7459 return ec._CreateOperation(ctx, sel, obj)
7460 case *bug.SetTitleOperation:
7461 return ec._SetTitleOperation(ctx, sel, obj)
7462 case *bug.AddCommentOperation:
7463 return ec._AddCommentOperation(ctx, sel, obj)
7464 case *bug.EditCommentOperation:
7465 return ec._EditCommentOperation(ctx, sel, obj)
7466 case *bug.SetStatusOperation:
7467 return ec._SetStatusOperation(ctx, sel, obj)
7468 case *bug.LabelChangeOperation:
7469 return ec._LabelChangeOperation(ctx, sel, obj)
7470 default:
7471 panic(fmt.Errorf("unexpected type %T", obj))
7472 }
7473}
7474
7475func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.TimelineItem) graphql.Marshaler {
7476 switch obj := (*obj).(type) {
7477 case nil:
7478 return graphql.Null
7479 case *bug.CreateTimelineItem:
7480 return ec._CreateTimelineItem(ctx, sel, obj)
7481 case *bug.AddCommentTimelineItem:
7482 return ec._AddCommentTimelineItem(ctx, sel, obj)
7483 case bug.LabelChangeTimelineItem:
7484 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
7485 case *bug.LabelChangeTimelineItem:
7486 return ec._LabelChangeTimelineItem(ctx, sel, obj)
7487 case bug.SetStatusTimelineItem:
7488 return ec._SetStatusTimelineItem(ctx, sel, &obj)
7489 case *bug.SetStatusTimelineItem:
7490 return ec._SetStatusTimelineItem(ctx, sel, obj)
7491 case bug.SetTitleTimelineItem:
7492 return ec._SetTitleTimelineItem(ctx, sel, &obj)
7493 case *bug.SetTitleTimelineItem:
7494 return ec._SetTitleTimelineItem(ctx, sel, obj)
7495 default:
7496 panic(fmt.Errorf("unexpected type %T", obj))
7497 }
7498}
7499
7500// endregion ************************** interface.gotpl ***************************
7501
7502// region **************************** object.gotpl ****************************
7503
7504var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
7505
7506func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
7507 fields := graphql.CollectFields(ec.RequestContext, sel, addCommentOperationImplementors)
7508
7509 out := graphql.NewFieldSet(fields)
7510 var invalids uint32
7511 for i, field := range fields {
7512 switch field.Name {
7513 case "__typename":
7514 out.Values[i] = graphql.MarshalString("AddCommentOperation")
7515 case "hash":
7516 out.Values[i] = ec._AddCommentOperation_hash(ctx, field, obj)
7517 if out.Values[i] == graphql.Null {
7518 atomic.AddUint32(&invalids, 1)
7519 }
7520 case "author":
7521 out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
7522 if out.Values[i] == graphql.Null {
7523 atomic.AddUint32(&invalids, 1)
7524 }
7525 case "date":
7526 field := field
7527 out.Concurrently(i, func() (res graphql.Marshaler) {
7528 defer func() {
7529 if r := recover(); r != nil {
7530 ec.Error(ctx, ec.Recover(ctx, r))
7531 }
7532 }()
7533 res = ec._AddCommentOperation_date(ctx, field, obj)
7534 if res == graphql.Null {
7535 atomic.AddUint32(&invalids, 1)
7536 }
7537 return res
7538 })
7539 case "message":
7540 out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
7541 if out.Values[i] == graphql.Null {
7542 atomic.AddUint32(&invalids, 1)
7543 }
7544 case "files":
7545 out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
7546 if out.Values[i] == graphql.Null {
7547 atomic.AddUint32(&invalids, 1)
7548 }
7549 default:
7550 panic("unknown field " + strconv.Quote(field.Name))
7551 }
7552 }
7553 out.Dispatch()
7554 if invalids > 0 {
7555 return graphql.Null
7556 }
7557 return out
7558}
7559
7560var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem"}
7561
7562func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
7563 fields := graphql.CollectFields(ec.RequestContext, sel, addCommentTimelineItemImplementors)
7564
7565 out := graphql.NewFieldSet(fields)
7566 var invalids uint32
7567 for i, field := range fields {
7568 switch field.Name {
7569 case "__typename":
7570 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
7571 case "hash":
7572 out.Values[i] = ec._AddCommentTimelineItem_hash(ctx, field, obj)
7573 if out.Values[i] == graphql.Null {
7574 atomic.AddUint32(&invalids, 1)
7575 }
7576 case "author":
7577 out.Values[i] = ec._AddCommentTimelineItem_author(ctx, field, obj)
7578 if out.Values[i] == graphql.Null {
7579 atomic.AddUint32(&invalids, 1)
7580 }
7581 case "message":
7582 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
7583 if out.Values[i] == graphql.Null {
7584 atomic.AddUint32(&invalids, 1)
7585 }
7586 case "messageIsEmpty":
7587 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
7588 if out.Values[i] == graphql.Null {
7589 atomic.AddUint32(&invalids, 1)
7590 }
7591 case "files":
7592 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
7593 if out.Values[i] == graphql.Null {
7594 atomic.AddUint32(&invalids, 1)
7595 }
7596 case "createdAt":
7597 field := field
7598 out.Concurrently(i, func() (res graphql.Marshaler) {
7599 defer func() {
7600 if r := recover(); r != nil {
7601 ec.Error(ctx, ec.Recover(ctx, r))
7602 }
7603 }()
7604 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
7605 if res == graphql.Null {
7606 atomic.AddUint32(&invalids, 1)
7607 }
7608 return res
7609 })
7610 case "lastEdit":
7611 field := field
7612 out.Concurrently(i, func() (res graphql.Marshaler) {
7613 defer func() {
7614 if r := recover(); r != nil {
7615 ec.Error(ctx, ec.Recover(ctx, r))
7616 }
7617 }()
7618 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
7619 if res == graphql.Null {
7620 atomic.AddUint32(&invalids, 1)
7621 }
7622 return res
7623 })
7624 case "edited":
7625 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
7626 if out.Values[i] == graphql.Null {
7627 atomic.AddUint32(&invalids, 1)
7628 }
7629 case "history":
7630 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
7631 if out.Values[i] == graphql.Null {
7632 atomic.AddUint32(&invalids, 1)
7633 }
7634 default:
7635 panic("unknown field " + strconv.Quote(field.Name))
7636 }
7637 }
7638 out.Dispatch()
7639 if invalids > 0 {
7640 return graphql.Null
7641 }
7642 return out
7643}
7644
7645var bugImplementors = []string{"Bug"}
7646
7647func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
7648 fields := graphql.CollectFields(ec.RequestContext, sel, bugImplementors)
7649
7650 out := graphql.NewFieldSet(fields)
7651 var invalids uint32
7652 for i, field := range fields {
7653 switch field.Name {
7654 case "__typename":
7655 out.Values[i] = graphql.MarshalString("Bug")
7656 case "id":
7657 out.Values[i] = ec._Bug_id(ctx, field, obj)
7658 if out.Values[i] == graphql.Null {
7659 atomic.AddUint32(&invalids, 1)
7660 }
7661 case "humanId":
7662 out.Values[i] = ec._Bug_humanId(ctx, field, obj)
7663 if out.Values[i] == graphql.Null {
7664 atomic.AddUint32(&invalids, 1)
7665 }
7666 case "status":
7667 field := field
7668 out.Concurrently(i, func() (res graphql.Marshaler) {
7669 defer func() {
7670 if r := recover(); r != nil {
7671 ec.Error(ctx, ec.Recover(ctx, r))
7672 }
7673 }()
7674 res = ec._Bug_status(ctx, field, obj)
7675 if res == graphql.Null {
7676 atomic.AddUint32(&invalids, 1)
7677 }
7678 return res
7679 })
7680 case "title":
7681 out.Values[i] = ec._Bug_title(ctx, field, obj)
7682 if out.Values[i] == graphql.Null {
7683 atomic.AddUint32(&invalids, 1)
7684 }
7685 case "labels":
7686 out.Values[i] = ec._Bug_labels(ctx, field, obj)
7687 if out.Values[i] == graphql.Null {
7688 atomic.AddUint32(&invalids, 1)
7689 }
7690 case "author":
7691 out.Values[i] = ec._Bug_author(ctx, field, obj)
7692 if out.Values[i] == graphql.Null {
7693 atomic.AddUint32(&invalids, 1)
7694 }
7695 case "createdAt":
7696 out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
7697 if out.Values[i] == graphql.Null {
7698 atomic.AddUint32(&invalids, 1)
7699 }
7700 case "lastEdit":
7701 field := field
7702 out.Concurrently(i, func() (res graphql.Marshaler) {
7703 defer func() {
7704 if r := recover(); r != nil {
7705 ec.Error(ctx, ec.Recover(ctx, r))
7706 }
7707 }()
7708 res = ec._Bug_lastEdit(ctx, field, obj)
7709 if res == graphql.Null {
7710 atomic.AddUint32(&invalids, 1)
7711 }
7712 return res
7713 })
7714 case "actors":
7715 field := field
7716 out.Concurrently(i, func() (res graphql.Marshaler) {
7717 defer func() {
7718 if r := recover(); r != nil {
7719 ec.Error(ctx, ec.Recover(ctx, r))
7720 }
7721 }()
7722 res = ec._Bug_actors(ctx, field, obj)
7723 if res == graphql.Null {
7724 atomic.AddUint32(&invalids, 1)
7725 }
7726 return res
7727 })
7728 case "participants":
7729 field := field
7730 out.Concurrently(i, func() (res graphql.Marshaler) {
7731 defer func() {
7732 if r := recover(); r != nil {
7733 ec.Error(ctx, ec.Recover(ctx, r))
7734 }
7735 }()
7736 res = ec._Bug_participants(ctx, field, obj)
7737 if res == graphql.Null {
7738 atomic.AddUint32(&invalids, 1)
7739 }
7740 return res
7741 })
7742 case "comments":
7743 field := field
7744 out.Concurrently(i, func() (res graphql.Marshaler) {
7745 defer func() {
7746 if r := recover(); r != nil {
7747 ec.Error(ctx, ec.Recover(ctx, r))
7748 }
7749 }()
7750 res = ec._Bug_comments(ctx, field, obj)
7751 if res == graphql.Null {
7752 atomic.AddUint32(&invalids, 1)
7753 }
7754 return res
7755 })
7756 case "timeline":
7757 field := field
7758 out.Concurrently(i, func() (res graphql.Marshaler) {
7759 defer func() {
7760 if r := recover(); r != nil {
7761 ec.Error(ctx, ec.Recover(ctx, r))
7762 }
7763 }()
7764 res = ec._Bug_timeline(ctx, field, obj)
7765 if res == graphql.Null {
7766 atomic.AddUint32(&invalids, 1)
7767 }
7768 return res
7769 })
7770 case "operations":
7771 field := field
7772 out.Concurrently(i, func() (res graphql.Marshaler) {
7773 defer func() {
7774 if r := recover(); r != nil {
7775 ec.Error(ctx, ec.Recover(ctx, r))
7776 }
7777 }()
7778 res = ec._Bug_operations(ctx, field, obj)
7779 if res == graphql.Null {
7780 atomic.AddUint32(&invalids, 1)
7781 }
7782 return res
7783 })
7784 default:
7785 panic("unknown field " + strconv.Quote(field.Name))
7786 }
7787 }
7788 out.Dispatch()
7789 if invalids > 0 {
7790 return graphql.Null
7791 }
7792 return out
7793}
7794
7795var bugConnectionImplementors = []string{"BugConnection"}
7796
7797func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
7798 fields := graphql.CollectFields(ec.RequestContext, sel, bugConnectionImplementors)
7799
7800 out := graphql.NewFieldSet(fields)
7801 var invalids uint32
7802 for i, field := range fields {
7803 switch field.Name {
7804 case "__typename":
7805 out.Values[i] = graphql.MarshalString("BugConnection")
7806 case "edges":
7807 out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
7808 if out.Values[i] == graphql.Null {
7809 invalids++
7810 }
7811 case "nodes":
7812 out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
7813 if out.Values[i] == graphql.Null {
7814 invalids++
7815 }
7816 case "pageInfo":
7817 out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
7818 if out.Values[i] == graphql.Null {
7819 invalids++
7820 }
7821 case "totalCount":
7822 out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
7823 if out.Values[i] == graphql.Null {
7824 invalids++
7825 }
7826 default:
7827 panic("unknown field " + strconv.Quote(field.Name))
7828 }
7829 }
7830 out.Dispatch()
7831 if invalids > 0 {
7832 return graphql.Null
7833 }
7834 return out
7835}
7836
7837var bugEdgeImplementors = []string{"BugEdge"}
7838
7839func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
7840 fields := graphql.CollectFields(ec.RequestContext, sel, bugEdgeImplementors)
7841
7842 out := graphql.NewFieldSet(fields)
7843 var invalids uint32
7844 for i, field := range fields {
7845 switch field.Name {
7846 case "__typename":
7847 out.Values[i] = graphql.MarshalString("BugEdge")
7848 case "cursor":
7849 out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
7850 if out.Values[i] == graphql.Null {
7851 invalids++
7852 }
7853 case "node":
7854 out.Values[i] = ec._BugEdge_node(ctx, field, obj)
7855 if out.Values[i] == graphql.Null {
7856 invalids++
7857 }
7858 default:
7859 panic("unknown field " + strconv.Quote(field.Name))
7860 }
7861 }
7862 out.Dispatch()
7863 if invalids > 0 {
7864 return graphql.Null
7865 }
7866 return out
7867}
7868
7869var colorImplementors = []string{"Color"}
7870
7871func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
7872 fields := graphql.CollectFields(ec.RequestContext, sel, colorImplementors)
7873
7874 out := graphql.NewFieldSet(fields)
7875 var invalids uint32
7876 for i, field := range fields {
7877 switch field.Name {
7878 case "__typename":
7879 out.Values[i] = graphql.MarshalString("Color")
7880 case "R":
7881 field := field
7882 out.Concurrently(i, func() (res graphql.Marshaler) {
7883 defer func() {
7884 if r := recover(); r != nil {
7885 ec.Error(ctx, ec.Recover(ctx, r))
7886 }
7887 }()
7888 res = ec._Color_R(ctx, field, obj)
7889 if res == graphql.Null {
7890 atomic.AddUint32(&invalids, 1)
7891 }
7892 return res
7893 })
7894 case "G":
7895 field := field
7896 out.Concurrently(i, func() (res graphql.Marshaler) {
7897 defer func() {
7898 if r := recover(); r != nil {
7899 ec.Error(ctx, ec.Recover(ctx, r))
7900 }
7901 }()
7902 res = ec._Color_G(ctx, field, obj)
7903 if res == graphql.Null {
7904 atomic.AddUint32(&invalids, 1)
7905 }
7906 return res
7907 })
7908 case "B":
7909 field := field
7910 out.Concurrently(i, func() (res graphql.Marshaler) {
7911 defer func() {
7912 if r := recover(); r != nil {
7913 ec.Error(ctx, ec.Recover(ctx, r))
7914 }
7915 }()
7916 res = ec._Color_B(ctx, field, obj)
7917 if res == graphql.Null {
7918 atomic.AddUint32(&invalids, 1)
7919 }
7920 return res
7921 })
7922 default:
7923 panic("unknown field " + strconv.Quote(field.Name))
7924 }
7925 }
7926 out.Dispatch()
7927 if invalids > 0 {
7928 return graphql.Null
7929 }
7930 return out
7931}
7932
7933var commentImplementors = []string{"Comment", "Authored"}
7934
7935func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
7936 fields := graphql.CollectFields(ec.RequestContext, sel, commentImplementors)
7937
7938 out := graphql.NewFieldSet(fields)
7939 var invalids uint32
7940 for i, field := range fields {
7941 switch field.Name {
7942 case "__typename":
7943 out.Values[i] = graphql.MarshalString("Comment")
7944 case "author":
7945 out.Values[i] = ec._Comment_author(ctx, field, obj)
7946 if out.Values[i] == graphql.Null {
7947 invalids++
7948 }
7949 case "message":
7950 out.Values[i] = ec._Comment_message(ctx, field, obj)
7951 if out.Values[i] == graphql.Null {
7952 invalids++
7953 }
7954 case "files":
7955 out.Values[i] = ec._Comment_files(ctx, field, obj)
7956 if out.Values[i] == graphql.Null {
7957 invalids++
7958 }
7959 default:
7960 panic("unknown field " + strconv.Quote(field.Name))
7961 }
7962 }
7963 out.Dispatch()
7964 if invalids > 0 {
7965 return graphql.Null
7966 }
7967 return out
7968}
7969
7970var commentConnectionImplementors = []string{"CommentConnection"}
7971
7972func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
7973 fields := graphql.CollectFields(ec.RequestContext, sel, commentConnectionImplementors)
7974
7975 out := graphql.NewFieldSet(fields)
7976 var invalids uint32
7977 for i, field := range fields {
7978 switch field.Name {
7979 case "__typename":
7980 out.Values[i] = graphql.MarshalString("CommentConnection")
7981 case "edges":
7982 out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
7983 if out.Values[i] == graphql.Null {
7984 invalids++
7985 }
7986 case "nodes":
7987 out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
7988 if out.Values[i] == graphql.Null {
7989 invalids++
7990 }
7991 case "pageInfo":
7992 out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
7993 if out.Values[i] == graphql.Null {
7994 invalids++
7995 }
7996 case "totalCount":
7997 out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
7998 if out.Values[i] == graphql.Null {
7999 invalids++
8000 }
8001 default:
8002 panic("unknown field " + strconv.Quote(field.Name))
8003 }
8004 }
8005 out.Dispatch()
8006 if invalids > 0 {
8007 return graphql.Null
8008 }
8009 return out
8010}
8011
8012var commentEdgeImplementors = []string{"CommentEdge"}
8013
8014func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
8015 fields := graphql.CollectFields(ec.RequestContext, sel, commentEdgeImplementors)
8016
8017 out := graphql.NewFieldSet(fields)
8018 var invalids uint32
8019 for i, field := range fields {
8020 switch field.Name {
8021 case "__typename":
8022 out.Values[i] = graphql.MarshalString("CommentEdge")
8023 case "cursor":
8024 out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
8025 if out.Values[i] == graphql.Null {
8026 invalids++
8027 }
8028 case "node":
8029 out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
8030 if out.Values[i] == graphql.Null {
8031 invalids++
8032 }
8033 default:
8034 panic("unknown field " + strconv.Quote(field.Name))
8035 }
8036 }
8037 out.Dispatch()
8038 if invalids > 0 {
8039 return graphql.Null
8040 }
8041 return out
8042}
8043
8044var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
8045
8046func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
8047 fields := graphql.CollectFields(ec.RequestContext, sel, commentHistoryStepImplementors)
8048
8049 out := graphql.NewFieldSet(fields)
8050 var invalids uint32
8051 for i, field := range fields {
8052 switch field.Name {
8053 case "__typename":
8054 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
8055 case "message":
8056 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
8057 if out.Values[i] == graphql.Null {
8058 atomic.AddUint32(&invalids, 1)
8059 }
8060 case "date":
8061 field := field
8062 out.Concurrently(i, func() (res graphql.Marshaler) {
8063 defer func() {
8064 if r := recover(); r != nil {
8065 ec.Error(ctx, ec.Recover(ctx, r))
8066 }
8067 }()
8068 res = ec._CommentHistoryStep_date(ctx, field, obj)
8069 if res == graphql.Null {
8070 atomic.AddUint32(&invalids, 1)
8071 }
8072 return res
8073 })
8074 default:
8075 panic("unknown field " + strconv.Quote(field.Name))
8076 }
8077 }
8078 out.Dispatch()
8079 if invalids > 0 {
8080 return graphql.Null
8081 }
8082 return out
8083}
8084
8085var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
8086
8087func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
8088 fields := graphql.CollectFields(ec.RequestContext, sel, createOperationImplementors)
8089
8090 out := graphql.NewFieldSet(fields)
8091 var invalids uint32
8092 for i, field := range fields {
8093 switch field.Name {
8094 case "__typename":
8095 out.Values[i] = graphql.MarshalString("CreateOperation")
8096 case "hash":
8097 out.Values[i] = ec._CreateOperation_hash(ctx, field, obj)
8098 if out.Values[i] == graphql.Null {
8099 atomic.AddUint32(&invalids, 1)
8100 }
8101 case "author":
8102 out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
8103 if out.Values[i] == graphql.Null {
8104 atomic.AddUint32(&invalids, 1)
8105 }
8106 case "date":
8107 field := field
8108 out.Concurrently(i, func() (res graphql.Marshaler) {
8109 defer func() {
8110 if r := recover(); r != nil {
8111 ec.Error(ctx, ec.Recover(ctx, r))
8112 }
8113 }()
8114 res = ec._CreateOperation_date(ctx, field, obj)
8115 if res == graphql.Null {
8116 atomic.AddUint32(&invalids, 1)
8117 }
8118 return res
8119 })
8120 case "title":
8121 out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
8122 if out.Values[i] == graphql.Null {
8123 atomic.AddUint32(&invalids, 1)
8124 }
8125 case "message":
8126 out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
8127 if out.Values[i] == graphql.Null {
8128 atomic.AddUint32(&invalids, 1)
8129 }
8130 case "files":
8131 out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
8132 if out.Values[i] == graphql.Null {
8133 atomic.AddUint32(&invalids, 1)
8134 }
8135 default:
8136 panic("unknown field " + strconv.Quote(field.Name))
8137 }
8138 }
8139 out.Dispatch()
8140 if invalids > 0 {
8141 return graphql.Null
8142 }
8143 return out
8144}
8145
8146var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem"}
8147
8148func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
8149 fields := graphql.CollectFields(ec.RequestContext, sel, createTimelineItemImplementors)
8150
8151 out := graphql.NewFieldSet(fields)
8152 var invalids uint32
8153 for i, field := range fields {
8154 switch field.Name {
8155 case "__typename":
8156 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
8157 case "hash":
8158 out.Values[i] = ec._CreateTimelineItem_hash(ctx, field, obj)
8159 if out.Values[i] == graphql.Null {
8160 atomic.AddUint32(&invalids, 1)
8161 }
8162 case "author":
8163 out.Values[i] = ec._CreateTimelineItem_author(ctx, field, obj)
8164 if out.Values[i] == graphql.Null {
8165 atomic.AddUint32(&invalids, 1)
8166 }
8167 case "message":
8168 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
8169 if out.Values[i] == graphql.Null {
8170 atomic.AddUint32(&invalids, 1)
8171 }
8172 case "messageIsEmpty":
8173 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
8174 if out.Values[i] == graphql.Null {
8175 atomic.AddUint32(&invalids, 1)
8176 }
8177 case "files":
8178 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
8179 if out.Values[i] == graphql.Null {
8180 atomic.AddUint32(&invalids, 1)
8181 }
8182 case "createdAt":
8183 field := field
8184 out.Concurrently(i, func() (res graphql.Marshaler) {
8185 defer func() {
8186 if r := recover(); r != nil {
8187 ec.Error(ctx, ec.Recover(ctx, r))
8188 }
8189 }()
8190 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
8191 if res == graphql.Null {
8192 atomic.AddUint32(&invalids, 1)
8193 }
8194 return res
8195 })
8196 case "lastEdit":
8197 field := field
8198 out.Concurrently(i, func() (res graphql.Marshaler) {
8199 defer func() {
8200 if r := recover(); r != nil {
8201 ec.Error(ctx, ec.Recover(ctx, r))
8202 }
8203 }()
8204 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
8205 if res == graphql.Null {
8206 atomic.AddUint32(&invalids, 1)
8207 }
8208 return res
8209 })
8210 case "edited":
8211 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
8212 if out.Values[i] == graphql.Null {
8213 atomic.AddUint32(&invalids, 1)
8214 }
8215 case "history":
8216 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
8217 if out.Values[i] == graphql.Null {
8218 atomic.AddUint32(&invalids, 1)
8219 }
8220 default:
8221 panic("unknown field " + strconv.Quote(field.Name))
8222 }
8223 }
8224 out.Dispatch()
8225 if invalids > 0 {
8226 return graphql.Null
8227 }
8228 return out
8229}
8230
8231var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
8232
8233func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
8234 fields := graphql.CollectFields(ec.RequestContext, sel, editCommentOperationImplementors)
8235
8236 out := graphql.NewFieldSet(fields)
8237 var invalids uint32
8238 for i, field := range fields {
8239 switch field.Name {
8240 case "__typename":
8241 out.Values[i] = graphql.MarshalString("EditCommentOperation")
8242 case "hash":
8243 out.Values[i] = ec._EditCommentOperation_hash(ctx, field, obj)
8244 if out.Values[i] == graphql.Null {
8245 atomic.AddUint32(&invalids, 1)
8246 }
8247 case "author":
8248 out.Values[i] = ec._EditCommentOperation_author(ctx, field, obj)
8249 if out.Values[i] == graphql.Null {
8250 atomic.AddUint32(&invalids, 1)
8251 }
8252 case "date":
8253 field := field
8254 out.Concurrently(i, func() (res graphql.Marshaler) {
8255 defer func() {
8256 if r := recover(); r != nil {
8257 ec.Error(ctx, ec.Recover(ctx, r))
8258 }
8259 }()
8260 res = ec._EditCommentOperation_date(ctx, field, obj)
8261 if res == graphql.Null {
8262 atomic.AddUint32(&invalids, 1)
8263 }
8264 return res
8265 })
8266 case "target":
8267 out.Values[i] = ec._EditCommentOperation_target(ctx, field, obj)
8268 if out.Values[i] == graphql.Null {
8269 atomic.AddUint32(&invalids, 1)
8270 }
8271 case "message":
8272 out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
8273 if out.Values[i] == graphql.Null {
8274 atomic.AddUint32(&invalids, 1)
8275 }
8276 case "files":
8277 out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
8278 if out.Values[i] == graphql.Null {
8279 atomic.AddUint32(&invalids, 1)
8280 }
8281 default:
8282 panic("unknown field " + strconv.Quote(field.Name))
8283 }
8284 }
8285 out.Dispatch()
8286 if invalids > 0 {
8287 return graphql.Null
8288 }
8289 return out
8290}
8291
8292var identityImplementors = []string{"Identity"}
8293
8294func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj *identity.Interface) graphql.Marshaler {
8295 fields := graphql.CollectFields(ec.RequestContext, sel, identityImplementors)
8296
8297 out := graphql.NewFieldSet(fields)
8298 var invalids uint32
8299 for i, field := range fields {
8300 switch field.Name {
8301 case "__typename":
8302 out.Values[i] = graphql.MarshalString("Identity")
8303 case "id":
8304 field := field
8305 out.Concurrently(i, func() (res graphql.Marshaler) {
8306 defer func() {
8307 if r := recover(); r != nil {
8308 ec.Error(ctx, ec.Recover(ctx, r))
8309 }
8310 }()
8311 res = ec._Identity_id(ctx, field, obj)
8312 if res == graphql.Null {
8313 atomic.AddUint32(&invalids, 1)
8314 }
8315 return res
8316 })
8317 case "humanId":
8318 field := field
8319 out.Concurrently(i, func() (res graphql.Marshaler) {
8320 defer func() {
8321 if r := recover(); r != nil {
8322 ec.Error(ctx, ec.Recover(ctx, r))
8323 }
8324 }()
8325 res = ec._Identity_humanId(ctx, field, obj)
8326 if res == graphql.Null {
8327 atomic.AddUint32(&invalids, 1)
8328 }
8329 return res
8330 })
8331 case "name":
8332 field := field
8333 out.Concurrently(i, func() (res graphql.Marshaler) {
8334 defer func() {
8335 if r := recover(); r != nil {
8336 ec.Error(ctx, ec.Recover(ctx, r))
8337 }
8338 }()
8339 res = ec._Identity_name(ctx, field, obj)
8340 return res
8341 })
8342 case "email":
8343 field := field
8344 out.Concurrently(i, func() (res graphql.Marshaler) {
8345 defer func() {
8346 if r := recover(); r != nil {
8347 ec.Error(ctx, ec.Recover(ctx, r))
8348 }
8349 }()
8350 res = ec._Identity_email(ctx, field, obj)
8351 return res
8352 })
8353 case "login":
8354 field := field
8355 out.Concurrently(i, func() (res graphql.Marshaler) {
8356 defer func() {
8357 if r := recover(); r != nil {
8358 ec.Error(ctx, ec.Recover(ctx, r))
8359 }
8360 }()
8361 res = ec._Identity_login(ctx, field, obj)
8362 return res
8363 })
8364 case "displayName":
8365 field := field
8366 out.Concurrently(i, func() (res graphql.Marshaler) {
8367 defer func() {
8368 if r := recover(); r != nil {
8369 ec.Error(ctx, ec.Recover(ctx, r))
8370 }
8371 }()
8372 res = ec._Identity_displayName(ctx, field, obj)
8373 if res == graphql.Null {
8374 atomic.AddUint32(&invalids, 1)
8375 }
8376 return res
8377 })
8378 case "avatarUrl":
8379 field := field
8380 out.Concurrently(i, func() (res graphql.Marshaler) {
8381 defer func() {
8382 if r := recover(); r != nil {
8383 ec.Error(ctx, ec.Recover(ctx, r))
8384 }
8385 }()
8386 res = ec._Identity_avatarUrl(ctx, field, obj)
8387 return res
8388 })
8389 case "isProtected":
8390 field := field
8391 out.Concurrently(i, func() (res graphql.Marshaler) {
8392 defer func() {
8393 if r := recover(); r != nil {
8394 ec.Error(ctx, ec.Recover(ctx, r))
8395 }
8396 }()
8397 res = ec._Identity_isProtected(ctx, field, obj)
8398 if res == graphql.Null {
8399 atomic.AddUint32(&invalids, 1)
8400 }
8401 return res
8402 })
8403 default:
8404 panic("unknown field " + strconv.Quote(field.Name))
8405 }
8406 }
8407 out.Dispatch()
8408 if invalids > 0 {
8409 return graphql.Null
8410 }
8411 return out
8412}
8413
8414var identityConnectionImplementors = []string{"IdentityConnection"}
8415
8416func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
8417 fields := graphql.CollectFields(ec.RequestContext, sel, identityConnectionImplementors)
8418
8419 out := graphql.NewFieldSet(fields)
8420 var invalids uint32
8421 for i, field := range fields {
8422 switch field.Name {
8423 case "__typename":
8424 out.Values[i] = graphql.MarshalString("IdentityConnection")
8425 case "edges":
8426 out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
8427 if out.Values[i] == graphql.Null {
8428 invalids++
8429 }
8430 case "nodes":
8431 out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
8432 if out.Values[i] == graphql.Null {
8433 invalids++
8434 }
8435 case "pageInfo":
8436 out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
8437 if out.Values[i] == graphql.Null {
8438 invalids++
8439 }
8440 case "totalCount":
8441 out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
8442 if out.Values[i] == graphql.Null {
8443 invalids++
8444 }
8445 default:
8446 panic("unknown field " + strconv.Quote(field.Name))
8447 }
8448 }
8449 out.Dispatch()
8450 if invalids > 0 {
8451 return graphql.Null
8452 }
8453 return out
8454}
8455
8456var identityEdgeImplementors = []string{"IdentityEdge"}
8457
8458func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
8459 fields := graphql.CollectFields(ec.RequestContext, sel, identityEdgeImplementors)
8460
8461 out := graphql.NewFieldSet(fields)
8462 var invalids uint32
8463 for i, field := range fields {
8464 switch field.Name {
8465 case "__typename":
8466 out.Values[i] = graphql.MarshalString("IdentityEdge")
8467 case "cursor":
8468 out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
8469 if out.Values[i] == graphql.Null {
8470 invalids++
8471 }
8472 case "node":
8473 out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
8474 if out.Values[i] == graphql.Null {
8475 invalids++
8476 }
8477 default:
8478 panic("unknown field " + strconv.Quote(field.Name))
8479 }
8480 }
8481 out.Dispatch()
8482 if invalids > 0 {
8483 return graphql.Null
8484 }
8485 return out
8486}
8487
8488var labelImplementors = []string{"Label"}
8489
8490func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
8491 fields := graphql.CollectFields(ec.RequestContext, sel, labelImplementors)
8492
8493 out := graphql.NewFieldSet(fields)
8494 var invalids uint32
8495 for i, field := range fields {
8496 switch field.Name {
8497 case "__typename":
8498 out.Values[i] = graphql.MarshalString("Label")
8499 case "name":
8500 field := field
8501 out.Concurrently(i, func() (res graphql.Marshaler) {
8502 defer func() {
8503 if r := recover(); r != nil {
8504 ec.Error(ctx, ec.Recover(ctx, r))
8505 }
8506 }()
8507 res = ec._Label_name(ctx, field, obj)
8508 if res == graphql.Null {
8509 atomic.AddUint32(&invalids, 1)
8510 }
8511 return res
8512 })
8513 case "color":
8514 field := field
8515 out.Concurrently(i, func() (res graphql.Marshaler) {
8516 defer func() {
8517 if r := recover(); r != nil {
8518 ec.Error(ctx, ec.Recover(ctx, r))
8519 }
8520 }()
8521 res = ec._Label_color(ctx, field, obj)
8522 if res == graphql.Null {
8523 atomic.AddUint32(&invalids, 1)
8524 }
8525 return res
8526 })
8527 default:
8528 panic("unknown field " + strconv.Quote(field.Name))
8529 }
8530 }
8531 out.Dispatch()
8532 if invalids > 0 {
8533 return graphql.Null
8534 }
8535 return out
8536}
8537
8538var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
8539
8540func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
8541 fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeOperationImplementors)
8542
8543 out := graphql.NewFieldSet(fields)
8544 var invalids uint32
8545 for i, field := range fields {
8546 switch field.Name {
8547 case "__typename":
8548 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
8549 case "hash":
8550 out.Values[i] = ec._LabelChangeOperation_hash(ctx, field, obj)
8551 if out.Values[i] == graphql.Null {
8552 atomic.AddUint32(&invalids, 1)
8553 }
8554 case "author":
8555 out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
8556 if out.Values[i] == graphql.Null {
8557 atomic.AddUint32(&invalids, 1)
8558 }
8559 case "date":
8560 field := field
8561 out.Concurrently(i, func() (res graphql.Marshaler) {
8562 defer func() {
8563 if r := recover(); r != nil {
8564 ec.Error(ctx, ec.Recover(ctx, r))
8565 }
8566 }()
8567 res = ec._LabelChangeOperation_date(ctx, field, obj)
8568 if res == graphql.Null {
8569 atomic.AddUint32(&invalids, 1)
8570 }
8571 return res
8572 })
8573 case "added":
8574 out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
8575 if out.Values[i] == graphql.Null {
8576 atomic.AddUint32(&invalids, 1)
8577 }
8578 case "removed":
8579 out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
8580 if out.Values[i] == graphql.Null {
8581 atomic.AddUint32(&invalids, 1)
8582 }
8583 default:
8584 panic("unknown field " + strconv.Quote(field.Name))
8585 }
8586 }
8587 out.Dispatch()
8588 if invalids > 0 {
8589 return graphql.Null
8590 }
8591 return out
8592}
8593
8594var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem"}
8595
8596func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
8597 fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeTimelineItemImplementors)
8598
8599 out := graphql.NewFieldSet(fields)
8600 var invalids uint32
8601 for i, field := range fields {
8602 switch field.Name {
8603 case "__typename":
8604 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
8605 case "hash":
8606 out.Values[i] = ec._LabelChangeTimelineItem_hash(ctx, field, obj)
8607 if out.Values[i] == graphql.Null {
8608 atomic.AddUint32(&invalids, 1)
8609 }
8610 case "author":
8611 out.Values[i] = ec._LabelChangeTimelineItem_author(ctx, field, obj)
8612 if out.Values[i] == graphql.Null {
8613 atomic.AddUint32(&invalids, 1)
8614 }
8615 case "date":
8616 field := field
8617 out.Concurrently(i, func() (res graphql.Marshaler) {
8618 defer func() {
8619 if r := recover(); r != nil {
8620 ec.Error(ctx, ec.Recover(ctx, r))
8621 }
8622 }()
8623 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
8624 if res == graphql.Null {
8625 atomic.AddUint32(&invalids, 1)
8626 }
8627 return res
8628 })
8629 case "added":
8630 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
8631 if out.Values[i] == graphql.Null {
8632 atomic.AddUint32(&invalids, 1)
8633 }
8634 case "removed":
8635 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
8636 if out.Values[i] == graphql.Null {
8637 atomic.AddUint32(&invalids, 1)
8638 }
8639 default:
8640 panic("unknown field " + strconv.Quote(field.Name))
8641 }
8642 }
8643 out.Dispatch()
8644 if invalids > 0 {
8645 return graphql.Null
8646 }
8647 return out
8648}
8649
8650var mutationImplementors = []string{"Mutation"}
8651
8652func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
8653 fields := graphql.CollectFields(ec.RequestContext, sel, mutationImplementors)
8654
8655 ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
8656 Object: "Mutation",
8657 })
8658
8659 out := graphql.NewFieldSet(fields)
8660 var invalids uint32
8661 for i, field := range fields {
8662 switch field.Name {
8663 case "__typename":
8664 out.Values[i] = graphql.MarshalString("Mutation")
8665 case "newBug":
8666 out.Values[i] = ec._Mutation_newBug(ctx, field)
8667 if out.Values[i] == graphql.Null {
8668 invalids++
8669 }
8670 case "addComment":
8671 out.Values[i] = ec._Mutation_addComment(ctx, field)
8672 if out.Values[i] == graphql.Null {
8673 invalids++
8674 }
8675 case "changeLabels":
8676 out.Values[i] = ec._Mutation_changeLabels(ctx, field)
8677 if out.Values[i] == graphql.Null {
8678 invalids++
8679 }
8680 case "open":
8681 out.Values[i] = ec._Mutation_open(ctx, field)
8682 if out.Values[i] == graphql.Null {
8683 invalids++
8684 }
8685 case "close":
8686 out.Values[i] = ec._Mutation_close(ctx, field)
8687 if out.Values[i] == graphql.Null {
8688 invalids++
8689 }
8690 case "setTitle":
8691 out.Values[i] = ec._Mutation_setTitle(ctx, field)
8692 if out.Values[i] == graphql.Null {
8693 invalids++
8694 }
8695 case "commit":
8696 out.Values[i] = ec._Mutation_commit(ctx, field)
8697 if out.Values[i] == graphql.Null {
8698 invalids++
8699 }
8700 default:
8701 panic("unknown field " + strconv.Quote(field.Name))
8702 }
8703 }
8704 out.Dispatch()
8705 if invalids > 0 {
8706 return graphql.Null
8707 }
8708 return out
8709}
8710
8711var operationConnectionImplementors = []string{"OperationConnection"}
8712
8713func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
8714 fields := graphql.CollectFields(ec.RequestContext, sel, operationConnectionImplementors)
8715
8716 out := graphql.NewFieldSet(fields)
8717 var invalids uint32
8718 for i, field := range fields {
8719 switch field.Name {
8720 case "__typename":
8721 out.Values[i] = graphql.MarshalString("OperationConnection")
8722 case "edges":
8723 out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
8724 if out.Values[i] == graphql.Null {
8725 invalids++
8726 }
8727 case "nodes":
8728 out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
8729 if out.Values[i] == graphql.Null {
8730 invalids++
8731 }
8732 case "pageInfo":
8733 out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
8734 if out.Values[i] == graphql.Null {
8735 invalids++
8736 }
8737 case "totalCount":
8738 out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
8739 if out.Values[i] == graphql.Null {
8740 invalids++
8741 }
8742 default:
8743 panic("unknown field " + strconv.Quote(field.Name))
8744 }
8745 }
8746 out.Dispatch()
8747 if invalids > 0 {
8748 return graphql.Null
8749 }
8750 return out
8751}
8752
8753var operationEdgeImplementors = []string{"OperationEdge"}
8754
8755func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
8756 fields := graphql.CollectFields(ec.RequestContext, sel, operationEdgeImplementors)
8757
8758 out := graphql.NewFieldSet(fields)
8759 var invalids uint32
8760 for i, field := range fields {
8761 switch field.Name {
8762 case "__typename":
8763 out.Values[i] = graphql.MarshalString("OperationEdge")
8764 case "cursor":
8765 out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
8766 if out.Values[i] == graphql.Null {
8767 invalids++
8768 }
8769 case "node":
8770 out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
8771 if out.Values[i] == graphql.Null {
8772 invalids++
8773 }
8774 default:
8775 panic("unknown field " + strconv.Quote(field.Name))
8776 }
8777 }
8778 out.Dispatch()
8779 if invalids > 0 {
8780 return graphql.Null
8781 }
8782 return out
8783}
8784
8785var pageInfoImplementors = []string{"PageInfo"}
8786
8787func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
8788 fields := graphql.CollectFields(ec.RequestContext, sel, pageInfoImplementors)
8789
8790 out := graphql.NewFieldSet(fields)
8791 var invalids uint32
8792 for i, field := range fields {
8793 switch field.Name {
8794 case "__typename":
8795 out.Values[i] = graphql.MarshalString("PageInfo")
8796 case "hasNextPage":
8797 out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
8798 if out.Values[i] == graphql.Null {
8799 invalids++
8800 }
8801 case "hasPreviousPage":
8802 out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
8803 if out.Values[i] == graphql.Null {
8804 invalids++
8805 }
8806 case "startCursor":
8807 out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
8808 if out.Values[i] == graphql.Null {
8809 invalids++
8810 }
8811 case "endCursor":
8812 out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
8813 if out.Values[i] == graphql.Null {
8814 invalids++
8815 }
8816 default:
8817 panic("unknown field " + strconv.Quote(field.Name))
8818 }
8819 }
8820 out.Dispatch()
8821 if invalids > 0 {
8822 return graphql.Null
8823 }
8824 return out
8825}
8826
8827var queryImplementors = []string{"Query"}
8828
8829func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
8830 fields := graphql.CollectFields(ec.RequestContext, sel, queryImplementors)
8831
8832 ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
8833 Object: "Query",
8834 })
8835
8836 out := graphql.NewFieldSet(fields)
8837 var invalids uint32
8838 for i, field := range fields {
8839 switch field.Name {
8840 case "__typename":
8841 out.Values[i] = graphql.MarshalString("Query")
8842 case "defaultRepository":
8843 field := field
8844 out.Concurrently(i, func() (res graphql.Marshaler) {
8845 defer func() {
8846 if r := recover(); r != nil {
8847 ec.Error(ctx, ec.Recover(ctx, r))
8848 }
8849 }()
8850 res = ec._Query_defaultRepository(ctx, field)
8851 return res
8852 })
8853 case "repository":
8854 field := field
8855 out.Concurrently(i, func() (res graphql.Marshaler) {
8856 defer func() {
8857 if r := recover(); r != nil {
8858 ec.Error(ctx, ec.Recover(ctx, r))
8859 }
8860 }()
8861 res = ec._Query_repository(ctx, field)
8862 return res
8863 })
8864 case "__type":
8865 out.Values[i] = ec._Query___type(ctx, field)
8866 case "__schema":
8867 out.Values[i] = ec._Query___schema(ctx, field)
8868 default:
8869 panic("unknown field " + strconv.Quote(field.Name))
8870 }
8871 }
8872 out.Dispatch()
8873 if invalids > 0 {
8874 return graphql.Null
8875 }
8876 return out
8877}
8878
8879var repositoryImplementors = []string{"Repository"}
8880
8881func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
8882 fields := graphql.CollectFields(ec.RequestContext, sel, repositoryImplementors)
8883
8884 out := graphql.NewFieldSet(fields)
8885 var invalids uint32
8886 for i, field := range fields {
8887 switch field.Name {
8888 case "__typename":
8889 out.Values[i] = graphql.MarshalString("Repository")
8890 case "allBugs":
8891 field := field
8892 out.Concurrently(i, func() (res graphql.Marshaler) {
8893 defer func() {
8894 if r := recover(); r != nil {
8895 ec.Error(ctx, ec.Recover(ctx, r))
8896 }
8897 }()
8898 res = ec._Repository_allBugs(ctx, field, obj)
8899 if res == graphql.Null {
8900 atomic.AddUint32(&invalids, 1)
8901 }
8902 return res
8903 })
8904 case "bug":
8905 field := field
8906 out.Concurrently(i, func() (res graphql.Marshaler) {
8907 defer func() {
8908 if r := recover(); r != nil {
8909 ec.Error(ctx, ec.Recover(ctx, r))
8910 }
8911 }()
8912 res = ec._Repository_bug(ctx, field, obj)
8913 return res
8914 })
8915 case "allIdentities":
8916 field := field
8917 out.Concurrently(i, func() (res graphql.Marshaler) {
8918 defer func() {
8919 if r := recover(); r != nil {
8920 ec.Error(ctx, ec.Recover(ctx, r))
8921 }
8922 }()
8923 res = ec._Repository_allIdentities(ctx, field, obj)
8924 if res == graphql.Null {
8925 atomic.AddUint32(&invalids, 1)
8926 }
8927 return res
8928 })
8929 case "identity":
8930 field := field
8931 out.Concurrently(i, func() (res graphql.Marshaler) {
8932 defer func() {
8933 if r := recover(); r != nil {
8934 ec.Error(ctx, ec.Recover(ctx, r))
8935 }
8936 }()
8937 res = ec._Repository_identity(ctx, field, obj)
8938 return res
8939 })
8940 case "userIdentity":
8941 field := field
8942 out.Concurrently(i, func() (res graphql.Marshaler) {
8943 defer func() {
8944 if r := recover(); r != nil {
8945 ec.Error(ctx, ec.Recover(ctx, r))
8946 }
8947 }()
8948 res = ec._Repository_userIdentity(ctx, field, obj)
8949 return res
8950 })
8951 case "validLabels":
8952 field := field
8953 out.Concurrently(i, func() (res graphql.Marshaler) {
8954 defer func() {
8955 if r := recover(); r != nil {
8956 ec.Error(ctx, ec.Recover(ctx, r))
8957 }
8958 }()
8959 res = ec._Repository_validLabels(ctx, field, obj)
8960 if res == graphql.Null {
8961 atomic.AddUint32(&invalids, 1)
8962 }
8963 return res
8964 })
8965 default:
8966 panic("unknown field " + strconv.Quote(field.Name))
8967 }
8968 }
8969 out.Dispatch()
8970 if invalids > 0 {
8971 return graphql.Null
8972 }
8973 return out
8974}
8975
8976var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
8977
8978func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
8979 fields := graphql.CollectFields(ec.RequestContext, sel, setStatusOperationImplementors)
8980
8981 out := graphql.NewFieldSet(fields)
8982 var invalids uint32
8983 for i, field := range fields {
8984 switch field.Name {
8985 case "__typename":
8986 out.Values[i] = graphql.MarshalString("SetStatusOperation")
8987 case "hash":
8988 out.Values[i] = ec._SetStatusOperation_hash(ctx, field, obj)
8989 if out.Values[i] == graphql.Null {
8990 atomic.AddUint32(&invalids, 1)
8991 }
8992 case "author":
8993 out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
8994 if out.Values[i] == graphql.Null {
8995 atomic.AddUint32(&invalids, 1)
8996 }
8997 case "date":
8998 field := field
8999 out.Concurrently(i, func() (res graphql.Marshaler) {
9000 defer func() {
9001 if r := recover(); r != nil {
9002 ec.Error(ctx, ec.Recover(ctx, r))
9003 }
9004 }()
9005 res = ec._SetStatusOperation_date(ctx, field, obj)
9006 if res == graphql.Null {
9007 atomic.AddUint32(&invalids, 1)
9008 }
9009 return res
9010 })
9011 case "status":
9012 field := field
9013 out.Concurrently(i, func() (res graphql.Marshaler) {
9014 defer func() {
9015 if r := recover(); r != nil {
9016 ec.Error(ctx, ec.Recover(ctx, r))
9017 }
9018 }()
9019 res = ec._SetStatusOperation_status(ctx, field, obj)
9020 if res == graphql.Null {
9021 atomic.AddUint32(&invalids, 1)
9022 }
9023 return res
9024 })
9025 default:
9026 panic("unknown field " + strconv.Quote(field.Name))
9027 }
9028 }
9029 out.Dispatch()
9030 if invalids > 0 {
9031 return graphql.Null
9032 }
9033 return out
9034}
9035
9036var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem"}
9037
9038func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
9039 fields := graphql.CollectFields(ec.RequestContext, sel, setStatusTimelineItemImplementors)
9040
9041 out := graphql.NewFieldSet(fields)
9042 var invalids uint32
9043 for i, field := range fields {
9044 switch field.Name {
9045 case "__typename":
9046 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
9047 case "hash":
9048 out.Values[i] = ec._SetStatusTimelineItem_hash(ctx, field, obj)
9049 if out.Values[i] == graphql.Null {
9050 atomic.AddUint32(&invalids, 1)
9051 }
9052 case "author":
9053 out.Values[i] = ec._SetStatusTimelineItem_author(ctx, field, obj)
9054 if out.Values[i] == graphql.Null {
9055 atomic.AddUint32(&invalids, 1)
9056 }
9057 case "date":
9058 field := field
9059 out.Concurrently(i, func() (res graphql.Marshaler) {
9060 defer func() {
9061 if r := recover(); r != nil {
9062 ec.Error(ctx, ec.Recover(ctx, r))
9063 }
9064 }()
9065 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
9066 if res == graphql.Null {
9067 atomic.AddUint32(&invalids, 1)
9068 }
9069 return res
9070 })
9071 case "status":
9072 field := field
9073 out.Concurrently(i, func() (res graphql.Marshaler) {
9074 defer func() {
9075 if r := recover(); r != nil {
9076 ec.Error(ctx, ec.Recover(ctx, r))
9077 }
9078 }()
9079 res = ec._SetStatusTimelineItem_status(ctx, field, obj)
9080 if res == graphql.Null {
9081 atomic.AddUint32(&invalids, 1)
9082 }
9083 return res
9084 })
9085 default:
9086 panic("unknown field " + strconv.Quote(field.Name))
9087 }
9088 }
9089 out.Dispatch()
9090 if invalids > 0 {
9091 return graphql.Null
9092 }
9093 return out
9094}
9095
9096var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
9097
9098func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
9099 fields := graphql.CollectFields(ec.RequestContext, sel, setTitleOperationImplementors)
9100
9101 out := graphql.NewFieldSet(fields)
9102 var invalids uint32
9103 for i, field := range fields {
9104 switch field.Name {
9105 case "__typename":
9106 out.Values[i] = graphql.MarshalString("SetTitleOperation")
9107 case "hash":
9108 out.Values[i] = ec._SetTitleOperation_hash(ctx, field, obj)
9109 if out.Values[i] == graphql.Null {
9110 atomic.AddUint32(&invalids, 1)
9111 }
9112 case "author":
9113 out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
9114 if out.Values[i] == graphql.Null {
9115 atomic.AddUint32(&invalids, 1)
9116 }
9117 case "date":
9118 field := field
9119 out.Concurrently(i, func() (res graphql.Marshaler) {
9120 defer func() {
9121 if r := recover(); r != nil {
9122 ec.Error(ctx, ec.Recover(ctx, r))
9123 }
9124 }()
9125 res = ec._SetTitleOperation_date(ctx, field, obj)
9126 if res == graphql.Null {
9127 atomic.AddUint32(&invalids, 1)
9128 }
9129 return res
9130 })
9131 case "title":
9132 out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
9133 if out.Values[i] == graphql.Null {
9134 atomic.AddUint32(&invalids, 1)
9135 }
9136 case "was":
9137 out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
9138 if out.Values[i] == graphql.Null {
9139 atomic.AddUint32(&invalids, 1)
9140 }
9141 default:
9142 panic("unknown field " + strconv.Quote(field.Name))
9143 }
9144 }
9145 out.Dispatch()
9146 if invalids > 0 {
9147 return graphql.Null
9148 }
9149 return out
9150}
9151
9152var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem"}
9153
9154func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
9155 fields := graphql.CollectFields(ec.RequestContext, sel, setTitleTimelineItemImplementors)
9156
9157 out := graphql.NewFieldSet(fields)
9158 var invalids uint32
9159 for i, field := range fields {
9160 switch field.Name {
9161 case "__typename":
9162 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
9163 case "hash":
9164 out.Values[i] = ec._SetTitleTimelineItem_hash(ctx, field, obj)
9165 if out.Values[i] == graphql.Null {
9166 atomic.AddUint32(&invalids, 1)
9167 }
9168 case "author":
9169 out.Values[i] = ec._SetTitleTimelineItem_author(ctx, field, obj)
9170 if out.Values[i] == graphql.Null {
9171 atomic.AddUint32(&invalids, 1)
9172 }
9173 case "date":
9174 field := field
9175 out.Concurrently(i, func() (res graphql.Marshaler) {
9176 defer func() {
9177 if r := recover(); r != nil {
9178 ec.Error(ctx, ec.Recover(ctx, r))
9179 }
9180 }()
9181 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
9182 if res == graphql.Null {
9183 atomic.AddUint32(&invalids, 1)
9184 }
9185 return res
9186 })
9187 case "title":
9188 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
9189 if out.Values[i] == graphql.Null {
9190 atomic.AddUint32(&invalids, 1)
9191 }
9192 case "was":
9193 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
9194 if out.Values[i] == graphql.Null {
9195 atomic.AddUint32(&invalids, 1)
9196 }
9197 default:
9198 panic("unknown field " + strconv.Quote(field.Name))
9199 }
9200 }
9201 out.Dispatch()
9202 if invalids > 0 {
9203 return graphql.Null
9204 }
9205 return out
9206}
9207
9208var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
9209
9210func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
9211 fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemConnectionImplementors)
9212
9213 out := graphql.NewFieldSet(fields)
9214 var invalids uint32
9215 for i, field := range fields {
9216 switch field.Name {
9217 case "__typename":
9218 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
9219 case "edges":
9220 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
9221 if out.Values[i] == graphql.Null {
9222 invalids++
9223 }
9224 case "nodes":
9225 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
9226 if out.Values[i] == graphql.Null {
9227 invalids++
9228 }
9229 case "pageInfo":
9230 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
9231 if out.Values[i] == graphql.Null {
9232 invalids++
9233 }
9234 case "totalCount":
9235 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
9236 if out.Values[i] == graphql.Null {
9237 invalids++
9238 }
9239 default:
9240 panic("unknown field " + strconv.Quote(field.Name))
9241 }
9242 }
9243 out.Dispatch()
9244 if invalids > 0 {
9245 return graphql.Null
9246 }
9247 return out
9248}
9249
9250var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
9251
9252func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
9253 fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemEdgeImplementors)
9254
9255 out := graphql.NewFieldSet(fields)
9256 var invalids uint32
9257 for i, field := range fields {
9258 switch field.Name {
9259 case "__typename":
9260 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
9261 case "cursor":
9262 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
9263 if out.Values[i] == graphql.Null {
9264 invalids++
9265 }
9266 case "node":
9267 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
9268 if out.Values[i] == graphql.Null {
9269 invalids++
9270 }
9271 default:
9272 panic("unknown field " + strconv.Quote(field.Name))
9273 }
9274 }
9275 out.Dispatch()
9276 if invalids > 0 {
9277 return graphql.Null
9278 }
9279 return out
9280}
9281
9282var __DirectiveImplementors = []string{"__Directive"}
9283
9284func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
9285 fields := graphql.CollectFields(ec.RequestContext, sel, __DirectiveImplementors)
9286
9287 out := graphql.NewFieldSet(fields)
9288 var invalids uint32
9289 for i, field := range fields {
9290 switch field.Name {
9291 case "__typename":
9292 out.Values[i] = graphql.MarshalString("__Directive")
9293 case "name":
9294 out.Values[i] = ec.___Directive_name(ctx, field, obj)
9295 if out.Values[i] == graphql.Null {
9296 invalids++
9297 }
9298 case "description":
9299 out.Values[i] = ec.___Directive_description(ctx, field, obj)
9300 case "locations":
9301 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
9302 if out.Values[i] == graphql.Null {
9303 invalids++
9304 }
9305 case "args":
9306 out.Values[i] = ec.___Directive_args(ctx, field, obj)
9307 if out.Values[i] == graphql.Null {
9308 invalids++
9309 }
9310 default:
9311 panic("unknown field " + strconv.Quote(field.Name))
9312 }
9313 }
9314 out.Dispatch()
9315 if invalids > 0 {
9316 return graphql.Null
9317 }
9318 return out
9319}
9320
9321var __EnumValueImplementors = []string{"__EnumValue"}
9322
9323func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
9324 fields := graphql.CollectFields(ec.RequestContext, sel, __EnumValueImplementors)
9325
9326 out := graphql.NewFieldSet(fields)
9327 var invalids uint32
9328 for i, field := range fields {
9329 switch field.Name {
9330 case "__typename":
9331 out.Values[i] = graphql.MarshalString("__EnumValue")
9332 case "name":
9333 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
9334 if out.Values[i] == graphql.Null {
9335 invalids++
9336 }
9337 case "description":
9338 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
9339 case "isDeprecated":
9340 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
9341 if out.Values[i] == graphql.Null {
9342 invalids++
9343 }
9344 case "deprecationReason":
9345 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
9346 default:
9347 panic("unknown field " + strconv.Quote(field.Name))
9348 }
9349 }
9350 out.Dispatch()
9351 if invalids > 0 {
9352 return graphql.Null
9353 }
9354 return out
9355}
9356
9357var __FieldImplementors = []string{"__Field"}
9358
9359func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
9360 fields := graphql.CollectFields(ec.RequestContext, sel, __FieldImplementors)
9361
9362 out := graphql.NewFieldSet(fields)
9363 var invalids uint32
9364 for i, field := range fields {
9365 switch field.Name {
9366 case "__typename":
9367 out.Values[i] = graphql.MarshalString("__Field")
9368 case "name":
9369 out.Values[i] = ec.___Field_name(ctx, field, obj)
9370 if out.Values[i] == graphql.Null {
9371 invalids++
9372 }
9373 case "description":
9374 out.Values[i] = ec.___Field_description(ctx, field, obj)
9375 case "args":
9376 out.Values[i] = ec.___Field_args(ctx, field, obj)
9377 if out.Values[i] == graphql.Null {
9378 invalids++
9379 }
9380 case "type":
9381 out.Values[i] = ec.___Field_type(ctx, field, obj)
9382 if out.Values[i] == graphql.Null {
9383 invalids++
9384 }
9385 case "isDeprecated":
9386 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
9387 if out.Values[i] == graphql.Null {
9388 invalids++
9389 }
9390 case "deprecationReason":
9391 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
9392 default:
9393 panic("unknown field " + strconv.Quote(field.Name))
9394 }
9395 }
9396 out.Dispatch()
9397 if invalids > 0 {
9398 return graphql.Null
9399 }
9400 return out
9401}
9402
9403var __InputValueImplementors = []string{"__InputValue"}
9404
9405func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
9406 fields := graphql.CollectFields(ec.RequestContext, sel, __InputValueImplementors)
9407
9408 out := graphql.NewFieldSet(fields)
9409 var invalids uint32
9410 for i, field := range fields {
9411 switch field.Name {
9412 case "__typename":
9413 out.Values[i] = graphql.MarshalString("__InputValue")
9414 case "name":
9415 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
9416 if out.Values[i] == graphql.Null {
9417 invalids++
9418 }
9419 case "description":
9420 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
9421 case "type":
9422 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
9423 if out.Values[i] == graphql.Null {
9424 invalids++
9425 }
9426 case "defaultValue":
9427 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
9428 default:
9429 panic("unknown field " + strconv.Quote(field.Name))
9430 }
9431 }
9432 out.Dispatch()
9433 if invalids > 0 {
9434 return graphql.Null
9435 }
9436 return out
9437}
9438
9439var __SchemaImplementors = []string{"__Schema"}
9440
9441func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
9442 fields := graphql.CollectFields(ec.RequestContext, sel, __SchemaImplementors)
9443
9444 out := graphql.NewFieldSet(fields)
9445 var invalids uint32
9446 for i, field := range fields {
9447 switch field.Name {
9448 case "__typename":
9449 out.Values[i] = graphql.MarshalString("__Schema")
9450 case "types":
9451 out.Values[i] = ec.___Schema_types(ctx, field, obj)
9452 if out.Values[i] == graphql.Null {
9453 invalids++
9454 }
9455 case "queryType":
9456 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
9457 if out.Values[i] == graphql.Null {
9458 invalids++
9459 }
9460 case "mutationType":
9461 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
9462 case "subscriptionType":
9463 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
9464 case "directives":
9465 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
9466 if out.Values[i] == graphql.Null {
9467 invalids++
9468 }
9469 default:
9470 panic("unknown field " + strconv.Quote(field.Name))
9471 }
9472 }
9473 out.Dispatch()
9474 if invalids > 0 {
9475 return graphql.Null
9476 }
9477 return out
9478}
9479
9480var __TypeImplementors = []string{"__Type"}
9481
9482func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
9483 fields := graphql.CollectFields(ec.RequestContext, sel, __TypeImplementors)
9484
9485 out := graphql.NewFieldSet(fields)
9486 var invalids uint32
9487 for i, field := range fields {
9488 switch field.Name {
9489 case "__typename":
9490 out.Values[i] = graphql.MarshalString("__Type")
9491 case "kind":
9492 out.Values[i] = ec.___Type_kind(ctx, field, obj)
9493 if out.Values[i] == graphql.Null {
9494 invalids++
9495 }
9496 case "name":
9497 out.Values[i] = ec.___Type_name(ctx, field, obj)
9498 case "description":
9499 out.Values[i] = ec.___Type_description(ctx, field, obj)
9500 case "fields":
9501 out.Values[i] = ec.___Type_fields(ctx, field, obj)
9502 case "interfaces":
9503 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
9504 case "possibleTypes":
9505 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
9506 case "enumValues":
9507 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
9508 case "inputFields":
9509 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
9510 case "ofType":
9511 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
9512 default:
9513 panic("unknown field " + strconv.Quote(field.Name))
9514 }
9515 }
9516 out.Dispatch()
9517 if invalids > 0 {
9518 return graphql.Null
9519 }
9520 return out
9521}
9522
9523// endregion **************************** object.gotpl ****************************
9524
9525// region ***************************** type.gotpl *****************************
9526
9527func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
9528 return graphql.UnmarshalBoolean(v)
9529}
9530
9531func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
9532 res := graphql.MarshalBoolean(v)
9533 if res == graphql.Null {
9534 if !ec.HasError(graphql.GetResolverContext(ctx)) {
9535 ec.Errorf(ctx, "must not be null")
9536 }
9537 }
9538 return res
9539}
9540
9541func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
9542 return ec._Bug(ctx, sel, &v)
9543}
9544
9545func (ec *executionContext) marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v []*bug.Snapshot) graphql.Marshaler {
9546 ret := make(graphql.Array, len(v))
9547 var wg sync.WaitGroup
9548 isLen1 := len(v) == 1
9549 if !isLen1 {
9550 wg.Add(len(v))
9551 }
9552 for i := range v {
9553 i := i
9554 rctx := &graphql.ResolverContext{
9555 Index: &i,
9556 Result: &v[i],
9557 }
9558 ctx := graphql.WithResolverContext(ctx, rctx)
9559 f := func(i int) {
9560 defer func() {
9561 if r := recover(); r != nil {
9562 ec.Error(ctx, ec.Recover(ctx, r))
9563 ret = nil
9564 }
9565 }()
9566 if !isLen1 {
9567 defer wg.Done()
9568 }
9569 ret[i] = ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, sel, v[i])
9570 }
9571 if isLen1 {
9572 f(i)
9573 } else {
9574 go f(i)
9575 }
9576
9577 }
9578 wg.Wait()
9579 return ret
9580}
9581
9582func (ec *executionContext) marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
9583 if v == nil {
9584 if !ec.HasError(graphql.GetResolverContext(ctx)) {
9585 ec.Errorf(ctx, "must not be null")
9586 }
9587 return graphql.Null
9588 }
9589 return ec._Bug(ctx, sel, v)
9590}
9591
9592func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
9593 return ec._BugConnection(ctx, sel, &v)
9594}
9595
9596func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
9597 if v == nil {
9598 if !ec.HasError(graphql.GetResolverContext(ctx)) {
9599 ec.Errorf(ctx, "must not be null")
9600 }
9601 return graphql.Null
9602 }
9603 return ec._BugConnection(ctx, sel, v)
9604}
9605
9606func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
9607 return ec._BugEdge(ctx, sel, &v)
9608}
9609
9610func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
9611 ret := make(graphql.Array, len(v))
9612 var wg sync.WaitGroup
9613 isLen1 := len(v) == 1
9614 if !isLen1 {
9615 wg.Add(len(v))
9616 }
9617 for i := range v {
9618 i := i
9619 rctx := &graphql.ResolverContext{
9620 Index: &i,
9621 Result: &v[i],
9622 }
9623 ctx := graphql.WithResolverContext(ctx, rctx)
9624 f := func(i int) {
9625 defer func() {
9626 if r := recover(); r != nil {
9627 ec.Error(ctx, ec.Recover(ctx, r))
9628 ret = nil
9629 }
9630 }()
9631 if !isLen1 {
9632 defer wg.Done()
9633 }
9634 ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
9635 }
9636 if isLen1 {
9637 f(i)
9638 } else {
9639 go f(i)
9640 }
9641
9642 }
9643 wg.Wait()
9644 return ret
9645}
9646
9647func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
9648 if v == nil {
9649 if !ec.HasError(graphql.GetResolverContext(ctx)) {
9650 ec.Errorf(ctx, "must not be null")
9651 }
9652 return graphql.Null
9653 }
9654 return ec._BugEdge(ctx, sel, v)
9655}
9656
9657func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
9658 return ec._Color(ctx, sel, &v)
9659}
9660
9661func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
9662 if v == nil {
9663 if !ec.HasError(graphql.GetResolverContext(ctx)) {
9664 ec.Errorf(ctx, "must not be null")
9665 }
9666 return graphql.Null
9667 }
9668 return ec._Color(ctx, sel, v)
9669}
9670
9671func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
9672 return ec._Comment(ctx, sel, &v)
9673}
9674
9675func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
9676 ret := make(graphql.Array, len(v))
9677 var wg sync.WaitGroup
9678 isLen1 := len(v) == 1
9679 if !isLen1 {
9680 wg.Add(len(v))
9681 }
9682 for i := range v {
9683 i := i
9684 rctx := &graphql.ResolverContext{
9685 Index: &i,
9686 Result: &v[i],
9687 }
9688 ctx := graphql.WithResolverContext(ctx, rctx)
9689 f := func(i int) {
9690 defer func() {
9691 if r := recover(); r != nil {
9692 ec.Error(ctx, ec.Recover(ctx, r))
9693 ret = nil
9694 }
9695 }()
9696 if !isLen1 {
9697 defer wg.Done()
9698 }
9699 ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
9700 }
9701 if isLen1 {
9702 f(i)
9703 } else {
9704 go f(i)
9705 }
9706
9707 }
9708 wg.Wait()
9709 return ret
9710}
9711
9712func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
9713 if v == nil {
9714 if !ec.HasError(graphql.GetResolverContext(ctx)) {
9715 ec.Errorf(ctx, "must not be null")
9716 }
9717 return graphql.Null
9718 }
9719 return ec._Comment(ctx, sel, v)
9720}
9721
9722func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
9723 return ec._CommentConnection(ctx, sel, &v)
9724}
9725
9726func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
9727 if v == nil {
9728 if !ec.HasError(graphql.GetResolverContext(ctx)) {
9729 ec.Errorf(ctx, "must not be null")
9730 }
9731 return graphql.Null
9732 }
9733 return ec._CommentConnection(ctx, sel, v)
9734}
9735
9736func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
9737 return ec._CommentEdge(ctx, sel, &v)
9738}
9739
9740func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
9741 ret := make(graphql.Array, len(v))
9742 var wg sync.WaitGroup
9743 isLen1 := len(v) == 1
9744 if !isLen1 {
9745 wg.Add(len(v))
9746 }
9747 for i := range v {
9748 i := i
9749 rctx := &graphql.ResolverContext{
9750 Index: &i,
9751 Result: &v[i],
9752 }
9753 ctx := graphql.WithResolverContext(ctx, rctx)
9754 f := func(i int) {
9755 defer func() {
9756 if r := recover(); r != nil {
9757 ec.Error(ctx, ec.Recover(ctx, r))
9758 ret = nil
9759 }
9760 }()
9761 if !isLen1 {
9762 defer wg.Done()
9763 }
9764 ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
9765 }
9766 if isLen1 {
9767 f(i)
9768 } else {
9769 go f(i)
9770 }
9771
9772 }
9773 wg.Wait()
9774 return ret
9775}
9776
9777func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
9778 if v == nil {
9779 if !ec.HasError(graphql.GetResolverContext(ctx)) {
9780 ec.Errorf(ctx, "must not be null")
9781 }
9782 return graphql.Null
9783 }
9784 return ec._CommentEdge(ctx, sel, v)
9785}
9786
9787func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
9788 return ec._CommentHistoryStep(ctx, sel, &v)
9789}
9790
9791func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
9792 ret := make(graphql.Array, len(v))
9793 var wg sync.WaitGroup
9794 isLen1 := len(v) == 1
9795 if !isLen1 {
9796 wg.Add(len(v))
9797 }
9798 for i := range v {
9799 i := i
9800 rctx := &graphql.ResolverContext{
9801 Index: &i,
9802 Result: &v[i],
9803 }
9804 ctx := graphql.WithResolverContext(ctx, rctx)
9805 f := func(i int) {
9806 defer func() {
9807 if r := recover(); r != nil {
9808 ec.Error(ctx, ec.Recover(ctx, r))
9809 ret = nil
9810 }
9811 }()
9812 if !isLen1 {
9813 defer wg.Done()
9814 }
9815 ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
9816 }
9817 if isLen1 {
9818 f(i)
9819 } else {
9820 go f(i)
9821 }
9822
9823 }
9824 wg.Wait()
9825 return ret
9826}
9827
9828func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
9829 var res git.Hash
9830 return res, res.UnmarshalGQL(v)
9831}
9832
9833func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
9834 return v
9835}
9836
9837func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
9838 var vSlice []interface{}
9839 if v != nil {
9840 if tmp1, ok := v.([]interface{}); ok {
9841 vSlice = tmp1
9842 } else {
9843 vSlice = []interface{}{v}
9844 }
9845 }
9846 var err error
9847 res := make([]git.Hash, len(vSlice))
9848 for i := range vSlice {
9849 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
9850 if err != nil {
9851 return nil, err
9852 }
9853 }
9854 return res, nil
9855}
9856
9857func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
9858 ret := make(graphql.Array, len(v))
9859 for i := range v {
9860 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
9861 }
9862
9863 return ret
9864}
9865
9866func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
9867 return ec._Identity(ctx, sel, &v)
9868}
9869
9870func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v []identity.Interface) graphql.Marshaler {
9871 ret := make(graphql.Array, len(v))
9872 var wg sync.WaitGroup
9873 isLen1 := len(v) == 1
9874 if !isLen1 {
9875 wg.Add(len(v))
9876 }
9877 for i := range v {
9878 i := i
9879 rctx := &graphql.ResolverContext{
9880 Index: &i,
9881 Result: &v[i],
9882 }
9883 ctx := graphql.WithResolverContext(ctx, rctx)
9884 f := func(i int) {
9885 defer func() {
9886 if r := recover(); r != nil {
9887 ec.Error(ctx, ec.Recover(ctx, r))
9888 ret = nil
9889 }
9890 }()
9891 if !isLen1 {
9892 defer wg.Done()
9893 }
9894 ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, sel, v[i])
9895 }
9896 if isLen1 {
9897 f(i)
9898 } else {
9899 go f(i)
9900 }
9901
9902 }
9903 wg.Wait()
9904 return ret
9905}
9906
9907func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
9908 return ec._IdentityConnection(ctx, sel, &v)
9909}
9910
9911func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
9912 if v == nil {
9913 if !ec.HasError(graphql.GetResolverContext(ctx)) {
9914 ec.Errorf(ctx, "must not be null")
9915 }
9916 return graphql.Null
9917 }
9918 return ec._IdentityConnection(ctx, sel, v)
9919}
9920
9921func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
9922 return ec._IdentityEdge(ctx, sel, &v)
9923}
9924
9925func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
9926 ret := make(graphql.Array, len(v))
9927 var wg sync.WaitGroup
9928 isLen1 := len(v) == 1
9929 if !isLen1 {
9930 wg.Add(len(v))
9931 }
9932 for i := range v {
9933 i := i
9934 rctx := &graphql.ResolverContext{
9935 Index: &i,
9936 Result: &v[i],
9937 }
9938 ctx := graphql.WithResolverContext(ctx, rctx)
9939 f := func(i int) {
9940 defer func() {
9941 if r := recover(); r != nil {
9942 ec.Error(ctx, ec.Recover(ctx, r))
9943 ret = nil
9944 }
9945 }()
9946 if !isLen1 {
9947 defer wg.Done()
9948 }
9949 ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
9950 }
9951 if isLen1 {
9952 f(i)
9953 } else {
9954 go f(i)
9955 }
9956
9957 }
9958 wg.Wait()
9959 return ret
9960}
9961
9962func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
9963 if v == nil {
9964 if !ec.HasError(graphql.GetResolverContext(ctx)) {
9965 ec.Errorf(ctx, "must not be null")
9966 }
9967 return graphql.Null
9968 }
9969 return ec._IdentityEdge(ctx, sel, v)
9970}
9971
9972func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
9973 return graphql.UnmarshalInt(v)
9974}
9975
9976func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
9977 res := graphql.MarshalInt(v)
9978 if res == graphql.Null {
9979 if !ec.HasError(graphql.GetResolverContext(ctx)) {
9980 ec.Errorf(ctx, "must not be null")
9981 }
9982 }
9983 return res
9984}
9985
9986func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
9987 return ec._Label(ctx, sel, &v)
9988}
9989
9990func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
9991 ret := make(graphql.Array, len(v))
9992 var wg sync.WaitGroup
9993 isLen1 := len(v) == 1
9994 if !isLen1 {
9995 wg.Add(len(v))
9996 }
9997 for i := range v {
9998 i := i
9999 rctx := &graphql.ResolverContext{
10000 Index: &i,
10001 Result: &v[i],
10002 }
10003 ctx := graphql.WithResolverContext(ctx, rctx)
10004 f := func(i int) {
10005 defer func() {
10006 if r := recover(); r != nil {
10007 ec.Error(ctx, ec.Recover(ctx, r))
10008 ret = nil
10009 }
10010 }()
10011 if !isLen1 {
10012 defer wg.Done()
10013 }
10014 ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
10015 }
10016 if isLen1 {
10017 f(i)
10018 } else {
10019 go f(i)
10020 }
10021
10022 }
10023 wg.Wait()
10024 return ret
10025}
10026
10027func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
10028 return ec._Operation(ctx, sel, &v)
10029}
10030
10031func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
10032 ret := make(graphql.Array, len(v))
10033 var wg sync.WaitGroup
10034 isLen1 := len(v) == 1
10035 if !isLen1 {
10036 wg.Add(len(v))
10037 }
10038 for i := range v {
10039 i := i
10040 rctx := &graphql.ResolverContext{
10041 Index: &i,
10042 Result: &v[i],
10043 }
10044 ctx := graphql.WithResolverContext(ctx, rctx)
10045 f := func(i int) {
10046 defer func() {
10047 if r := recover(); r != nil {
10048 ec.Error(ctx, ec.Recover(ctx, r))
10049 ret = nil
10050 }
10051 }()
10052 if !isLen1 {
10053 defer wg.Done()
10054 }
10055 ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
10056 }
10057 if isLen1 {
10058 f(i)
10059 } else {
10060 go f(i)
10061 }
10062
10063 }
10064 wg.Wait()
10065 return ret
10066}
10067
10068func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
10069 return ec._OperationConnection(ctx, sel, &v)
10070}
10071
10072func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
10073 if v == nil {
10074 if !ec.HasError(graphql.GetResolverContext(ctx)) {
10075 ec.Errorf(ctx, "must not be null")
10076 }
10077 return graphql.Null
10078 }
10079 return ec._OperationConnection(ctx, sel, v)
10080}
10081
10082func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
10083 return ec._OperationEdge(ctx, sel, &v)
10084}
10085
10086func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
10087 ret := make(graphql.Array, len(v))
10088 var wg sync.WaitGroup
10089 isLen1 := len(v) == 1
10090 if !isLen1 {
10091 wg.Add(len(v))
10092 }
10093 for i := range v {
10094 i := i
10095 rctx := &graphql.ResolverContext{
10096 Index: &i,
10097 Result: &v[i],
10098 }
10099 ctx := graphql.WithResolverContext(ctx, rctx)
10100 f := func(i int) {
10101 defer func() {
10102 if r := recover(); r != nil {
10103 ec.Error(ctx, ec.Recover(ctx, r))
10104 ret = nil
10105 }
10106 }()
10107 if !isLen1 {
10108 defer wg.Done()
10109 }
10110 ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
10111 }
10112 if isLen1 {
10113 f(i)
10114 } else {
10115 go f(i)
10116 }
10117
10118 }
10119 wg.Wait()
10120 return ret
10121}
10122
10123func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
10124 if v == nil {
10125 if !ec.HasError(graphql.GetResolverContext(ctx)) {
10126 ec.Errorf(ctx, "must not be null")
10127 }
10128 return graphql.Null
10129 }
10130 return ec._OperationEdge(ctx, sel, v)
10131}
10132
10133func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
10134 return ec._PageInfo(ctx, sel, &v)
10135}
10136
10137func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
10138 if v == nil {
10139 if !ec.HasError(graphql.GetResolverContext(ctx)) {
10140 ec.Errorf(ctx, "must not be null")
10141 }
10142 return graphql.Null
10143 }
10144 return ec._PageInfo(ctx, sel, v)
10145}
10146
10147func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
10148 var res models.Status
10149 return res, res.UnmarshalGQL(v)
10150}
10151
10152func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
10153 return v
10154}
10155
10156func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
10157 return graphql.UnmarshalString(v)
10158}
10159
10160func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
10161 res := graphql.MarshalString(v)
10162 if res == graphql.Null {
10163 if !ec.HasError(graphql.GetResolverContext(ctx)) {
10164 ec.Errorf(ctx, "must not be null")
10165 }
10166 }
10167 return res
10168}
10169
10170func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
10171 return graphql.UnmarshalTime(v)
10172}
10173
10174func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
10175 res := graphql.MarshalTime(v)
10176 if res == graphql.Null {
10177 if !ec.HasError(graphql.GetResolverContext(ctx)) {
10178 ec.Errorf(ctx, "must not be null")
10179 }
10180 }
10181 return res
10182}
10183
10184func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
10185 if v == nil {
10186 return nil, nil
10187 }
10188 res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
10189 return &res, err
10190}
10191
10192func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
10193 if v == nil {
10194 if !ec.HasError(graphql.GetResolverContext(ctx)) {
10195 ec.Errorf(ctx, "must not be null")
10196 }
10197 return graphql.Null
10198 }
10199 return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
10200}
10201
10202func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
10203 return ec._TimelineItem(ctx, sel, &v)
10204}
10205
10206func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
10207 ret := make(graphql.Array, len(v))
10208 var wg sync.WaitGroup
10209 isLen1 := len(v) == 1
10210 if !isLen1 {
10211 wg.Add(len(v))
10212 }
10213 for i := range v {
10214 i := i
10215 rctx := &graphql.ResolverContext{
10216 Index: &i,
10217 Result: &v[i],
10218 }
10219 ctx := graphql.WithResolverContext(ctx, rctx)
10220 f := func(i int) {
10221 defer func() {
10222 if r := recover(); r != nil {
10223 ec.Error(ctx, ec.Recover(ctx, r))
10224 ret = nil
10225 }
10226 }()
10227 if !isLen1 {
10228 defer wg.Done()
10229 }
10230 ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
10231 }
10232 if isLen1 {
10233 f(i)
10234 } else {
10235 go f(i)
10236 }
10237
10238 }
10239 wg.Wait()
10240 return ret
10241}
10242
10243func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
10244 return ec._TimelineItemConnection(ctx, sel, &v)
10245}
10246
10247func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
10248 if v == nil {
10249 if !ec.HasError(graphql.GetResolverContext(ctx)) {
10250 ec.Errorf(ctx, "must not be null")
10251 }
10252 return graphql.Null
10253 }
10254 return ec._TimelineItemConnection(ctx, sel, v)
10255}
10256
10257func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
10258 return ec._TimelineItemEdge(ctx, sel, &v)
10259}
10260
10261func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
10262 ret := make(graphql.Array, len(v))
10263 var wg sync.WaitGroup
10264 isLen1 := len(v) == 1
10265 if !isLen1 {
10266 wg.Add(len(v))
10267 }
10268 for i := range v {
10269 i := i
10270 rctx := &graphql.ResolverContext{
10271 Index: &i,
10272 Result: &v[i],
10273 }
10274 ctx := graphql.WithResolverContext(ctx, rctx)
10275 f := func(i int) {
10276 defer func() {
10277 if r := recover(); r != nil {
10278 ec.Error(ctx, ec.Recover(ctx, r))
10279 ret = nil
10280 }
10281 }()
10282 if !isLen1 {
10283 defer wg.Done()
10284 }
10285 ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
10286 }
10287 if isLen1 {
10288 f(i)
10289 } else {
10290 go f(i)
10291 }
10292
10293 }
10294 wg.Wait()
10295 return ret
10296}
10297
10298func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
10299 if v == nil {
10300 if !ec.HasError(graphql.GetResolverContext(ctx)) {
10301 ec.Errorf(ctx, "must not be null")
10302 }
10303 return graphql.Null
10304 }
10305 return ec._TimelineItemEdge(ctx, sel, v)
10306}
10307
10308func (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 {
10309 return ec.___Directive(ctx, sel, &v)
10310}
10311
10312func (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 {
10313 ret := make(graphql.Array, len(v))
10314 var wg sync.WaitGroup
10315 isLen1 := len(v) == 1
10316 if !isLen1 {
10317 wg.Add(len(v))
10318 }
10319 for i := range v {
10320 i := i
10321 rctx := &graphql.ResolverContext{
10322 Index: &i,
10323 Result: &v[i],
10324 }
10325 ctx := graphql.WithResolverContext(ctx, rctx)
10326 f := func(i int) {
10327 defer func() {
10328 if r := recover(); r != nil {
10329 ec.Error(ctx, ec.Recover(ctx, r))
10330 ret = nil
10331 }
10332 }()
10333 if !isLen1 {
10334 defer wg.Done()
10335 }
10336 ret[i] = ec.marshalN__Directive2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
10337 }
10338 if isLen1 {
10339 f(i)
10340 } else {
10341 go f(i)
10342 }
10343
10344 }
10345 wg.Wait()
10346 return ret
10347}
10348
10349func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
10350 return graphql.UnmarshalString(v)
10351}
10352
10353func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
10354 res := graphql.MarshalString(v)
10355 if res == graphql.Null {
10356 if !ec.HasError(graphql.GetResolverContext(ctx)) {
10357 ec.Errorf(ctx, "must not be null")
10358 }
10359 }
10360 return res
10361}
10362
10363func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
10364 var vSlice []interface{}
10365 if v != nil {
10366 if tmp1, ok := v.([]interface{}); ok {
10367 vSlice = tmp1
10368 } else {
10369 vSlice = []interface{}{v}
10370 }
10371 }
10372 var err error
10373 res := make([]string, len(vSlice))
10374 for i := range vSlice {
10375 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
10376 if err != nil {
10377 return nil, err
10378 }
10379 }
10380 return res, nil
10381}
10382
10383func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
10384 ret := make(graphql.Array, len(v))
10385 var wg sync.WaitGroup
10386 isLen1 := len(v) == 1
10387 if !isLen1 {
10388 wg.Add(len(v))
10389 }
10390 for i := range v {
10391 i := i
10392 rctx := &graphql.ResolverContext{
10393 Index: &i,
10394 Result: &v[i],
10395 }
10396 ctx := graphql.WithResolverContext(ctx, rctx)
10397 f := func(i int) {
10398 defer func() {
10399 if r := recover(); r != nil {
10400 ec.Error(ctx, ec.Recover(ctx, r))
10401 ret = nil
10402 }
10403 }()
10404 if !isLen1 {
10405 defer wg.Done()
10406 }
10407 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
10408 }
10409 if isLen1 {
10410 f(i)
10411 } else {
10412 go f(i)
10413 }
10414
10415 }
10416 wg.Wait()
10417 return ret
10418}
10419
10420func (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 {
10421 return ec.___EnumValue(ctx, sel, &v)
10422}
10423
10424func (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 {
10425 return ec.___Field(ctx, sel, &v)
10426}
10427
10428func (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 {
10429 return ec.___InputValue(ctx, sel, &v)
10430}
10431
10432func (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 {
10433 ret := make(graphql.Array, len(v))
10434 var wg sync.WaitGroup
10435 isLen1 := len(v) == 1
10436 if !isLen1 {
10437 wg.Add(len(v))
10438 }
10439 for i := range v {
10440 i := i
10441 rctx := &graphql.ResolverContext{
10442 Index: &i,
10443 Result: &v[i],
10444 }
10445 ctx := graphql.WithResolverContext(ctx, rctx)
10446 f := func(i int) {
10447 defer func() {
10448 if r := recover(); r != nil {
10449 ec.Error(ctx, ec.Recover(ctx, r))
10450 ret = nil
10451 }
10452 }()
10453 if !isLen1 {
10454 defer wg.Done()
10455 }
10456 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
10457 }
10458 if isLen1 {
10459 f(i)
10460 } else {
10461 go f(i)
10462 }
10463
10464 }
10465 wg.Wait()
10466 return ret
10467}
10468
10469func (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 {
10470 return ec.___Type(ctx, sel, &v)
10471}
10472
10473func (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 {
10474 ret := make(graphql.Array, len(v))
10475 var wg sync.WaitGroup
10476 isLen1 := len(v) == 1
10477 if !isLen1 {
10478 wg.Add(len(v))
10479 }
10480 for i := range v {
10481 i := i
10482 rctx := &graphql.ResolverContext{
10483 Index: &i,
10484 Result: &v[i],
10485 }
10486 ctx := graphql.WithResolverContext(ctx, rctx)
10487 f := func(i int) {
10488 defer func() {
10489 if r := recover(); r != nil {
10490 ec.Error(ctx, ec.Recover(ctx, r))
10491 ret = nil
10492 }
10493 }()
10494 if !isLen1 {
10495 defer wg.Done()
10496 }
10497 ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
10498 }
10499 if isLen1 {
10500 f(i)
10501 } else {
10502 go f(i)
10503 }
10504
10505 }
10506 wg.Wait()
10507 return ret
10508}
10509
10510func (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 {
10511 if v == nil {
10512 if !ec.HasError(graphql.GetResolverContext(ctx)) {
10513 ec.Errorf(ctx, "must not be null")
10514 }
10515 return graphql.Null
10516 }
10517 return ec.___Type(ctx, sel, v)
10518}
10519
10520func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
10521 return graphql.UnmarshalString(v)
10522}
10523
10524func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
10525 res := graphql.MarshalString(v)
10526 if res == graphql.Null {
10527 if !ec.HasError(graphql.GetResolverContext(ctx)) {
10528 ec.Errorf(ctx, "must not be null")
10529 }
10530 }
10531 return res
10532}
10533
10534func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
10535 return graphql.UnmarshalBoolean(v)
10536}
10537
10538func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
10539 return graphql.MarshalBoolean(v)
10540}
10541
10542func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
10543 if v == nil {
10544 return nil, nil
10545 }
10546 res, err := ec.unmarshalOBoolean2bool(ctx, v)
10547 return &res, err
10548}
10549
10550func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
10551 if v == nil {
10552 return graphql.Null
10553 }
10554 return ec.marshalOBoolean2bool(ctx, sel, *v)
10555}
10556
10557func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
10558 return ec._Bug(ctx, sel, &v)
10559}
10560
10561func (ec *executionContext) marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
10562 if v == nil {
10563 return graphql.Null
10564 }
10565 return ec._Bug(ctx, sel, v)
10566}
10567
10568func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
10569 var vSlice []interface{}
10570 if v != nil {
10571 if tmp1, ok := v.([]interface{}); ok {
10572 vSlice = tmp1
10573 } else {
10574 vSlice = []interface{}{v}
10575 }
10576 }
10577 var err error
10578 res := make([]git.Hash, len(vSlice))
10579 for i := range vSlice {
10580 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
10581 if err != nil {
10582 return nil, err
10583 }
10584 }
10585 return res, nil
10586}
10587
10588func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
10589 if v == nil {
10590 return graphql.Null
10591 }
10592 ret := make(graphql.Array, len(v))
10593 for i := range v {
10594 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
10595 }
10596
10597 return ret
10598}
10599
10600func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
10601 return ec._Identity(ctx, sel, &v)
10602}
10603
10604func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
10605 return graphql.UnmarshalInt(v)
10606}
10607
10608func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
10609 return graphql.MarshalInt(v)
10610}
10611
10612func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
10613 if v == nil {
10614 return nil, nil
10615 }
10616 res, err := ec.unmarshalOInt2int(ctx, v)
10617 return &res, err
10618}
10619
10620func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
10621 if v == nil {
10622 return graphql.Null
10623 }
10624 return ec.marshalOInt2int(ctx, sel, *v)
10625}
10626
10627func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
10628 return ec._Repository(ctx, sel, &v)
10629}
10630
10631func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
10632 if v == nil {
10633 return graphql.Null
10634 }
10635 return ec._Repository(ctx, sel, v)
10636}
10637
10638func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
10639 return graphql.UnmarshalString(v)
10640}
10641
10642func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
10643 return graphql.MarshalString(v)
10644}
10645
10646func (ec *executionContext) unmarshalOString2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
10647 var vSlice []interface{}
10648 if v != nil {
10649 if tmp1, ok := v.([]interface{}); ok {
10650 vSlice = tmp1
10651 } else {
10652 vSlice = []interface{}{v}
10653 }
10654 }
10655 var err error
10656 res := make([]string, len(vSlice))
10657 for i := range vSlice {
10658 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
10659 if err != nil {
10660 return nil, err
10661 }
10662 }
10663 return res, nil
10664}
10665
10666func (ec *executionContext) marshalOString2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
10667 if v == nil {
10668 return graphql.Null
10669 }
10670 ret := make(graphql.Array, len(v))
10671 for i := range v {
10672 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
10673 }
10674
10675 return ret
10676}
10677
10678func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
10679 if v == nil {
10680 return nil, nil
10681 }
10682 res, err := ec.unmarshalOString2string(ctx, v)
10683 return &res, err
10684}
10685
10686func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
10687 if v == nil {
10688 return graphql.Null
10689 }
10690 return ec.marshalOString2string(ctx, sel, *v)
10691}
10692
10693func (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 {
10694 if v == nil {
10695 return graphql.Null
10696 }
10697 ret := make(graphql.Array, len(v))
10698 var wg sync.WaitGroup
10699 isLen1 := len(v) == 1
10700 if !isLen1 {
10701 wg.Add(len(v))
10702 }
10703 for i := range v {
10704 i := i
10705 rctx := &graphql.ResolverContext{
10706 Index: &i,
10707 Result: &v[i],
10708 }
10709 ctx := graphql.WithResolverContext(ctx, rctx)
10710 f := func(i int) {
10711 defer func() {
10712 if r := recover(); r != nil {
10713 ec.Error(ctx, ec.Recover(ctx, r))
10714 ret = nil
10715 }
10716 }()
10717 if !isLen1 {
10718 defer wg.Done()
10719 }
10720 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
10721 }
10722 if isLen1 {
10723 f(i)
10724 } else {
10725 go f(i)
10726 }
10727
10728 }
10729 wg.Wait()
10730 return ret
10731}
10732
10733func (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 {
10734 if v == nil {
10735 return graphql.Null
10736 }
10737 ret := make(graphql.Array, len(v))
10738 var wg sync.WaitGroup
10739 isLen1 := len(v) == 1
10740 if !isLen1 {
10741 wg.Add(len(v))
10742 }
10743 for i := range v {
10744 i := i
10745 rctx := &graphql.ResolverContext{
10746 Index: &i,
10747 Result: &v[i],
10748 }
10749 ctx := graphql.WithResolverContext(ctx, rctx)
10750 f := func(i int) {
10751 defer func() {
10752 if r := recover(); r != nil {
10753 ec.Error(ctx, ec.Recover(ctx, r))
10754 ret = nil
10755 }
10756 }()
10757 if !isLen1 {
10758 defer wg.Done()
10759 }
10760 ret[i] = ec.marshalN__Field2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
10761 }
10762 if isLen1 {
10763 f(i)
10764 } else {
10765 go f(i)
10766 }
10767
10768 }
10769 wg.Wait()
10770 return ret
10771}
10772
10773func (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 {
10774 if v == nil {
10775 return graphql.Null
10776 }
10777 ret := make(graphql.Array, len(v))
10778 var wg sync.WaitGroup
10779 isLen1 := len(v) == 1
10780 if !isLen1 {
10781 wg.Add(len(v))
10782 }
10783 for i := range v {
10784 i := i
10785 rctx := &graphql.ResolverContext{
10786 Index: &i,
10787 Result: &v[i],
10788 }
10789 ctx := graphql.WithResolverContext(ctx, rctx)
10790 f := func(i int) {
10791 defer func() {
10792 if r := recover(); r != nil {
10793 ec.Error(ctx, ec.Recover(ctx, r))
10794 ret = nil
10795 }
10796 }()
10797 if !isLen1 {
10798 defer wg.Done()
10799 }
10800 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
10801 }
10802 if isLen1 {
10803 f(i)
10804 } else {
10805 go f(i)
10806 }
10807
10808 }
10809 wg.Wait()
10810 return ret
10811}
10812
10813func (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 {
10814 return ec.___Schema(ctx, sel, &v)
10815}
10816
10817func (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 {
10818 if v == nil {
10819 return graphql.Null
10820 }
10821 return ec.___Schema(ctx, sel, v)
10822}
10823
10824func (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 {
10825 return ec.___Type(ctx, sel, &v)
10826}
10827
10828func (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 {
10829 if v == nil {
10830 return graphql.Null
10831 }
10832 ret := make(graphql.Array, len(v))
10833 var wg sync.WaitGroup
10834 isLen1 := len(v) == 1
10835 if !isLen1 {
10836 wg.Add(len(v))
10837 }
10838 for i := range v {
10839 i := i
10840 rctx := &graphql.ResolverContext{
10841 Index: &i,
10842 Result: &v[i],
10843 }
10844 ctx := graphql.WithResolverContext(ctx, rctx)
10845 f := func(i int) {
10846 defer func() {
10847 if r := recover(); r != nil {
10848 ec.Error(ctx, ec.Recover(ctx, r))
10849 ret = nil
10850 }
10851 }()
10852 if !isLen1 {
10853 defer wg.Done()
10854 }
10855 ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
10856 }
10857 if isLen1 {
10858 f(i)
10859 } else {
10860 go f(i)
10861 }
10862
10863 }
10864 wg.Wait()
10865 return ret
10866}
10867
10868func (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 {
10869 if v == nil {
10870 return graphql.Null
10871 }
10872 return ec.___Type(ctx, sel, v)
10873}
10874
10875// endregion ***************************** type.gotpl *****************************