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