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