1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
2
3package graph
4
5import (
6 "bytes"
7 "context"
8 "errors"
9 "fmt"
10 "image/color"
11 "strconv"
12 "sync"
13 "sync/atomic"
14 "time"
15
16 "github.com/99designs/gqlgen/graphql"
17 "github.com/99designs/gqlgen/graphql/introspection"
18 "github.com/MichaelMure/git-bug/bug"
19 "github.com/MichaelMure/git-bug/graphql/models"
20 "github.com/MichaelMure/git-bug/identity"
21 "github.com/MichaelMure/git-bug/util/git"
22 "github.com/vektah/gqlparser"
23 "github.com/vektah/gqlparser/ast"
24)
25
26// region ************************** generated!.gotpl **************************
27
28// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
29func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
30 return &executableSchema{
31 resolvers: cfg.Resolvers,
32 directives: cfg.Directives,
33 complexity: cfg.Complexity,
34 }
35}
36
37type Config struct {
38 Resolvers ResolverRoot
39 Directives DirectiveRoot
40 Complexity ComplexityRoot
41}
42
43type ResolverRoot interface {
44 AddCommentOperation() AddCommentOperationResolver
45 AddCommentTimelineItem() AddCommentTimelineItemResolver
46 Bug() BugResolver
47 Color() ColorResolver
48 CommentHistoryStep() CommentHistoryStepResolver
49 CreateOperation() CreateOperationResolver
50 CreateTimelineItem() CreateTimelineItemResolver
51 EditCommentOperation() EditCommentOperationResolver
52 Identity() IdentityResolver
53 Label() LabelResolver
54 LabelChangeOperation() LabelChangeOperationResolver
55 LabelChangeResult() LabelChangeResultResolver
56 LabelChangeTimelineItem() LabelChangeTimelineItemResolver
57 Mutation() MutationResolver
58 Query() QueryResolver
59 Repository() RepositoryResolver
60 SetStatusOperation() SetStatusOperationResolver
61 SetStatusTimelineItem() SetStatusTimelineItemResolver
62 SetTitleOperation() SetTitleOperationResolver
63 SetTitleTimelineItem() SetTitleTimelineItemResolver
64}
65
66type DirectiveRoot struct {
67}
68
69type ComplexityRoot struct {
70 AddCommentOperation struct {
71 Author func(childComplexity int) int
72 Date func(childComplexity int) int
73 Files func(childComplexity int) int
74 ID func(childComplexity int) int
75 Message func(childComplexity int) int
76 }
77
78 AddCommentPayload struct {
79 Bug func(childComplexity int) int
80 ClientMutationID func(childComplexity int) int
81 Operation func(childComplexity int) int
82 }
83
84 AddCommentTimelineItem struct {
85 Author func(childComplexity int) int
86 CreatedAt func(childComplexity int) int
87 Edited func(childComplexity int) int
88 Files func(childComplexity int) int
89 History func(childComplexity int) int
90 ID func(childComplexity int) int
91 LastEdit func(childComplexity int) int
92 Message func(childComplexity int) int
93 MessageIsEmpty func(childComplexity int) int
94 }
95
96 Bug struct {
97 Actors func(childComplexity int, after *string, before *string, first *int, last *int) int
98 Author func(childComplexity int) int
99 Comments func(childComplexity int, after *string, before *string, first *int, last *int) int
100 CreatedAt func(childComplexity int) int
101 HumanID func(childComplexity int) int
102 ID func(childComplexity int) int
103 Labels func(childComplexity int) int
104 LastEdit func(childComplexity int) int
105 Operations func(childComplexity int, after *string, before *string, first *int, last *int) int
106 Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
107 Status func(childComplexity int) int
108 Timeline func(childComplexity int, after *string, before *string, first *int, last *int) int
109 Title func(childComplexity int) int
110 }
111
112 BugConnection struct {
113 Edges func(childComplexity int) int
114 Nodes func(childComplexity int) int
115 PageInfo func(childComplexity int) int
116 TotalCount func(childComplexity int) int
117 }
118
119 BugEdge struct {
120 Cursor func(childComplexity int) int
121 Node func(childComplexity int) int
122 }
123
124 ChangeLabelPayload struct {
125 Bug func(childComplexity int) int
126 ClientMutationID func(childComplexity int) int
127 Operation func(childComplexity int) int
128 Results func(childComplexity int) int
129 }
130
131 CloseBugPayload struct {
132 Bug func(childComplexity int) int
133 ClientMutationID func(childComplexity int) int
134 Operation func(childComplexity int) int
135 }
136
137 Color struct {
138 B func(childComplexity int) int
139 G func(childComplexity int) int
140 R func(childComplexity int) int
141 }
142
143 Comment struct {
144 Author func(childComplexity int) int
145 Files func(childComplexity int) int
146 Message func(childComplexity int) int
147 }
148
149 CommentConnection struct {
150 Edges func(childComplexity int) int
151 Nodes func(childComplexity int) int
152 PageInfo func(childComplexity int) int
153 TotalCount func(childComplexity int) int
154 }
155
156 CommentEdge struct {
157 Cursor func(childComplexity int) int
158 Node func(childComplexity int) int
159 }
160
161 CommentHistoryStep struct {
162 Date func(childComplexity int) int
163 Message func(childComplexity int) int
164 }
165
166 CommitAsNeededPayload struct {
167 Bug func(childComplexity int) int
168 ClientMutationID func(childComplexity int) int
169 }
170
171 CommitPayload struct {
172 Bug func(childComplexity int) int
173 ClientMutationID func(childComplexity int) int
174 }
175
176 CreateOperation struct {
177 Author func(childComplexity int) int
178 Date func(childComplexity int) int
179 Files func(childComplexity int) int
180 ID func(childComplexity int) int
181 Message func(childComplexity int) int
182 Title func(childComplexity int) int
183 }
184
185 CreateTimelineItem struct {
186 Author func(childComplexity int) int
187 CreatedAt func(childComplexity int) int
188 Edited func(childComplexity int) int
189 Files func(childComplexity int) int
190 History func(childComplexity int) int
191 ID func(childComplexity int) int
192 LastEdit func(childComplexity int) int
193 Message func(childComplexity int) int
194 MessageIsEmpty func(childComplexity int) int
195 }
196
197 EditCommentOperation struct {
198 Author func(childComplexity int) int
199 Date func(childComplexity int) int
200 Files func(childComplexity int) int
201 ID func(childComplexity int) int
202 Message func(childComplexity int) int
203 Target func(childComplexity int) int
204 }
205
206 Identity struct {
207 AvatarURL func(childComplexity int) int
208 DisplayName func(childComplexity int) int
209 Email func(childComplexity int) int
210 HumanID func(childComplexity int) int
211 ID func(childComplexity int) int
212 IsProtected func(childComplexity int) int
213 Login func(childComplexity int) int
214 Name func(childComplexity int) int
215 }
216
217 IdentityConnection struct {
218 Edges func(childComplexity int) int
219 Nodes func(childComplexity int) int
220 PageInfo func(childComplexity int) int
221 TotalCount func(childComplexity int) int
222 }
223
224 IdentityEdge struct {
225 Cursor func(childComplexity int) int
226 Node func(childComplexity int) int
227 }
228
229 Label struct {
230 Color func(childComplexity int) int
231 Name func(childComplexity int) int
232 }
233
234 LabelChangeOperation struct {
235 Added func(childComplexity int) int
236 Author func(childComplexity int) int
237 Date func(childComplexity int) int
238 ID func(childComplexity int) int
239 Removed func(childComplexity int) int
240 }
241
242 LabelChangeResult struct {
243 Label func(childComplexity int) int
244 Status func(childComplexity int) int
245 }
246
247 LabelChangeTimelineItem struct {
248 Added func(childComplexity int) int
249 Author func(childComplexity int) int
250 Date func(childComplexity int) int
251 ID func(childComplexity int) int
252 Removed func(childComplexity int) int
253 }
254
255 Mutation struct {
256 AddComment func(childComplexity int, input models.AddCommentInput) int
257 ChangeLabels func(childComplexity int, input *models.ChangeLabelInput) int
258 CloseBug func(childComplexity int, input models.CloseBugInput) int
259 Commit func(childComplexity int, input models.CommitInput) int
260 CommitAsNeeded func(childComplexity int, input models.CommitAsNeededInput) int
261 NewBug func(childComplexity int, input models.NewBugInput) int
262 OpenBug func(childComplexity int, input models.OpenBugInput) int
263 SetTitle func(childComplexity int, input models.SetTitleInput) int
264 }
265
266 NewBugPayload struct {
267 Bug func(childComplexity int) int
268 ClientMutationID func(childComplexity int) int
269 Operation func(childComplexity int) int
270 }
271
272 OpenBugPayload struct {
273 Bug func(childComplexity int) int
274 ClientMutationID func(childComplexity int) int
275 Operation func(childComplexity int) int
276 }
277
278 OperationConnection struct {
279 Edges func(childComplexity int) int
280 Nodes func(childComplexity int) int
281 PageInfo func(childComplexity int) int
282 TotalCount func(childComplexity int) int
283 }
284
285 OperationEdge struct {
286 Cursor func(childComplexity int) int
287 Node func(childComplexity int) int
288 }
289
290 PageInfo struct {
291 EndCursor func(childComplexity int) int
292 HasNextPage func(childComplexity int) int
293 HasPreviousPage func(childComplexity int) int
294 StartCursor func(childComplexity int) int
295 }
296
297 Query struct {
298 DefaultRepository func(childComplexity int) int
299 Repository func(childComplexity int, ref string) int
300 }
301
302 Repository struct {
303 AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
304 AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
305 Bug func(childComplexity int, prefix string) int
306 Identity func(childComplexity int, prefix string) int
307 UserIdentity func(childComplexity int) int
308 ValidLabels func(childComplexity int) int
309 }
310
311 SetStatusOperation struct {
312 Author func(childComplexity int) int
313 Date func(childComplexity int) int
314 ID func(childComplexity int) int
315 Status func(childComplexity int) int
316 }
317
318 SetStatusTimelineItem struct {
319 Author func(childComplexity int) int
320 Date func(childComplexity int) int
321 ID func(childComplexity int) int
322 Status func(childComplexity int) int
323 }
324
325 SetTitleOperation struct {
326 Author func(childComplexity int) int
327 Date func(childComplexity int) int
328 ID func(childComplexity int) int
329 Title func(childComplexity int) int
330 Was func(childComplexity int) int
331 }
332
333 SetTitlePayload struct {
334 Bug func(childComplexity int) int
335 ClientMutationID func(childComplexity int) int
336 Operation func(childComplexity int) int
337 }
338
339 SetTitleTimelineItem struct {
340 Author func(childComplexity int) int
341 Date func(childComplexity int) int
342 ID func(childComplexity int) int
343 Title func(childComplexity int) int
344 Was func(childComplexity int) int
345 }
346
347 TimelineItemConnection struct {
348 Edges func(childComplexity int) int
349 Nodes func(childComplexity int) int
350 PageInfo func(childComplexity int) int
351 TotalCount func(childComplexity int) int
352 }
353
354 TimelineItemEdge struct {
355 Cursor func(childComplexity int) int
356 Node func(childComplexity int) int
357 }
358}
359
360type AddCommentOperationResolver interface {
361 ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
362
363 Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
364}
365type AddCommentTimelineItemResolver interface {
366 ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
367
368 CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
369 LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
370}
371type BugResolver interface {
372 ID(ctx context.Context, obj *bug.Snapshot) (string, error)
373 HumanID(ctx context.Context, obj *bug.Snapshot) (string, error)
374 Status(ctx context.Context, obj *bug.Snapshot) (models.Status, error)
375
376 LastEdit(ctx context.Context, obj *bug.Snapshot) (*time.Time, error)
377 Actors(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
378 Participants(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
379 Comments(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
380 Timeline(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
381 Operations(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
382}
383type ColorResolver interface {
384 R(ctx context.Context, obj *color.RGBA) (int, error)
385 G(ctx context.Context, obj *color.RGBA) (int, error)
386 B(ctx context.Context, obj *color.RGBA) (int, error)
387}
388type CommentHistoryStepResolver interface {
389 Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
390}
391type CreateOperationResolver interface {
392 ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
393
394 Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
395}
396type CreateTimelineItemResolver interface {
397 ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
398
399 CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
400 LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
401}
402type EditCommentOperationResolver interface {
403 ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
404
405 Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
406 Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
407}
408type IdentityResolver interface {
409 ID(ctx context.Context, obj *identity.Interface) (string, error)
410 HumanID(ctx context.Context, obj *identity.Interface) (string, error)
411 Name(ctx context.Context, obj *identity.Interface) (*string, error)
412 Email(ctx context.Context, obj *identity.Interface) (*string, error)
413 Login(ctx context.Context, obj *identity.Interface) (*string, error)
414 DisplayName(ctx context.Context, obj *identity.Interface) (string, error)
415 AvatarURL(ctx context.Context, obj *identity.Interface) (*string, error)
416 IsProtected(ctx context.Context, obj *identity.Interface) (bool, error)
417}
418type LabelResolver interface {
419 Name(ctx context.Context, obj *bug.Label) (string, error)
420 Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
421}
422type LabelChangeOperationResolver interface {
423 ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
424
425 Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
426}
427type LabelChangeResultResolver interface {
428 Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
429}
430type LabelChangeTimelineItemResolver interface {
431 ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
432
433 Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
434}
435type MutationResolver interface {
436 NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
437 AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
438 ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
439 OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
440 CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
441 SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
442 Commit(ctx context.Context, input models.CommitInput) (*models.CommitPayload, error)
443 CommitAsNeeded(ctx context.Context, input models.CommitAsNeededInput) (*models.CommitAsNeededPayload, error)
444}
445type QueryResolver interface {
446 DefaultRepository(ctx context.Context) (*models.Repository, error)
447 Repository(ctx context.Context, ref string) (*models.Repository, error)
448}
449type RepositoryResolver interface {
450 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
451 Bug(ctx context.Context, obj *models.Repository, prefix string) (*bug.Snapshot, error)
452 AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
453 Identity(ctx context.Context, obj *models.Repository, prefix string) (identity.Interface, error)
454 UserIdentity(ctx context.Context, obj *models.Repository) (identity.Interface, error)
455 ValidLabels(ctx context.Context, obj *models.Repository) ([]bug.Label, error)
456}
457type SetStatusOperationResolver interface {
458 ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
459
460 Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
461 Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
462}
463type SetStatusTimelineItemResolver interface {
464 ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
465
466 Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
467 Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
468}
469type SetTitleOperationResolver interface {
470 ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
471
472 Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
473}
474type SetTitleTimelineItemResolver interface {
475 ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
476
477 Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
478}
479
480type executableSchema struct {
481 resolvers ResolverRoot
482 directives DirectiveRoot
483 complexity ComplexityRoot
484}
485
486func (e *executableSchema) Schema() *ast.Schema {
487 return parsedSchema
488}
489
490func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
491 ec := executionContext{nil, e}
492 _ = ec
493 switch typeName + "." + field {
494
495 case "AddCommentOperation.author":
496 if e.complexity.AddCommentOperation.Author == nil {
497 break
498 }
499
500 return e.complexity.AddCommentOperation.Author(childComplexity), true
501
502 case "AddCommentOperation.date":
503 if e.complexity.AddCommentOperation.Date == nil {
504 break
505 }
506
507 return e.complexity.AddCommentOperation.Date(childComplexity), true
508
509 case "AddCommentOperation.files":
510 if e.complexity.AddCommentOperation.Files == nil {
511 break
512 }
513
514 return e.complexity.AddCommentOperation.Files(childComplexity), true
515
516 case "AddCommentOperation.id":
517 if e.complexity.AddCommentOperation.ID == nil {
518 break
519 }
520
521 return e.complexity.AddCommentOperation.ID(childComplexity), true
522
523 case "AddCommentOperation.message":
524 if e.complexity.AddCommentOperation.Message == nil {
525 break
526 }
527
528 return e.complexity.AddCommentOperation.Message(childComplexity), true
529
530 case "AddCommentPayload.bug":
531 if e.complexity.AddCommentPayload.Bug == nil {
532 break
533 }
534
535 return e.complexity.AddCommentPayload.Bug(childComplexity), true
536
537 case "AddCommentPayload.clientMutationId":
538 if e.complexity.AddCommentPayload.ClientMutationID == nil {
539 break
540 }
541
542 return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
543
544 case "AddCommentPayload.operation":
545 if e.complexity.AddCommentPayload.Operation == nil {
546 break
547 }
548
549 return e.complexity.AddCommentPayload.Operation(childComplexity), true
550
551 case "AddCommentTimelineItem.author":
552 if e.complexity.AddCommentTimelineItem.Author == nil {
553 break
554 }
555
556 return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
557
558 case "AddCommentTimelineItem.createdAt":
559 if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
560 break
561 }
562
563 return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
564
565 case "AddCommentTimelineItem.edited":
566 if e.complexity.AddCommentTimelineItem.Edited == nil {
567 break
568 }
569
570 return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
571
572 case "AddCommentTimelineItem.files":
573 if e.complexity.AddCommentTimelineItem.Files == nil {
574 break
575 }
576
577 return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
578
579 case "AddCommentTimelineItem.history":
580 if e.complexity.AddCommentTimelineItem.History == nil {
581 break
582 }
583
584 return e.complexity.AddCommentTimelineItem.History(childComplexity), true
585
586 case "AddCommentTimelineItem.id":
587 if e.complexity.AddCommentTimelineItem.ID == nil {
588 break
589 }
590
591 return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
592
593 case "AddCommentTimelineItem.lastEdit":
594 if e.complexity.AddCommentTimelineItem.LastEdit == nil {
595 break
596 }
597
598 return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
599
600 case "AddCommentTimelineItem.message":
601 if e.complexity.AddCommentTimelineItem.Message == nil {
602 break
603 }
604
605 return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
606
607 case "AddCommentTimelineItem.messageIsEmpty":
608 if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
609 break
610 }
611
612 return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
613
614 case "Bug.actors":
615 if e.complexity.Bug.Actors == nil {
616 break
617 }
618
619 args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
620 if err != nil {
621 return 0, false
622 }
623
624 return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
625
626 case "Bug.author":
627 if e.complexity.Bug.Author == nil {
628 break
629 }
630
631 return e.complexity.Bug.Author(childComplexity), true
632
633 case "Bug.comments":
634 if e.complexity.Bug.Comments == nil {
635 break
636 }
637
638 args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
639 if err != nil {
640 return 0, false
641 }
642
643 return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
644
645 case "Bug.createdAt":
646 if e.complexity.Bug.CreatedAt == nil {
647 break
648 }
649
650 return e.complexity.Bug.CreatedAt(childComplexity), true
651
652 case "Bug.humanId":
653 if e.complexity.Bug.HumanID == nil {
654 break
655 }
656
657 return e.complexity.Bug.HumanID(childComplexity), true
658
659 case "Bug.id":
660 if e.complexity.Bug.ID == nil {
661 break
662 }
663
664 return e.complexity.Bug.ID(childComplexity), true
665
666 case "Bug.labels":
667 if e.complexity.Bug.Labels == nil {
668 break
669 }
670
671 return e.complexity.Bug.Labels(childComplexity), true
672
673 case "Bug.lastEdit":
674 if e.complexity.Bug.LastEdit == nil {
675 break
676 }
677
678 return e.complexity.Bug.LastEdit(childComplexity), true
679
680 case "Bug.operations":
681 if e.complexity.Bug.Operations == nil {
682 break
683 }
684
685 args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
686 if err != nil {
687 return 0, false
688 }
689
690 return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
691
692 case "Bug.participants":
693 if e.complexity.Bug.Participants == nil {
694 break
695 }
696
697 args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
698 if err != nil {
699 return 0, false
700 }
701
702 return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
703
704 case "Bug.status":
705 if e.complexity.Bug.Status == nil {
706 break
707 }
708
709 return e.complexity.Bug.Status(childComplexity), true
710
711 case "Bug.timeline":
712 if e.complexity.Bug.Timeline == nil {
713 break
714 }
715
716 args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
717 if err != nil {
718 return 0, false
719 }
720
721 return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
722
723 case "Bug.title":
724 if e.complexity.Bug.Title == nil {
725 break
726 }
727
728 return e.complexity.Bug.Title(childComplexity), true
729
730 case "BugConnection.edges":
731 if e.complexity.BugConnection.Edges == nil {
732 break
733 }
734
735 return e.complexity.BugConnection.Edges(childComplexity), true
736
737 case "BugConnection.nodes":
738 if e.complexity.BugConnection.Nodes == nil {
739 break
740 }
741
742 return e.complexity.BugConnection.Nodes(childComplexity), true
743
744 case "BugConnection.pageInfo":
745 if e.complexity.BugConnection.PageInfo == nil {
746 break
747 }
748
749 return e.complexity.BugConnection.PageInfo(childComplexity), true
750
751 case "BugConnection.totalCount":
752 if e.complexity.BugConnection.TotalCount == nil {
753 break
754 }
755
756 return e.complexity.BugConnection.TotalCount(childComplexity), true
757
758 case "BugEdge.cursor":
759 if e.complexity.BugEdge.Cursor == nil {
760 break
761 }
762
763 return e.complexity.BugEdge.Cursor(childComplexity), true
764
765 case "BugEdge.node":
766 if e.complexity.BugEdge.Node == nil {
767 break
768 }
769
770 return e.complexity.BugEdge.Node(childComplexity), true
771
772 case "ChangeLabelPayload.bug":
773 if e.complexity.ChangeLabelPayload.Bug == nil {
774 break
775 }
776
777 return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
778
779 case "ChangeLabelPayload.clientMutationId":
780 if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
781 break
782 }
783
784 return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
785
786 case "ChangeLabelPayload.operation":
787 if e.complexity.ChangeLabelPayload.Operation == nil {
788 break
789 }
790
791 return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
792
793 case "ChangeLabelPayload.results":
794 if e.complexity.ChangeLabelPayload.Results == nil {
795 break
796 }
797
798 return e.complexity.ChangeLabelPayload.Results(childComplexity), true
799
800 case "CloseBugPayload.bug":
801 if e.complexity.CloseBugPayload.Bug == nil {
802 break
803 }
804
805 return e.complexity.CloseBugPayload.Bug(childComplexity), true
806
807 case "CloseBugPayload.clientMutationId":
808 if e.complexity.CloseBugPayload.ClientMutationID == nil {
809 break
810 }
811
812 return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
813
814 case "CloseBugPayload.operation":
815 if e.complexity.CloseBugPayload.Operation == nil {
816 break
817 }
818
819 return e.complexity.CloseBugPayload.Operation(childComplexity), true
820
821 case "Color.B":
822 if e.complexity.Color.B == nil {
823 break
824 }
825
826 return e.complexity.Color.B(childComplexity), true
827
828 case "Color.G":
829 if e.complexity.Color.G == nil {
830 break
831 }
832
833 return e.complexity.Color.G(childComplexity), true
834
835 case "Color.R":
836 if e.complexity.Color.R == nil {
837 break
838 }
839
840 return e.complexity.Color.R(childComplexity), true
841
842 case "Comment.author":
843 if e.complexity.Comment.Author == nil {
844 break
845 }
846
847 return e.complexity.Comment.Author(childComplexity), true
848
849 case "Comment.files":
850 if e.complexity.Comment.Files == nil {
851 break
852 }
853
854 return e.complexity.Comment.Files(childComplexity), true
855
856 case "Comment.message":
857 if e.complexity.Comment.Message == nil {
858 break
859 }
860
861 return e.complexity.Comment.Message(childComplexity), true
862
863 case "CommentConnection.edges":
864 if e.complexity.CommentConnection.Edges == nil {
865 break
866 }
867
868 return e.complexity.CommentConnection.Edges(childComplexity), true
869
870 case "CommentConnection.nodes":
871 if e.complexity.CommentConnection.Nodes == nil {
872 break
873 }
874
875 return e.complexity.CommentConnection.Nodes(childComplexity), true
876
877 case "CommentConnection.pageInfo":
878 if e.complexity.CommentConnection.PageInfo == nil {
879 break
880 }
881
882 return e.complexity.CommentConnection.PageInfo(childComplexity), true
883
884 case "CommentConnection.totalCount":
885 if e.complexity.CommentConnection.TotalCount == nil {
886 break
887 }
888
889 return e.complexity.CommentConnection.TotalCount(childComplexity), true
890
891 case "CommentEdge.cursor":
892 if e.complexity.CommentEdge.Cursor == nil {
893 break
894 }
895
896 return e.complexity.CommentEdge.Cursor(childComplexity), true
897
898 case "CommentEdge.node":
899 if e.complexity.CommentEdge.Node == nil {
900 break
901 }
902
903 return e.complexity.CommentEdge.Node(childComplexity), true
904
905 case "CommentHistoryStep.date":
906 if e.complexity.CommentHistoryStep.Date == nil {
907 break
908 }
909
910 return e.complexity.CommentHistoryStep.Date(childComplexity), true
911
912 case "CommentHistoryStep.message":
913 if e.complexity.CommentHistoryStep.Message == nil {
914 break
915 }
916
917 return e.complexity.CommentHistoryStep.Message(childComplexity), true
918
919 case "CommitAsNeededPayload.bug":
920 if e.complexity.CommitAsNeededPayload.Bug == nil {
921 break
922 }
923
924 return e.complexity.CommitAsNeededPayload.Bug(childComplexity), true
925
926 case "CommitAsNeededPayload.clientMutationId":
927 if e.complexity.CommitAsNeededPayload.ClientMutationID == nil {
928 break
929 }
930
931 return e.complexity.CommitAsNeededPayload.ClientMutationID(childComplexity), true
932
933 case "CommitPayload.bug":
934 if e.complexity.CommitPayload.Bug == nil {
935 break
936 }
937
938 return e.complexity.CommitPayload.Bug(childComplexity), true
939
940 case "CommitPayload.clientMutationId":
941 if e.complexity.CommitPayload.ClientMutationID == nil {
942 break
943 }
944
945 return e.complexity.CommitPayload.ClientMutationID(childComplexity), true
946
947 case "CreateOperation.author":
948 if e.complexity.CreateOperation.Author == nil {
949 break
950 }
951
952 return e.complexity.CreateOperation.Author(childComplexity), true
953
954 case "CreateOperation.date":
955 if e.complexity.CreateOperation.Date == nil {
956 break
957 }
958
959 return e.complexity.CreateOperation.Date(childComplexity), true
960
961 case "CreateOperation.files":
962 if e.complexity.CreateOperation.Files == nil {
963 break
964 }
965
966 return e.complexity.CreateOperation.Files(childComplexity), true
967
968 case "CreateOperation.id":
969 if e.complexity.CreateOperation.ID == nil {
970 break
971 }
972
973 return e.complexity.CreateOperation.ID(childComplexity), true
974
975 case "CreateOperation.message":
976 if e.complexity.CreateOperation.Message == nil {
977 break
978 }
979
980 return e.complexity.CreateOperation.Message(childComplexity), true
981
982 case "CreateOperation.title":
983 if e.complexity.CreateOperation.Title == nil {
984 break
985 }
986
987 return e.complexity.CreateOperation.Title(childComplexity), true
988
989 case "CreateTimelineItem.author":
990 if e.complexity.CreateTimelineItem.Author == nil {
991 break
992 }
993
994 return e.complexity.CreateTimelineItem.Author(childComplexity), true
995
996 case "CreateTimelineItem.createdAt":
997 if e.complexity.CreateTimelineItem.CreatedAt == nil {
998 break
999 }
1000
1001 return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
1002
1003 case "CreateTimelineItem.edited":
1004 if e.complexity.CreateTimelineItem.Edited == nil {
1005 break
1006 }
1007
1008 return e.complexity.CreateTimelineItem.Edited(childComplexity), true
1009
1010 case "CreateTimelineItem.files":
1011 if e.complexity.CreateTimelineItem.Files == nil {
1012 break
1013 }
1014
1015 return e.complexity.CreateTimelineItem.Files(childComplexity), true
1016
1017 case "CreateTimelineItem.history":
1018 if e.complexity.CreateTimelineItem.History == nil {
1019 break
1020 }
1021
1022 return e.complexity.CreateTimelineItem.History(childComplexity), true
1023
1024 case "CreateTimelineItem.id":
1025 if e.complexity.CreateTimelineItem.ID == nil {
1026 break
1027 }
1028
1029 return e.complexity.CreateTimelineItem.ID(childComplexity), true
1030
1031 case "CreateTimelineItem.lastEdit":
1032 if e.complexity.CreateTimelineItem.LastEdit == nil {
1033 break
1034 }
1035
1036 return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
1037
1038 case "CreateTimelineItem.message":
1039 if e.complexity.CreateTimelineItem.Message == nil {
1040 break
1041 }
1042
1043 return e.complexity.CreateTimelineItem.Message(childComplexity), true
1044
1045 case "CreateTimelineItem.messageIsEmpty":
1046 if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
1047 break
1048 }
1049
1050 return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
1051
1052 case "EditCommentOperation.author":
1053 if e.complexity.EditCommentOperation.Author == nil {
1054 break
1055 }
1056
1057 return e.complexity.EditCommentOperation.Author(childComplexity), true
1058
1059 case "EditCommentOperation.date":
1060 if e.complexity.EditCommentOperation.Date == nil {
1061 break
1062 }
1063
1064 return e.complexity.EditCommentOperation.Date(childComplexity), true
1065
1066 case "EditCommentOperation.files":
1067 if e.complexity.EditCommentOperation.Files == nil {
1068 break
1069 }
1070
1071 return e.complexity.EditCommentOperation.Files(childComplexity), true
1072
1073 case "EditCommentOperation.id":
1074 if e.complexity.EditCommentOperation.ID == nil {
1075 break
1076 }
1077
1078 return e.complexity.EditCommentOperation.ID(childComplexity), true
1079
1080 case "EditCommentOperation.message":
1081 if e.complexity.EditCommentOperation.Message == nil {
1082 break
1083 }
1084
1085 return e.complexity.EditCommentOperation.Message(childComplexity), true
1086
1087 case "EditCommentOperation.target":
1088 if e.complexity.EditCommentOperation.Target == nil {
1089 break
1090 }
1091
1092 return e.complexity.EditCommentOperation.Target(childComplexity), true
1093
1094 case "Identity.avatarUrl":
1095 if e.complexity.Identity.AvatarURL == nil {
1096 break
1097 }
1098
1099 return e.complexity.Identity.AvatarURL(childComplexity), true
1100
1101 case "Identity.displayName":
1102 if e.complexity.Identity.DisplayName == nil {
1103 break
1104 }
1105
1106 return e.complexity.Identity.DisplayName(childComplexity), true
1107
1108 case "Identity.email":
1109 if e.complexity.Identity.Email == nil {
1110 break
1111 }
1112
1113 return e.complexity.Identity.Email(childComplexity), true
1114
1115 case "Identity.humanId":
1116 if e.complexity.Identity.HumanID == nil {
1117 break
1118 }
1119
1120 return e.complexity.Identity.HumanID(childComplexity), true
1121
1122 case "Identity.id":
1123 if e.complexity.Identity.ID == nil {
1124 break
1125 }
1126
1127 return e.complexity.Identity.ID(childComplexity), true
1128
1129 case "Identity.isProtected":
1130 if e.complexity.Identity.IsProtected == nil {
1131 break
1132 }
1133
1134 return e.complexity.Identity.IsProtected(childComplexity), true
1135
1136 case "Identity.login":
1137 if e.complexity.Identity.Login == nil {
1138 break
1139 }
1140
1141 return e.complexity.Identity.Login(childComplexity), true
1142
1143 case "Identity.name":
1144 if e.complexity.Identity.Name == nil {
1145 break
1146 }
1147
1148 return e.complexity.Identity.Name(childComplexity), true
1149
1150 case "IdentityConnection.edges":
1151 if e.complexity.IdentityConnection.Edges == nil {
1152 break
1153 }
1154
1155 return e.complexity.IdentityConnection.Edges(childComplexity), true
1156
1157 case "IdentityConnection.nodes":
1158 if e.complexity.IdentityConnection.Nodes == nil {
1159 break
1160 }
1161
1162 return e.complexity.IdentityConnection.Nodes(childComplexity), true
1163
1164 case "IdentityConnection.pageInfo":
1165 if e.complexity.IdentityConnection.PageInfo == nil {
1166 break
1167 }
1168
1169 return e.complexity.IdentityConnection.PageInfo(childComplexity), true
1170
1171 case "IdentityConnection.totalCount":
1172 if e.complexity.IdentityConnection.TotalCount == nil {
1173 break
1174 }
1175
1176 return e.complexity.IdentityConnection.TotalCount(childComplexity), true
1177
1178 case "IdentityEdge.cursor":
1179 if e.complexity.IdentityEdge.Cursor == nil {
1180 break
1181 }
1182
1183 return e.complexity.IdentityEdge.Cursor(childComplexity), true
1184
1185 case "IdentityEdge.node":
1186 if e.complexity.IdentityEdge.Node == nil {
1187 break
1188 }
1189
1190 return e.complexity.IdentityEdge.Node(childComplexity), true
1191
1192 case "Label.color":
1193 if e.complexity.Label.Color == nil {
1194 break
1195 }
1196
1197 return e.complexity.Label.Color(childComplexity), true
1198
1199 case "Label.name":
1200 if e.complexity.Label.Name == nil {
1201 break
1202 }
1203
1204 return e.complexity.Label.Name(childComplexity), true
1205
1206 case "LabelChangeOperation.added":
1207 if e.complexity.LabelChangeOperation.Added == nil {
1208 break
1209 }
1210
1211 return e.complexity.LabelChangeOperation.Added(childComplexity), true
1212
1213 case "LabelChangeOperation.author":
1214 if e.complexity.LabelChangeOperation.Author == nil {
1215 break
1216 }
1217
1218 return e.complexity.LabelChangeOperation.Author(childComplexity), true
1219
1220 case "LabelChangeOperation.date":
1221 if e.complexity.LabelChangeOperation.Date == nil {
1222 break
1223 }
1224
1225 return e.complexity.LabelChangeOperation.Date(childComplexity), true
1226
1227 case "LabelChangeOperation.id":
1228 if e.complexity.LabelChangeOperation.ID == nil {
1229 break
1230 }
1231
1232 return e.complexity.LabelChangeOperation.ID(childComplexity), true
1233
1234 case "LabelChangeOperation.removed":
1235 if e.complexity.LabelChangeOperation.Removed == nil {
1236 break
1237 }
1238
1239 return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1240
1241 case "LabelChangeResult.label":
1242 if e.complexity.LabelChangeResult.Label == nil {
1243 break
1244 }
1245
1246 return e.complexity.LabelChangeResult.Label(childComplexity), true
1247
1248 case "LabelChangeResult.status":
1249 if e.complexity.LabelChangeResult.Status == nil {
1250 break
1251 }
1252
1253 return e.complexity.LabelChangeResult.Status(childComplexity), true
1254
1255 case "LabelChangeTimelineItem.added":
1256 if e.complexity.LabelChangeTimelineItem.Added == nil {
1257 break
1258 }
1259
1260 return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
1261
1262 case "LabelChangeTimelineItem.author":
1263 if e.complexity.LabelChangeTimelineItem.Author == nil {
1264 break
1265 }
1266
1267 return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
1268
1269 case "LabelChangeTimelineItem.date":
1270 if e.complexity.LabelChangeTimelineItem.Date == nil {
1271 break
1272 }
1273
1274 return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
1275
1276 case "LabelChangeTimelineItem.id":
1277 if e.complexity.LabelChangeTimelineItem.ID == nil {
1278 break
1279 }
1280
1281 return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
1282
1283 case "LabelChangeTimelineItem.removed":
1284 if e.complexity.LabelChangeTimelineItem.Removed == nil {
1285 break
1286 }
1287
1288 return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
1289
1290 case "Mutation.addComment":
1291 if e.complexity.Mutation.AddComment == nil {
1292 break
1293 }
1294
1295 args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
1296 if err != nil {
1297 return 0, false
1298 }
1299
1300 return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
1301
1302 case "Mutation.changeLabels":
1303 if e.complexity.Mutation.ChangeLabels == nil {
1304 break
1305 }
1306
1307 args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
1308 if err != nil {
1309 return 0, false
1310 }
1311
1312 return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
1313
1314 case "Mutation.closeBug":
1315 if e.complexity.Mutation.CloseBug == nil {
1316 break
1317 }
1318
1319 args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
1320 if err != nil {
1321 return 0, false
1322 }
1323
1324 return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
1325
1326 case "Mutation.commit":
1327 if e.complexity.Mutation.Commit == nil {
1328 break
1329 }
1330
1331 args, err := ec.field_Mutation_commit_args(context.TODO(), rawArgs)
1332 if err != nil {
1333 return 0, false
1334 }
1335
1336 return e.complexity.Mutation.Commit(childComplexity, args["input"].(models.CommitInput)), true
1337
1338 case "Mutation.commitAsNeeded":
1339 if e.complexity.Mutation.CommitAsNeeded == nil {
1340 break
1341 }
1342
1343 args, err := ec.field_Mutation_commitAsNeeded_args(context.TODO(), rawArgs)
1344 if err != nil {
1345 return 0, false
1346 }
1347
1348 return e.complexity.Mutation.CommitAsNeeded(childComplexity, args["input"].(models.CommitAsNeededInput)), true
1349
1350 case "Mutation.newBug":
1351 if e.complexity.Mutation.NewBug == nil {
1352 break
1353 }
1354
1355 args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
1356 if err != nil {
1357 return 0, false
1358 }
1359
1360 return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
1361
1362 case "Mutation.openBug":
1363 if e.complexity.Mutation.OpenBug == nil {
1364 break
1365 }
1366
1367 args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
1368 if err != nil {
1369 return 0, false
1370 }
1371
1372 return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
1373
1374 case "Mutation.setTitle":
1375 if e.complexity.Mutation.SetTitle == nil {
1376 break
1377 }
1378
1379 args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
1380 if err != nil {
1381 return 0, false
1382 }
1383
1384 return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
1385
1386 case "NewBugPayload.bug":
1387 if e.complexity.NewBugPayload.Bug == nil {
1388 break
1389 }
1390
1391 return e.complexity.NewBugPayload.Bug(childComplexity), true
1392
1393 case "NewBugPayload.clientMutationId":
1394 if e.complexity.NewBugPayload.ClientMutationID == nil {
1395 break
1396 }
1397
1398 return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
1399
1400 case "NewBugPayload.operation":
1401 if e.complexity.NewBugPayload.Operation == nil {
1402 break
1403 }
1404
1405 return e.complexity.NewBugPayload.Operation(childComplexity), true
1406
1407 case "OpenBugPayload.bug":
1408 if e.complexity.OpenBugPayload.Bug == nil {
1409 break
1410 }
1411
1412 return e.complexity.OpenBugPayload.Bug(childComplexity), true
1413
1414 case "OpenBugPayload.clientMutationId":
1415 if e.complexity.OpenBugPayload.ClientMutationID == nil {
1416 break
1417 }
1418
1419 return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
1420
1421 case "OpenBugPayload.operation":
1422 if e.complexity.OpenBugPayload.Operation == nil {
1423 break
1424 }
1425
1426 return e.complexity.OpenBugPayload.Operation(childComplexity), true
1427
1428 case "OperationConnection.edges":
1429 if e.complexity.OperationConnection.Edges == nil {
1430 break
1431 }
1432
1433 return e.complexity.OperationConnection.Edges(childComplexity), true
1434
1435 case "OperationConnection.nodes":
1436 if e.complexity.OperationConnection.Nodes == nil {
1437 break
1438 }
1439
1440 return e.complexity.OperationConnection.Nodes(childComplexity), true
1441
1442 case "OperationConnection.pageInfo":
1443 if e.complexity.OperationConnection.PageInfo == nil {
1444 break
1445 }
1446
1447 return e.complexity.OperationConnection.PageInfo(childComplexity), true
1448
1449 case "OperationConnection.totalCount":
1450 if e.complexity.OperationConnection.TotalCount == nil {
1451 break
1452 }
1453
1454 return e.complexity.OperationConnection.TotalCount(childComplexity), true
1455
1456 case "OperationEdge.cursor":
1457 if e.complexity.OperationEdge.Cursor == nil {
1458 break
1459 }
1460
1461 return e.complexity.OperationEdge.Cursor(childComplexity), true
1462
1463 case "OperationEdge.node":
1464 if e.complexity.OperationEdge.Node == nil {
1465 break
1466 }
1467
1468 return e.complexity.OperationEdge.Node(childComplexity), true
1469
1470 case "PageInfo.endCursor":
1471 if e.complexity.PageInfo.EndCursor == nil {
1472 break
1473 }
1474
1475 return e.complexity.PageInfo.EndCursor(childComplexity), true
1476
1477 case "PageInfo.hasNextPage":
1478 if e.complexity.PageInfo.HasNextPage == nil {
1479 break
1480 }
1481
1482 return e.complexity.PageInfo.HasNextPage(childComplexity), true
1483
1484 case "PageInfo.hasPreviousPage":
1485 if e.complexity.PageInfo.HasPreviousPage == nil {
1486 break
1487 }
1488
1489 return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1490
1491 case "PageInfo.startCursor":
1492 if e.complexity.PageInfo.StartCursor == nil {
1493 break
1494 }
1495
1496 return e.complexity.PageInfo.StartCursor(childComplexity), true
1497
1498 case "Query.defaultRepository":
1499 if e.complexity.Query.DefaultRepository == nil {
1500 break
1501 }
1502
1503 return e.complexity.Query.DefaultRepository(childComplexity), true
1504
1505 case "Query.repository":
1506 if e.complexity.Query.Repository == nil {
1507 break
1508 }
1509
1510 args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
1511 if err != nil {
1512 return 0, false
1513 }
1514
1515 return e.complexity.Query.Repository(childComplexity, args["ref"].(string)), true
1516
1517 case "Repository.allBugs":
1518 if e.complexity.Repository.AllBugs == nil {
1519 break
1520 }
1521
1522 args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
1523 if err != nil {
1524 return 0, false
1525 }
1526
1527 return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1528
1529 case "Repository.allIdentities":
1530 if e.complexity.Repository.AllIdentities == nil {
1531 break
1532 }
1533
1534 args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
1535 if err != nil {
1536 return 0, false
1537 }
1538
1539 return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1540
1541 case "Repository.bug":
1542 if e.complexity.Repository.Bug == nil {
1543 break
1544 }
1545
1546 args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
1547 if err != nil {
1548 return 0, false
1549 }
1550
1551 return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1552
1553 case "Repository.identity":
1554 if e.complexity.Repository.Identity == nil {
1555 break
1556 }
1557
1558 args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
1559 if err != nil {
1560 return 0, false
1561 }
1562
1563 return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
1564
1565 case "Repository.userIdentity":
1566 if e.complexity.Repository.UserIdentity == nil {
1567 break
1568 }
1569
1570 return e.complexity.Repository.UserIdentity(childComplexity), true
1571
1572 case "Repository.validLabels":
1573 if e.complexity.Repository.ValidLabels == nil {
1574 break
1575 }
1576
1577 return e.complexity.Repository.ValidLabels(childComplexity), true
1578
1579 case "SetStatusOperation.author":
1580 if e.complexity.SetStatusOperation.Author == nil {
1581 break
1582 }
1583
1584 return e.complexity.SetStatusOperation.Author(childComplexity), true
1585
1586 case "SetStatusOperation.date":
1587 if e.complexity.SetStatusOperation.Date == nil {
1588 break
1589 }
1590
1591 return e.complexity.SetStatusOperation.Date(childComplexity), true
1592
1593 case "SetStatusOperation.id":
1594 if e.complexity.SetStatusOperation.ID == nil {
1595 break
1596 }
1597
1598 return e.complexity.SetStatusOperation.ID(childComplexity), true
1599
1600 case "SetStatusOperation.status":
1601 if e.complexity.SetStatusOperation.Status == nil {
1602 break
1603 }
1604
1605 return e.complexity.SetStatusOperation.Status(childComplexity), true
1606
1607 case "SetStatusTimelineItem.author":
1608 if e.complexity.SetStatusTimelineItem.Author == nil {
1609 break
1610 }
1611
1612 return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
1613
1614 case "SetStatusTimelineItem.date":
1615 if e.complexity.SetStatusTimelineItem.Date == nil {
1616 break
1617 }
1618
1619 return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
1620
1621 case "SetStatusTimelineItem.id":
1622 if e.complexity.SetStatusTimelineItem.ID == nil {
1623 break
1624 }
1625
1626 return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
1627
1628 case "SetStatusTimelineItem.status":
1629 if e.complexity.SetStatusTimelineItem.Status == nil {
1630 break
1631 }
1632
1633 return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
1634
1635 case "SetTitleOperation.author":
1636 if e.complexity.SetTitleOperation.Author == nil {
1637 break
1638 }
1639
1640 return e.complexity.SetTitleOperation.Author(childComplexity), true
1641
1642 case "SetTitleOperation.date":
1643 if e.complexity.SetTitleOperation.Date == nil {
1644 break
1645 }
1646
1647 return e.complexity.SetTitleOperation.Date(childComplexity), true
1648
1649 case "SetTitleOperation.id":
1650 if e.complexity.SetTitleOperation.ID == nil {
1651 break
1652 }
1653
1654 return e.complexity.SetTitleOperation.ID(childComplexity), true
1655
1656 case "SetTitleOperation.title":
1657 if e.complexity.SetTitleOperation.Title == nil {
1658 break
1659 }
1660
1661 return e.complexity.SetTitleOperation.Title(childComplexity), true
1662
1663 case "SetTitleOperation.was":
1664 if e.complexity.SetTitleOperation.Was == nil {
1665 break
1666 }
1667
1668 return e.complexity.SetTitleOperation.Was(childComplexity), true
1669
1670 case "SetTitlePayload.bug":
1671 if e.complexity.SetTitlePayload.Bug == nil {
1672 break
1673 }
1674
1675 return e.complexity.SetTitlePayload.Bug(childComplexity), true
1676
1677 case "SetTitlePayload.clientMutationId":
1678 if e.complexity.SetTitlePayload.ClientMutationID == nil {
1679 break
1680 }
1681
1682 return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
1683
1684 case "SetTitlePayload.operation":
1685 if e.complexity.SetTitlePayload.Operation == nil {
1686 break
1687 }
1688
1689 return e.complexity.SetTitlePayload.Operation(childComplexity), true
1690
1691 case "SetTitleTimelineItem.author":
1692 if e.complexity.SetTitleTimelineItem.Author == nil {
1693 break
1694 }
1695
1696 return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
1697
1698 case "SetTitleTimelineItem.date":
1699 if e.complexity.SetTitleTimelineItem.Date == nil {
1700 break
1701 }
1702
1703 return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
1704
1705 case "SetTitleTimelineItem.id":
1706 if e.complexity.SetTitleTimelineItem.ID == nil {
1707 break
1708 }
1709
1710 return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
1711
1712 case "SetTitleTimelineItem.title":
1713 if e.complexity.SetTitleTimelineItem.Title == nil {
1714 break
1715 }
1716
1717 return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
1718
1719 case "SetTitleTimelineItem.was":
1720 if e.complexity.SetTitleTimelineItem.Was == nil {
1721 break
1722 }
1723
1724 return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
1725
1726 case "TimelineItemConnection.edges":
1727 if e.complexity.TimelineItemConnection.Edges == nil {
1728 break
1729 }
1730
1731 return e.complexity.TimelineItemConnection.Edges(childComplexity), true
1732
1733 case "TimelineItemConnection.nodes":
1734 if e.complexity.TimelineItemConnection.Nodes == nil {
1735 break
1736 }
1737
1738 return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
1739
1740 case "TimelineItemConnection.pageInfo":
1741 if e.complexity.TimelineItemConnection.PageInfo == nil {
1742 break
1743 }
1744
1745 return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
1746
1747 case "TimelineItemConnection.totalCount":
1748 if e.complexity.TimelineItemConnection.TotalCount == nil {
1749 break
1750 }
1751
1752 return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
1753
1754 case "TimelineItemEdge.cursor":
1755 if e.complexity.TimelineItemEdge.Cursor == nil {
1756 break
1757 }
1758
1759 return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
1760
1761 case "TimelineItemEdge.node":
1762 if e.complexity.TimelineItemEdge.Node == nil {
1763 break
1764 }
1765
1766 return e.complexity.TimelineItemEdge.Node(childComplexity), true
1767
1768 }
1769 return 0, false
1770}
1771
1772func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
1773 ec := executionContext{graphql.GetRequestContext(ctx), e}
1774
1775 buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
1776 data := ec._Query(ctx, op.SelectionSet)
1777 var buf bytes.Buffer
1778 data.MarshalGQL(&buf)
1779 return buf.Bytes()
1780 })
1781
1782 return &graphql.Response{
1783 Data: buf,
1784 Errors: ec.Errors,
1785 Extensions: ec.Extensions,
1786 }
1787}
1788
1789func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
1790 ec := executionContext{graphql.GetRequestContext(ctx), e}
1791
1792 buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
1793 data := ec._Mutation(ctx, op.SelectionSet)
1794 var buf bytes.Buffer
1795 data.MarshalGQL(&buf)
1796 return buf.Bytes()
1797 })
1798
1799 return &graphql.Response{
1800 Data: buf,
1801 Errors: ec.Errors,
1802 Extensions: ec.Extensions,
1803 }
1804}
1805
1806func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
1807 return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
1808}
1809
1810type executionContext struct {
1811 *graphql.RequestContext
1812 *executableSchema
1813}
1814
1815func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
1816 if ec.DisableIntrospection {
1817 return nil, errors.New("introspection disabled")
1818 }
1819 return introspection.WrapSchema(parsedSchema), nil
1820}
1821
1822func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
1823 if ec.DisableIntrospection {
1824 return nil, errors.New("introspection disabled")
1825 }
1826 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
1827}
1828
1829var parsedSchema = gqlparser.MustLoadSchema(
1830 &ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
1831type Comment implements Authored {
1832 """The author of this comment."""
1833 author: Identity!
1834
1835 """The message of this comment."""
1836 message: String!
1837
1838 """All media's hash referenced in this comment"""
1839 files: [Hash!]!
1840}
1841
1842type CommentConnection {
1843 edges: [CommentEdge!]!
1844 nodes: [Comment!]!
1845 pageInfo: PageInfo!
1846 totalCount: Int!
1847}
1848
1849type CommentEdge {
1850 cursor: String!
1851 node: Comment!
1852}
1853
1854enum Status {
1855 OPEN
1856 CLOSED
1857}
1858
1859type Bug implements Authored {
1860 """The identifier for this bug"""
1861 id: String!
1862 """The human version (truncated) identifier for this bug"""
1863 humanId: String!
1864 status: Status!
1865 title: String!
1866 labels: [Label!]!
1867 author: Identity!
1868 createdAt: Time!
1869 lastEdit: Time!
1870
1871 """The actors of the bug. Actors are Identity that have interacted with the bug."""
1872 actors(
1873 """Returns the elements in the list that come after the specified cursor."""
1874 after: String
1875 """Returns the elements in the list that come before the specified cursor."""
1876 before: String
1877 """Returns the first _n_ elements from the list."""
1878 first: Int
1879 """Returns the last _n_ elements from the list."""
1880 last: Int
1881 ): IdentityConnection!
1882
1883 """The participants of the bug. Participants are Identity that have created or
1884 added a comment on the bug."""
1885 participants(
1886 """Returns the elements in the list that come after the specified cursor."""
1887 after: String
1888 """Returns the elements in the list that come before the specified cursor."""
1889 before: String
1890 """Returns the first _n_ elements from the list."""
1891 first: Int
1892 """Returns the last _n_ elements from the list."""
1893 last: Int
1894 ): IdentityConnection!
1895
1896 comments(
1897 """Returns the elements in the list that come after the specified cursor."""
1898 after: String
1899 """Returns the elements in the list that come before the specified cursor."""
1900 before: String
1901 """Returns the first _n_ elements from the list."""
1902 first: Int
1903 """Returns the last _n_ elements from the list."""
1904 last: Int
1905 ): CommentConnection!
1906
1907 timeline(
1908 """Returns the elements in the list that come after the specified cursor."""
1909 after: String
1910 """Returns the elements in the list that come before the specified cursor."""
1911 before: String
1912 """Returns the first _n_ elements from the list."""
1913 first: Int
1914 """Returns the last _n_ elements from the list."""
1915 last: Int
1916 ): TimelineItemConnection!
1917
1918 operations(
1919 """Returns the elements in the list that come after the specified cursor."""
1920 after: String
1921 """Returns the elements in the list that come before the specified cursor."""
1922 before: String
1923 """Returns the first _n_ elements from the list."""
1924 first: Int
1925 """Returns the last _n_ elements from the list."""
1926 last: Int
1927 ): OperationConnection!
1928}
1929
1930"""The connection type for Bug."""
1931type BugConnection {
1932 """A list of edges."""
1933 edges: [BugEdge!]!
1934 nodes: [Bug!]!
1935 """Information to aid in pagination."""
1936 pageInfo: PageInfo!
1937 """Identifies the total count of items in the connection."""
1938 totalCount: Int!
1939}
1940
1941"""An edge in a connection."""
1942type BugEdge {
1943 """A cursor for use in pagination."""
1944 cursor: String!
1945 """The item at the end of the edge."""
1946 node: Bug!
1947}
1948`},
1949 &ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
1950type Identity {
1951 """The identifier for this identity"""
1952 id: String!
1953 """The human version (truncated) identifier for this identity"""
1954 humanId: String!
1955 """The name of the person, if known."""
1956 name: String
1957 """The email of the person, if known."""
1958 email: String
1959 """The login of the person, if known."""
1960 login: String
1961 """A string containing the either the name of the person, its login or both"""
1962 displayName: String!
1963 """An url to an avatar"""
1964 avatarUrl: String
1965 """isProtected is true if the chain of git commits started to be signed.
1966 If that's the case, only signed commit with a valid key for this identity can be added."""
1967 isProtected: Boolean!
1968}
1969
1970type IdentityConnection {
1971 edges: [IdentityEdge!]!
1972 nodes: [Identity!]!
1973 pageInfo: PageInfo!
1974 totalCount: Int!
1975}
1976
1977type IdentityEdge {
1978 cursor: String!
1979 node: Identity!
1980}`},
1981 &ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
1982 """A unique identifier for the client performing the mutation."""
1983 clientMutationId: String
1984 """"The name of the repository. If not set, the default repository is used."""
1985 repoRef: String
1986 """The title of the new bug."""
1987 title: String!
1988 """The first message of the new bug."""
1989 message: String!
1990 """The collection of file's hash required for the first message."""
1991 files: [Hash!]
1992}
1993
1994type NewBugPayload {
1995 """A unique identifier for the client performing the mutation."""
1996 clientMutationId: String
1997 """The created bug."""
1998 bug: Bug!
1999 """The resulting operation."""
2000 operation: CreateOperation!
2001}
2002
2003input AddCommentInput {
2004 """A unique identifier for the client performing the mutation."""
2005 clientMutationId: String
2006 """"The name of the repository. If not set, the default repository is used."""
2007 repoRef: String
2008 """The bug ID's prefix."""
2009 prefix: String!
2010 """The first message of the new bug."""
2011 message: String!
2012 """The collection of file's hash required for the first message."""
2013 files: [Hash!]
2014}
2015
2016type AddCommentPayload {
2017 """A unique identifier for the client performing the mutation."""
2018 clientMutationId: String
2019 """The affected bug."""
2020 bug: Bug!
2021 """The resulting operation."""
2022 operation: AddCommentOperation!
2023}
2024
2025input ChangeLabelInput {
2026 """A unique identifier for the client performing the mutation."""
2027 clientMutationId: String
2028 """"The name of the repository. If not set, the default repository is used."""
2029 repoRef: String
2030 """The bug ID's prefix."""
2031 prefix: String!
2032 """The list of label to add."""
2033 added: [String!]
2034 """The list of label to remove."""
2035 Removed: [String!]
2036}
2037
2038enum LabelChangeStatus {
2039 ADDED
2040 REMOVED
2041 DUPLICATE_IN_OP
2042 ALREADY_EXIST
2043 DOESNT_EXIST
2044}
2045
2046type LabelChangeResult {
2047 """The source label."""
2048 label: Label!
2049 """The effect this label had."""
2050 status: LabelChangeStatus!
2051}
2052
2053type ChangeLabelPayload {
2054 """A unique identifier for the client performing the mutation."""
2055 clientMutationId: String
2056 """The affected bug."""
2057 bug: Bug!
2058 """The resulting operation."""
2059 operation: LabelChangeOperation!
2060 """The effect each source label had."""
2061 results: [LabelChangeResult]!
2062}
2063
2064input OpenBugInput {
2065 """A unique identifier for the client performing the mutation."""
2066 clientMutationId: String
2067 """"The name of the repository. If not set, the default repository is used."""
2068 repoRef: String
2069 """The bug ID's prefix."""
2070 prefix: String!
2071}
2072
2073type OpenBugPayload {
2074 """A unique identifier for the client performing the mutation."""
2075 clientMutationId: String
2076 """The affected bug."""
2077 bug: Bug!
2078 """The resulting operation."""
2079 operation: SetStatusOperation!
2080}
2081
2082input CloseBugInput {
2083 """A unique identifier for the client performing the mutation."""
2084 clientMutationId: String
2085 """"The name of the repository. If not set, the default repository is used."""
2086 repoRef: String
2087 """The bug ID's prefix."""
2088 prefix: String!
2089}
2090
2091type CloseBugPayload {
2092 """A unique identifier for the client performing the mutation."""
2093 clientMutationId: String
2094 """The affected bug."""
2095 bug: Bug!
2096 """The resulting operation."""
2097 operation: SetStatusOperation!
2098}
2099
2100input SetTitleInput {
2101 """A unique identifier for the client performing the mutation."""
2102 clientMutationId: String
2103 """"The name of the repository. If not set, the default repository is used."""
2104 repoRef: String
2105 """The bug ID's prefix."""
2106 prefix: String!
2107 """The new title."""
2108 title: String!
2109}
2110
2111type SetTitlePayload {
2112 """A unique identifier for the client performing the mutation."""
2113 clientMutationId: String
2114 """The affected bug."""
2115 bug: Bug!
2116 """The resulting operation"""
2117 operation: SetTitleOperation!
2118}
2119
2120input CommitInput {
2121 """A unique identifier for the client performing the mutation."""
2122 clientMutationId: String
2123 """"The name of the repository. If not set, the default repository is used."""
2124 repoRef: String
2125 """The bug ID's prefix."""
2126 prefix: String!
2127}
2128
2129type CommitPayload {
2130 """A unique identifier for the client performing the mutation."""
2131 clientMutationId: String
2132 """The affected bug."""
2133 bug: Bug!
2134}
2135
2136input CommitAsNeededInput {
2137 """A unique identifier for the client performing the mutation."""
2138 clientMutationId: String
2139 """"The name of the repository. If not set, the default repository is used."""
2140 repoRef: String
2141 """The bug ID's prefix."""
2142 prefix: String!
2143}
2144
2145type CommitAsNeededPayload {
2146 """A unique identifier for the client performing the mutation."""
2147 clientMutationId: String
2148 """The affected bug."""
2149 bug: Bug!
2150}
2151`},
2152 &ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
2153interface Operation {
2154 """The identifier of the operation"""
2155 id: String!
2156 """The operations author."""
2157 author: Identity!
2158 """The datetime when this operation was issued."""
2159 date: Time!
2160}
2161
2162# Connection
2163
2164"""The connection type for an Operation"""
2165type OperationConnection {
2166 edges: [OperationEdge!]!
2167 nodes: [Operation!]!
2168 pageInfo: PageInfo!
2169 totalCount: Int!
2170}
2171
2172"""Represent an Operation"""
2173type OperationEdge {
2174 cursor: String!
2175 node: Operation!
2176}
2177
2178# Operations
2179
2180type CreateOperation implements Operation & Authored {
2181 """The identifier of the operation"""
2182 id: String!
2183 """The author of this object."""
2184 author: Identity!
2185 """The datetime when this operation was issued."""
2186 date: Time!
2187
2188 title: String!
2189 message: String!
2190 files: [Hash!]!
2191}
2192
2193type SetTitleOperation implements Operation & Authored {
2194 """The identifier of the operation"""
2195 id: String!
2196 """The author of this object."""
2197 author: Identity!
2198 """The datetime when this operation was issued."""
2199 date: Time!
2200
2201 title: String!
2202 was: String!
2203}
2204
2205type AddCommentOperation implements Operation & Authored {
2206 """The identifier of the operation"""
2207 id: String!
2208 """The author of this object."""
2209 author: Identity!
2210 """The datetime when this operation was issued."""
2211 date: Time!
2212
2213 message: String!
2214 files: [Hash!]!
2215}
2216
2217type EditCommentOperation implements Operation & Authored {
2218 """The identifier of the operation"""
2219 id: String!
2220 """The author of this object."""
2221 author: Identity!
2222 """The datetime when this operation was issued."""
2223 date: Time!
2224
2225 target: String!
2226 message: String!
2227 files: [Hash!]!
2228}
2229
2230type SetStatusOperation implements Operation & Authored {
2231 """The identifier of the operation"""
2232 id: String!
2233 """The author of this object."""
2234 author: Identity!
2235 """The datetime when this operation was issued."""
2236 date: Time!
2237
2238 status: Status!
2239}
2240
2241type LabelChangeOperation implements Operation & Authored {
2242 """The identifier of the operation"""
2243 id: String!
2244 """The author of this object."""
2245 author: Identity!
2246 """The datetime when this operation was issued."""
2247 date: Time!
2248
2249 added: [Label!]!
2250 removed: [Label!]!
2251}
2252`},
2253 &ast.Source{Name: "schema/repository.graphql", Input: `
2254type Repository {
2255 """All the bugs"""
2256 allBugs(
2257 """Returns the elements in the list that come after the specified cursor."""
2258 after: String
2259 """Returns the elements in the list that come before the specified cursor."""
2260 before: String
2261 """Returns the first _n_ elements from the list."""
2262 first: Int
2263 """Returns the last _n_ elements from the list."""
2264 last: Int
2265 """A query to select and order bugs"""
2266 query: String
2267 ): BugConnection!
2268
2269 bug(prefix: String!): Bug
2270
2271 """All the identities"""
2272 allIdentities(
2273 """Returns the elements in the list that come after the specified cursor."""
2274 after: String
2275 """Returns the elements in the list that come before the specified cursor."""
2276 before: String
2277 """Returns the first _n_ elements from the list."""
2278 first: Int
2279 """Returns the last _n_ elements from the list."""
2280 last: Int
2281 ): IdentityConnection!
2282
2283 identity(prefix: String!): Identity
2284
2285 """The identity created or selected by the user as its own"""
2286 userIdentity: Identity
2287
2288 """List of valid labels."""
2289 validLabels: [Label!]!
2290}`},
2291 &ast.Source{Name: "schema/root.graphql", Input: `type Query {
2292 """The default unnamend repository."""
2293 defaultRepository: Repository
2294 """Access a repository by reference/name."""
2295 repository(ref: String!): Repository
2296}
2297
2298type Mutation {
2299 """Create a new bug"""
2300 newBug(input: NewBugInput!): NewBugPayload!
2301 """Add a new comment to a bug"""
2302 addComment(input: AddCommentInput!): AddCommentPayload!
2303 """Add or remove a set of label on a bug"""
2304 changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
2305 """Change a bug's status to open"""
2306 openBug(input: OpenBugInput!): OpenBugPayload!
2307 """Change a bug's status to closed"""
2308 closeBug(input: CloseBugInput!): CloseBugPayload!
2309 """Change a bug's title"""
2310 setTitle(input: SetTitleInput!): SetTitlePayload!
2311 """Commit write the pending operations into storage. This mutation fail if nothing is pending"""
2312 commit(input: CommitInput!): CommitPayload!
2313 """Commit write the pending operations into storage. This mutation succed if nothing is pending"""
2314 commitAsNeeded(input: CommitAsNeededInput!): CommitAsNeededPayload!
2315}
2316`},
2317 &ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
2318interface TimelineItem {
2319 """The identifier of the source operation"""
2320 id: String!
2321}
2322
2323"""CommentHistoryStep hold one version of a message in the history"""
2324type CommentHistoryStep {
2325 message: String!
2326 date: Time!
2327}
2328
2329# Connection
2330
2331"""The connection type for TimelineItem"""
2332type TimelineItemConnection {
2333 edges: [TimelineItemEdge!]!
2334 nodes: [TimelineItem!]!
2335 pageInfo: PageInfo!
2336 totalCount: Int!
2337}
2338
2339"""Represent a TimelineItem"""
2340type TimelineItemEdge {
2341 cursor: String!
2342 node: TimelineItem!
2343}
2344
2345# Items
2346
2347"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
2348type CreateTimelineItem implements TimelineItem & Authored {
2349 """The identifier of the source operation"""
2350 id: String!
2351 author: Identity!
2352 message: String!
2353 messageIsEmpty: Boolean!
2354 files: [Hash!]!
2355 createdAt: Time!
2356 lastEdit: Time!
2357 edited: Boolean!
2358 history: [CommentHistoryStep!]!
2359}
2360
2361"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
2362type AddCommentTimelineItem implements TimelineItem & Authored {
2363 """The identifier of the source operation"""
2364 id: String!
2365 author: Identity!
2366 message: String!
2367 messageIsEmpty: Boolean!
2368 files: [Hash!]!
2369 createdAt: Time!
2370 lastEdit: Time!
2371 edited: Boolean!
2372 history: [CommentHistoryStep!]!
2373}
2374
2375"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
2376type LabelChangeTimelineItem implements TimelineItem & Authored {
2377 """The identifier of the source operation"""
2378 id: String!
2379 author: Identity!
2380 date: Time!
2381 added: [Label!]!
2382 removed: [Label!]!
2383}
2384
2385"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
2386type SetStatusTimelineItem implements TimelineItem & Authored {
2387 """The identifier of the source operation"""
2388 id: String!
2389 author: Identity!
2390 date: Time!
2391 status: Status!
2392}
2393
2394"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
2395type SetTitleTimelineItem implements TimelineItem & Authored {
2396 """The identifier of the source operation"""
2397 id: String!
2398 author: Identity!
2399 date: Time!
2400 title: String!
2401 was: String!
2402}
2403`},
2404 &ast.Source{Name: "schema/types.graphql", Input: `scalar Time
2405scalar Hash
2406
2407"""Defines a color by red, green and blue components."""
2408type Color {
2409 """Red component of the color."""
2410 R: Int!
2411 """Green component of the color."""
2412 G: Int!
2413 """Blue component of the color."""
2414 B: Int!
2415}
2416
2417"""Label for a bug."""
2418type Label {
2419 """The name of the label."""
2420 name: String!
2421 """Color of the label."""
2422 color: Color!
2423}
2424
2425"""Information about pagination in a connection."""
2426type PageInfo {
2427 """When paginating forwards, are there more items?"""
2428 hasNextPage: Boolean!
2429 """When paginating backwards, are there more items?"""
2430 hasPreviousPage: Boolean!
2431 """When paginating backwards, the cursor to continue."""
2432 startCursor: String!
2433 """When paginating forwards, the cursor to continue."""
2434 endCursor: String!
2435}
2436
2437"""An object that has an author."""
2438interface Authored {
2439 """The author of this object."""
2440 author: Identity!
2441}
2442`},
2443)
2444
2445// endregion ************************** generated!.gotpl **************************
2446
2447// region ***************************** args.gotpl *****************************
2448
2449func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2450 var err error
2451 args := map[string]interface{}{}
2452 var arg0 *string
2453 if tmp, ok := rawArgs["after"]; ok {
2454 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2455 if err != nil {
2456 return nil, err
2457 }
2458 }
2459 args["after"] = arg0
2460 var arg1 *string
2461 if tmp, ok := rawArgs["before"]; ok {
2462 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2463 if err != nil {
2464 return nil, err
2465 }
2466 }
2467 args["before"] = arg1
2468 var arg2 *int
2469 if tmp, ok := rawArgs["first"]; ok {
2470 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2471 if err != nil {
2472 return nil, err
2473 }
2474 }
2475 args["first"] = arg2
2476 var arg3 *int
2477 if tmp, ok := rawArgs["last"]; ok {
2478 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2479 if err != nil {
2480 return nil, err
2481 }
2482 }
2483 args["last"] = arg3
2484 return args, nil
2485}
2486
2487func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2488 var err error
2489 args := map[string]interface{}{}
2490 var arg0 *string
2491 if tmp, ok := rawArgs["after"]; ok {
2492 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2493 if err != nil {
2494 return nil, err
2495 }
2496 }
2497 args["after"] = arg0
2498 var arg1 *string
2499 if tmp, ok := rawArgs["before"]; ok {
2500 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2501 if err != nil {
2502 return nil, err
2503 }
2504 }
2505 args["before"] = arg1
2506 var arg2 *int
2507 if tmp, ok := rawArgs["first"]; ok {
2508 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2509 if err != nil {
2510 return nil, err
2511 }
2512 }
2513 args["first"] = arg2
2514 var arg3 *int
2515 if tmp, ok := rawArgs["last"]; ok {
2516 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2517 if err != nil {
2518 return nil, err
2519 }
2520 }
2521 args["last"] = arg3
2522 return args, nil
2523}
2524
2525func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2526 var err error
2527 args := map[string]interface{}{}
2528 var arg0 *string
2529 if tmp, ok := rawArgs["after"]; ok {
2530 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2531 if err != nil {
2532 return nil, err
2533 }
2534 }
2535 args["after"] = arg0
2536 var arg1 *string
2537 if tmp, ok := rawArgs["before"]; ok {
2538 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2539 if err != nil {
2540 return nil, err
2541 }
2542 }
2543 args["before"] = arg1
2544 var arg2 *int
2545 if tmp, ok := rawArgs["first"]; ok {
2546 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2547 if err != nil {
2548 return nil, err
2549 }
2550 }
2551 args["first"] = arg2
2552 var arg3 *int
2553 if tmp, ok := rawArgs["last"]; ok {
2554 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2555 if err != nil {
2556 return nil, err
2557 }
2558 }
2559 args["last"] = arg3
2560 return args, nil
2561}
2562
2563func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2564 var err error
2565 args := map[string]interface{}{}
2566 var arg0 *string
2567 if tmp, ok := rawArgs["after"]; ok {
2568 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2569 if err != nil {
2570 return nil, err
2571 }
2572 }
2573 args["after"] = arg0
2574 var arg1 *string
2575 if tmp, ok := rawArgs["before"]; ok {
2576 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2577 if err != nil {
2578 return nil, err
2579 }
2580 }
2581 args["before"] = arg1
2582 var arg2 *int
2583 if tmp, ok := rawArgs["first"]; ok {
2584 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2585 if err != nil {
2586 return nil, err
2587 }
2588 }
2589 args["first"] = arg2
2590 var arg3 *int
2591 if tmp, ok := rawArgs["last"]; ok {
2592 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2593 if err != nil {
2594 return nil, err
2595 }
2596 }
2597 args["last"] = arg3
2598 return args, nil
2599}
2600
2601func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2602 var err error
2603 args := map[string]interface{}{}
2604 var arg0 *string
2605 if tmp, ok := rawArgs["after"]; ok {
2606 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2607 if err != nil {
2608 return nil, err
2609 }
2610 }
2611 args["after"] = arg0
2612 var arg1 *string
2613 if tmp, ok := rawArgs["before"]; ok {
2614 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2615 if err != nil {
2616 return nil, err
2617 }
2618 }
2619 args["before"] = arg1
2620 var arg2 *int
2621 if tmp, ok := rawArgs["first"]; ok {
2622 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2623 if err != nil {
2624 return nil, err
2625 }
2626 }
2627 args["first"] = arg2
2628 var arg3 *int
2629 if tmp, ok := rawArgs["last"]; ok {
2630 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2631 if err != nil {
2632 return nil, err
2633 }
2634 }
2635 args["last"] = arg3
2636 return args, nil
2637}
2638
2639func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2640 var err error
2641 args := map[string]interface{}{}
2642 var arg0 models.AddCommentInput
2643 if tmp, ok := rawArgs["input"]; ok {
2644 arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
2645 if err != nil {
2646 return nil, err
2647 }
2648 }
2649 args["input"] = arg0
2650 return args, nil
2651}
2652
2653func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2654 var err error
2655 args := map[string]interface{}{}
2656 var arg0 *models.ChangeLabelInput
2657 if tmp, ok := rawArgs["input"]; ok {
2658 arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
2659 if err != nil {
2660 return nil, err
2661 }
2662 }
2663 args["input"] = arg0
2664 return args, nil
2665}
2666
2667func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2668 var err error
2669 args := map[string]interface{}{}
2670 var arg0 models.CloseBugInput
2671 if tmp, ok := rawArgs["input"]; ok {
2672 arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
2673 if err != nil {
2674 return nil, err
2675 }
2676 }
2677 args["input"] = arg0
2678 return args, nil
2679}
2680
2681func (ec *executionContext) field_Mutation_commitAsNeeded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2682 var err error
2683 args := map[string]interface{}{}
2684 var arg0 models.CommitAsNeededInput
2685 if tmp, ok := rawArgs["input"]; ok {
2686 arg0, err = ec.unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx, tmp)
2687 if err != nil {
2688 return nil, err
2689 }
2690 }
2691 args["input"] = arg0
2692 return args, nil
2693}
2694
2695func (ec *executionContext) field_Mutation_commit_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2696 var err error
2697 args := map[string]interface{}{}
2698 var arg0 models.CommitInput
2699 if tmp, ok := rawArgs["input"]; ok {
2700 arg0, err = ec.unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx, tmp)
2701 if err != nil {
2702 return nil, err
2703 }
2704 }
2705 args["input"] = arg0
2706 return args, nil
2707}
2708
2709func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2710 var err error
2711 args := map[string]interface{}{}
2712 var arg0 models.NewBugInput
2713 if tmp, ok := rawArgs["input"]; ok {
2714 arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
2715 if err != nil {
2716 return nil, err
2717 }
2718 }
2719 args["input"] = arg0
2720 return args, nil
2721}
2722
2723func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2724 var err error
2725 args := map[string]interface{}{}
2726 var arg0 models.OpenBugInput
2727 if tmp, ok := rawArgs["input"]; ok {
2728 arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
2729 if err != nil {
2730 return nil, err
2731 }
2732 }
2733 args["input"] = arg0
2734 return args, nil
2735}
2736
2737func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2738 var err error
2739 args := map[string]interface{}{}
2740 var arg0 models.SetTitleInput
2741 if tmp, ok := rawArgs["input"]; ok {
2742 arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
2743 if err != nil {
2744 return nil, err
2745 }
2746 }
2747 args["input"] = arg0
2748 return args, nil
2749}
2750
2751func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2752 var err error
2753 args := map[string]interface{}{}
2754 var arg0 string
2755 if tmp, ok := rawArgs["name"]; ok {
2756 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2757 if err != nil {
2758 return nil, err
2759 }
2760 }
2761 args["name"] = arg0
2762 return args, nil
2763}
2764
2765func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2766 var err error
2767 args := map[string]interface{}{}
2768 var arg0 string
2769 if tmp, ok := rawArgs["ref"]; ok {
2770 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2771 if err != nil {
2772 return nil, err
2773 }
2774 }
2775 args["ref"] = arg0
2776 return args, nil
2777}
2778
2779func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2780 var err error
2781 args := map[string]interface{}{}
2782 var arg0 *string
2783 if tmp, ok := rawArgs["after"]; ok {
2784 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2785 if err != nil {
2786 return nil, err
2787 }
2788 }
2789 args["after"] = arg0
2790 var arg1 *string
2791 if tmp, ok := rawArgs["before"]; ok {
2792 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2793 if err != nil {
2794 return nil, err
2795 }
2796 }
2797 args["before"] = arg1
2798 var arg2 *int
2799 if tmp, ok := rawArgs["first"]; ok {
2800 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2801 if err != nil {
2802 return nil, err
2803 }
2804 }
2805 args["first"] = arg2
2806 var arg3 *int
2807 if tmp, ok := rawArgs["last"]; ok {
2808 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2809 if err != nil {
2810 return nil, err
2811 }
2812 }
2813 args["last"] = arg3
2814 var arg4 *string
2815 if tmp, ok := rawArgs["query"]; ok {
2816 arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2817 if err != nil {
2818 return nil, err
2819 }
2820 }
2821 args["query"] = arg4
2822 return args, nil
2823}
2824
2825func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2826 var err error
2827 args := map[string]interface{}{}
2828 var arg0 *string
2829 if tmp, ok := rawArgs["after"]; ok {
2830 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2831 if err != nil {
2832 return nil, err
2833 }
2834 }
2835 args["after"] = arg0
2836 var arg1 *string
2837 if tmp, ok := rawArgs["before"]; ok {
2838 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2839 if err != nil {
2840 return nil, err
2841 }
2842 }
2843 args["before"] = arg1
2844 var arg2 *int
2845 if tmp, ok := rawArgs["first"]; ok {
2846 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2847 if err != nil {
2848 return nil, err
2849 }
2850 }
2851 args["first"] = arg2
2852 var arg3 *int
2853 if tmp, ok := rawArgs["last"]; ok {
2854 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2855 if err != nil {
2856 return nil, err
2857 }
2858 }
2859 args["last"] = arg3
2860 return args, nil
2861}
2862
2863func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2864 var err error
2865 args := map[string]interface{}{}
2866 var arg0 string
2867 if tmp, ok := rawArgs["prefix"]; ok {
2868 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2869 if err != nil {
2870 return nil, err
2871 }
2872 }
2873 args["prefix"] = arg0
2874 return args, nil
2875}
2876
2877func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2878 var err error
2879 args := map[string]interface{}{}
2880 var arg0 string
2881 if tmp, ok := rawArgs["prefix"]; ok {
2882 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2883 if err != nil {
2884 return nil, err
2885 }
2886 }
2887 args["prefix"] = arg0
2888 return args, nil
2889}
2890
2891func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2892 var err error
2893 args := map[string]interface{}{}
2894 var arg0 bool
2895 if tmp, ok := rawArgs["includeDeprecated"]; ok {
2896 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
2897 if err != nil {
2898 return nil, err
2899 }
2900 }
2901 args["includeDeprecated"] = arg0
2902 return args, nil
2903}
2904
2905func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2906 var err error
2907 args := map[string]interface{}{}
2908 var arg0 bool
2909 if tmp, ok := rawArgs["includeDeprecated"]; ok {
2910 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
2911 if err != nil {
2912 return nil, err
2913 }
2914 }
2915 args["includeDeprecated"] = arg0
2916 return args, nil
2917}
2918
2919// endregion ***************************** args.gotpl *****************************
2920
2921// region ************************** directives.gotpl **************************
2922
2923// endregion ************************** directives.gotpl **************************
2924
2925// region **************************** field.gotpl *****************************
2926
2927func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
2928 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2929 defer func() {
2930 if r := recover(); r != nil {
2931 ec.Error(ctx, ec.Recover(ctx, r))
2932 ret = graphql.Null
2933 }
2934 ec.Tracer.EndFieldExecution(ctx)
2935 }()
2936 rctx := &graphql.ResolverContext{
2937 Object: "AddCommentOperation",
2938 Field: field,
2939 Args: nil,
2940 IsMethod: true,
2941 }
2942 ctx = graphql.WithResolverContext(ctx, rctx)
2943 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2944 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
2945 ctx = rctx // use context from middleware stack in children
2946 return ec.resolvers.AddCommentOperation().ID(rctx, obj)
2947 })
2948 if err != nil {
2949 ec.Error(ctx, err)
2950 return graphql.Null
2951 }
2952 if resTmp == nil {
2953 if !ec.HasError(rctx) {
2954 ec.Errorf(ctx, "must not be null")
2955 }
2956 return graphql.Null
2957 }
2958 res := resTmp.(string)
2959 rctx.Result = res
2960 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2961 return ec.marshalNString2string(ctx, field.Selections, res)
2962}
2963
2964func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
2965 ctx = ec.Tracer.StartFieldExecution(ctx, field)
2966 defer func() {
2967 if r := recover(); r != nil {
2968 ec.Error(ctx, ec.Recover(ctx, r))
2969 ret = graphql.Null
2970 }
2971 ec.Tracer.EndFieldExecution(ctx)
2972 }()
2973 rctx := &graphql.ResolverContext{
2974 Object: "AddCommentOperation",
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, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
2982 ctx = rctx // use context from middleware stack in children
2983 return obj.Author, nil
2984 })
2985 if err != nil {
2986 ec.Error(ctx, err)
2987 return graphql.Null
2988 }
2989 if resTmp == nil {
2990 if !ec.HasError(rctx) {
2991 ec.Errorf(ctx, "must not be null")
2992 }
2993 return graphql.Null
2994 }
2995 res := resTmp.(identity.Interface)
2996 rctx.Result = res
2997 ctx = ec.Tracer.StartFieldChildExecution(ctx)
2998 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
2999}
3000
3001func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3002 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3003 defer func() {
3004 if r := recover(); r != nil {
3005 ec.Error(ctx, ec.Recover(ctx, r))
3006 ret = graphql.Null
3007 }
3008 ec.Tracer.EndFieldExecution(ctx)
3009 }()
3010 rctx := &graphql.ResolverContext{
3011 Object: "AddCommentOperation",
3012 Field: field,
3013 Args: nil,
3014 IsMethod: true,
3015 }
3016 ctx = graphql.WithResolverContext(ctx, rctx)
3017 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3018 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3019 ctx = rctx // use context from middleware stack in children
3020 return ec.resolvers.AddCommentOperation().Date(rctx, obj)
3021 })
3022 if err != nil {
3023 ec.Error(ctx, err)
3024 return graphql.Null
3025 }
3026 if resTmp == nil {
3027 if !ec.HasError(rctx) {
3028 ec.Errorf(ctx, "must not be null")
3029 }
3030 return graphql.Null
3031 }
3032 res := resTmp.(*time.Time)
3033 rctx.Result = res
3034 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3035 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3036}
3037
3038func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3039 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3040 defer func() {
3041 if r := recover(); r != nil {
3042 ec.Error(ctx, ec.Recover(ctx, r))
3043 ret = graphql.Null
3044 }
3045 ec.Tracer.EndFieldExecution(ctx)
3046 }()
3047 rctx := &graphql.ResolverContext{
3048 Object: "AddCommentOperation",
3049 Field: field,
3050 Args: nil,
3051 IsMethod: false,
3052 }
3053 ctx = graphql.WithResolverContext(ctx, rctx)
3054 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3055 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3056 ctx = rctx // use context from middleware stack in children
3057 return obj.Message, nil
3058 })
3059 if err != nil {
3060 ec.Error(ctx, err)
3061 return graphql.Null
3062 }
3063 if resTmp == nil {
3064 if !ec.HasError(rctx) {
3065 ec.Errorf(ctx, "must not be null")
3066 }
3067 return graphql.Null
3068 }
3069 res := resTmp.(string)
3070 rctx.Result = res
3071 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3072 return ec.marshalNString2string(ctx, field.Selections, res)
3073}
3074
3075func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3076 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3077 defer func() {
3078 if r := recover(); r != nil {
3079 ec.Error(ctx, ec.Recover(ctx, r))
3080 ret = graphql.Null
3081 }
3082 ec.Tracer.EndFieldExecution(ctx)
3083 }()
3084 rctx := &graphql.ResolverContext{
3085 Object: "AddCommentOperation",
3086 Field: field,
3087 Args: nil,
3088 IsMethod: false,
3089 }
3090 ctx = graphql.WithResolverContext(ctx, rctx)
3091 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3092 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3093 ctx = rctx // use context from middleware stack in children
3094 return obj.Files, nil
3095 })
3096 if err != nil {
3097 ec.Error(ctx, err)
3098 return graphql.Null
3099 }
3100 if resTmp == nil {
3101 if !ec.HasError(rctx) {
3102 ec.Errorf(ctx, "must not be null")
3103 }
3104 return graphql.Null
3105 }
3106 res := resTmp.([]git.Hash)
3107 rctx.Result = res
3108 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3109 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
3110}
3111
3112func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3113 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3114 defer func() {
3115 if r := recover(); r != nil {
3116 ec.Error(ctx, ec.Recover(ctx, r))
3117 ret = graphql.Null
3118 }
3119 ec.Tracer.EndFieldExecution(ctx)
3120 }()
3121 rctx := &graphql.ResolverContext{
3122 Object: "AddCommentPayload",
3123 Field: field,
3124 Args: nil,
3125 IsMethod: false,
3126 }
3127 ctx = graphql.WithResolverContext(ctx, rctx)
3128 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3129 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3130 ctx = rctx // use context from middleware stack in children
3131 return obj.ClientMutationID, nil
3132 })
3133 if err != nil {
3134 ec.Error(ctx, err)
3135 return graphql.Null
3136 }
3137 if resTmp == nil {
3138 return graphql.Null
3139 }
3140 res := resTmp.(*string)
3141 rctx.Result = res
3142 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3143 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3144}
3145
3146func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3147 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3148 defer func() {
3149 if r := recover(); r != nil {
3150 ec.Error(ctx, ec.Recover(ctx, r))
3151 ret = graphql.Null
3152 }
3153 ec.Tracer.EndFieldExecution(ctx)
3154 }()
3155 rctx := &graphql.ResolverContext{
3156 Object: "AddCommentPayload",
3157 Field: field,
3158 Args: nil,
3159 IsMethod: false,
3160 }
3161 ctx = graphql.WithResolverContext(ctx, rctx)
3162 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3163 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3164 ctx = rctx // use context from middleware stack in children
3165 return obj.Bug, nil
3166 })
3167 if err != nil {
3168 ec.Error(ctx, err)
3169 return graphql.Null
3170 }
3171 if resTmp == nil {
3172 if !ec.HasError(rctx) {
3173 ec.Errorf(ctx, "must not be null")
3174 }
3175 return graphql.Null
3176 }
3177 res := resTmp.(*bug.Snapshot)
3178 rctx.Result = res
3179 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3180 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
3181}
3182
3183func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3184 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3185 defer func() {
3186 if r := recover(); r != nil {
3187 ec.Error(ctx, ec.Recover(ctx, r))
3188 ret = graphql.Null
3189 }
3190 ec.Tracer.EndFieldExecution(ctx)
3191 }()
3192 rctx := &graphql.ResolverContext{
3193 Object: "AddCommentPayload",
3194 Field: field,
3195 Args: nil,
3196 IsMethod: false,
3197 }
3198 ctx = graphql.WithResolverContext(ctx, rctx)
3199 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3200 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3201 ctx = rctx // use context from middleware stack in children
3202 return obj.Operation, nil
3203 })
3204 if err != nil {
3205 ec.Error(ctx, err)
3206 return graphql.Null
3207 }
3208 if resTmp == nil {
3209 if !ec.HasError(rctx) {
3210 ec.Errorf(ctx, "must not be null")
3211 }
3212 return graphql.Null
3213 }
3214 res := resTmp.(*bug.AddCommentOperation)
3215 rctx.Result = res
3216 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3217 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3218}
3219
3220func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3221 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3222 defer func() {
3223 if r := recover(); r != nil {
3224 ec.Error(ctx, ec.Recover(ctx, r))
3225 ret = graphql.Null
3226 }
3227 ec.Tracer.EndFieldExecution(ctx)
3228 }()
3229 rctx := &graphql.ResolverContext{
3230 Object: "AddCommentTimelineItem",
3231 Field: field,
3232 Args: nil,
3233 IsMethod: true,
3234 }
3235 ctx = graphql.WithResolverContext(ctx, rctx)
3236 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3237 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3238 ctx = rctx // use context from middleware stack in children
3239 return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
3240 })
3241 if err != nil {
3242 ec.Error(ctx, err)
3243 return graphql.Null
3244 }
3245 if resTmp == nil {
3246 if !ec.HasError(rctx) {
3247 ec.Errorf(ctx, "must not be null")
3248 }
3249 return graphql.Null
3250 }
3251 res := resTmp.(string)
3252 rctx.Result = res
3253 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3254 return ec.marshalNString2string(ctx, field.Selections, res)
3255}
3256
3257func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3258 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3259 defer func() {
3260 if r := recover(); r != nil {
3261 ec.Error(ctx, ec.Recover(ctx, r))
3262 ret = graphql.Null
3263 }
3264 ec.Tracer.EndFieldExecution(ctx)
3265 }()
3266 rctx := &graphql.ResolverContext{
3267 Object: "AddCommentTimelineItem",
3268 Field: field,
3269 Args: nil,
3270 IsMethod: false,
3271 }
3272 ctx = graphql.WithResolverContext(ctx, rctx)
3273 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3274 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3275 ctx = rctx // use context from middleware stack in children
3276 return obj.Author, nil
3277 })
3278 if err != nil {
3279 ec.Error(ctx, err)
3280 return graphql.Null
3281 }
3282 if resTmp == nil {
3283 if !ec.HasError(rctx) {
3284 ec.Errorf(ctx, "must not be null")
3285 }
3286 return graphql.Null
3287 }
3288 res := resTmp.(identity.Interface)
3289 rctx.Result = res
3290 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3291 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
3292}
3293
3294func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3295 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3296 defer func() {
3297 if r := recover(); r != nil {
3298 ec.Error(ctx, ec.Recover(ctx, r))
3299 ret = graphql.Null
3300 }
3301 ec.Tracer.EndFieldExecution(ctx)
3302 }()
3303 rctx := &graphql.ResolverContext{
3304 Object: "AddCommentTimelineItem",
3305 Field: field,
3306 Args: nil,
3307 IsMethod: false,
3308 }
3309 ctx = graphql.WithResolverContext(ctx, rctx)
3310 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3311 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3312 ctx = rctx // use context from middleware stack in children
3313 return obj.Message, nil
3314 })
3315 if err != nil {
3316 ec.Error(ctx, err)
3317 return graphql.Null
3318 }
3319 if resTmp == nil {
3320 if !ec.HasError(rctx) {
3321 ec.Errorf(ctx, "must not be null")
3322 }
3323 return graphql.Null
3324 }
3325 res := resTmp.(string)
3326 rctx.Result = res
3327 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3328 return ec.marshalNString2string(ctx, field.Selections, res)
3329}
3330
3331func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3332 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3333 defer func() {
3334 if r := recover(); r != nil {
3335 ec.Error(ctx, ec.Recover(ctx, r))
3336 ret = graphql.Null
3337 }
3338 ec.Tracer.EndFieldExecution(ctx)
3339 }()
3340 rctx := &graphql.ResolverContext{
3341 Object: "AddCommentTimelineItem",
3342 Field: field,
3343 Args: nil,
3344 IsMethod: true,
3345 }
3346 ctx = graphql.WithResolverContext(ctx, rctx)
3347 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3348 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3349 ctx = rctx // use context from middleware stack in children
3350 return obj.MessageIsEmpty(), nil
3351 })
3352 if err != nil {
3353 ec.Error(ctx, err)
3354 return graphql.Null
3355 }
3356 if resTmp == nil {
3357 if !ec.HasError(rctx) {
3358 ec.Errorf(ctx, "must not be null")
3359 }
3360 return graphql.Null
3361 }
3362 res := resTmp.(bool)
3363 rctx.Result = res
3364 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3365 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3366}
3367
3368func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3369 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3370 defer func() {
3371 if r := recover(); r != nil {
3372 ec.Error(ctx, ec.Recover(ctx, r))
3373 ret = graphql.Null
3374 }
3375 ec.Tracer.EndFieldExecution(ctx)
3376 }()
3377 rctx := &graphql.ResolverContext{
3378 Object: "AddCommentTimelineItem",
3379 Field: field,
3380 Args: nil,
3381 IsMethod: false,
3382 }
3383 ctx = graphql.WithResolverContext(ctx, rctx)
3384 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3385 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3386 ctx = rctx // use context from middleware stack in children
3387 return obj.Files, nil
3388 })
3389 if err != nil {
3390 ec.Error(ctx, err)
3391 return graphql.Null
3392 }
3393 if resTmp == nil {
3394 if !ec.HasError(rctx) {
3395 ec.Errorf(ctx, "must not be null")
3396 }
3397 return graphql.Null
3398 }
3399 res := resTmp.([]git.Hash)
3400 rctx.Result = res
3401 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3402 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
3403}
3404
3405func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3406 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3407 defer func() {
3408 if r := recover(); r != nil {
3409 ec.Error(ctx, ec.Recover(ctx, r))
3410 ret = graphql.Null
3411 }
3412 ec.Tracer.EndFieldExecution(ctx)
3413 }()
3414 rctx := &graphql.ResolverContext{
3415 Object: "AddCommentTimelineItem",
3416 Field: field,
3417 Args: nil,
3418 IsMethod: true,
3419 }
3420 ctx = graphql.WithResolverContext(ctx, rctx)
3421 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3422 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3423 ctx = rctx // use context from middleware stack in children
3424 return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
3425 })
3426 if err != nil {
3427 ec.Error(ctx, err)
3428 return graphql.Null
3429 }
3430 if resTmp == nil {
3431 if !ec.HasError(rctx) {
3432 ec.Errorf(ctx, "must not be null")
3433 }
3434 return graphql.Null
3435 }
3436 res := resTmp.(*time.Time)
3437 rctx.Result = res
3438 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3439 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3440}
3441
3442func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3443 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3444 defer func() {
3445 if r := recover(); r != nil {
3446 ec.Error(ctx, ec.Recover(ctx, r))
3447 ret = graphql.Null
3448 }
3449 ec.Tracer.EndFieldExecution(ctx)
3450 }()
3451 rctx := &graphql.ResolverContext{
3452 Object: "AddCommentTimelineItem",
3453 Field: field,
3454 Args: nil,
3455 IsMethod: true,
3456 }
3457 ctx = graphql.WithResolverContext(ctx, rctx)
3458 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3459 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3460 ctx = rctx // use context from middleware stack in children
3461 return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
3462 })
3463 if err != nil {
3464 ec.Error(ctx, err)
3465 return graphql.Null
3466 }
3467 if resTmp == nil {
3468 if !ec.HasError(rctx) {
3469 ec.Errorf(ctx, "must not be null")
3470 }
3471 return graphql.Null
3472 }
3473 res := resTmp.(*time.Time)
3474 rctx.Result = res
3475 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3476 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3477}
3478
3479func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3480 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3481 defer func() {
3482 if r := recover(); r != nil {
3483 ec.Error(ctx, ec.Recover(ctx, r))
3484 ret = graphql.Null
3485 }
3486 ec.Tracer.EndFieldExecution(ctx)
3487 }()
3488 rctx := &graphql.ResolverContext{
3489 Object: "AddCommentTimelineItem",
3490 Field: field,
3491 Args: nil,
3492 IsMethod: true,
3493 }
3494 ctx = graphql.WithResolverContext(ctx, rctx)
3495 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3496 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3497 ctx = rctx // use context from middleware stack in children
3498 return obj.Edited(), nil
3499 })
3500 if err != nil {
3501 ec.Error(ctx, err)
3502 return graphql.Null
3503 }
3504 if resTmp == nil {
3505 if !ec.HasError(rctx) {
3506 ec.Errorf(ctx, "must not be null")
3507 }
3508 return graphql.Null
3509 }
3510 res := resTmp.(bool)
3511 rctx.Result = res
3512 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3513 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3514}
3515
3516func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3517 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3518 defer func() {
3519 if r := recover(); r != nil {
3520 ec.Error(ctx, ec.Recover(ctx, r))
3521 ret = graphql.Null
3522 }
3523 ec.Tracer.EndFieldExecution(ctx)
3524 }()
3525 rctx := &graphql.ResolverContext{
3526 Object: "AddCommentTimelineItem",
3527 Field: field,
3528 Args: nil,
3529 IsMethod: false,
3530 }
3531 ctx = graphql.WithResolverContext(ctx, rctx)
3532 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3533 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3534 ctx = rctx // use context from middleware stack in children
3535 return obj.History, nil
3536 })
3537 if err != nil {
3538 ec.Error(ctx, err)
3539 return graphql.Null
3540 }
3541 if resTmp == nil {
3542 if !ec.HasError(rctx) {
3543 ec.Errorf(ctx, "must not be null")
3544 }
3545 return graphql.Null
3546 }
3547 res := resTmp.([]bug.CommentHistoryStep)
3548 rctx.Result = res
3549 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3550 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, field.Selections, res)
3551}
3552
3553func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3554 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3555 defer func() {
3556 if r := recover(); r != nil {
3557 ec.Error(ctx, ec.Recover(ctx, r))
3558 ret = graphql.Null
3559 }
3560 ec.Tracer.EndFieldExecution(ctx)
3561 }()
3562 rctx := &graphql.ResolverContext{
3563 Object: "Bug",
3564 Field: field,
3565 Args: nil,
3566 IsMethod: true,
3567 }
3568 ctx = graphql.WithResolverContext(ctx, rctx)
3569 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3570 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3571 ctx = rctx // use context from middleware stack in children
3572 return ec.resolvers.Bug().ID(rctx, obj)
3573 })
3574 if err != nil {
3575 ec.Error(ctx, err)
3576 return graphql.Null
3577 }
3578 if resTmp == nil {
3579 if !ec.HasError(rctx) {
3580 ec.Errorf(ctx, "must not be null")
3581 }
3582 return graphql.Null
3583 }
3584 res := resTmp.(string)
3585 rctx.Result = res
3586 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3587 return ec.marshalNString2string(ctx, field.Selections, res)
3588}
3589
3590func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3591 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3592 defer func() {
3593 if r := recover(); r != nil {
3594 ec.Error(ctx, ec.Recover(ctx, r))
3595 ret = graphql.Null
3596 }
3597 ec.Tracer.EndFieldExecution(ctx)
3598 }()
3599 rctx := &graphql.ResolverContext{
3600 Object: "Bug",
3601 Field: field,
3602 Args: nil,
3603 IsMethod: true,
3604 }
3605 ctx = graphql.WithResolverContext(ctx, rctx)
3606 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3607 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3608 ctx = rctx // use context from middleware stack in children
3609 return ec.resolvers.Bug().HumanID(rctx, obj)
3610 })
3611 if err != nil {
3612 ec.Error(ctx, err)
3613 return graphql.Null
3614 }
3615 if resTmp == nil {
3616 if !ec.HasError(rctx) {
3617 ec.Errorf(ctx, "must not be null")
3618 }
3619 return graphql.Null
3620 }
3621 res := resTmp.(string)
3622 rctx.Result = res
3623 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3624 return ec.marshalNString2string(ctx, field.Selections, res)
3625}
3626
3627func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3628 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3629 defer func() {
3630 if r := recover(); r != nil {
3631 ec.Error(ctx, ec.Recover(ctx, r))
3632 ret = graphql.Null
3633 }
3634 ec.Tracer.EndFieldExecution(ctx)
3635 }()
3636 rctx := &graphql.ResolverContext{
3637 Object: "Bug",
3638 Field: field,
3639 Args: nil,
3640 IsMethod: true,
3641 }
3642 ctx = graphql.WithResolverContext(ctx, rctx)
3643 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3644 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3645 ctx = rctx // use context from middleware stack in children
3646 return ec.resolvers.Bug().Status(rctx, obj)
3647 })
3648 if err != nil {
3649 ec.Error(ctx, err)
3650 return graphql.Null
3651 }
3652 if resTmp == nil {
3653 if !ec.HasError(rctx) {
3654 ec.Errorf(ctx, "must not be null")
3655 }
3656 return graphql.Null
3657 }
3658 res := resTmp.(models.Status)
3659 rctx.Result = res
3660 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3661 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
3662}
3663
3664func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3665 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3666 defer func() {
3667 if r := recover(); r != nil {
3668 ec.Error(ctx, ec.Recover(ctx, r))
3669 ret = graphql.Null
3670 }
3671 ec.Tracer.EndFieldExecution(ctx)
3672 }()
3673 rctx := &graphql.ResolverContext{
3674 Object: "Bug",
3675 Field: field,
3676 Args: nil,
3677 IsMethod: false,
3678 }
3679 ctx = graphql.WithResolverContext(ctx, rctx)
3680 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3681 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3682 ctx = rctx // use context from middleware stack in children
3683 return obj.Title, nil
3684 })
3685 if err != nil {
3686 ec.Error(ctx, err)
3687 return graphql.Null
3688 }
3689 if resTmp == nil {
3690 if !ec.HasError(rctx) {
3691 ec.Errorf(ctx, "must not be null")
3692 }
3693 return graphql.Null
3694 }
3695 res := resTmp.(string)
3696 rctx.Result = res
3697 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3698 return ec.marshalNString2string(ctx, field.Selections, res)
3699}
3700
3701func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3702 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3703 defer func() {
3704 if r := recover(); r != nil {
3705 ec.Error(ctx, ec.Recover(ctx, r))
3706 ret = graphql.Null
3707 }
3708 ec.Tracer.EndFieldExecution(ctx)
3709 }()
3710 rctx := &graphql.ResolverContext{
3711 Object: "Bug",
3712 Field: field,
3713 Args: nil,
3714 IsMethod: false,
3715 }
3716 ctx = graphql.WithResolverContext(ctx, rctx)
3717 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3718 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3719 ctx = rctx // use context from middleware stack in children
3720 return obj.Labels, nil
3721 })
3722 if err != nil {
3723 ec.Error(ctx, err)
3724 return graphql.Null
3725 }
3726 if resTmp == nil {
3727 if !ec.HasError(rctx) {
3728 ec.Errorf(ctx, "must not be null")
3729 }
3730 return graphql.Null
3731 }
3732 res := resTmp.([]bug.Label)
3733 rctx.Result = res
3734 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3735 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
3736}
3737
3738func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3739 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3740 defer func() {
3741 if r := recover(); r != nil {
3742 ec.Error(ctx, ec.Recover(ctx, r))
3743 ret = graphql.Null
3744 }
3745 ec.Tracer.EndFieldExecution(ctx)
3746 }()
3747 rctx := &graphql.ResolverContext{
3748 Object: "Bug",
3749 Field: field,
3750 Args: nil,
3751 IsMethod: false,
3752 }
3753 ctx = graphql.WithResolverContext(ctx, rctx)
3754 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3755 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3756 ctx = rctx // use context from middleware stack in children
3757 return obj.Author, nil
3758 })
3759 if err != nil {
3760 ec.Error(ctx, err)
3761 return graphql.Null
3762 }
3763 if resTmp == nil {
3764 if !ec.HasError(rctx) {
3765 ec.Errorf(ctx, "must not be null")
3766 }
3767 return graphql.Null
3768 }
3769 res := resTmp.(identity.Interface)
3770 rctx.Result = res
3771 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3772 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
3773}
3774
3775func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3776 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3777 defer func() {
3778 if r := recover(); r != nil {
3779 ec.Error(ctx, ec.Recover(ctx, r))
3780 ret = graphql.Null
3781 }
3782 ec.Tracer.EndFieldExecution(ctx)
3783 }()
3784 rctx := &graphql.ResolverContext{
3785 Object: "Bug",
3786 Field: field,
3787 Args: nil,
3788 IsMethod: false,
3789 }
3790 ctx = graphql.WithResolverContext(ctx, rctx)
3791 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3792 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3793 ctx = rctx // use context from middleware stack in children
3794 return obj.CreatedAt, nil
3795 })
3796 if err != nil {
3797 ec.Error(ctx, err)
3798 return graphql.Null
3799 }
3800 if resTmp == nil {
3801 if !ec.HasError(rctx) {
3802 ec.Errorf(ctx, "must not be null")
3803 }
3804 return graphql.Null
3805 }
3806 res := resTmp.(time.Time)
3807 rctx.Result = res
3808 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3809 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
3810}
3811
3812func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3813 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3814 defer func() {
3815 if r := recover(); r != nil {
3816 ec.Error(ctx, ec.Recover(ctx, r))
3817 ret = graphql.Null
3818 }
3819 ec.Tracer.EndFieldExecution(ctx)
3820 }()
3821 rctx := &graphql.ResolverContext{
3822 Object: "Bug",
3823 Field: field,
3824 Args: nil,
3825 IsMethod: true,
3826 }
3827 ctx = graphql.WithResolverContext(ctx, rctx)
3828 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3829 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3830 ctx = rctx // use context from middleware stack in children
3831 return ec.resolvers.Bug().LastEdit(rctx, obj)
3832 })
3833 if err != nil {
3834 ec.Error(ctx, err)
3835 return graphql.Null
3836 }
3837 if resTmp == nil {
3838 if !ec.HasError(rctx) {
3839 ec.Errorf(ctx, "must not be null")
3840 }
3841 return graphql.Null
3842 }
3843 res := resTmp.(*time.Time)
3844 rctx.Result = res
3845 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3846 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3847}
3848
3849func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3850 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3851 defer func() {
3852 if r := recover(); r != nil {
3853 ec.Error(ctx, ec.Recover(ctx, r))
3854 ret = graphql.Null
3855 }
3856 ec.Tracer.EndFieldExecution(ctx)
3857 }()
3858 rctx := &graphql.ResolverContext{
3859 Object: "Bug",
3860 Field: field,
3861 Args: nil,
3862 IsMethod: true,
3863 }
3864 ctx = graphql.WithResolverContext(ctx, rctx)
3865 rawArgs := field.ArgumentMap(ec.Variables)
3866 args, err := ec.field_Bug_actors_args(ctx, rawArgs)
3867 if err != nil {
3868 ec.Error(ctx, err)
3869 return graphql.Null
3870 }
3871 rctx.Args = args
3872 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3873 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3874 ctx = rctx // use context from middleware stack in children
3875 return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
3876 })
3877 if err != nil {
3878 ec.Error(ctx, err)
3879 return graphql.Null
3880 }
3881 if resTmp == nil {
3882 if !ec.HasError(rctx) {
3883 ec.Errorf(ctx, "must not be null")
3884 }
3885 return graphql.Null
3886 }
3887 res := resTmp.(*models.IdentityConnection)
3888 rctx.Result = res
3889 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3890 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
3891}
3892
3893func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3894 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3895 defer func() {
3896 if r := recover(); r != nil {
3897 ec.Error(ctx, ec.Recover(ctx, r))
3898 ret = graphql.Null
3899 }
3900 ec.Tracer.EndFieldExecution(ctx)
3901 }()
3902 rctx := &graphql.ResolverContext{
3903 Object: "Bug",
3904 Field: field,
3905 Args: nil,
3906 IsMethod: true,
3907 }
3908 ctx = graphql.WithResolverContext(ctx, rctx)
3909 rawArgs := field.ArgumentMap(ec.Variables)
3910 args, err := ec.field_Bug_participants_args(ctx, rawArgs)
3911 if err != nil {
3912 ec.Error(ctx, err)
3913 return graphql.Null
3914 }
3915 rctx.Args = args
3916 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3917 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3918 ctx = rctx // use context from middleware stack in children
3919 return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
3920 })
3921 if err != nil {
3922 ec.Error(ctx, err)
3923 return graphql.Null
3924 }
3925 if resTmp == nil {
3926 if !ec.HasError(rctx) {
3927 ec.Errorf(ctx, "must not be null")
3928 }
3929 return graphql.Null
3930 }
3931 res := resTmp.(*models.IdentityConnection)
3932 rctx.Result = res
3933 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3934 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
3935}
3936
3937func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3938 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3939 defer func() {
3940 if r := recover(); r != nil {
3941 ec.Error(ctx, ec.Recover(ctx, r))
3942 ret = graphql.Null
3943 }
3944 ec.Tracer.EndFieldExecution(ctx)
3945 }()
3946 rctx := &graphql.ResolverContext{
3947 Object: "Bug",
3948 Field: field,
3949 Args: nil,
3950 IsMethod: true,
3951 }
3952 ctx = graphql.WithResolverContext(ctx, rctx)
3953 rawArgs := field.ArgumentMap(ec.Variables)
3954 args, err := ec.field_Bug_comments_args(ctx, rawArgs)
3955 if err != nil {
3956 ec.Error(ctx, err)
3957 return graphql.Null
3958 }
3959 rctx.Args = args
3960 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3961 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3962 ctx = rctx // use context from middleware stack in children
3963 return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
3964 })
3965 if err != nil {
3966 ec.Error(ctx, err)
3967 return graphql.Null
3968 }
3969 if resTmp == nil {
3970 if !ec.HasError(rctx) {
3971 ec.Errorf(ctx, "must not be null")
3972 }
3973 return graphql.Null
3974 }
3975 res := resTmp.(*models.CommentConnection)
3976 rctx.Result = res
3977 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3978 return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
3979}
3980
3981func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3982 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3983 defer func() {
3984 if r := recover(); r != nil {
3985 ec.Error(ctx, ec.Recover(ctx, r))
3986 ret = graphql.Null
3987 }
3988 ec.Tracer.EndFieldExecution(ctx)
3989 }()
3990 rctx := &graphql.ResolverContext{
3991 Object: "Bug",
3992 Field: field,
3993 Args: nil,
3994 IsMethod: true,
3995 }
3996 ctx = graphql.WithResolverContext(ctx, rctx)
3997 rawArgs := field.ArgumentMap(ec.Variables)
3998 args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
3999 if err != nil {
4000 ec.Error(ctx, err)
4001 return graphql.Null
4002 }
4003 rctx.Args = args
4004 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4005 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4006 ctx = rctx // use context from middleware stack in children
4007 return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4008 })
4009 if err != nil {
4010 ec.Error(ctx, err)
4011 return graphql.Null
4012 }
4013 if resTmp == nil {
4014 if !ec.HasError(rctx) {
4015 ec.Errorf(ctx, "must not be null")
4016 }
4017 return graphql.Null
4018 }
4019 res := resTmp.(*models.TimelineItemConnection)
4020 rctx.Result = res
4021 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4022 return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
4023}
4024
4025func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4026 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4027 defer func() {
4028 if r := recover(); r != nil {
4029 ec.Error(ctx, ec.Recover(ctx, r))
4030 ret = graphql.Null
4031 }
4032 ec.Tracer.EndFieldExecution(ctx)
4033 }()
4034 rctx := &graphql.ResolverContext{
4035 Object: "Bug",
4036 Field: field,
4037 Args: nil,
4038 IsMethod: true,
4039 }
4040 ctx = graphql.WithResolverContext(ctx, rctx)
4041 rawArgs := field.ArgumentMap(ec.Variables)
4042 args, err := ec.field_Bug_operations_args(ctx, rawArgs)
4043 if err != nil {
4044 ec.Error(ctx, err)
4045 return graphql.Null
4046 }
4047 rctx.Args = args
4048 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4049 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4050 ctx = rctx // use context from middleware stack in children
4051 return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4052 })
4053 if err != nil {
4054 ec.Error(ctx, err)
4055 return graphql.Null
4056 }
4057 if resTmp == nil {
4058 if !ec.HasError(rctx) {
4059 ec.Errorf(ctx, "must not be null")
4060 }
4061 return graphql.Null
4062 }
4063 res := resTmp.(*models.OperationConnection)
4064 rctx.Result = res
4065 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4066 return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
4067}
4068
4069func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4070 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4071 defer func() {
4072 if r := recover(); r != nil {
4073 ec.Error(ctx, ec.Recover(ctx, r))
4074 ret = graphql.Null
4075 }
4076 ec.Tracer.EndFieldExecution(ctx)
4077 }()
4078 rctx := &graphql.ResolverContext{
4079 Object: "BugConnection",
4080 Field: field,
4081 Args: nil,
4082 IsMethod: false,
4083 }
4084 ctx = graphql.WithResolverContext(ctx, rctx)
4085 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4086 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4087 ctx = rctx // use context from middleware stack in children
4088 return obj.Edges, nil
4089 })
4090 if err != nil {
4091 ec.Error(ctx, err)
4092 return graphql.Null
4093 }
4094 if resTmp == nil {
4095 if !ec.HasError(rctx) {
4096 ec.Errorf(ctx, "must not be null")
4097 }
4098 return graphql.Null
4099 }
4100 res := resTmp.([]*models.BugEdge)
4101 rctx.Result = res
4102 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4103 return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, field.Selections, res)
4104}
4105
4106func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4107 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4108 defer func() {
4109 if r := recover(); r != nil {
4110 ec.Error(ctx, ec.Recover(ctx, r))
4111 ret = graphql.Null
4112 }
4113 ec.Tracer.EndFieldExecution(ctx)
4114 }()
4115 rctx := &graphql.ResolverContext{
4116 Object: "BugConnection",
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, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4124 ctx = rctx // use context from middleware stack in children
4125 return obj.Nodes, nil
4126 })
4127 if err != nil {
4128 ec.Error(ctx, err)
4129 return graphql.Null
4130 }
4131 if resTmp == nil {
4132 if !ec.HasError(rctx) {
4133 ec.Errorf(ctx, "must not be null")
4134 }
4135 return graphql.Null
4136 }
4137 res := resTmp.([]*bug.Snapshot)
4138 rctx.Result = res
4139 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4140 return ec.marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
4141}
4142
4143func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4144 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4145 defer func() {
4146 if r := recover(); r != nil {
4147 ec.Error(ctx, ec.Recover(ctx, r))
4148 ret = graphql.Null
4149 }
4150 ec.Tracer.EndFieldExecution(ctx)
4151 }()
4152 rctx := &graphql.ResolverContext{
4153 Object: "BugConnection",
4154 Field: field,
4155 Args: nil,
4156 IsMethod: false,
4157 }
4158 ctx = graphql.WithResolverContext(ctx, rctx)
4159 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4160 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4161 ctx = rctx // use context from middleware stack in children
4162 return obj.PageInfo, nil
4163 })
4164 if err != nil {
4165 ec.Error(ctx, err)
4166 return graphql.Null
4167 }
4168 if resTmp == nil {
4169 if !ec.HasError(rctx) {
4170 ec.Errorf(ctx, "must not be null")
4171 }
4172 return graphql.Null
4173 }
4174 res := resTmp.(*models.PageInfo)
4175 rctx.Result = res
4176 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4177 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4178}
4179
4180func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4181 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4182 defer func() {
4183 if r := recover(); r != nil {
4184 ec.Error(ctx, ec.Recover(ctx, r))
4185 ret = graphql.Null
4186 }
4187 ec.Tracer.EndFieldExecution(ctx)
4188 }()
4189 rctx := &graphql.ResolverContext{
4190 Object: "BugConnection",
4191 Field: field,
4192 Args: nil,
4193 IsMethod: false,
4194 }
4195 ctx = graphql.WithResolverContext(ctx, rctx)
4196 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4197 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4198 ctx = rctx // use context from middleware stack in children
4199 return obj.TotalCount, nil
4200 })
4201 if err != nil {
4202 ec.Error(ctx, err)
4203 return graphql.Null
4204 }
4205 if resTmp == nil {
4206 if !ec.HasError(rctx) {
4207 ec.Errorf(ctx, "must not be null")
4208 }
4209 return graphql.Null
4210 }
4211 res := resTmp.(int)
4212 rctx.Result = res
4213 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4214 return ec.marshalNInt2int(ctx, field.Selections, res)
4215}
4216
4217func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4218 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4219 defer func() {
4220 if r := recover(); r != nil {
4221 ec.Error(ctx, ec.Recover(ctx, r))
4222 ret = graphql.Null
4223 }
4224 ec.Tracer.EndFieldExecution(ctx)
4225 }()
4226 rctx := &graphql.ResolverContext{
4227 Object: "BugEdge",
4228 Field: field,
4229 Args: nil,
4230 IsMethod: false,
4231 }
4232 ctx = graphql.WithResolverContext(ctx, rctx)
4233 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4234 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4235 ctx = rctx // use context from middleware stack in children
4236 return obj.Cursor, nil
4237 })
4238 if err != nil {
4239 ec.Error(ctx, err)
4240 return graphql.Null
4241 }
4242 if resTmp == nil {
4243 if !ec.HasError(rctx) {
4244 ec.Errorf(ctx, "must not be null")
4245 }
4246 return graphql.Null
4247 }
4248 res := resTmp.(string)
4249 rctx.Result = res
4250 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4251 return ec.marshalNString2string(ctx, field.Selections, res)
4252}
4253
4254func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4255 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4256 defer func() {
4257 if r := recover(); r != nil {
4258 ec.Error(ctx, ec.Recover(ctx, r))
4259 ret = graphql.Null
4260 }
4261 ec.Tracer.EndFieldExecution(ctx)
4262 }()
4263 rctx := &graphql.ResolverContext{
4264 Object: "BugEdge",
4265 Field: field,
4266 Args: nil,
4267 IsMethod: false,
4268 }
4269 ctx = graphql.WithResolverContext(ctx, rctx)
4270 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4271 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4272 ctx = rctx // use context from middleware stack in children
4273 return obj.Node, nil
4274 })
4275 if err != nil {
4276 ec.Error(ctx, err)
4277 return graphql.Null
4278 }
4279 if resTmp == nil {
4280 if !ec.HasError(rctx) {
4281 ec.Errorf(ctx, "must not be null")
4282 }
4283 return graphql.Null
4284 }
4285 res := resTmp.(*bug.Snapshot)
4286 rctx.Result = res
4287 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4288 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
4289}
4290
4291func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4292 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4293 defer func() {
4294 if r := recover(); r != nil {
4295 ec.Error(ctx, ec.Recover(ctx, r))
4296 ret = graphql.Null
4297 }
4298 ec.Tracer.EndFieldExecution(ctx)
4299 }()
4300 rctx := &graphql.ResolverContext{
4301 Object: "ChangeLabelPayload",
4302 Field: field,
4303 Args: nil,
4304 IsMethod: false,
4305 }
4306 ctx = graphql.WithResolverContext(ctx, rctx)
4307 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4308 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4309 ctx = rctx // use context from middleware stack in children
4310 return obj.ClientMutationID, nil
4311 })
4312 if err != nil {
4313 ec.Error(ctx, err)
4314 return graphql.Null
4315 }
4316 if resTmp == nil {
4317 return graphql.Null
4318 }
4319 res := resTmp.(*string)
4320 rctx.Result = res
4321 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4322 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4323}
4324
4325func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4326 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4327 defer func() {
4328 if r := recover(); r != nil {
4329 ec.Error(ctx, ec.Recover(ctx, r))
4330 ret = graphql.Null
4331 }
4332 ec.Tracer.EndFieldExecution(ctx)
4333 }()
4334 rctx := &graphql.ResolverContext{
4335 Object: "ChangeLabelPayload",
4336 Field: field,
4337 Args: nil,
4338 IsMethod: false,
4339 }
4340 ctx = graphql.WithResolverContext(ctx, rctx)
4341 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4342 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4343 ctx = rctx // use context from middleware stack in children
4344 return obj.Bug, nil
4345 })
4346 if err != nil {
4347 ec.Error(ctx, err)
4348 return graphql.Null
4349 }
4350 if resTmp == nil {
4351 if !ec.HasError(rctx) {
4352 ec.Errorf(ctx, "must not be null")
4353 }
4354 return graphql.Null
4355 }
4356 res := resTmp.(*bug.Snapshot)
4357 rctx.Result = res
4358 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4359 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
4360}
4361
4362func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4363 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4364 defer func() {
4365 if r := recover(); r != nil {
4366 ec.Error(ctx, ec.Recover(ctx, r))
4367 ret = graphql.Null
4368 }
4369 ec.Tracer.EndFieldExecution(ctx)
4370 }()
4371 rctx := &graphql.ResolverContext{
4372 Object: "ChangeLabelPayload",
4373 Field: field,
4374 Args: nil,
4375 IsMethod: false,
4376 }
4377 ctx = graphql.WithResolverContext(ctx, rctx)
4378 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4379 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4380 ctx = rctx // use context from middleware stack in children
4381 return obj.Operation, nil
4382 })
4383 if err != nil {
4384 ec.Error(ctx, err)
4385 return graphql.Null
4386 }
4387 if resTmp == nil {
4388 if !ec.HasError(rctx) {
4389 ec.Errorf(ctx, "must not be null")
4390 }
4391 return graphql.Null
4392 }
4393 res := resTmp.(*bug.LabelChangeOperation)
4394 rctx.Result = res
4395 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4396 return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
4397}
4398
4399func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4400 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4401 defer func() {
4402 if r := recover(); r != nil {
4403 ec.Error(ctx, ec.Recover(ctx, r))
4404 ret = graphql.Null
4405 }
4406 ec.Tracer.EndFieldExecution(ctx)
4407 }()
4408 rctx := &graphql.ResolverContext{
4409 Object: "ChangeLabelPayload",
4410 Field: field,
4411 Args: nil,
4412 IsMethod: false,
4413 }
4414 ctx = graphql.WithResolverContext(ctx, rctx)
4415 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4416 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4417 ctx = rctx // use context from middleware stack in children
4418 return obj.Results, nil
4419 })
4420 if err != nil {
4421 ec.Error(ctx, err)
4422 return graphql.Null
4423 }
4424 if resTmp == nil {
4425 if !ec.HasError(rctx) {
4426 ec.Errorf(ctx, "must not be null")
4427 }
4428 return graphql.Null
4429 }
4430 res := resTmp.([]*bug.LabelChangeResult)
4431 rctx.Result = res
4432 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4433 return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
4434}
4435
4436func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4437 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4438 defer func() {
4439 if r := recover(); r != nil {
4440 ec.Error(ctx, ec.Recover(ctx, r))
4441 ret = graphql.Null
4442 }
4443 ec.Tracer.EndFieldExecution(ctx)
4444 }()
4445 rctx := &graphql.ResolverContext{
4446 Object: "CloseBugPayload",
4447 Field: field,
4448 Args: nil,
4449 IsMethod: false,
4450 }
4451 ctx = graphql.WithResolverContext(ctx, rctx)
4452 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4453 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4454 ctx = rctx // use context from middleware stack in children
4455 return obj.ClientMutationID, nil
4456 })
4457 if err != nil {
4458 ec.Error(ctx, err)
4459 return graphql.Null
4460 }
4461 if resTmp == nil {
4462 return graphql.Null
4463 }
4464 res := resTmp.(*string)
4465 rctx.Result = res
4466 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4467 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4468}
4469
4470func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4471 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4472 defer func() {
4473 if r := recover(); r != nil {
4474 ec.Error(ctx, ec.Recover(ctx, r))
4475 ret = graphql.Null
4476 }
4477 ec.Tracer.EndFieldExecution(ctx)
4478 }()
4479 rctx := &graphql.ResolverContext{
4480 Object: "CloseBugPayload",
4481 Field: field,
4482 Args: nil,
4483 IsMethod: false,
4484 }
4485 ctx = graphql.WithResolverContext(ctx, rctx)
4486 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4487 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4488 ctx = rctx // use context from middleware stack in children
4489 return obj.Bug, nil
4490 })
4491 if err != nil {
4492 ec.Error(ctx, err)
4493 return graphql.Null
4494 }
4495 if resTmp == nil {
4496 if !ec.HasError(rctx) {
4497 ec.Errorf(ctx, "must not be null")
4498 }
4499 return graphql.Null
4500 }
4501 res := resTmp.(*bug.Snapshot)
4502 rctx.Result = res
4503 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4504 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
4505}
4506
4507func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4508 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4509 defer func() {
4510 if r := recover(); r != nil {
4511 ec.Error(ctx, ec.Recover(ctx, r))
4512 ret = graphql.Null
4513 }
4514 ec.Tracer.EndFieldExecution(ctx)
4515 }()
4516 rctx := &graphql.ResolverContext{
4517 Object: "CloseBugPayload",
4518 Field: field,
4519 Args: nil,
4520 IsMethod: false,
4521 }
4522 ctx = graphql.WithResolverContext(ctx, rctx)
4523 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4524 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4525 ctx = rctx // use context from middleware stack in children
4526 return obj.Operation, nil
4527 })
4528 if err != nil {
4529 ec.Error(ctx, err)
4530 return graphql.Null
4531 }
4532 if resTmp == nil {
4533 if !ec.HasError(rctx) {
4534 ec.Errorf(ctx, "must not be null")
4535 }
4536 return graphql.Null
4537 }
4538 res := resTmp.(*bug.SetStatusOperation)
4539 rctx.Result = res
4540 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4541 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
4542}
4543
4544func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4545 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4546 defer func() {
4547 if r := recover(); r != nil {
4548 ec.Error(ctx, ec.Recover(ctx, r))
4549 ret = graphql.Null
4550 }
4551 ec.Tracer.EndFieldExecution(ctx)
4552 }()
4553 rctx := &graphql.ResolverContext{
4554 Object: "Color",
4555 Field: field,
4556 Args: nil,
4557 IsMethod: true,
4558 }
4559 ctx = graphql.WithResolverContext(ctx, rctx)
4560 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4561 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4562 ctx = rctx // use context from middleware stack in children
4563 return ec.resolvers.Color().R(rctx, obj)
4564 })
4565 if err != nil {
4566 ec.Error(ctx, err)
4567 return graphql.Null
4568 }
4569 if resTmp == nil {
4570 if !ec.HasError(rctx) {
4571 ec.Errorf(ctx, "must not be null")
4572 }
4573 return graphql.Null
4574 }
4575 res := resTmp.(int)
4576 rctx.Result = res
4577 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4578 return ec.marshalNInt2int(ctx, field.Selections, res)
4579}
4580
4581func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4582 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4583 defer func() {
4584 if r := recover(); r != nil {
4585 ec.Error(ctx, ec.Recover(ctx, r))
4586 ret = graphql.Null
4587 }
4588 ec.Tracer.EndFieldExecution(ctx)
4589 }()
4590 rctx := &graphql.ResolverContext{
4591 Object: "Color",
4592 Field: field,
4593 Args: nil,
4594 IsMethod: true,
4595 }
4596 ctx = graphql.WithResolverContext(ctx, rctx)
4597 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4598 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4599 ctx = rctx // use context from middleware stack in children
4600 return ec.resolvers.Color().G(rctx, obj)
4601 })
4602 if err != nil {
4603 ec.Error(ctx, err)
4604 return graphql.Null
4605 }
4606 if resTmp == nil {
4607 if !ec.HasError(rctx) {
4608 ec.Errorf(ctx, "must not be null")
4609 }
4610 return graphql.Null
4611 }
4612 res := resTmp.(int)
4613 rctx.Result = res
4614 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4615 return ec.marshalNInt2int(ctx, field.Selections, res)
4616}
4617
4618func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4619 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4620 defer func() {
4621 if r := recover(); r != nil {
4622 ec.Error(ctx, ec.Recover(ctx, r))
4623 ret = graphql.Null
4624 }
4625 ec.Tracer.EndFieldExecution(ctx)
4626 }()
4627 rctx := &graphql.ResolverContext{
4628 Object: "Color",
4629 Field: field,
4630 Args: nil,
4631 IsMethod: true,
4632 }
4633 ctx = graphql.WithResolverContext(ctx, rctx)
4634 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4635 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4636 ctx = rctx // use context from middleware stack in children
4637 return ec.resolvers.Color().B(rctx, obj)
4638 })
4639 if err != nil {
4640 ec.Error(ctx, err)
4641 return graphql.Null
4642 }
4643 if resTmp == nil {
4644 if !ec.HasError(rctx) {
4645 ec.Errorf(ctx, "must not be null")
4646 }
4647 return graphql.Null
4648 }
4649 res := resTmp.(int)
4650 rctx.Result = res
4651 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4652 return ec.marshalNInt2int(ctx, field.Selections, res)
4653}
4654
4655func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4656 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4657 defer func() {
4658 if r := recover(); r != nil {
4659 ec.Error(ctx, ec.Recover(ctx, r))
4660 ret = graphql.Null
4661 }
4662 ec.Tracer.EndFieldExecution(ctx)
4663 }()
4664 rctx := &graphql.ResolverContext{
4665 Object: "Comment",
4666 Field: field,
4667 Args: nil,
4668 IsMethod: false,
4669 }
4670 ctx = graphql.WithResolverContext(ctx, rctx)
4671 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4672 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4673 ctx = rctx // use context from middleware stack in children
4674 return obj.Author, nil
4675 })
4676 if err != nil {
4677 ec.Error(ctx, err)
4678 return graphql.Null
4679 }
4680 if resTmp == nil {
4681 if !ec.HasError(rctx) {
4682 ec.Errorf(ctx, "must not be null")
4683 }
4684 return graphql.Null
4685 }
4686 res := resTmp.(identity.Interface)
4687 rctx.Result = res
4688 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4689 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
4690}
4691
4692func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4693 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4694 defer func() {
4695 if r := recover(); r != nil {
4696 ec.Error(ctx, ec.Recover(ctx, r))
4697 ret = graphql.Null
4698 }
4699 ec.Tracer.EndFieldExecution(ctx)
4700 }()
4701 rctx := &graphql.ResolverContext{
4702 Object: "Comment",
4703 Field: field,
4704 Args: nil,
4705 IsMethod: false,
4706 }
4707 ctx = graphql.WithResolverContext(ctx, rctx)
4708 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4709 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4710 ctx = rctx // use context from middleware stack in children
4711 return obj.Message, nil
4712 })
4713 if err != nil {
4714 ec.Error(ctx, err)
4715 return graphql.Null
4716 }
4717 if resTmp == nil {
4718 if !ec.HasError(rctx) {
4719 ec.Errorf(ctx, "must not be null")
4720 }
4721 return graphql.Null
4722 }
4723 res := resTmp.(string)
4724 rctx.Result = res
4725 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4726 return ec.marshalNString2string(ctx, field.Selections, res)
4727}
4728
4729func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4730 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4731 defer func() {
4732 if r := recover(); r != nil {
4733 ec.Error(ctx, ec.Recover(ctx, r))
4734 ret = graphql.Null
4735 }
4736 ec.Tracer.EndFieldExecution(ctx)
4737 }()
4738 rctx := &graphql.ResolverContext{
4739 Object: "Comment",
4740 Field: field,
4741 Args: nil,
4742 IsMethod: false,
4743 }
4744 ctx = graphql.WithResolverContext(ctx, rctx)
4745 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4746 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4747 ctx = rctx // use context from middleware stack in children
4748 return obj.Files, nil
4749 })
4750 if err != nil {
4751 ec.Error(ctx, err)
4752 return graphql.Null
4753 }
4754 if resTmp == nil {
4755 if !ec.HasError(rctx) {
4756 ec.Errorf(ctx, "must not be null")
4757 }
4758 return graphql.Null
4759 }
4760 res := resTmp.([]git.Hash)
4761 rctx.Result = res
4762 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4763 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
4764}
4765
4766func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4767 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4768 defer func() {
4769 if r := recover(); r != nil {
4770 ec.Error(ctx, ec.Recover(ctx, r))
4771 ret = graphql.Null
4772 }
4773 ec.Tracer.EndFieldExecution(ctx)
4774 }()
4775 rctx := &graphql.ResolverContext{
4776 Object: "CommentConnection",
4777 Field: field,
4778 Args: nil,
4779 IsMethod: false,
4780 }
4781 ctx = graphql.WithResolverContext(ctx, rctx)
4782 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4783 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4784 ctx = rctx // use context from middleware stack in children
4785 return obj.Edges, nil
4786 })
4787 if err != nil {
4788 ec.Error(ctx, err)
4789 return graphql.Null
4790 }
4791 if resTmp == nil {
4792 if !ec.HasError(rctx) {
4793 ec.Errorf(ctx, "must not be null")
4794 }
4795 return graphql.Null
4796 }
4797 res := resTmp.([]*models.CommentEdge)
4798 rctx.Result = res
4799 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4800 return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, field.Selections, res)
4801}
4802
4803func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4804 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4805 defer func() {
4806 if r := recover(); r != nil {
4807 ec.Error(ctx, ec.Recover(ctx, r))
4808 ret = graphql.Null
4809 }
4810 ec.Tracer.EndFieldExecution(ctx)
4811 }()
4812 rctx := &graphql.ResolverContext{
4813 Object: "CommentConnection",
4814 Field: field,
4815 Args: nil,
4816 IsMethod: false,
4817 }
4818 ctx = graphql.WithResolverContext(ctx, rctx)
4819 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4820 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4821 ctx = rctx // use context from middleware stack in children
4822 return obj.Nodes, nil
4823 })
4824 if err != nil {
4825 ec.Error(ctx, err)
4826 return graphql.Null
4827 }
4828 if resTmp == nil {
4829 if !ec.HasError(rctx) {
4830 ec.Errorf(ctx, "must not be null")
4831 }
4832 return graphql.Null
4833 }
4834 res := resTmp.([]*bug.Comment)
4835 rctx.Result = res
4836 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4837 return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
4838}
4839
4840func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4841 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4842 defer func() {
4843 if r := recover(); r != nil {
4844 ec.Error(ctx, ec.Recover(ctx, r))
4845 ret = graphql.Null
4846 }
4847 ec.Tracer.EndFieldExecution(ctx)
4848 }()
4849 rctx := &graphql.ResolverContext{
4850 Object: "CommentConnection",
4851 Field: field,
4852 Args: nil,
4853 IsMethod: false,
4854 }
4855 ctx = graphql.WithResolverContext(ctx, rctx)
4856 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4857 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4858 ctx = rctx // use context from middleware stack in children
4859 return obj.PageInfo, nil
4860 })
4861 if err != nil {
4862 ec.Error(ctx, err)
4863 return graphql.Null
4864 }
4865 if resTmp == nil {
4866 if !ec.HasError(rctx) {
4867 ec.Errorf(ctx, "must not be null")
4868 }
4869 return graphql.Null
4870 }
4871 res := resTmp.(*models.PageInfo)
4872 rctx.Result = res
4873 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4874 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4875}
4876
4877func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4878 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4879 defer func() {
4880 if r := recover(); r != nil {
4881 ec.Error(ctx, ec.Recover(ctx, r))
4882 ret = graphql.Null
4883 }
4884 ec.Tracer.EndFieldExecution(ctx)
4885 }()
4886 rctx := &graphql.ResolverContext{
4887 Object: "CommentConnection",
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, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4895 ctx = rctx // use context from middleware stack in children
4896 return obj.TotalCount, nil
4897 })
4898 if err != nil {
4899 ec.Error(ctx, err)
4900 return graphql.Null
4901 }
4902 if resTmp == nil {
4903 if !ec.HasError(rctx) {
4904 ec.Errorf(ctx, "must not be null")
4905 }
4906 return graphql.Null
4907 }
4908 res := resTmp.(int)
4909 rctx.Result = res
4910 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4911 return ec.marshalNInt2int(ctx, field.Selections, res)
4912}
4913
4914func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
4915 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4916 defer func() {
4917 if r := recover(); r != nil {
4918 ec.Error(ctx, ec.Recover(ctx, r))
4919 ret = graphql.Null
4920 }
4921 ec.Tracer.EndFieldExecution(ctx)
4922 }()
4923 rctx := &graphql.ResolverContext{
4924 Object: "CommentEdge",
4925 Field: field,
4926 Args: nil,
4927 IsMethod: false,
4928 }
4929 ctx = graphql.WithResolverContext(ctx, rctx)
4930 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4931 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4932 ctx = rctx // use context from middleware stack in children
4933 return obj.Cursor, nil
4934 })
4935 if err != nil {
4936 ec.Error(ctx, err)
4937 return graphql.Null
4938 }
4939 if resTmp == nil {
4940 if !ec.HasError(rctx) {
4941 ec.Errorf(ctx, "must not be null")
4942 }
4943 return graphql.Null
4944 }
4945 res := resTmp.(string)
4946 rctx.Result = res
4947 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4948 return ec.marshalNString2string(ctx, field.Selections, res)
4949}
4950
4951func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
4952 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4953 defer func() {
4954 if r := recover(); r != nil {
4955 ec.Error(ctx, ec.Recover(ctx, r))
4956 ret = graphql.Null
4957 }
4958 ec.Tracer.EndFieldExecution(ctx)
4959 }()
4960 rctx := &graphql.ResolverContext{
4961 Object: "CommentEdge",
4962 Field: field,
4963 Args: nil,
4964 IsMethod: false,
4965 }
4966 ctx = graphql.WithResolverContext(ctx, rctx)
4967 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4968 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4969 ctx = rctx // use context from middleware stack in children
4970 return obj.Node, nil
4971 })
4972 if err != nil {
4973 ec.Error(ctx, err)
4974 return graphql.Null
4975 }
4976 if resTmp == nil {
4977 if !ec.HasError(rctx) {
4978 ec.Errorf(ctx, "must not be null")
4979 }
4980 return graphql.Null
4981 }
4982 res := resTmp.(*bug.Comment)
4983 rctx.Result = res
4984 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4985 return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
4986}
4987
4988func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
4989 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4990 defer func() {
4991 if r := recover(); r != nil {
4992 ec.Error(ctx, ec.Recover(ctx, r))
4993 ret = graphql.Null
4994 }
4995 ec.Tracer.EndFieldExecution(ctx)
4996 }()
4997 rctx := &graphql.ResolverContext{
4998 Object: "CommentHistoryStep",
4999 Field: field,
5000 Args: nil,
5001 IsMethod: false,
5002 }
5003 ctx = graphql.WithResolverContext(ctx, rctx)
5004 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5005 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5006 ctx = rctx // use context from middleware stack in children
5007 return obj.Message, nil
5008 })
5009 if err != nil {
5010 ec.Error(ctx, err)
5011 return graphql.Null
5012 }
5013 if resTmp == nil {
5014 if !ec.HasError(rctx) {
5015 ec.Errorf(ctx, "must not be null")
5016 }
5017 return graphql.Null
5018 }
5019 res := resTmp.(string)
5020 rctx.Result = res
5021 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5022 return ec.marshalNString2string(ctx, field.Selections, res)
5023}
5024
5025func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
5026 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5027 defer func() {
5028 if r := recover(); r != nil {
5029 ec.Error(ctx, ec.Recover(ctx, r))
5030 ret = graphql.Null
5031 }
5032 ec.Tracer.EndFieldExecution(ctx)
5033 }()
5034 rctx := &graphql.ResolverContext{
5035 Object: "CommentHistoryStep",
5036 Field: field,
5037 Args: nil,
5038 IsMethod: true,
5039 }
5040 ctx = graphql.WithResolverContext(ctx, rctx)
5041 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5042 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5043 ctx = rctx // use context from middleware stack in children
5044 return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
5045 })
5046 if err != nil {
5047 ec.Error(ctx, err)
5048 return graphql.Null
5049 }
5050 if resTmp == nil {
5051 if !ec.HasError(rctx) {
5052 ec.Errorf(ctx, "must not be null")
5053 }
5054 return graphql.Null
5055 }
5056 res := resTmp.(*time.Time)
5057 rctx.Result = res
5058 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5059 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5060}
5061
5062func (ec *executionContext) _CommitAsNeededPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
5063 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5064 defer func() {
5065 if r := recover(); r != nil {
5066 ec.Error(ctx, ec.Recover(ctx, r))
5067 ret = graphql.Null
5068 }
5069 ec.Tracer.EndFieldExecution(ctx)
5070 }()
5071 rctx := &graphql.ResolverContext{
5072 Object: "CommitAsNeededPayload",
5073 Field: field,
5074 Args: nil,
5075 IsMethod: false,
5076 }
5077 ctx = graphql.WithResolverContext(ctx, rctx)
5078 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5079 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5080 ctx = rctx // use context from middleware stack in children
5081 return obj.ClientMutationID, nil
5082 })
5083 if err != nil {
5084 ec.Error(ctx, err)
5085 return graphql.Null
5086 }
5087 if resTmp == nil {
5088 return graphql.Null
5089 }
5090 res := resTmp.(*string)
5091 rctx.Result = res
5092 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5093 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5094}
5095
5096func (ec *executionContext) _CommitAsNeededPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
5097 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5098 defer func() {
5099 if r := recover(); r != nil {
5100 ec.Error(ctx, ec.Recover(ctx, r))
5101 ret = graphql.Null
5102 }
5103 ec.Tracer.EndFieldExecution(ctx)
5104 }()
5105 rctx := &graphql.ResolverContext{
5106 Object: "CommitAsNeededPayload",
5107 Field: field,
5108 Args: nil,
5109 IsMethod: false,
5110 }
5111 ctx = graphql.WithResolverContext(ctx, rctx)
5112 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5113 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5114 ctx = rctx // use context from middleware stack in children
5115 return obj.Bug, nil
5116 })
5117 if err != nil {
5118 ec.Error(ctx, err)
5119 return graphql.Null
5120 }
5121 if resTmp == nil {
5122 if !ec.HasError(rctx) {
5123 ec.Errorf(ctx, "must not be null")
5124 }
5125 return graphql.Null
5126 }
5127 res := resTmp.(*bug.Snapshot)
5128 rctx.Result = res
5129 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5130 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
5131}
5132
5133func (ec *executionContext) _CommitPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
5134 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5135 defer func() {
5136 if r := recover(); r != nil {
5137 ec.Error(ctx, ec.Recover(ctx, r))
5138 ret = graphql.Null
5139 }
5140 ec.Tracer.EndFieldExecution(ctx)
5141 }()
5142 rctx := &graphql.ResolverContext{
5143 Object: "CommitPayload",
5144 Field: field,
5145 Args: nil,
5146 IsMethod: false,
5147 }
5148 ctx = graphql.WithResolverContext(ctx, rctx)
5149 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5150 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5151 ctx = rctx // use context from middleware stack in children
5152 return obj.ClientMutationID, nil
5153 })
5154 if err != nil {
5155 ec.Error(ctx, err)
5156 return graphql.Null
5157 }
5158 if resTmp == nil {
5159 return graphql.Null
5160 }
5161 res := resTmp.(*string)
5162 rctx.Result = res
5163 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5164 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5165}
5166
5167func (ec *executionContext) _CommitPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
5168 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5169 defer func() {
5170 if r := recover(); r != nil {
5171 ec.Error(ctx, ec.Recover(ctx, r))
5172 ret = graphql.Null
5173 }
5174 ec.Tracer.EndFieldExecution(ctx)
5175 }()
5176 rctx := &graphql.ResolverContext{
5177 Object: "CommitPayload",
5178 Field: field,
5179 Args: nil,
5180 IsMethod: false,
5181 }
5182 ctx = graphql.WithResolverContext(ctx, rctx)
5183 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5184 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5185 ctx = rctx // use context from middleware stack in children
5186 return obj.Bug, nil
5187 })
5188 if err != nil {
5189 ec.Error(ctx, err)
5190 return graphql.Null
5191 }
5192 if resTmp == nil {
5193 if !ec.HasError(rctx) {
5194 ec.Errorf(ctx, "must not be null")
5195 }
5196 return graphql.Null
5197 }
5198 res := resTmp.(*bug.Snapshot)
5199 rctx.Result = res
5200 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5201 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
5202}
5203
5204func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5205 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5206 defer func() {
5207 if r := recover(); r != nil {
5208 ec.Error(ctx, ec.Recover(ctx, r))
5209 ret = graphql.Null
5210 }
5211 ec.Tracer.EndFieldExecution(ctx)
5212 }()
5213 rctx := &graphql.ResolverContext{
5214 Object: "CreateOperation",
5215 Field: field,
5216 Args: nil,
5217 IsMethod: true,
5218 }
5219 ctx = graphql.WithResolverContext(ctx, rctx)
5220 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5221 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5222 ctx = rctx // use context from middleware stack in children
5223 return ec.resolvers.CreateOperation().ID(rctx, obj)
5224 })
5225 if err != nil {
5226 ec.Error(ctx, err)
5227 return graphql.Null
5228 }
5229 if resTmp == nil {
5230 if !ec.HasError(rctx) {
5231 ec.Errorf(ctx, "must not be null")
5232 }
5233 return graphql.Null
5234 }
5235 res := resTmp.(string)
5236 rctx.Result = res
5237 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5238 return ec.marshalNString2string(ctx, field.Selections, res)
5239}
5240
5241func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5242 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5243 defer func() {
5244 if r := recover(); r != nil {
5245 ec.Error(ctx, ec.Recover(ctx, r))
5246 ret = graphql.Null
5247 }
5248 ec.Tracer.EndFieldExecution(ctx)
5249 }()
5250 rctx := &graphql.ResolverContext{
5251 Object: "CreateOperation",
5252 Field: field,
5253 Args: nil,
5254 IsMethod: false,
5255 }
5256 ctx = graphql.WithResolverContext(ctx, rctx)
5257 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5258 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5259 ctx = rctx // use context from middleware stack in children
5260 return obj.Author, nil
5261 })
5262 if err != nil {
5263 ec.Error(ctx, err)
5264 return graphql.Null
5265 }
5266 if resTmp == nil {
5267 if !ec.HasError(rctx) {
5268 ec.Errorf(ctx, "must not be null")
5269 }
5270 return graphql.Null
5271 }
5272 res := resTmp.(identity.Interface)
5273 rctx.Result = res
5274 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5275 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
5276}
5277
5278func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5279 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5280 defer func() {
5281 if r := recover(); r != nil {
5282 ec.Error(ctx, ec.Recover(ctx, r))
5283 ret = graphql.Null
5284 }
5285 ec.Tracer.EndFieldExecution(ctx)
5286 }()
5287 rctx := &graphql.ResolverContext{
5288 Object: "CreateOperation",
5289 Field: field,
5290 Args: nil,
5291 IsMethod: true,
5292 }
5293 ctx = graphql.WithResolverContext(ctx, rctx)
5294 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5295 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5296 ctx = rctx // use context from middleware stack in children
5297 return ec.resolvers.CreateOperation().Date(rctx, obj)
5298 })
5299 if err != nil {
5300 ec.Error(ctx, err)
5301 return graphql.Null
5302 }
5303 if resTmp == nil {
5304 if !ec.HasError(rctx) {
5305 ec.Errorf(ctx, "must not be null")
5306 }
5307 return graphql.Null
5308 }
5309 res := resTmp.(*time.Time)
5310 rctx.Result = res
5311 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5312 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5313}
5314
5315func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5316 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5317 defer func() {
5318 if r := recover(); r != nil {
5319 ec.Error(ctx, ec.Recover(ctx, r))
5320 ret = graphql.Null
5321 }
5322 ec.Tracer.EndFieldExecution(ctx)
5323 }()
5324 rctx := &graphql.ResolverContext{
5325 Object: "CreateOperation",
5326 Field: field,
5327 Args: nil,
5328 IsMethod: false,
5329 }
5330 ctx = graphql.WithResolverContext(ctx, rctx)
5331 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5332 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5333 ctx = rctx // use context from middleware stack in children
5334 return obj.Title, nil
5335 })
5336 if err != nil {
5337 ec.Error(ctx, err)
5338 return graphql.Null
5339 }
5340 if resTmp == nil {
5341 if !ec.HasError(rctx) {
5342 ec.Errorf(ctx, "must not be null")
5343 }
5344 return graphql.Null
5345 }
5346 res := resTmp.(string)
5347 rctx.Result = res
5348 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5349 return ec.marshalNString2string(ctx, field.Selections, res)
5350}
5351
5352func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5353 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5354 defer func() {
5355 if r := recover(); r != nil {
5356 ec.Error(ctx, ec.Recover(ctx, r))
5357 ret = graphql.Null
5358 }
5359 ec.Tracer.EndFieldExecution(ctx)
5360 }()
5361 rctx := &graphql.ResolverContext{
5362 Object: "CreateOperation",
5363 Field: field,
5364 Args: nil,
5365 IsMethod: false,
5366 }
5367 ctx = graphql.WithResolverContext(ctx, rctx)
5368 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5369 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5370 ctx = rctx // use context from middleware stack in children
5371 return obj.Message, nil
5372 })
5373 if err != nil {
5374 ec.Error(ctx, err)
5375 return graphql.Null
5376 }
5377 if resTmp == nil {
5378 if !ec.HasError(rctx) {
5379 ec.Errorf(ctx, "must not be null")
5380 }
5381 return graphql.Null
5382 }
5383 res := resTmp.(string)
5384 rctx.Result = res
5385 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5386 return ec.marshalNString2string(ctx, field.Selections, res)
5387}
5388
5389func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5390 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5391 defer func() {
5392 if r := recover(); r != nil {
5393 ec.Error(ctx, ec.Recover(ctx, r))
5394 ret = graphql.Null
5395 }
5396 ec.Tracer.EndFieldExecution(ctx)
5397 }()
5398 rctx := &graphql.ResolverContext{
5399 Object: "CreateOperation",
5400 Field: field,
5401 Args: nil,
5402 IsMethod: false,
5403 }
5404 ctx = graphql.WithResolverContext(ctx, rctx)
5405 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5406 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5407 ctx = rctx // use context from middleware stack in children
5408 return obj.Files, nil
5409 })
5410 if err != nil {
5411 ec.Error(ctx, err)
5412 return graphql.Null
5413 }
5414 if resTmp == nil {
5415 if !ec.HasError(rctx) {
5416 ec.Errorf(ctx, "must not be null")
5417 }
5418 return graphql.Null
5419 }
5420 res := resTmp.([]git.Hash)
5421 rctx.Result = res
5422 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5423 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
5424}
5425
5426func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5427 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5428 defer func() {
5429 if r := recover(); r != nil {
5430 ec.Error(ctx, ec.Recover(ctx, r))
5431 ret = graphql.Null
5432 }
5433 ec.Tracer.EndFieldExecution(ctx)
5434 }()
5435 rctx := &graphql.ResolverContext{
5436 Object: "CreateTimelineItem",
5437 Field: field,
5438 Args: nil,
5439 IsMethod: true,
5440 }
5441 ctx = graphql.WithResolverContext(ctx, rctx)
5442 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5443 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5444 ctx = rctx // use context from middleware stack in children
5445 return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
5446 })
5447 if err != nil {
5448 ec.Error(ctx, err)
5449 return graphql.Null
5450 }
5451 if resTmp == nil {
5452 if !ec.HasError(rctx) {
5453 ec.Errorf(ctx, "must not be null")
5454 }
5455 return graphql.Null
5456 }
5457 res := resTmp.(string)
5458 rctx.Result = res
5459 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5460 return ec.marshalNString2string(ctx, field.Selections, res)
5461}
5462
5463func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5464 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5465 defer func() {
5466 if r := recover(); r != nil {
5467 ec.Error(ctx, ec.Recover(ctx, r))
5468 ret = graphql.Null
5469 }
5470 ec.Tracer.EndFieldExecution(ctx)
5471 }()
5472 rctx := &graphql.ResolverContext{
5473 Object: "CreateTimelineItem",
5474 Field: field,
5475 Args: nil,
5476 IsMethod: false,
5477 }
5478 ctx = graphql.WithResolverContext(ctx, rctx)
5479 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5480 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5481 ctx = rctx // use context from middleware stack in children
5482 return obj.Author, nil
5483 })
5484 if err != nil {
5485 ec.Error(ctx, err)
5486 return graphql.Null
5487 }
5488 if resTmp == nil {
5489 if !ec.HasError(rctx) {
5490 ec.Errorf(ctx, "must not be null")
5491 }
5492 return graphql.Null
5493 }
5494 res := resTmp.(identity.Interface)
5495 rctx.Result = res
5496 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5497 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
5498}
5499
5500func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5501 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5502 defer func() {
5503 if r := recover(); r != nil {
5504 ec.Error(ctx, ec.Recover(ctx, r))
5505 ret = graphql.Null
5506 }
5507 ec.Tracer.EndFieldExecution(ctx)
5508 }()
5509 rctx := &graphql.ResolverContext{
5510 Object: "CreateTimelineItem",
5511 Field: field,
5512 Args: nil,
5513 IsMethod: false,
5514 }
5515 ctx = graphql.WithResolverContext(ctx, rctx)
5516 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5517 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5518 ctx = rctx // use context from middleware stack in children
5519 return obj.Message, nil
5520 })
5521 if err != nil {
5522 ec.Error(ctx, err)
5523 return graphql.Null
5524 }
5525 if resTmp == nil {
5526 if !ec.HasError(rctx) {
5527 ec.Errorf(ctx, "must not be null")
5528 }
5529 return graphql.Null
5530 }
5531 res := resTmp.(string)
5532 rctx.Result = res
5533 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5534 return ec.marshalNString2string(ctx, field.Selections, res)
5535}
5536
5537func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5538 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5539 defer func() {
5540 if r := recover(); r != nil {
5541 ec.Error(ctx, ec.Recover(ctx, r))
5542 ret = graphql.Null
5543 }
5544 ec.Tracer.EndFieldExecution(ctx)
5545 }()
5546 rctx := &graphql.ResolverContext{
5547 Object: "CreateTimelineItem",
5548 Field: field,
5549 Args: nil,
5550 IsMethod: true,
5551 }
5552 ctx = graphql.WithResolverContext(ctx, rctx)
5553 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5554 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5555 ctx = rctx // use context from middleware stack in children
5556 return obj.MessageIsEmpty(), nil
5557 })
5558 if err != nil {
5559 ec.Error(ctx, err)
5560 return graphql.Null
5561 }
5562 if resTmp == nil {
5563 if !ec.HasError(rctx) {
5564 ec.Errorf(ctx, "must not be null")
5565 }
5566 return graphql.Null
5567 }
5568 res := resTmp.(bool)
5569 rctx.Result = res
5570 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5571 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5572}
5573
5574func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5575 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5576 defer func() {
5577 if r := recover(); r != nil {
5578 ec.Error(ctx, ec.Recover(ctx, r))
5579 ret = graphql.Null
5580 }
5581 ec.Tracer.EndFieldExecution(ctx)
5582 }()
5583 rctx := &graphql.ResolverContext{
5584 Object: "CreateTimelineItem",
5585 Field: field,
5586 Args: nil,
5587 IsMethod: false,
5588 }
5589 ctx = graphql.WithResolverContext(ctx, rctx)
5590 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5591 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5592 ctx = rctx // use context from middleware stack in children
5593 return obj.Files, nil
5594 })
5595 if err != nil {
5596 ec.Error(ctx, err)
5597 return graphql.Null
5598 }
5599 if resTmp == nil {
5600 if !ec.HasError(rctx) {
5601 ec.Errorf(ctx, "must not be null")
5602 }
5603 return graphql.Null
5604 }
5605 res := resTmp.([]git.Hash)
5606 rctx.Result = res
5607 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5608 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
5609}
5610
5611func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5612 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5613 defer func() {
5614 if r := recover(); r != nil {
5615 ec.Error(ctx, ec.Recover(ctx, r))
5616 ret = graphql.Null
5617 }
5618 ec.Tracer.EndFieldExecution(ctx)
5619 }()
5620 rctx := &graphql.ResolverContext{
5621 Object: "CreateTimelineItem",
5622 Field: field,
5623 Args: nil,
5624 IsMethod: true,
5625 }
5626 ctx = graphql.WithResolverContext(ctx, rctx)
5627 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5628 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5629 ctx = rctx // use context from middleware stack in children
5630 return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
5631 })
5632 if err != nil {
5633 ec.Error(ctx, err)
5634 return graphql.Null
5635 }
5636 if resTmp == nil {
5637 if !ec.HasError(rctx) {
5638 ec.Errorf(ctx, "must not be null")
5639 }
5640 return graphql.Null
5641 }
5642 res := resTmp.(*time.Time)
5643 rctx.Result = res
5644 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5645 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5646}
5647
5648func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5649 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5650 defer func() {
5651 if r := recover(); r != nil {
5652 ec.Error(ctx, ec.Recover(ctx, r))
5653 ret = graphql.Null
5654 }
5655 ec.Tracer.EndFieldExecution(ctx)
5656 }()
5657 rctx := &graphql.ResolverContext{
5658 Object: "CreateTimelineItem",
5659 Field: field,
5660 Args: nil,
5661 IsMethod: true,
5662 }
5663 ctx = graphql.WithResolverContext(ctx, rctx)
5664 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5665 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5666 ctx = rctx // use context from middleware stack in children
5667 return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
5668 })
5669 if err != nil {
5670 ec.Error(ctx, err)
5671 return graphql.Null
5672 }
5673 if resTmp == nil {
5674 if !ec.HasError(rctx) {
5675 ec.Errorf(ctx, "must not be null")
5676 }
5677 return graphql.Null
5678 }
5679 res := resTmp.(*time.Time)
5680 rctx.Result = res
5681 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5682 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5683}
5684
5685func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5686 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5687 defer func() {
5688 if r := recover(); r != nil {
5689 ec.Error(ctx, ec.Recover(ctx, r))
5690 ret = graphql.Null
5691 }
5692 ec.Tracer.EndFieldExecution(ctx)
5693 }()
5694 rctx := &graphql.ResolverContext{
5695 Object: "CreateTimelineItem",
5696 Field: field,
5697 Args: nil,
5698 IsMethod: true,
5699 }
5700 ctx = graphql.WithResolverContext(ctx, rctx)
5701 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5702 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5703 ctx = rctx // use context from middleware stack in children
5704 return obj.Edited(), nil
5705 })
5706 if err != nil {
5707 ec.Error(ctx, err)
5708 return graphql.Null
5709 }
5710 if resTmp == nil {
5711 if !ec.HasError(rctx) {
5712 ec.Errorf(ctx, "must not be null")
5713 }
5714 return graphql.Null
5715 }
5716 res := resTmp.(bool)
5717 rctx.Result = res
5718 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5719 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5720}
5721
5722func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5723 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5724 defer func() {
5725 if r := recover(); r != nil {
5726 ec.Error(ctx, ec.Recover(ctx, r))
5727 ret = graphql.Null
5728 }
5729 ec.Tracer.EndFieldExecution(ctx)
5730 }()
5731 rctx := &graphql.ResolverContext{
5732 Object: "CreateTimelineItem",
5733 Field: field,
5734 Args: nil,
5735 IsMethod: false,
5736 }
5737 ctx = graphql.WithResolverContext(ctx, rctx)
5738 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5739 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5740 ctx = rctx // use context from middleware stack in children
5741 return obj.History, nil
5742 })
5743 if err != nil {
5744 ec.Error(ctx, err)
5745 return graphql.Null
5746 }
5747 if resTmp == nil {
5748 if !ec.HasError(rctx) {
5749 ec.Errorf(ctx, "must not be null")
5750 }
5751 return graphql.Null
5752 }
5753 res := resTmp.([]bug.CommentHistoryStep)
5754 rctx.Result = res
5755 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5756 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, field.Selections, res)
5757}
5758
5759func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5760 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5761 defer func() {
5762 if r := recover(); r != nil {
5763 ec.Error(ctx, ec.Recover(ctx, r))
5764 ret = graphql.Null
5765 }
5766 ec.Tracer.EndFieldExecution(ctx)
5767 }()
5768 rctx := &graphql.ResolverContext{
5769 Object: "EditCommentOperation",
5770 Field: field,
5771 Args: nil,
5772 IsMethod: true,
5773 }
5774 ctx = graphql.WithResolverContext(ctx, rctx)
5775 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5776 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5777 ctx = rctx // use context from middleware stack in children
5778 return ec.resolvers.EditCommentOperation().ID(rctx, obj)
5779 })
5780 if err != nil {
5781 ec.Error(ctx, err)
5782 return graphql.Null
5783 }
5784 if resTmp == nil {
5785 if !ec.HasError(rctx) {
5786 ec.Errorf(ctx, "must not be null")
5787 }
5788 return graphql.Null
5789 }
5790 res := resTmp.(string)
5791 rctx.Result = res
5792 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5793 return ec.marshalNString2string(ctx, field.Selections, res)
5794}
5795
5796func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5797 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5798 defer func() {
5799 if r := recover(); r != nil {
5800 ec.Error(ctx, ec.Recover(ctx, r))
5801 ret = graphql.Null
5802 }
5803 ec.Tracer.EndFieldExecution(ctx)
5804 }()
5805 rctx := &graphql.ResolverContext{
5806 Object: "EditCommentOperation",
5807 Field: field,
5808 Args: nil,
5809 IsMethod: false,
5810 }
5811 ctx = graphql.WithResolverContext(ctx, rctx)
5812 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5813 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5814 ctx = rctx // use context from middleware stack in children
5815 return obj.Author, nil
5816 })
5817 if err != nil {
5818 ec.Error(ctx, err)
5819 return graphql.Null
5820 }
5821 if resTmp == nil {
5822 if !ec.HasError(rctx) {
5823 ec.Errorf(ctx, "must not be null")
5824 }
5825 return graphql.Null
5826 }
5827 res := resTmp.(identity.Interface)
5828 rctx.Result = res
5829 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5830 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
5831}
5832
5833func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5834 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5835 defer func() {
5836 if r := recover(); r != nil {
5837 ec.Error(ctx, ec.Recover(ctx, r))
5838 ret = graphql.Null
5839 }
5840 ec.Tracer.EndFieldExecution(ctx)
5841 }()
5842 rctx := &graphql.ResolverContext{
5843 Object: "EditCommentOperation",
5844 Field: field,
5845 Args: nil,
5846 IsMethod: true,
5847 }
5848 ctx = graphql.WithResolverContext(ctx, rctx)
5849 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5850 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5851 ctx = rctx // use context from middleware stack in children
5852 return ec.resolvers.EditCommentOperation().Date(rctx, obj)
5853 })
5854 if err != nil {
5855 ec.Error(ctx, err)
5856 return graphql.Null
5857 }
5858 if resTmp == nil {
5859 if !ec.HasError(rctx) {
5860 ec.Errorf(ctx, "must not be null")
5861 }
5862 return graphql.Null
5863 }
5864 res := resTmp.(*time.Time)
5865 rctx.Result = res
5866 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5867 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5868}
5869
5870func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5871 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5872 defer func() {
5873 if r := recover(); r != nil {
5874 ec.Error(ctx, ec.Recover(ctx, r))
5875 ret = graphql.Null
5876 }
5877 ec.Tracer.EndFieldExecution(ctx)
5878 }()
5879 rctx := &graphql.ResolverContext{
5880 Object: "EditCommentOperation",
5881 Field: field,
5882 Args: nil,
5883 IsMethod: true,
5884 }
5885 ctx = graphql.WithResolverContext(ctx, rctx)
5886 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5887 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5888 ctx = rctx // use context from middleware stack in children
5889 return ec.resolvers.EditCommentOperation().Target(rctx, obj)
5890 })
5891 if err != nil {
5892 ec.Error(ctx, err)
5893 return graphql.Null
5894 }
5895 if resTmp == nil {
5896 if !ec.HasError(rctx) {
5897 ec.Errorf(ctx, "must not be null")
5898 }
5899 return graphql.Null
5900 }
5901 res := resTmp.(string)
5902 rctx.Result = res
5903 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5904 return ec.marshalNString2string(ctx, field.Selections, res)
5905}
5906
5907func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5908 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5909 defer func() {
5910 if r := recover(); r != nil {
5911 ec.Error(ctx, ec.Recover(ctx, r))
5912 ret = graphql.Null
5913 }
5914 ec.Tracer.EndFieldExecution(ctx)
5915 }()
5916 rctx := &graphql.ResolverContext{
5917 Object: "EditCommentOperation",
5918 Field: field,
5919 Args: nil,
5920 IsMethod: false,
5921 }
5922 ctx = graphql.WithResolverContext(ctx, rctx)
5923 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5924 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5925 ctx = rctx // use context from middleware stack in children
5926 return obj.Message, nil
5927 })
5928 if err != nil {
5929 ec.Error(ctx, err)
5930 return graphql.Null
5931 }
5932 if resTmp == nil {
5933 if !ec.HasError(rctx) {
5934 ec.Errorf(ctx, "must not be null")
5935 }
5936 return graphql.Null
5937 }
5938 res := resTmp.(string)
5939 rctx.Result = res
5940 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5941 return ec.marshalNString2string(ctx, field.Selections, res)
5942}
5943
5944func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5945 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5946 defer func() {
5947 if r := recover(); r != nil {
5948 ec.Error(ctx, ec.Recover(ctx, r))
5949 ret = graphql.Null
5950 }
5951 ec.Tracer.EndFieldExecution(ctx)
5952 }()
5953 rctx := &graphql.ResolverContext{
5954 Object: "EditCommentOperation",
5955 Field: field,
5956 Args: nil,
5957 IsMethod: false,
5958 }
5959 ctx = graphql.WithResolverContext(ctx, rctx)
5960 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5961 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5962 ctx = rctx // use context from middleware stack in children
5963 return obj.Files, nil
5964 })
5965 if err != nil {
5966 ec.Error(ctx, err)
5967 return graphql.Null
5968 }
5969 if resTmp == nil {
5970 if !ec.HasError(rctx) {
5971 ec.Errorf(ctx, "must not be null")
5972 }
5973 return graphql.Null
5974 }
5975 res := resTmp.([]git.Hash)
5976 rctx.Result = res
5977 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5978 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
5979}
5980
5981func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
5982 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5983 defer func() {
5984 if r := recover(); r != nil {
5985 ec.Error(ctx, ec.Recover(ctx, r))
5986 ret = graphql.Null
5987 }
5988 ec.Tracer.EndFieldExecution(ctx)
5989 }()
5990 rctx := &graphql.ResolverContext{
5991 Object: "Identity",
5992 Field: field,
5993 Args: nil,
5994 IsMethod: true,
5995 }
5996 ctx = graphql.WithResolverContext(ctx, rctx)
5997 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5998 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5999 ctx = rctx // use context from middleware stack in children
6000 return ec.resolvers.Identity().ID(rctx, obj)
6001 })
6002 if err != nil {
6003 ec.Error(ctx, err)
6004 return graphql.Null
6005 }
6006 if resTmp == nil {
6007 if !ec.HasError(rctx) {
6008 ec.Errorf(ctx, "must not be null")
6009 }
6010 return graphql.Null
6011 }
6012 res := resTmp.(string)
6013 rctx.Result = res
6014 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6015 return ec.marshalNString2string(ctx, field.Selections, res)
6016}
6017
6018func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6019 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6020 defer func() {
6021 if r := recover(); r != nil {
6022 ec.Error(ctx, ec.Recover(ctx, r))
6023 ret = graphql.Null
6024 }
6025 ec.Tracer.EndFieldExecution(ctx)
6026 }()
6027 rctx := &graphql.ResolverContext{
6028 Object: "Identity",
6029 Field: field,
6030 Args: nil,
6031 IsMethod: true,
6032 }
6033 ctx = graphql.WithResolverContext(ctx, rctx)
6034 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6035 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6036 ctx = rctx // use context from middleware stack in children
6037 return ec.resolvers.Identity().HumanID(rctx, obj)
6038 })
6039 if err != nil {
6040 ec.Error(ctx, err)
6041 return graphql.Null
6042 }
6043 if resTmp == nil {
6044 if !ec.HasError(rctx) {
6045 ec.Errorf(ctx, "must not be null")
6046 }
6047 return graphql.Null
6048 }
6049 res := resTmp.(string)
6050 rctx.Result = res
6051 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6052 return ec.marshalNString2string(ctx, field.Selections, res)
6053}
6054
6055func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6056 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6057 defer func() {
6058 if r := recover(); r != nil {
6059 ec.Error(ctx, ec.Recover(ctx, r))
6060 ret = graphql.Null
6061 }
6062 ec.Tracer.EndFieldExecution(ctx)
6063 }()
6064 rctx := &graphql.ResolverContext{
6065 Object: "Identity",
6066 Field: field,
6067 Args: nil,
6068 IsMethod: true,
6069 }
6070 ctx = graphql.WithResolverContext(ctx, rctx)
6071 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6072 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6073 ctx = rctx // use context from middleware stack in children
6074 return ec.resolvers.Identity().Name(rctx, obj)
6075 })
6076 if err != nil {
6077 ec.Error(ctx, err)
6078 return graphql.Null
6079 }
6080 if resTmp == nil {
6081 return graphql.Null
6082 }
6083 res := resTmp.(*string)
6084 rctx.Result = res
6085 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6086 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6087}
6088
6089func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6090 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6091 defer func() {
6092 if r := recover(); r != nil {
6093 ec.Error(ctx, ec.Recover(ctx, r))
6094 ret = graphql.Null
6095 }
6096 ec.Tracer.EndFieldExecution(ctx)
6097 }()
6098 rctx := &graphql.ResolverContext{
6099 Object: "Identity",
6100 Field: field,
6101 Args: nil,
6102 IsMethod: true,
6103 }
6104 ctx = graphql.WithResolverContext(ctx, rctx)
6105 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6106 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6107 ctx = rctx // use context from middleware stack in children
6108 return ec.resolvers.Identity().Email(rctx, obj)
6109 })
6110 if err != nil {
6111 ec.Error(ctx, err)
6112 return graphql.Null
6113 }
6114 if resTmp == nil {
6115 return graphql.Null
6116 }
6117 res := resTmp.(*string)
6118 rctx.Result = res
6119 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6120 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6121}
6122
6123func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6124 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6125 defer func() {
6126 if r := recover(); r != nil {
6127 ec.Error(ctx, ec.Recover(ctx, r))
6128 ret = graphql.Null
6129 }
6130 ec.Tracer.EndFieldExecution(ctx)
6131 }()
6132 rctx := &graphql.ResolverContext{
6133 Object: "Identity",
6134 Field: field,
6135 Args: nil,
6136 IsMethod: true,
6137 }
6138 ctx = graphql.WithResolverContext(ctx, rctx)
6139 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6140 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6141 ctx = rctx // use context from middleware stack in children
6142 return ec.resolvers.Identity().Login(rctx, obj)
6143 })
6144 if err != nil {
6145 ec.Error(ctx, err)
6146 return graphql.Null
6147 }
6148 if resTmp == nil {
6149 return graphql.Null
6150 }
6151 res := resTmp.(*string)
6152 rctx.Result = res
6153 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6154 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6155}
6156
6157func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6158 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6159 defer func() {
6160 if r := recover(); r != nil {
6161 ec.Error(ctx, ec.Recover(ctx, r))
6162 ret = graphql.Null
6163 }
6164 ec.Tracer.EndFieldExecution(ctx)
6165 }()
6166 rctx := &graphql.ResolverContext{
6167 Object: "Identity",
6168 Field: field,
6169 Args: nil,
6170 IsMethod: true,
6171 }
6172 ctx = graphql.WithResolverContext(ctx, rctx)
6173 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6174 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6175 ctx = rctx // use context from middleware stack in children
6176 return ec.resolvers.Identity().DisplayName(rctx, obj)
6177 })
6178 if err != nil {
6179 ec.Error(ctx, err)
6180 return graphql.Null
6181 }
6182 if resTmp == nil {
6183 if !ec.HasError(rctx) {
6184 ec.Errorf(ctx, "must not be null")
6185 }
6186 return graphql.Null
6187 }
6188 res := resTmp.(string)
6189 rctx.Result = res
6190 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6191 return ec.marshalNString2string(ctx, field.Selections, res)
6192}
6193
6194func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6195 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6196 defer func() {
6197 if r := recover(); r != nil {
6198 ec.Error(ctx, ec.Recover(ctx, r))
6199 ret = graphql.Null
6200 }
6201 ec.Tracer.EndFieldExecution(ctx)
6202 }()
6203 rctx := &graphql.ResolverContext{
6204 Object: "Identity",
6205 Field: field,
6206 Args: nil,
6207 IsMethod: true,
6208 }
6209 ctx = graphql.WithResolverContext(ctx, rctx)
6210 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6211 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6212 ctx = rctx // use context from middleware stack in children
6213 return ec.resolvers.Identity().AvatarURL(rctx, obj)
6214 })
6215 if err != nil {
6216 ec.Error(ctx, err)
6217 return graphql.Null
6218 }
6219 if resTmp == nil {
6220 return graphql.Null
6221 }
6222 res := resTmp.(*string)
6223 rctx.Result = res
6224 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6225 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6226}
6227
6228func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6229 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6230 defer func() {
6231 if r := recover(); r != nil {
6232 ec.Error(ctx, ec.Recover(ctx, r))
6233 ret = graphql.Null
6234 }
6235 ec.Tracer.EndFieldExecution(ctx)
6236 }()
6237 rctx := &graphql.ResolverContext{
6238 Object: "Identity",
6239 Field: field,
6240 Args: nil,
6241 IsMethod: true,
6242 }
6243 ctx = graphql.WithResolverContext(ctx, rctx)
6244 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6245 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6246 ctx = rctx // use context from middleware stack in children
6247 return ec.resolvers.Identity().IsProtected(rctx, obj)
6248 })
6249 if err != nil {
6250 ec.Error(ctx, err)
6251 return graphql.Null
6252 }
6253 if resTmp == nil {
6254 if !ec.HasError(rctx) {
6255 ec.Errorf(ctx, "must not be null")
6256 }
6257 return graphql.Null
6258 }
6259 res := resTmp.(bool)
6260 rctx.Result = res
6261 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6262 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6263}
6264
6265func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6266 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6267 defer func() {
6268 if r := recover(); r != nil {
6269 ec.Error(ctx, ec.Recover(ctx, r))
6270 ret = graphql.Null
6271 }
6272 ec.Tracer.EndFieldExecution(ctx)
6273 }()
6274 rctx := &graphql.ResolverContext{
6275 Object: "IdentityConnection",
6276 Field: field,
6277 Args: nil,
6278 IsMethod: false,
6279 }
6280 ctx = graphql.WithResolverContext(ctx, rctx)
6281 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6282 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6283 ctx = rctx // use context from middleware stack in children
6284 return obj.Edges, nil
6285 })
6286 if err != nil {
6287 ec.Error(ctx, err)
6288 return graphql.Null
6289 }
6290 if resTmp == nil {
6291 if !ec.HasError(rctx) {
6292 ec.Errorf(ctx, "must not be null")
6293 }
6294 return graphql.Null
6295 }
6296 res := resTmp.([]*models.IdentityEdge)
6297 rctx.Result = res
6298 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6299 return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, field.Selections, res)
6300}
6301
6302func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6303 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6304 defer func() {
6305 if r := recover(); r != nil {
6306 ec.Error(ctx, ec.Recover(ctx, r))
6307 ret = graphql.Null
6308 }
6309 ec.Tracer.EndFieldExecution(ctx)
6310 }()
6311 rctx := &graphql.ResolverContext{
6312 Object: "IdentityConnection",
6313 Field: field,
6314 Args: nil,
6315 IsMethod: false,
6316 }
6317 ctx = graphql.WithResolverContext(ctx, rctx)
6318 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6319 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6320 ctx = rctx // use context from middleware stack in children
6321 return obj.Nodes, nil
6322 })
6323 if err != nil {
6324 ec.Error(ctx, err)
6325 return graphql.Null
6326 }
6327 if resTmp == nil {
6328 if !ec.HasError(rctx) {
6329 ec.Errorf(ctx, "must not be null")
6330 }
6331 return graphql.Null
6332 }
6333 res := resTmp.([]identity.Interface)
6334 rctx.Result = res
6335 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6336 return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
6337}
6338
6339func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6340 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6341 defer func() {
6342 if r := recover(); r != nil {
6343 ec.Error(ctx, ec.Recover(ctx, r))
6344 ret = graphql.Null
6345 }
6346 ec.Tracer.EndFieldExecution(ctx)
6347 }()
6348 rctx := &graphql.ResolverContext{
6349 Object: "IdentityConnection",
6350 Field: field,
6351 Args: nil,
6352 IsMethod: false,
6353 }
6354 ctx = graphql.WithResolverContext(ctx, rctx)
6355 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6356 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6357 ctx = rctx // use context from middleware stack in children
6358 return obj.PageInfo, nil
6359 })
6360 if err != nil {
6361 ec.Error(ctx, err)
6362 return graphql.Null
6363 }
6364 if resTmp == nil {
6365 if !ec.HasError(rctx) {
6366 ec.Errorf(ctx, "must not be null")
6367 }
6368 return graphql.Null
6369 }
6370 res := resTmp.(*models.PageInfo)
6371 rctx.Result = res
6372 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6373 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
6374}
6375
6376func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6377 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6378 defer func() {
6379 if r := recover(); r != nil {
6380 ec.Error(ctx, ec.Recover(ctx, r))
6381 ret = graphql.Null
6382 }
6383 ec.Tracer.EndFieldExecution(ctx)
6384 }()
6385 rctx := &graphql.ResolverContext{
6386 Object: "IdentityConnection",
6387 Field: field,
6388 Args: nil,
6389 IsMethod: false,
6390 }
6391 ctx = graphql.WithResolverContext(ctx, rctx)
6392 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6393 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6394 ctx = rctx // use context from middleware stack in children
6395 return obj.TotalCount, nil
6396 })
6397 if err != nil {
6398 ec.Error(ctx, err)
6399 return graphql.Null
6400 }
6401 if resTmp == nil {
6402 if !ec.HasError(rctx) {
6403 ec.Errorf(ctx, "must not be null")
6404 }
6405 return graphql.Null
6406 }
6407 res := resTmp.(int)
6408 rctx.Result = res
6409 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6410 return ec.marshalNInt2int(ctx, field.Selections, res)
6411}
6412
6413func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6414 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6415 defer func() {
6416 if r := recover(); r != nil {
6417 ec.Error(ctx, ec.Recover(ctx, r))
6418 ret = graphql.Null
6419 }
6420 ec.Tracer.EndFieldExecution(ctx)
6421 }()
6422 rctx := &graphql.ResolverContext{
6423 Object: "IdentityEdge",
6424 Field: field,
6425 Args: nil,
6426 IsMethod: false,
6427 }
6428 ctx = graphql.WithResolverContext(ctx, rctx)
6429 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6430 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6431 ctx = rctx // use context from middleware stack in children
6432 return obj.Cursor, nil
6433 })
6434 if err != nil {
6435 ec.Error(ctx, err)
6436 return graphql.Null
6437 }
6438 if resTmp == nil {
6439 if !ec.HasError(rctx) {
6440 ec.Errorf(ctx, "must not be null")
6441 }
6442 return graphql.Null
6443 }
6444 res := resTmp.(string)
6445 rctx.Result = res
6446 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6447 return ec.marshalNString2string(ctx, field.Selections, res)
6448}
6449
6450func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6451 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6452 defer func() {
6453 if r := recover(); r != nil {
6454 ec.Error(ctx, ec.Recover(ctx, r))
6455 ret = graphql.Null
6456 }
6457 ec.Tracer.EndFieldExecution(ctx)
6458 }()
6459 rctx := &graphql.ResolverContext{
6460 Object: "IdentityEdge",
6461 Field: field,
6462 Args: nil,
6463 IsMethod: false,
6464 }
6465 ctx = graphql.WithResolverContext(ctx, rctx)
6466 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6467 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6468 ctx = rctx // use context from middleware stack in children
6469 return obj.Node, nil
6470 })
6471 if err != nil {
6472 ec.Error(ctx, err)
6473 return graphql.Null
6474 }
6475 if resTmp == nil {
6476 if !ec.HasError(rctx) {
6477 ec.Errorf(ctx, "must not be null")
6478 }
6479 return graphql.Null
6480 }
6481 res := resTmp.(identity.Interface)
6482 rctx.Result = res
6483 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6484 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
6485}
6486
6487func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6488 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6489 defer func() {
6490 if r := recover(); r != nil {
6491 ec.Error(ctx, ec.Recover(ctx, r))
6492 ret = graphql.Null
6493 }
6494 ec.Tracer.EndFieldExecution(ctx)
6495 }()
6496 rctx := &graphql.ResolverContext{
6497 Object: "Label",
6498 Field: field,
6499 Args: nil,
6500 IsMethod: true,
6501 }
6502 ctx = graphql.WithResolverContext(ctx, rctx)
6503 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6504 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6505 ctx = rctx // use context from middleware stack in children
6506 return ec.resolvers.Label().Name(rctx, obj)
6507 })
6508 if err != nil {
6509 ec.Error(ctx, err)
6510 return graphql.Null
6511 }
6512 if resTmp == nil {
6513 if !ec.HasError(rctx) {
6514 ec.Errorf(ctx, "must not be null")
6515 }
6516 return graphql.Null
6517 }
6518 res := resTmp.(string)
6519 rctx.Result = res
6520 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6521 return ec.marshalNString2string(ctx, field.Selections, res)
6522}
6523
6524func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6525 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6526 defer func() {
6527 if r := recover(); r != nil {
6528 ec.Error(ctx, ec.Recover(ctx, r))
6529 ret = graphql.Null
6530 }
6531 ec.Tracer.EndFieldExecution(ctx)
6532 }()
6533 rctx := &graphql.ResolverContext{
6534 Object: "Label",
6535 Field: field,
6536 Args: nil,
6537 IsMethod: true,
6538 }
6539 ctx = graphql.WithResolverContext(ctx, rctx)
6540 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6541 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6542 ctx = rctx // use context from middleware stack in children
6543 return ec.resolvers.Label().Color(rctx, obj)
6544 })
6545 if err != nil {
6546 ec.Error(ctx, err)
6547 return graphql.Null
6548 }
6549 if resTmp == nil {
6550 if !ec.HasError(rctx) {
6551 ec.Errorf(ctx, "must not be null")
6552 }
6553 return graphql.Null
6554 }
6555 res := resTmp.(*color.RGBA)
6556 rctx.Result = res
6557 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6558 return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
6559}
6560
6561func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6562 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6563 defer func() {
6564 if r := recover(); r != nil {
6565 ec.Error(ctx, ec.Recover(ctx, r))
6566 ret = graphql.Null
6567 }
6568 ec.Tracer.EndFieldExecution(ctx)
6569 }()
6570 rctx := &graphql.ResolverContext{
6571 Object: "LabelChangeOperation",
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, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6579 ctx = rctx // use context from middleware stack in children
6580 return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
6581 })
6582 if err != nil {
6583 ec.Error(ctx, err)
6584 return graphql.Null
6585 }
6586 if resTmp == nil {
6587 if !ec.HasError(rctx) {
6588 ec.Errorf(ctx, "must not be null")
6589 }
6590 return graphql.Null
6591 }
6592 res := resTmp.(string)
6593 rctx.Result = res
6594 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6595 return ec.marshalNString2string(ctx, field.Selections, res)
6596}
6597
6598func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6599 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6600 defer func() {
6601 if r := recover(); r != nil {
6602 ec.Error(ctx, ec.Recover(ctx, r))
6603 ret = graphql.Null
6604 }
6605 ec.Tracer.EndFieldExecution(ctx)
6606 }()
6607 rctx := &graphql.ResolverContext{
6608 Object: "LabelChangeOperation",
6609 Field: field,
6610 Args: nil,
6611 IsMethod: false,
6612 }
6613 ctx = graphql.WithResolverContext(ctx, rctx)
6614 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6615 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6616 ctx = rctx // use context from middleware stack in children
6617 return obj.Author, nil
6618 })
6619 if err != nil {
6620 ec.Error(ctx, err)
6621 return graphql.Null
6622 }
6623 if resTmp == nil {
6624 if !ec.HasError(rctx) {
6625 ec.Errorf(ctx, "must not be null")
6626 }
6627 return graphql.Null
6628 }
6629 res := resTmp.(identity.Interface)
6630 rctx.Result = res
6631 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6632 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
6633}
6634
6635func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6636 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6637 defer func() {
6638 if r := recover(); r != nil {
6639 ec.Error(ctx, ec.Recover(ctx, r))
6640 ret = graphql.Null
6641 }
6642 ec.Tracer.EndFieldExecution(ctx)
6643 }()
6644 rctx := &graphql.ResolverContext{
6645 Object: "LabelChangeOperation",
6646 Field: field,
6647 Args: nil,
6648 IsMethod: true,
6649 }
6650 ctx = graphql.WithResolverContext(ctx, rctx)
6651 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6652 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6653 ctx = rctx // use context from middleware stack in children
6654 return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
6655 })
6656 if err != nil {
6657 ec.Error(ctx, err)
6658 return graphql.Null
6659 }
6660 if resTmp == nil {
6661 if !ec.HasError(rctx) {
6662 ec.Errorf(ctx, "must not be null")
6663 }
6664 return graphql.Null
6665 }
6666 res := resTmp.(*time.Time)
6667 rctx.Result = res
6668 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6669 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6670}
6671
6672func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6673 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6674 defer func() {
6675 if r := recover(); r != nil {
6676 ec.Error(ctx, ec.Recover(ctx, r))
6677 ret = graphql.Null
6678 }
6679 ec.Tracer.EndFieldExecution(ctx)
6680 }()
6681 rctx := &graphql.ResolverContext{
6682 Object: "LabelChangeOperation",
6683 Field: field,
6684 Args: nil,
6685 IsMethod: false,
6686 }
6687 ctx = graphql.WithResolverContext(ctx, rctx)
6688 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6689 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6690 ctx = rctx // use context from middleware stack in children
6691 return obj.Added, nil
6692 })
6693 if err != nil {
6694 ec.Error(ctx, err)
6695 return graphql.Null
6696 }
6697 if resTmp == nil {
6698 if !ec.HasError(rctx) {
6699 ec.Errorf(ctx, "must not be null")
6700 }
6701 return graphql.Null
6702 }
6703 res := resTmp.([]bug.Label)
6704 rctx.Result = res
6705 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6706 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6707}
6708
6709func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6710 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6711 defer func() {
6712 if r := recover(); r != nil {
6713 ec.Error(ctx, ec.Recover(ctx, r))
6714 ret = graphql.Null
6715 }
6716 ec.Tracer.EndFieldExecution(ctx)
6717 }()
6718 rctx := &graphql.ResolverContext{
6719 Object: "LabelChangeOperation",
6720 Field: field,
6721 Args: nil,
6722 IsMethod: false,
6723 }
6724 ctx = graphql.WithResolverContext(ctx, rctx)
6725 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6726 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6727 ctx = rctx // use context from middleware stack in children
6728 return obj.Removed, nil
6729 })
6730 if err != nil {
6731 ec.Error(ctx, err)
6732 return graphql.Null
6733 }
6734 if resTmp == nil {
6735 if !ec.HasError(rctx) {
6736 ec.Errorf(ctx, "must not be null")
6737 }
6738 return graphql.Null
6739 }
6740 res := resTmp.([]bug.Label)
6741 rctx.Result = res
6742 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6743 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6744}
6745
6746func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6747 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6748 defer func() {
6749 if r := recover(); r != nil {
6750 ec.Error(ctx, ec.Recover(ctx, r))
6751 ret = graphql.Null
6752 }
6753 ec.Tracer.EndFieldExecution(ctx)
6754 }()
6755 rctx := &graphql.ResolverContext{
6756 Object: "LabelChangeResult",
6757 Field: field,
6758 Args: nil,
6759 IsMethod: false,
6760 }
6761 ctx = graphql.WithResolverContext(ctx, rctx)
6762 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6763 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6764 ctx = rctx // use context from middleware stack in children
6765 return obj.Label, nil
6766 })
6767 if err != nil {
6768 ec.Error(ctx, err)
6769 return graphql.Null
6770 }
6771 if resTmp == nil {
6772 if !ec.HasError(rctx) {
6773 ec.Errorf(ctx, "must not be null")
6774 }
6775 return graphql.Null
6776 }
6777 res := resTmp.(bug.Label)
6778 rctx.Result = res
6779 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6780 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6781}
6782
6783func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6784 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6785 defer func() {
6786 if r := recover(); r != nil {
6787 ec.Error(ctx, ec.Recover(ctx, r))
6788 ret = graphql.Null
6789 }
6790 ec.Tracer.EndFieldExecution(ctx)
6791 }()
6792 rctx := &graphql.ResolverContext{
6793 Object: "LabelChangeResult",
6794 Field: field,
6795 Args: nil,
6796 IsMethod: true,
6797 }
6798 ctx = graphql.WithResolverContext(ctx, rctx)
6799 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6800 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6801 ctx = rctx // use context from middleware stack in children
6802 return ec.resolvers.LabelChangeResult().Status(rctx, obj)
6803 })
6804 if err != nil {
6805 ec.Error(ctx, err)
6806 return graphql.Null
6807 }
6808 if resTmp == nil {
6809 if !ec.HasError(rctx) {
6810 ec.Errorf(ctx, "must not be null")
6811 }
6812 return graphql.Null
6813 }
6814 res := resTmp.(models.LabelChangeStatus)
6815 rctx.Result = res
6816 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6817 return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
6818}
6819
6820func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6821 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6822 defer func() {
6823 if r := recover(); r != nil {
6824 ec.Error(ctx, ec.Recover(ctx, r))
6825 ret = graphql.Null
6826 }
6827 ec.Tracer.EndFieldExecution(ctx)
6828 }()
6829 rctx := &graphql.ResolverContext{
6830 Object: "LabelChangeTimelineItem",
6831 Field: field,
6832 Args: nil,
6833 IsMethod: true,
6834 }
6835 ctx = graphql.WithResolverContext(ctx, rctx)
6836 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6837 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6838 ctx = rctx // use context from middleware stack in children
6839 return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
6840 })
6841 if err != nil {
6842 ec.Error(ctx, err)
6843 return graphql.Null
6844 }
6845 if resTmp == nil {
6846 if !ec.HasError(rctx) {
6847 ec.Errorf(ctx, "must not be null")
6848 }
6849 return graphql.Null
6850 }
6851 res := resTmp.(string)
6852 rctx.Result = res
6853 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6854 return ec.marshalNString2string(ctx, field.Selections, res)
6855}
6856
6857func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6858 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6859 defer func() {
6860 if r := recover(); r != nil {
6861 ec.Error(ctx, ec.Recover(ctx, r))
6862 ret = graphql.Null
6863 }
6864 ec.Tracer.EndFieldExecution(ctx)
6865 }()
6866 rctx := &graphql.ResolverContext{
6867 Object: "LabelChangeTimelineItem",
6868 Field: field,
6869 Args: nil,
6870 IsMethod: false,
6871 }
6872 ctx = graphql.WithResolverContext(ctx, rctx)
6873 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6874 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6875 ctx = rctx // use context from middleware stack in children
6876 return obj.Author, nil
6877 })
6878 if err != nil {
6879 ec.Error(ctx, err)
6880 return graphql.Null
6881 }
6882 if resTmp == nil {
6883 if !ec.HasError(rctx) {
6884 ec.Errorf(ctx, "must not be null")
6885 }
6886 return graphql.Null
6887 }
6888 res := resTmp.(identity.Interface)
6889 rctx.Result = res
6890 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6891 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
6892}
6893
6894func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6895 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6896 defer func() {
6897 if r := recover(); r != nil {
6898 ec.Error(ctx, ec.Recover(ctx, r))
6899 ret = graphql.Null
6900 }
6901 ec.Tracer.EndFieldExecution(ctx)
6902 }()
6903 rctx := &graphql.ResolverContext{
6904 Object: "LabelChangeTimelineItem",
6905 Field: field,
6906 Args: nil,
6907 IsMethod: true,
6908 }
6909 ctx = graphql.WithResolverContext(ctx, rctx)
6910 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6911 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6912 ctx = rctx // use context from middleware stack in children
6913 return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
6914 })
6915 if err != nil {
6916 ec.Error(ctx, err)
6917 return graphql.Null
6918 }
6919 if resTmp == nil {
6920 if !ec.HasError(rctx) {
6921 ec.Errorf(ctx, "must not be null")
6922 }
6923 return graphql.Null
6924 }
6925 res := resTmp.(*time.Time)
6926 rctx.Result = res
6927 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6928 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6929}
6930
6931func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6932 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6933 defer func() {
6934 if r := recover(); r != nil {
6935 ec.Error(ctx, ec.Recover(ctx, r))
6936 ret = graphql.Null
6937 }
6938 ec.Tracer.EndFieldExecution(ctx)
6939 }()
6940 rctx := &graphql.ResolverContext{
6941 Object: "LabelChangeTimelineItem",
6942 Field: field,
6943 Args: nil,
6944 IsMethod: false,
6945 }
6946 ctx = graphql.WithResolverContext(ctx, rctx)
6947 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6948 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6949 ctx = rctx // use context from middleware stack in children
6950 return obj.Added, nil
6951 })
6952 if err != nil {
6953 ec.Error(ctx, err)
6954 return graphql.Null
6955 }
6956 if resTmp == nil {
6957 if !ec.HasError(rctx) {
6958 ec.Errorf(ctx, "must not be null")
6959 }
6960 return graphql.Null
6961 }
6962 res := resTmp.([]bug.Label)
6963 rctx.Result = res
6964 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6965 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6966}
6967
6968func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6969 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6970 defer func() {
6971 if r := recover(); r != nil {
6972 ec.Error(ctx, ec.Recover(ctx, r))
6973 ret = graphql.Null
6974 }
6975 ec.Tracer.EndFieldExecution(ctx)
6976 }()
6977 rctx := &graphql.ResolverContext{
6978 Object: "LabelChangeTimelineItem",
6979 Field: field,
6980 Args: nil,
6981 IsMethod: false,
6982 }
6983 ctx = graphql.WithResolverContext(ctx, rctx)
6984 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6985 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6986 ctx = rctx // use context from middleware stack in children
6987 return obj.Removed, nil
6988 })
6989 if err != nil {
6990 ec.Error(ctx, err)
6991 return graphql.Null
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.([]bug.Label)
7000 rctx.Result = res
7001 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7002 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
7003}
7004
7005func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7006 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7007 defer func() {
7008 if r := recover(); r != nil {
7009 ec.Error(ctx, ec.Recover(ctx, r))
7010 ret = graphql.Null
7011 }
7012 ec.Tracer.EndFieldExecution(ctx)
7013 }()
7014 rctx := &graphql.ResolverContext{
7015 Object: "Mutation",
7016 Field: field,
7017 Args: nil,
7018 IsMethod: true,
7019 }
7020 ctx = graphql.WithResolverContext(ctx, rctx)
7021 rawArgs := field.ArgumentMap(ec.Variables)
7022 args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
7023 if err != nil {
7024 ec.Error(ctx, err)
7025 return graphql.Null
7026 }
7027 rctx.Args = args
7028 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7029 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7030 ctx = rctx // use context from middleware stack in children
7031 return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
7032 })
7033 if err != nil {
7034 ec.Error(ctx, err)
7035 return graphql.Null
7036 }
7037 if resTmp == nil {
7038 if !ec.HasError(rctx) {
7039 ec.Errorf(ctx, "must not be null")
7040 }
7041 return graphql.Null
7042 }
7043 res := resTmp.(*models.NewBugPayload)
7044 rctx.Result = res
7045 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7046 return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
7047}
7048
7049func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7050 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7051 defer func() {
7052 if r := recover(); r != nil {
7053 ec.Error(ctx, ec.Recover(ctx, r))
7054 ret = graphql.Null
7055 }
7056 ec.Tracer.EndFieldExecution(ctx)
7057 }()
7058 rctx := &graphql.ResolverContext{
7059 Object: "Mutation",
7060 Field: field,
7061 Args: nil,
7062 IsMethod: true,
7063 }
7064 ctx = graphql.WithResolverContext(ctx, rctx)
7065 rawArgs := field.ArgumentMap(ec.Variables)
7066 args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
7067 if err != nil {
7068 ec.Error(ctx, err)
7069 return graphql.Null
7070 }
7071 rctx.Args = args
7072 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7073 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7074 ctx = rctx // use context from middleware stack in children
7075 return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
7076 })
7077 if err != nil {
7078 ec.Error(ctx, err)
7079 return graphql.Null
7080 }
7081 if resTmp == nil {
7082 if !ec.HasError(rctx) {
7083 ec.Errorf(ctx, "must not be null")
7084 }
7085 return graphql.Null
7086 }
7087 res := resTmp.(*models.AddCommentPayload)
7088 rctx.Result = res
7089 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7090 return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
7091}
7092
7093func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7094 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7095 defer func() {
7096 if r := recover(); r != nil {
7097 ec.Error(ctx, ec.Recover(ctx, r))
7098 ret = graphql.Null
7099 }
7100 ec.Tracer.EndFieldExecution(ctx)
7101 }()
7102 rctx := &graphql.ResolverContext{
7103 Object: "Mutation",
7104 Field: field,
7105 Args: nil,
7106 IsMethod: true,
7107 }
7108 ctx = graphql.WithResolverContext(ctx, rctx)
7109 rawArgs := field.ArgumentMap(ec.Variables)
7110 args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
7111 if err != nil {
7112 ec.Error(ctx, err)
7113 return graphql.Null
7114 }
7115 rctx.Args = args
7116 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7117 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7118 ctx = rctx // use context from middleware stack in children
7119 return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
7120 })
7121 if err != nil {
7122 ec.Error(ctx, err)
7123 return graphql.Null
7124 }
7125 if resTmp == nil {
7126 if !ec.HasError(rctx) {
7127 ec.Errorf(ctx, "must not be null")
7128 }
7129 return graphql.Null
7130 }
7131 res := resTmp.(*models.ChangeLabelPayload)
7132 rctx.Result = res
7133 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7134 return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
7135}
7136
7137func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7138 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7139 defer func() {
7140 if r := recover(); r != nil {
7141 ec.Error(ctx, ec.Recover(ctx, r))
7142 ret = graphql.Null
7143 }
7144 ec.Tracer.EndFieldExecution(ctx)
7145 }()
7146 rctx := &graphql.ResolverContext{
7147 Object: "Mutation",
7148 Field: field,
7149 Args: nil,
7150 IsMethod: true,
7151 }
7152 ctx = graphql.WithResolverContext(ctx, rctx)
7153 rawArgs := field.ArgumentMap(ec.Variables)
7154 args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
7155 if err != nil {
7156 ec.Error(ctx, err)
7157 return graphql.Null
7158 }
7159 rctx.Args = args
7160 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7161 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7162 ctx = rctx // use context from middleware stack in children
7163 return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
7164 })
7165 if err != nil {
7166 ec.Error(ctx, err)
7167 return graphql.Null
7168 }
7169 if resTmp == nil {
7170 if !ec.HasError(rctx) {
7171 ec.Errorf(ctx, "must not be null")
7172 }
7173 return graphql.Null
7174 }
7175 res := resTmp.(*models.OpenBugPayload)
7176 rctx.Result = res
7177 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7178 return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
7179}
7180
7181func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7182 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7183 defer func() {
7184 if r := recover(); r != nil {
7185 ec.Error(ctx, ec.Recover(ctx, r))
7186 ret = graphql.Null
7187 }
7188 ec.Tracer.EndFieldExecution(ctx)
7189 }()
7190 rctx := &graphql.ResolverContext{
7191 Object: "Mutation",
7192 Field: field,
7193 Args: nil,
7194 IsMethod: true,
7195 }
7196 ctx = graphql.WithResolverContext(ctx, rctx)
7197 rawArgs := field.ArgumentMap(ec.Variables)
7198 args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
7199 if err != nil {
7200 ec.Error(ctx, err)
7201 return graphql.Null
7202 }
7203 rctx.Args = args
7204 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7205 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7206 ctx = rctx // use context from middleware stack in children
7207 return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
7208 })
7209 if err != nil {
7210 ec.Error(ctx, err)
7211 return graphql.Null
7212 }
7213 if resTmp == nil {
7214 if !ec.HasError(rctx) {
7215 ec.Errorf(ctx, "must not be null")
7216 }
7217 return graphql.Null
7218 }
7219 res := resTmp.(*models.CloseBugPayload)
7220 rctx.Result = res
7221 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7222 return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
7223}
7224
7225func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7226 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7227 defer func() {
7228 if r := recover(); r != nil {
7229 ec.Error(ctx, ec.Recover(ctx, r))
7230 ret = graphql.Null
7231 }
7232 ec.Tracer.EndFieldExecution(ctx)
7233 }()
7234 rctx := &graphql.ResolverContext{
7235 Object: "Mutation",
7236 Field: field,
7237 Args: nil,
7238 IsMethod: true,
7239 }
7240 ctx = graphql.WithResolverContext(ctx, rctx)
7241 rawArgs := field.ArgumentMap(ec.Variables)
7242 args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
7243 if err != nil {
7244 ec.Error(ctx, err)
7245 return graphql.Null
7246 }
7247 rctx.Args = args
7248 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7249 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7250 ctx = rctx // use context from middleware stack in children
7251 return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
7252 })
7253 if err != nil {
7254 ec.Error(ctx, err)
7255 return graphql.Null
7256 }
7257 if resTmp == nil {
7258 if !ec.HasError(rctx) {
7259 ec.Errorf(ctx, "must not be null")
7260 }
7261 return graphql.Null
7262 }
7263 res := resTmp.(*models.SetTitlePayload)
7264 rctx.Result = res
7265 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7266 return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
7267}
7268
7269func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7270 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7271 defer func() {
7272 if r := recover(); r != nil {
7273 ec.Error(ctx, ec.Recover(ctx, r))
7274 ret = graphql.Null
7275 }
7276 ec.Tracer.EndFieldExecution(ctx)
7277 }()
7278 rctx := &graphql.ResolverContext{
7279 Object: "Mutation",
7280 Field: field,
7281 Args: nil,
7282 IsMethod: true,
7283 }
7284 ctx = graphql.WithResolverContext(ctx, rctx)
7285 rawArgs := field.ArgumentMap(ec.Variables)
7286 args, err := ec.field_Mutation_commit_args(ctx, rawArgs)
7287 if err != nil {
7288 ec.Error(ctx, err)
7289 return graphql.Null
7290 }
7291 rctx.Args = args
7292 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7293 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7294 ctx = rctx // use context from middleware stack in children
7295 return ec.resolvers.Mutation().Commit(rctx, args["input"].(models.CommitInput))
7296 })
7297 if err != nil {
7298 ec.Error(ctx, err)
7299 return graphql.Null
7300 }
7301 if resTmp == nil {
7302 if !ec.HasError(rctx) {
7303 ec.Errorf(ctx, "must not be null")
7304 }
7305 return graphql.Null
7306 }
7307 res := resTmp.(*models.CommitPayload)
7308 rctx.Result = res
7309 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7310 return ec.marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx, field.Selections, res)
7311}
7312
7313func (ec *executionContext) _Mutation_commitAsNeeded(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7314 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7315 defer func() {
7316 if r := recover(); r != nil {
7317 ec.Error(ctx, ec.Recover(ctx, r))
7318 ret = graphql.Null
7319 }
7320 ec.Tracer.EndFieldExecution(ctx)
7321 }()
7322 rctx := &graphql.ResolverContext{
7323 Object: "Mutation",
7324 Field: field,
7325 Args: nil,
7326 IsMethod: true,
7327 }
7328 ctx = graphql.WithResolverContext(ctx, rctx)
7329 rawArgs := field.ArgumentMap(ec.Variables)
7330 args, err := ec.field_Mutation_commitAsNeeded_args(ctx, rawArgs)
7331 if err != nil {
7332 ec.Error(ctx, err)
7333 return graphql.Null
7334 }
7335 rctx.Args = args
7336 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7337 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7338 ctx = rctx // use context from middleware stack in children
7339 return ec.resolvers.Mutation().CommitAsNeeded(rctx, args["input"].(models.CommitAsNeededInput))
7340 })
7341 if err != nil {
7342 ec.Error(ctx, err)
7343 return graphql.Null
7344 }
7345 if resTmp == nil {
7346 if !ec.HasError(rctx) {
7347 ec.Errorf(ctx, "must not be null")
7348 }
7349 return graphql.Null
7350 }
7351 res := resTmp.(*models.CommitAsNeededPayload)
7352 rctx.Result = res
7353 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7354 return ec.marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx, field.Selections, res)
7355}
7356
7357func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7358 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7359 defer func() {
7360 if r := recover(); r != nil {
7361 ec.Error(ctx, ec.Recover(ctx, r))
7362 ret = graphql.Null
7363 }
7364 ec.Tracer.EndFieldExecution(ctx)
7365 }()
7366 rctx := &graphql.ResolverContext{
7367 Object: "NewBugPayload",
7368 Field: field,
7369 Args: nil,
7370 IsMethod: false,
7371 }
7372 ctx = graphql.WithResolverContext(ctx, rctx)
7373 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7374 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7375 ctx = rctx // use context from middleware stack in children
7376 return obj.ClientMutationID, nil
7377 })
7378 if err != nil {
7379 ec.Error(ctx, err)
7380 return graphql.Null
7381 }
7382 if resTmp == nil {
7383 return graphql.Null
7384 }
7385 res := resTmp.(*string)
7386 rctx.Result = res
7387 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7388 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7389}
7390
7391func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7392 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7393 defer func() {
7394 if r := recover(); r != nil {
7395 ec.Error(ctx, ec.Recover(ctx, r))
7396 ret = graphql.Null
7397 }
7398 ec.Tracer.EndFieldExecution(ctx)
7399 }()
7400 rctx := &graphql.ResolverContext{
7401 Object: "NewBugPayload",
7402 Field: field,
7403 Args: nil,
7404 IsMethod: false,
7405 }
7406 ctx = graphql.WithResolverContext(ctx, rctx)
7407 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7408 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7409 ctx = rctx // use context from middleware stack in children
7410 return obj.Bug, nil
7411 })
7412 if err != nil {
7413 ec.Error(ctx, err)
7414 return graphql.Null
7415 }
7416 if resTmp == nil {
7417 if !ec.HasError(rctx) {
7418 ec.Errorf(ctx, "must not be null")
7419 }
7420 return graphql.Null
7421 }
7422 res := resTmp.(*bug.Snapshot)
7423 rctx.Result = res
7424 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7425 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
7426}
7427
7428func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7429 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7430 defer func() {
7431 if r := recover(); r != nil {
7432 ec.Error(ctx, ec.Recover(ctx, r))
7433 ret = graphql.Null
7434 }
7435 ec.Tracer.EndFieldExecution(ctx)
7436 }()
7437 rctx := &graphql.ResolverContext{
7438 Object: "NewBugPayload",
7439 Field: field,
7440 Args: nil,
7441 IsMethod: false,
7442 }
7443 ctx = graphql.WithResolverContext(ctx, rctx)
7444 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7445 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7446 ctx = rctx // use context from middleware stack in children
7447 return obj.Operation, nil
7448 })
7449 if err != nil {
7450 ec.Error(ctx, err)
7451 return graphql.Null
7452 }
7453 if resTmp == nil {
7454 if !ec.HasError(rctx) {
7455 ec.Errorf(ctx, "must not be null")
7456 }
7457 return graphql.Null
7458 }
7459 res := resTmp.(*bug.CreateOperation)
7460 rctx.Result = res
7461 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7462 return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
7463}
7464
7465func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7466 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7467 defer func() {
7468 if r := recover(); r != nil {
7469 ec.Error(ctx, ec.Recover(ctx, r))
7470 ret = graphql.Null
7471 }
7472 ec.Tracer.EndFieldExecution(ctx)
7473 }()
7474 rctx := &graphql.ResolverContext{
7475 Object: "OpenBugPayload",
7476 Field: field,
7477 Args: nil,
7478 IsMethod: false,
7479 }
7480 ctx = graphql.WithResolverContext(ctx, rctx)
7481 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7482 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7483 ctx = rctx // use context from middleware stack in children
7484 return obj.ClientMutationID, nil
7485 })
7486 if err != nil {
7487 ec.Error(ctx, err)
7488 return graphql.Null
7489 }
7490 if resTmp == nil {
7491 return graphql.Null
7492 }
7493 res := resTmp.(*string)
7494 rctx.Result = res
7495 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7496 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7497}
7498
7499func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7500 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7501 defer func() {
7502 if r := recover(); r != nil {
7503 ec.Error(ctx, ec.Recover(ctx, r))
7504 ret = graphql.Null
7505 }
7506 ec.Tracer.EndFieldExecution(ctx)
7507 }()
7508 rctx := &graphql.ResolverContext{
7509 Object: "OpenBugPayload",
7510 Field: field,
7511 Args: nil,
7512 IsMethod: false,
7513 }
7514 ctx = graphql.WithResolverContext(ctx, rctx)
7515 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7516 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7517 ctx = rctx // use context from middleware stack in children
7518 return obj.Bug, nil
7519 })
7520 if err != nil {
7521 ec.Error(ctx, err)
7522 return graphql.Null
7523 }
7524 if resTmp == nil {
7525 if !ec.HasError(rctx) {
7526 ec.Errorf(ctx, "must not be null")
7527 }
7528 return graphql.Null
7529 }
7530 res := resTmp.(*bug.Snapshot)
7531 rctx.Result = res
7532 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7533 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
7534}
7535
7536func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7537 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7538 defer func() {
7539 if r := recover(); r != nil {
7540 ec.Error(ctx, ec.Recover(ctx, r))
7541 ret = graphql.Null
7542 }
7543 ec.Tracer.EndFieldExecution(ctx)
7544 }()
7545 rctx := &graphql.ResolverContext{
7546 Object: "OpenBugPayload",
7547 Field: field,
7548 Args: nil,
7549 IsMethod: false,
7550 }
7551 ctx = graphql.WithResolverContext(ctx, rctx)
7552 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7553 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7554 ctx = rctx // use context from middleware stack in children
7555 return obj.Operation, nil
7556 })
7557 if err != nil {
7558 ec.Error(ctx, err)
7559 return graphql.Null
7560 }
7561 if resTmp == nil {
7562 if !ec.HasError(rctx) {
7563 ec.Errorf(ctx, "must not be null")
7564 }
7565 return graphql.Null
7566 }
7567 res := resTmp.(*bug.SetStatusOperation)
7568 rctx.Result = res
7569 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7570 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
7571}
7572
7573func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7574 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7575 defer func() {
7576 if r := recover(); r != nil {
7577 ec.Error(ctx, ec.Recover(ctx, r))
7578 ret = graphql.Null
7579 }
7580 ec.Tracer.EndFieldExecution(ctx)
7581 }()
7582 rctx := &graphql.ResolverContext{
7583 Object: "OperationConnection",
7584 Field: field,
7585 Args: nil,
7586 IsMethod: false,
7587 }
7588 ctx = graphql.WithResolverContext(ctx, rctx)
7589 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7590 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7591 ctx = rctx // use context from middleware stack in children
7592 return obj.Edges, nil
7593 })
7594 if err != nil {
7595 ec.Error(ctx, err)
7596 return graphql.Null
7597 }
7598 if resTmp == nil {
7599 if !ec.HasError(rctx) {
7600 ec.Errorf(ctx, "must not be null")
7601 }
7602 return graphql.Null
7603 }
7604 res := resTmp.([]*models.OperationEdge)
7605 rctx.Result = res
7606 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7607 return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, field.Selections, res)
7608}
7609
7610func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7611 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7612 defer func() {
7613 if r := recover(); r != nil {
7614 ec.Error(ctx, ec.Recover(ctx, r))
7615 ret = graphql.Null
7616 }
7617 ec.Tracer.EndFieldExecution(ctx)
7618 }()
7619 rctx := &graphql.ResolverContext{
7620 Object: "OperationConnection",
7621 Field: field,
7622 Args: nil,
7623 IsMethod: false,
7624 }
7625 ctx = graphql.WithResolverContext(ctx, rctx)
7626 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7627 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7628 ctx = rctx // use context from middleware stack in children
7629 return obj.Nodes, nil
7630 })
7631 if err != nil {
7632 ec.Error(ctx, err)
7633 return graphql.Null
7634 }
7635 if resTmp == nil {
7636 if !ec.HasError(rctx) {
7637 ec.Errorf(ctx, "must not be null")
7638 }
7639 return graphql.Null
7640 }
7641 res := resTmp.([]bug.Operation)
7642 rctx.Result = res
7643 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7644 return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
7645}
7646
7647func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7648 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7649 defer func() {
7650 if r := recover(); r != nil {
7651 ec.Error(ctx, ec.Recover(ctx, r))
7652 ret = graphql.Null
7653 }
7654 ec.Tracer.EndFieldExecution(ctx)
7655 }()
7656 rctx := &graphql.ResolverContext{
7657 Object: "OperationConnection",
7658 Field: field,
7659 Args: nil,
7660 IsMethod: false,
7661 }
7662 ctx = graphql.WithResolverContext(ctx, rctx)
7663 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7664 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7665 ctx = rctx // use context from middleware stack in children
7666 return obj.PageInfo, nil
7667 })
7668 if err != nil {
7669 ec.Error(ctx, err)
7670 return graphql.Null
7671 }
7672 if resTmp == nil {
7673 if !ec.HasError(rctx) {
7674 ec.Errorf(ctx, "must not be null")
7675 }
7676 return graphql.Null
7677 }
7678 res := resTmp.(*models.PageInfo)
7679 rctx.Result = res
7680 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7681 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
7682}
7683
7684func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7685 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7686 defer func() {
7687 if r := recover(); r != nil {
7688 ec.Error(ctx, ec.Recover(ctx, r))
7689 ret = graphql.Null
7690 }
7691 ec.Tracer.EndFieldExecution(ctx)
7692 }()
7693 rctx := &graphql.ResolverContext{
7694 Object: "OperationConnection",
7695 Field: field,
7696 Args: nil,
7697 IsMethod: false,
7698 }
7699 ctx = graphql.WithResolverContext(ctx, rctx)
7700 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7701 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7702 ctx = rctx // use context from middleware stack in children
7703 return obj.TotalCount, nil
7704 })
7705 if err != nil {
7706 ec.Error(ctx, err)
7707 return graphql.Null
7708 }
7709 if resTmp == nil {
7710 if !ec.HasError(rctx) {
7711 ec.Errorf(ctx, "must not be null")
7712 }
7713 return graphql.Null
7714 }
7715 res := resTmp.(int)
7716 rctx.Result = res
7717 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7718 return ec.marshalNInt2int(ctx, field.Selections, res)
7719}
7720
7721func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
7722 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7723 defer func() {
7724 if r := recover(); r != nil {
7725 ec.Error(ctx, ec.Recover(ctx, r))
7726 ret = graphql.Null
7727 }
7728 ec.Tracer.EndFieldExecution(ctx)
7729 }()
7730 rctx := &graphql.ResolverContext{
7731 Object: "OperationEdge",
7732 Field: field,
7733 Args: nil,
7734 IsMethod: false,
7735 }
7736 ctx = graphql.WithResolverContext(ctx, rctx)
7737 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7738 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7739 ctx = rctx // use context from middleware stack in children
7740 return obj.Cursor, nil
7741 })
7742 if err != nil {
7743 ec.Error(ctx, err)
7744 return graphql.Null
7745 }
7746 if resTmp == nil {
7747 if !ec.HasError(rctx) {
7748 ec.Errorf(ctx, "must not be null")
7749 }
7750 return graphql.Null
7751 }
7752 res := resTmp.(string)
7753 rctx.Result = res
7754 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7755 return ec.marshalNString2string(ctx, field.Selections, res)
7756}
7757
7758func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
7759 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7760 defer func() {
7761 if r := recover(); r != nil {
7762 ec.Error(ctx, ec.Recover(ctx, r))
7763 ret = graphql.Null
7764 }
7765 ec.Tracer.EndFieldExecution(ctx)
7766 }()
7767 rctx := &graphql.ResolverContext{
7768 Object: "OperationEdge",
7769 Field: field,
7770 Args: nil,
7771 IsMethod: false,
7772 }
7773 ctx = graphql.WithResolverContext(ctx, rctx)
7774 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7775 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7776 ctx = rctx // use context from middleware stack in children
7777 return obj.Node, nil
7778 })
7779 if err != nil {
7780 ec.Error(ctx, err)
7781 return graphql.Null
7782 }
7783 if resTmp == nil {
7784 if !ec.HasError(rctx) {
7785 ec.Errorf(ctx, "must not be null")
7786 }
7787 return graphql.Null
7788 }
7789 res := resTmp.(bug.Operation)
7790 rctx.Result = res
7791 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7792 return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
7793}
7794
7795func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7796 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7797 defer func() {
7798 if r := recover(); r != nil {
7799 ec.Error(ctx, ec.Recover(ctx, r))
7800 ret = graphql.Null
7801 }
7802 ec.Tracer.EndFieldExecution(ctx)
7803 }()
7804 rctx := &graphql.ResolverContext{
7805 Object: "PageInfo",
7806 Field: field,
7807 Args: nil,
7808 IsMethod: false,
7809 }
7810 ctx = graphql.WithResolverContext(ctx, rctx)
7811 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7812 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7813 ctx = rctx // use context from middleware stack in children
7814 return obj.HasNextPage, nil
7815 })
7816 if err != nil {
7817 ec.Error(ctx, err)
7818 return graphql.Null
7819 }
7820 if resTmp == nil {
7821 if !ec.HasError(rctx) {
7822 ec.Errorf(ctx, "must not be null")
7823 }
7824 return graphql.Null
7825 }
7826 res := resTmp.(bool)
7827 rctx.Result = res
7828 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7829 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7830}
7831
7832func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7833 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7834 defer func() {
7835 if r := recover(); r != nil {
7836 ec.Error(ctx, ec.Recover(ctx, r))
7837 ret = graphql.Null
7838 }
7839 ec.Tracer.EndFieldExecution(ctx)
7840 }()
7841 rctx := &graphql.ResolverContext{
7842 Object: "PageInfo",
7843 Field: field,
7844 Args: nil,
7845 IsMethod: false,
7846 }
7847 ctx = graphql.WithResolverContext(ctx, rctx)
7848 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7849 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7850 ctx = rctx // use context from middleware stack in children
7851 return obj.HasPreviousPage, nil
7852 })
7853 if err != nil {
7854 ec.Error(ctx, err)
7855 return graphql.Null
7856 }
7857 if resTmp == nil {
7858 if !ec.HasError(rctx) {
7859 ec.Errorf(ctx, "must not be null")
7860 }
7861 return graphql.Null
7862 }
7863 res := resTmp.(bool)
7864 rctx.Result = res
7865 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7866 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7867}
7868
7869func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7870 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7871 defer func() {
7872 if r := recover(); r != nil {
7873 ec.Error(ctx, ec.Recover(ctx, r))
7874 ret = graphql.Null
7875 }
7876 ec.Tracer.EndFieldExecution(ctx)
7877 }()
7878 rctx := &graphql.ResolverContext{
7879 Object: "PageInfo",
7880 Field: field,
7881 Args: nil,
7882 IsMethod: false,
7883 }
7884 ctx = graphql.WithResolverContext(ctx, rctx)
7885 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7886 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7887 ctx = rctx // use context from middleware stack in children
7888 return obj.StartCursor, nil
7889 })
7890 if err != nil {
7891 ec.Error(ctx, err)
7892 return graphql.Null
7893 }
7894 if resTmp == nil {
7895 if !ec.HasError(rctx) {
7896 ec.Errorf(ctx, "must not be null")
7897 }
7898 return graphql.Null
7899 }
7900 res := resTmp.(string)
7901 rctx.Result = res
7902 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7903 return ec.marshalNString2string(ctx, field.Selections, res)
7904}
7905
7906func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7907 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7908 defer func() {
7909 if r := recover(); r != nil {
7910 ec.Error(ctx, ec.Recover(ctx, r))
7911 ret = graphql.Null
7912 }
7913 ec.Tracer.EndFieldExecution(ctx)
7914 }()
7915 rctx := &graphql.ResolverContext{
7916 Object: "PageInfo",
7917 Field: field,
7918 Args: nil,
7919 IsMethod: false,
7920 }
7921 ctx = graphql.WithResolverContext(ctx, rctx)
7922 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7923 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7924 ctx = rctx // use context from middleware stack in children
7925 return obj.EndCursor, nil
7926 })
7927 if err != nil {
7928 ec.Error(ctx, err)
7929 return graphql.Null
7930 }
7931 if resTmp == nil {
7932 if !ec.HasError(rctx) {
7933 ec.Errorf(ctx, "must not be null")
7934 }
7935 return graphql.Null
7936 }
7937 res := resTmp.(string)
7938 rctx.Result = res
7939 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7940 return ec.marshalNString2string(ctx, field.Selections, res)
7941}
7942
7943func (ec *executionContext) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7944 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7945 defer func() {
7946 if r := recover(); r != nil {
7947 ec.Error(ctx, ec.Recover(ctx, r))
7948 ret = graphql.Null
7949 }
7950 ec.Tracer.EndFieldExecution(ctx)
7951 }()
7952 rctx := &graphql.ResolverContext{
7953 Object: "Query",
7954 Field: field,
7955 Args: nil,
7956 IsMethod: true,
7957 }
7958 ctx = graphql.WithResolverContext(ctx, rctx)
7959 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7960 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7961 ctx = rctx // use context from middleware stack in children
7962 return ec.resolvers.Query().DefaultRepository(rctx)
7963 })
7964 if err != nil {
7965 ec.Error(ctx, err)
7966 return graphql.Null
7967 }
7968 if resTmp == nil {
7969 return graphql.Null
7970 }
7971 res := resTmp.(*models.Repository)
7972 rctx.Result = res
7973 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7974 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
7975}
7976
7977func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7978 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7979 defer func() {
7980 if r := recover(); r != nil {
7981 ec.Error(ctx, ec.Recover(ctx, r))
7982 ret = graphql.Null
7983 }
7984 ec.Tracer.EndFieldExecution(ctx)
7985 }()
7986 rctx := &graphql.ResolverContext{
7987 Object: "Query",
7988 Field: field,
7989 Args: nil,
7990 IsMethod: true,
7991 }
7992 ctx = graphql.WithResolverContext(ctx, rctx)
7993 rawArgs := field.ArgumentMap(ec.Variables)
7994 args, err := ec.field_Query_repository_args(ctx, rawArgs)
7995 if err != nil {
7996 ec.Error(ctx, err)
7997 return graphql.Null
7998 }
7999 rctx.Args = args
8000 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8001 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8002 ctx = rctx // use context from middleware stack in children
8003 return ec.resolvers.Query().Repository(rctx, args["ref"].(string))
8004 })
8005 if err != nil {
8006 ec.Error(ctx, err)
8007 return graphql.Null
8008 }
8009 if resTmp == nil {
8010 return graphql.Null
8011 }
8012 res := resTmp.(*models.Repository)
8013 rctx.Result = res
8014 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8015 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
8016}
8017
8018func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8019 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8020 defer func() {
8021 if r := recover(); r != nil {
8022 ec.Error(ctx, ec.Recover(ctx, r))
8023 ret = graphql.Null
8024 }
8025 ec.Tracer.EndFieldExecution(ctx)
8026 }()
8027 rctx := &graphql.ResolverContext{
8028 Object: "Query",
8029 Field: field,
8030 Args: nil,
8031 IsMethod: true,
8032 }
8033 ctx = graphql.WithResolverContext(ctx, rctx)
8034 rawArgs := field.ArgumentMap(ec.Variables)
8035 args, err := ec.field_Query___type_args(ctx, rawArgs)
8036 if err != nil {
8037 ec.Error(ctx, err)
8038 return graphql.Null
8039 }
8040 rctx.Args = args
8041 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8042 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8043 ctx = rctx // use context from middleware stack in children
8044 return ec.introspectType(args["name"].(string))
8045 })
8046 if err != nil {
8047 ec.Error(ctx, err)
8048 return graphql.Null
8049 }
8050 if resTmp == nil {
8051 return graphql.Null
8052 }
8053 res := resTmp.(*introspection.Type)
8054 rctx.Result = res
8055 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8056 return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
8057}
8058
8059func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8060 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8061 defer func() {
8062 if r := recover(); r != nil {
8063 ec.Error(ctx, ec.Recover(ctx, r))
8064 ret = graphql.Null
8065 }
8066 ec.Tracer.EndFieldExecution(ctx)
8067 }()
8068 rctx := &graphql.ResolverContext{
8069 Object: "Query",
8070 Field: field,
8071 Args: nil,
8072 IsMethod: true,
8073 }
8074 ctx = graphql.WithResolverContext(ctx, rctx)
8075 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8076 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8077 ctx = rctx // use context from middleware stack in children
8078 return ec.introspectSchema()
8079 })
8080 if err != nil {
8081 ec.Error(ctx, err)
8082 return graphql.Null
8083 }
8084 if resTmp == nil {
8085 return graphql.Null
8086 }
8087 res := resTmp.(*introspection.Schema)
8088 rctx.Result = res
8089 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8090 return ec.marshalO__Schema2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
8091}
8092
8093func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8094 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8095 defer func() {
8096 if r := recover(); r != nil {
8097 ec.Error(ctx, ec.Recover(ctx, r))
8098 ret = graphql.Null
8099 }
8100 ec.Tracer.EndFieldExecution(ctx)
8101 }()
8102 rctx := &graphql.ResolverContext{
8103 Object: "Repository",
8104 Field: field,
8105 Args: nil,
8106 IsMethod: true,
8107 }
8108 ctx = graphql.WithResolverContext(ctx, rctx)
8109 rawArgs := field.ArgumentMap(ec.Variables)
8110 args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
8111 if err != nil {
8112 ec.Error(ctx, err)
8113 return graphql.Null
8114 }
8115 rctx.Args = args
8116 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8117 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8118 ctx = rctx // use context from middleware stack in children
8119 return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
8120 })
8121 if err != nil {
8122 ec.Error(ctx, err)
8123 return graphql.Null
8124 }
8125 if resTmp == nil {
8126 if !ec.HasError(rctx) {
8127 ec.Errorf(ctx, "must not be null")
8128 }
8129 return graphql.Null
8130 }
8131 res := resTmp.(*models.BugConnection)
8132 rctx.Result = res
8133 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8134 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
8135}
8136
8137func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8138 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8139 defer func() {
8140 if r := recover(); r != nil {
8141 ec.Error(ctx, ec.Recover(ctx, r))
8142 ret = graphql.Null
8143 }
8144 ec.Tracer.EndFieldExecution(ctx)
8145 }()
8146 rctx := &graphql.ResolverContext{
8147 Object: "Repository",
8148 Field: field,
8149 Args: nil,
8150 IsMethod: true,
8151 }
8152 ctx = graphql.WithResolverContext(ctx, rctx)
8153 rawArgs := field.ArgumentMap(ec.Variables)
8154 args, err := ec.field_Repository_bug_args(ctx, rawArgs)
8155 if err != nil {
8156 ec.Error(ctx, err)
8157 return graphql.Null
8158 }
8159 rctx.Args = args
8160 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8161 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8162 ctx = rctx // use context from middleware stack in children
8163 return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
8164 })
8165 if err != nil {
8166 ec.Error(ctx, err)
8167 return graphql.Null
8168 }
8169 if resTmp == nil {
8170 return graphql.Null
8171 }
8172 res := resTmp.(*bug.Snapshot)
8173 rctx.Result = res
8174 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8175 return ec.marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
8176}
8177
8178func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8179 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8180 defer func() {
8181 if r := recover(); r != nil {
8182 ec.Error(ctx, ec.Recover(ctx, r))
8183 ret = graphql.Null
8184 }
8185 ec.Tracer.EndFieldExecution(ctx)
8186 }()
8187 rctx := &graphql.ResolverContext{
8188 Object: "Repository",
8189 Field: field,
8190 Args: nil,
8191 IsMethod: true,
8192 }
8193 ctx = graphql.WithResolverContext(ctx, rctx)
8194 rawArgs := field.ArgumentMap(ec.Variables)
8195 args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
8196 if err != nil {
8197 ec.Error(ctx, err)
8198 return graphql.Null
8199 }
8200 rctx.Args = args
8201 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8202 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8203 ctx = rctx // use context from middleware stack in children
8204 return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8205 })
8206 if err != nil {
8207 ec.Error(ctx, err)
8208 return graphql.Null
8209 }
8210 if resTmp == nil {
8211 if !ec.HasError(rctx) {
8212 ec.Errorf(ctx, "must not be null")
8213 }
8214 return graphql.Null
8215 }
8216 res := resTmp.(*models.IdentityConnection)
8217 rctx.Result = res
8218 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8219 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
8220}
8221
8222func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8223 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8224 defer func() {
8225 if r := recover(); r != nil {
8226 ec.Error(ctx, ec.Recover(ctx, r))
8227 ret = graphql.Null
8228 }
8229 ec.Tracer.EndFieldExecution(ctx)
8230 }()
8231 rctx := &graphql.ResolverContext{
8232 Object: "Repository",
8233 Field: field,
8234 Args: nil,
8235 IsMethod: true,
8236 }
8237 ctx = graphql.WithResolverContext(ctx, rctx)
8238 rawArgs := field.ArgumentMap(ec.Variables)
8239 args, err := ec.field_Repository_identity_args(ctx, rawArgs)
8240 if err != nil {
8241 ec.Error(ctx, err)
8242 return graphql.Null
8243 }
8244 rctx.Args = args
8245 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8246 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8247 ctx = rctx // use context from middleware stack in children
8248 return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
8249 })
8250 if err != nil {
8251 ec.Error(ctx, err)
8252 return graphql.Null
8253 }
8254 if resTmp == nil {
8255 return graphql.Null
8256 }
8257 res := resTmp.(identity.Interface)
8258 rctx.Result = res
8259 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8260 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8261}
8262
8263func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8264 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8265 defer func() {
8266 if r := recover(); r != nil {
8267 ec.Error(ctx, ec.Recover(ctx, r))
8268 ret = graphql.Null
8269 }
8270 ec.Tracer.EndFieldExecution(ctx)
8271 }()
8272 rctx := &graphql.ResolverContext{
8273 Object: "Repository",
8274 Field: field,
8275 Args: nil,
8276 IsMethod: true,
8277 }
8278 ctx = graphql.WithResolverContext(ctx, rctx)
8279 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8280 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8281 ctx = rctx // use context from middleware stack in children
8282 return ec.resolvers.Repository().UserIdentity(rctx, obj)
8283 })
8284 if err != nil {
8285 ec.Error(ctx, err)
8286 return graphql.Null
8287 }
8288 if resTmp == nil {
8289 return graphql.Null
8290 }
8291 res := resTmp.(identity.Interface)
8292 rctx.Result = res
8293 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8294 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8295}
8296
8297func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8298 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8299 defer func() {
8300 if r := recover(); r != nil {
8301 ec.Error(ctx, ec.Recover(ctx, r))
8302 ret = graphql.Null
8303 }
8304 ec.Tracer.EndFieldExecution(ctx)
8305 }()
8306 rctx := &graphql.ResolverContext{
8307 Object: "Repository",
8308 Field: field,
8309 Args: nil,
8310 IsMethod: true,
8311 }
8312 ctx = graphql.WithResolverContext(ctx, rctx)
8313 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8314 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8315 ctx = rctx // use context from middleware stack in children
8316 return ec.resolvers.Repository().ValidLabels(rctx, obj)
8317 })
8318 if err != nil {
8319 ec.Error(ctx, err)
8320 return graphql.Null
8321 }
8322 if resTmp == nil {
8323 if !ec.HasError(rctx) {
8324 ec.Errorf(ctx, "must not be null")
8325 }
8326 return graphql.Null
8327 }
8328 res := resTmp.([]bug.Label)
8329 rctx.Result = res
8330 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8331 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
8332}
8333
8334func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8335 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8336 defer func() {
8337 if r := recover(); r != nil {
8338 ec.Error(ctx, ec.Recover(ctx, r))
8339 ret = graphql.Null
8340 }
8341 ec.Tracer.EndFieldExecution(ctx)
8342 }()
8343 rctx := &graphql.ResolverContext{
8344 Object: "SetStatusOperation",
8345 Field: field,
8346 Args: nil,
8347 IsMethod: true,
8348 }
8349 ctx = graphql.WithResolverContext(ctx, rctx)
8350 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8351 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8352 ctx = rctx // use context from middleware stack in children
8353 return ec.resolvers.SetStatusOperation().ID(rctx, obj)
8354 })
8355 if err != nil {
8356 ec.Error(ctx, err)
8357 return graphql.Null
8358 }
8359 if resTmp == nil {
8360 if !ec.HasError(rctx) {
8361 ec.Errorf(ctx, "must not be null")
8362 }
8363 return graphql.Null
8364 }
8365 res := resTmp.(string)
8366 rctx.Result = res
8367 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8368 return ec.marshalNString2string(ctx, field.Selections, res)
8369}
8370
8371func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8372 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8373 defer func() {
8374 if r := recover(); r != nil {
8375 ec.Error(ctx, ec.Recover(ctx, r))
8376 ret = graphql.Null
8377 }
8378 ec.Tracer.EndFieldExecution(ctx)
8379 }()
8380 rctx := &graphql.ResolverContext{
8381 Object: "SetStatusOperation",
8382 Field: field,
8383 Args: nil,
8384 IsMethod: false,
8385 }
8386 ctx = graphql.WithResolverContext(ctx, rctx)
8387 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8388 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8389 ctx = rctx // use context from middleware stack in children
8390 return obj.Author, nil
8391 })
8392 if err != nil {
8393 ec.Error(ctx, err)
8394 return graphql.Null
8395 }
8396 if resTmp == nil {
8397 if !ec.HasError(rctx) {
8398 ec.Errorf(ctx, "must not be null")
8399 }
8400 return graphql.Null
8401 }
8402 res := resTmp.(identity.Interface)
8403 rctx.Result = res
8404 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8405 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8406}
8407
8408func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8409 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8410 defer func() {
8411 if r := recover(); r != nil {
8412 ec.Error(ctx, ec.Recover(ctx, r))
8413 ret = graphql.Null
8414 }
8415 ec.Tracer.EndFieldExecution(ctx)
8416 }()
8417 rctx := &graphql.ResolverContext{
8418 Object: "SetStatusOperation",
8419 Field: field,
8420 Args: nil,
8421 IsMethod: true,
8422 }
8423 ctx = graphql.WithResolverContext(ctx, rctx)
8424 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8425 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8426 ctx = rctx // use context from middleware stack in children
8427 return ec.resolvers.SetStatusOperation().Date(rctx, obj)
8428 })
8429 if err != nil {
8430 ec.Error(ctx, err)
8431 return graphql.Null
8432 }
8433 if resTmp == nil {
8434 if !ec.HasError(rctx) {
8435 ec.Errorf(ctx, "must not be null")
8436 }
8437 return graphql.Null
8438 }
8439 res := resTmp.(*time.Time)
8440 rctx.Result = res
8441 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8442 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8443}
8444
8445func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8446 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8447 defer func() {
8448 if r := recover(); r != nil {
8449 ec.Error(ctx, ec.Recover(ctx, r))
8450 ret = graphql.Null
8451 }
8452 ec.Tracer.EndFieldExecution(ctx)
8453 }()
8454 rctx := &graphql.ResolverContext{
8455 Object: "SetStatusOperation",
8456 Field: field,
8457 Args: nil,
8458 IsMethod: true,
8459 }
8460 ctx = graphql.WithResolverContext(ctx, rctx)
8461 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8462 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8463 ctx = rctx // use context from middleware stack in children
8464 return ec.resolvers.SetStatusOperation().Status(rctx, obj)
8465 })
8466 if err != nil {
8467 ec.Error(ctx, err)
8468 return graphql.Null
8469 }
8470 if resTmp == nil {
8471 if !ec.HasError(rctx) {
8472 ec.Errorf(ctx, "must not be null")
8473 }
8474 return graphql.Null
8475 }
8476 res := resTmp.(models.Status)
8477 rctx.Result = res
8478 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8479 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8480}
8481
8482func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8483 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8484 defer func() {
8485 if r := recover(); r != nil {
8486 ec.Error(ctx, ec.Recover(ctx, r))
8487 ret = graphql.Null
8488 }
8489 ec.Tracer.EndFieldExecution(ctx)
8490 }()
8491 rctx := &graphql.ResolverContext{
8492 Object: "SetStatusTimelineItem",
8493 Field: field,
8494 Args: nil,
8495 IsMethod: true,
8496 }
8497 ctx = graphql.WithResolverContext(ctx, rctx)
8498 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8499 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8500 ctx = rctx // use context from middleware stack in children
8501 return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
8502 })
8503 if err != nil {
8504 ec.Error(ctx, err)
8505 return graphql.Null
8506 }
8507 if resTmp == nil {
8508 if !ec.HasError(rctx) {
8509 ec.Errorf(ctx, "must not be null")
8510 }
8511 return graphql.Null
8512 }
8513 res := resTmp.(string)
8514 rctx.Result = res
8515 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8516 return ec.marshalNString2string(ctx, field.Selections, res)
8517}
8518
8519func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8520 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8521 defer func() {
8522 if r := recover(); r != nil {
8523 ec.Error(ctx, ec.Recover(ctx, r))
8524 ret = graphql.Null
8525 }
8526 ec.Tracer.EndFieldExecution(ctx)
8527 }()
8528 rctx := &graphql.ResolverContext{
8529 Object: "SetStatusTimelineItem",
8530 Field: field,
8531 Args: nil,
8532 IsMethod: false,
8533 }
8534 ctx = graphql.WithResolverContext(ctx, rctx)
8535 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8536 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8537 ctx = rctx // use context from middleware stack in children
8538 return obj.Author, nil
8539 })
8540 if err != nil {
8541 ec.Error(ctx, err)
8542 return graphql.Null
8543 }
8544 if resTmp == nil {
8545 if !ec.HasError(rctx) {
8546 ec.Errorf(ctx, "must not be null")
8547 }
8548 return graphql.Null
8549 }
8550 res := resTmp.(identity.Interface)
8551 rctx.Result = res
8552 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8553 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8554}
8555
8556func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8557 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8558 defer func() {
8559 if r := recover(); r != nil {
8560 ec.Error(ctx, ec.Recover(ctx, r))
8561 ret = graphql.Null
8562 }
8563 ec.Tracer.EndFieldExecution(ctx)
8564 }()
8565 rctx := &graphql.ResolverContext{
8566 Object: "SetStatusTimelineItem",
8567 Field: field,
8568 Args: nil,
8569 IsMethod: true,
8570 }
8571 ctx = graphql.WithResolverContext(ctx, rctx)
8572 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8573 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8574 ctx = rctx // use context from middleware stack in children
8575 return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
8576 })
8577 if err != nil {
8578 ec.Error(ctx, err)
8579 return graphql.Null
8580 }
8581 if resTmp == nil {
8582 if !ec.HasError(rctx) {
8583 ec.Errorf(ctx, "must not be null")
8584 }
8585 return graphql.Null
8586 }
8587 res := resTmp.(*time.Time)
8588 rctx.Result = res
8589 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8590 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8591}
8592
8593func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8594 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8595 defer func() {
8596 if r := recover(); r != nil {
8597 ec.Error(ctx, ec.Recover(ctx, r))
8598 ret = graphql.Null
8599 }
8600 ec.Tracer.EndFieldExecution(ctx)
8601 }()
8602 rctx := &graphql.ResolverContext{
8603 Object: "SetStatusTimelineItem",
8604 Field: field,
8605 Args: nil,
8606 IsMethod: true,
8607 }
8608 ctx = graphql.WithResolverContext(ctx, rctx)
8609 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8610 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8611 ctx = rctx // use context from middleware stack in children
8612 return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
8613 })
8614 if err != nil {
8615 ec.Error(ctx, err)
8616 return graphql.Null
8617 }
8618 if resTmp == nil {
8619 if !ec.HasError(rctx) {
8620 ec.Errorf(ctx, "must not be null")
8621 }
8622 return graphql.Null
8623 }
8624 res := resTmp.(models.Status)
8625 rctx.Result = res
8626 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8627 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8628}
8629
8630func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8631 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8632 defer func() {
8633 if r := recover(); r != nil {
8634 ec.Error(ctx, ec.Recover(ctx, r))
8635 ret = graphql.Null
8636 }
8637 ec.Tracer.EndFieldExecution(ctx)
8638 }()
8639 rctx := &graphql.ResolverContext{
8640 Object: "SetTitleOperation",
8641 Field: field,
8642 Args: nil,
8643 IsMethod: true,
8644 }
8645 ctx = graphql.WithResolverContext(ctx, rctx)
8646 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8647 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8648 ctx = rctx // use context from middleware stack in children
8649 return ec.resolvers.SetTitleOperation().ID(rctx, obj)
8650 })
8651 if err != nil {
8652 ec.Error(ctx, err)
8653 return graphql.Null
8654 }
8655 if resTmp == nil {
8656 if !ec.HasError(rctx) {
8657 ec.Errorf(ctx, "must not be null")
8658 }
8659 return graphql.Null
8660 }
8661 res := resTmp.(string)
8662 rctx.Result = res
8663 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8664 return ec.marshalNString2string(ctx, field.Selections, res)
8665}
8666
8667func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8668 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8669 defer func() {
8670 if r := recover(); r != nil {
8671 ec.Error(ctx, ec.Recover(ctx, r))
8672 ret = graphql.Null
8673 }
8674 ec.Tracer.EndFieldExecution(ctx)
8675 }()
8676 rctx := &graphql.ResolverContext{
8677 Object: "SetTitleOperation",
8678 Field: field,
8679 Args: nil,
8680 IsMethod: false,
8681 }
8682 ctx = graphql.WithResolverContext(ctx, rctx)
8683 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8684 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8685 ctx = rctx // use context from middleware stack in children
8686 return obj.Author, nil
8687 })
8688 if err != nil {
8689 ec.Error(ctx, err)
8690 return graphql.Null
8691 }
8692 if resTmp == nil {
8693 if !ec.HasError(rctx) {
8694 ec.Errorf(ctx, "must not be null")
8695 }
8696 return graphql.Null
8697 }
8698 res := resTmp.(identity.Interface)
8699 rctx.Result = res
8700 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8701 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8702}
8703
8704func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8705 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8706 defer func() {
8707 if r := recover(); r != nil {
8708 ec.Error(ctx, ec.Recover(ctx, r))
8709 ret = graphql.Null
8710 }
8711 ec.Tracer.EndFieldExecution(ctx)
8712 }()
8713 rctx := &graphql.ResolverContext{
8714 Object: "SetTitleOperation",
8715 Field: field,
8716 Args: nil,
8717 IsMethod: true,
8718 }
8719 ctx = graphql.WithResolverContext(ctx, rctx)
8720 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8721 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8722 ctx = rctx // use context from middleware stack in children
8723 return ec.resolvers.SetTitleOperation().Date(rctx, obj)
8724 })
8725 if err != nil {
8726 ec.Error(ctx, err)
8727 return graphql.Null
8728 }
8729 if resTmp == nil {
8730 if !ec.HasError(rctx) {
8731 ec.Errorf(ctx, "must not be null")
8732 }
8733 return graphql.Null
8734 }
8735 res := resTmp.(*time.Time)
8736 rctx.Result = res
8737 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8738 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8739}
8740
8741func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8742 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8743 defer func() {
8744 if r := recover(); r != nil {
8745 ec.Error(ctx, ec.Recover(ctx, r))
8746 ret = graphql.Null
8747 }
8748 ec.Tracer.EndFieldExecution(ctx)
8749 }()
8750 rctx := &graphql.ResolverContext{
8751 Object: "SetTitleOperation",
8752 Field: field,
8753 Args: nil,
8754 IsMethod: false,
8755 }
8756 ctx = graphql.WithResolverContext(ctx, rctx)
8757 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8758 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8759 ctx = rctx // use context from middleware stack in children
8760 return obj.Title, nil
8761 })
8762 if err != nil {
8763 ec.Error(ctx, err)
8764 return graphql.Null
8765 }
8766 if resTmp == nil {
8767 if !ec.HasError(rctx) {
8768 ec.Errorf(ctx, "must not be null")
8769 }
8770 return graphql.Null
8771 }
8772 res := resTmp.(string)
8773 rctx.Result = res
8774 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8775 return ec.marshalNString2string(ctx, field.Selections, res)
8776}
8777
8778func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8779 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8780 defer func() {
8781 if r := recover(); r != nil {
8782 ec.Error(ctx, ec.Recover(ctx, r))
8783 ret = graphql.Null
8784 }
8785 ec.Tracer.EndFieldExecution(ctx)
8786 }()
8787 rctx := &graphql.ResolverContext{
8788 Object: "SetTitleOperation",
8789 Field: field,
8790 Args: nil,
8791 IsMethod: false,
8792 }
8793 ctx = graphql.WithResolverContext(ctx, rctx)
8794 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8795 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8796 ctx = rctx // use context from middleware stack in children
8797 return obj.Was, nil
8798 })
8799 if err != nil {
8800 ec.Error(ctx, err)
8801 return graphql.Null
8802 }
8803 if resTmp == nil {
8804 if !ec.HasError(rctx) {
8805 ec.Errorf(ctx, "must not be null")
8806 }
8807 return graphql.Null
8808 }
8809 res := resTmp.(string)
8810 rctx.Result = res
8811 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8812 return ec.marshalNString2string(ctx, field.Selections, res)
8813}
8814
8815func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8816 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8817 defer func() {
8818 if r := recover(); r != nil {
8819 ec.Error(ctx, ec.Recover(ctx, r))
8820 ret = graphql.Null
8821 }
8822 ec.Tracer.EndFieldExecution(ctx)
8823 }()
8824 rctx := &graphql.ResolverContext{
8825 Object: "SetTitlePayload",
8826 Field: field,
8827 Args: nil,
8828 IsMethod: false,
8829 }
8830 ctx = graphql.WithResolverContext(ctx, rctx)
8831 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8832 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8833 ctx = rctx // use context from middleware stack in children
8834 return obj.ClientMutationID, nil
8835 })
8836 if err != nil {
8837 ec.Error(ctx, err)
8838 return graphql.Null
8839 }
8840 if resTmp == nil {
8841 return graphql.Null
8842 }
8843 res := resTmp.(*string)
8844 rctx.Result = res
8845 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8846 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8847}
8848
8849func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8850 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8851 defer func() {
8852 if r := recover(); r != nil {
8853 ec.Error(ctx, ec.Recover(ctx, r))
8854 ret = graphql.Null
8855 }
8856 ec.Tracer.EndFieldExecution(ctx)
8857 }()
8858 rctx := &graphql.ResolverContext{
8859 Object: "SetTitlePayload",
8860 Field: field,
8861 Args: nil,
8862 IsMethod: false,
8863 }
8864 ctx = graphql.WithResolverContext(ctx, rctx)
8865 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8866 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8867 ctx = rctx // use context from middleware stack in children
8868 return obj.Bug, nil
8869 })
8870 if err != nil {
8871 ec.Error(ctx, err)
8872 return graphql.Null
8873 }
8874 if resTmp == nil {
8875 if !ec.HasError(rctx) {
8876 ec.Errorf(ctx, "must not be null")
8877 }
8878 return graphql.Null
8879 }
8880 res := resTmp.(*bug.Snapshot)
8881 rctx.Result = res
8882 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8883 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
8884}
8885
8886func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8887 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8888 defer func() {
8889 if r := recover(); r != nil {
8890 ec.Error(ctx, ec.Recover(ctx, r))
8891 ret = graphql.Null
8892 }
8893 ec.Tracer.EndFieldExecution(ctx)
8894 }()
8895 rctx := &graphql.ResolverContext{
8896 Object: "SetTitlePayload",
8897 Field: field,
8898 Args: nil,
8899 IsMethod: false,
8900 }
8901 ctx = graphql.WithResolverContext(ctx, rctx)
8902 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8903 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8904 ctx = rctx // use context from middleware stack in children
8905 return obj.Operation, nil
8906 })
8907 if err != nil {
8908 ec.Error(ctx, err)
8909 return graphql.Null
8910 }
8911 if resTmp == nil {
8912 if !ec.HasError(rctx) {
8913 ec.Errorf(ctx, "must not be null")
8914 }
8915 return graphql.Null
8916 }
8917 res := resTmp.(*bug.SetTitleOperation)
8918 rctx.Result = res
8919 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8920 return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
8921}
8922
8923func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8924 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8925 defer func() {
8926 if r := recover(); r != nil {
8927 ec.Error(ctx, ec.Recover(ctx, r))
8928 ret = graphql.Null
8929 }
8930 ec.Tracer.EndFieldExecution(ctx)
8931 }()
8932 rctx := &graphql.ResolverContext{
8933 Object: "SetTitleTimelineItem",
8934 Field: field,
8935 Args: nil,
8936 IsMethod: true,
8937 }
8938 ctx = graphql.WithResolverContext(ctx, rctx)
8939 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8940 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8941 ctx = rctx // use context from middleware stack in children
8942 return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
8943 })
8944 if err != nil {
8945 ec.Error(ctx, err)
8946 return graphql.Null
8947 }
8948 if resTmp == nil {
8949 if !ec.HasError(rctx) {
8950 ec.Errorf(ctx, "must not be null")
8951 }
8952 return graphql.Null
8953 }
8954 res := resTmp.(string)
8955 rctx.Result = res
8956 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8957 return ec.marshalNString2string(ctx, field.Selections, res)
8958}
8959
8960func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8961 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8962 defer func() {
8963 if r := recover(); r != nil {
8964 ec.Error(ctx, ec.Recover(ctx, r))
8965 ret = graphql.Null
8966 }
8967 ec.Tracer.EndFieldExecution(ctx)
8968 }()
8969 rctx := &graphql.ResolverContext{
8970 Object: "SetTitleTimelineItem",
8971 Field: field,
8972 Args: nil,
8973 IsMethod: false,
8974 }
8975 ctx = graphql.WithResolverContext(ctx, rctx)
8976 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8977 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8978 ctx = rctx // use context from middleware stack in children
8979 return obj.Author, nil
8980 })
8981 if err != nil {
8982 ec.Error(ctx, err)
8983 return graphql.Null
8984 }
8985 if resTmp == nil {
8986 if !ec.HasError(rctx) {
8987 ec.Errorf(ctx, "must not be null")
8988 }
8989 return graphql.Null
8990 }
8991 res := resTmp.(identity.Interface)
8992 rctx.Result = res
8993 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8994 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8995}
8996
8997func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8998 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8999 defer func() {
9000 if r := recover(); r != nil {
9001 ec.Error(ctx, ec.Recover(ctx, r))
9002 ret = graphql.Null
9003 }
9004 ec.Tracer.EndFieldExecution(ctx)
9005 }()
9006 rctx := &graphql.ResolverContext{
9007 Object: "SetTitleTimelineItem",
9008 Field: field,
9009 Args: nil,
9010 IsMethod: true,
9011 }
9012 ctx = graphql.WithResolverContext(ctx, rctx)
9013 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9014 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9015 ctx = rctx // use context from middleware stack in children
9016 return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
9017 })
9018 if err != nil {
9019 ec.Error(ctx, err)
9020 return graphql.Null
9021 }
9022 if resTmp == nil {
9023 if !ec.HasError(rctx) {
9024 ec.Errorf(ctx, "must not be null")
9025 }
9026 return graphql.Null
9027 }
9028 res := resTmp.(*time.Time)
9029 rctx.Result = res
9030 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9031 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
9032}
9033
9034func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9035 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9036 defer func() {
9037 if r := recover(); r != nil {
9038 ec.Error(ctx, ec.Recover(ctx, r))
9039 ret = graphql.Null
9040 }
9041 ec.Tracer.EndFieldExecution(ctx)
9042 }()
9043 rctx := &graphql.ResolverContext{
9044 Object: "SetTitleTimelineItem",
9045 Field: field,
9046 Args: nil,
9047 IsMethod: false,
9048 }
9049 ctx = graphql.WithResolverContext(ctx, rctx)
9050 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9051 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9052 ctx = rctx // use context from middleware stack in children
9053 return obj.Title, nil
9054 })
9055 if err != nil {
9056 ec.Error(ctx, err)
9057 return graphql.Null
9058 }
9059 if resTmp == nil {
9060 if !ec.HasError(rctx) {
9061 ec.Errorf(ctx, "must not be null")
9062 }
9063 return graphql.Null
9064 }
9065 res := resTmp.(string)
9066 rctx.Result = res
9067 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9068 return ec.marshalNString2string(ctx, field.Selections, res)
9069}
9070
9071func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9072 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9073 defer func() {
9074 if r := recover(); r != nil {
9075 ec.Error(ctx, ec.Recover(ctx, r))
9076 ret = graphql.Null
9077 }
9078 ec.Tracer.EndFieldExecution(ctx)
9079 }()
9080 rctx := &graphql.ResolverContext{
9081 Object: "SetTitleTimelineItem",
9082 Field: field,
9083 Args: nil,
9084 IsMethod: false,
9085 }
9086 ctx = graphql.WithResolverContext(ctx, rctx)
9087 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9088 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9089 ctx = rctx // use context from middleware stack in children
9090 return obj.Was, nil
9091 })
9092 if err != nil {
9093 ec.Error(ctx, err)
9094 return graphql.Null
9095 }
9096 if resTmp == nil {
9097 if !ec.HasError(rctx) {
9098 ec.Errorf(ctx, "must not be null")
9099 }
9100 return graphql.Null
9101 }
9102 res := resTmp.(string)
9103 rctx.Result = res
9104 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9105 return ec.marshalNString2string(ctx, field.Selections, res)
9106}
9107
9108func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9109 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9110 defer func() {
9111 if r := recover(); r != nil {
9112 ec.Error(ctx, ec.Recover(ctx, r))
9113 ret = graphql.Null
9114 }
9115 ec.Tracer.EndFieldExecution(ctx)
9116 }()
9117 rctx := &graphql.ResolverContext{
9118 Object: "TimelineItemConnection",
9119 Field: field,
9120 Args: nil,
9121 IsMethod: false,
9122 }
9123 ctx = graphql.WithResolverContext(ctx, rctx)
9124 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9125 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9126 ctx = rctx // use context from middleware stack in children
9127 return obj.Edges, nil
9128 })
9129 if err != nil {
9130 ec.Error(ctx, err)
9131 return graphql.Null
9132 }
9133 if resTmp == nil {
9134 if !ec.HasError(rctx) {
9135 ec.Errorf(ctx, "must not be null")
9136 }
9137 return graphql.Null
9138 }
9139 res := resTmp.([]*models.TimelineItemEdge)
9140 rctx.Result = res
9141 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9142 return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, field.Selections, res)
9143}
9144
9145func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9146 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9147 defer func() {
9148 if r := recover(); r != nil {
9149 ec.Error(ctx, ec.Recover(ctx, r))
9150 ret = graphql.Null
9151 }
9152 ec.Tracer.EndFieldExecution(ctx)
9153 }()
9154 rctx := &graphql.ResolverContext{
9155 Object: "TimelineItemConnection",
9156 Field: field,
9157 Args: nil,
9158 IsMethod: false,
9159 }
9160 ctx = graphql.WithResolverContext(ctx, rctx)
9161 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9162 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9163 ctx = rctx // use context from middleware stack in children
9164 return obj.Nodes, nil
9165 })
9166 if err != nil {
9167 ec.Error(ctx, err)
9168 return graphql.Null
9169 }
9170 if resTmp == nil {
9171 if !ec.HasError(rctx) {
9172 ec.Errorf(ctx, "must not be null")
9173 }
9174 return graphql.Null
9175 }
9176 res := resTmp.([]bug.TimelineItem)
9177 rctx.Result = res
9178 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9179 return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
9180}
9181
9182func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9183 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9184 defer func() {
9185 if r := recover(); r != nil {
9186 ec.Error(ctx, ec.Recover(ctx, r))
9187 ret = graphql.Null
9188 }
9189 ec.Tracer.EndFieldExecution(ctx)
9190 }()
9191 rctx := &graphql.ResolverContext{
9192 Object: "TimelineItemConnection",
9193 Field: field,
9194 Args: nil,
9195 IsMethod: false,
9196 }
9197 ctx = graphql.WithResolverContext(ctx, rctx)
9198 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9199 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9200 ctx = rctx // use context from middleware stack in children
9201 return obj.PageInfo, nil
9202 })
9203 if err != nil {
9204 ec.Error(ctx, err)
9205 return graphql.Null
9206 }
9207 if resTmp == nil {
9208 if !ec.HasError(rctx) {
9209 ec.Errorf(ctx, "must not be null")
9210 }
9211 return graphql.Null
9212 }
9213 res := resTmp.(*models.PageInfo)
9214 rctx.Result = res
9215 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9216 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
9217}
9218
9219func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9220 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9221 defer func() {
9222 if r := recover(); r != nil {
9223 ec.Error(ctx, ec.Recover(ctx, r))
9224 ret = graphql.Null
9225 }
9226 ec.Tracer.EndFieldExecution(ctx)
9227 }()
9228 rctx := &graphql.ResolverContext{
9229 Object: "TimelineItemConnection",
9230 Field: field,
9231 Args: nil,
9232 IsMethod: false,
9233 }
9234 ctx = graphql.WithResolverContext(ctx, rctx)
9235 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9236 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9237 ctx = rctx // use context from middleware stack in children
9238 return obj.TotalCount, nil
9239 })
9240 if err != nil {
9241 ec.Error(ctx, err)
9242 return graphql.Null
9243 }
9244 if resTmp == nil {
9245 if !ec.HasError(rctx) {
9246 ec.Errorf(ctx, "must not be null")
9247 }
9248 return graphql.Null
9249 }
9250 res := resTmp.(int)
9251 rctx.Result = res
9252 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9253 return ec.marshalNInt2int(ctx, field.Selections, res)
9254}
9255
9256func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9257 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9258 defer func() {
9259 if r := recover(); r != nil {
9260 ec.Error(ctx, ec.Recover(ctx, r))
9261 ret = graphql.Null
9262 }
9263 ec.Tracer.EndFieldExecution(ctx)
9264 }()
9265 rctx := &graphql.ResolverContext{
9266 Object: "TimelineItemEdge",
9267 Field: field,
9268 Args: nil,
9269 IsMethod: false,
9270 }
9271 ctx = graphql.WithResolverContext(ctx, rctx)
9272 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9273 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9274 ctx = rctx // use context from middleware stack in children
9275 return obj.Cursor, nil
9276 })
9277 if err != nil {
9278 ec.Error(ctx, err)
9279 return graphql.Null
9280 }
9281 if resTmp == nil {
9282 if !ec.HasError(rctx) {
9283 ec.Errorf(ctx, "must not be null")
9284 }
9285 return graphql.Null
9286 }
9287 res := resTmp.(string)
9288 rctx.Result = res
9289 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9290 return ec.marshalNString2string(ctx, field.Selections, res)
9291}
9292
9293func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9294 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9295 defer func() {
9296 if r := recover(); r != nil {
9297 ec.Error(ctx, ec.Recover(ctx, r))
9298 ret = graphql.Null
9299 }
9300 ec.Tracer.EndFieldExecution(ctx)
9301 }()
9302 rctx := &graphql.ResolverContext{
9303 Object: "TimelineItemEdge",
9304 Field: field,
9305 Args: nil,
9306 IsMethod: false,
9307 }
9308 ctx = graphql.WithResolverContext(ctx, rctx)
9309 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9310 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9311 ctx = rctx // use context from middleware stack in children
9312 return obj.Node, nil
9313 })
9314 if err != nil {
9315 ec.Error(ctx, err)
9316 return graphql.Null
9317 }
9318 if resTmp == nil {
9319 if !ec.HasError(rctx) {
9320 ec.Errorf(ctx, "must not be null")
9321 }
9322 return graphql.Null
9323 }
9324 res := resTmp.(bug.TimelineItem)
9325 rctx.Result = res
9326 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9327 return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
9328}
9329
9330func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9331 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9332 defer func() {
9333 if r := recover(); r != nil {
9334 ec.Error(ctx, ec.Recover(ctx, r))
9335 ret = graphql.Null
9336 }
9337 ec.Tracer.EndFieldExecution(ctx)
9338 }()
9339 rctx := &graphql.ResolverContext{
9340 Object: "__Directive",
9341 Field: field,
9342 Args: nil,
9343 IsMethod: false,
9344 }
9345 ctx = graphql.WithResolverContext(ctx, rctx)
9346 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9347 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9348 ctx = rctx // use context from middleware stack in children
9349 return obj.Name, nil
9350 })
9351 if err != nil {
9352 ec.Error(ctx, err)
9353 return graphql.Null
9354 }
9355 if resTmp == nil {
9356 if !ec.HasError(rctx) {
9357 ec.Errorf(ctx, "must not be null")
9358 }
9359 return graphql.Null
9360 }
9361 res := resTmp.(string)
9362 rctx.Result = res
9363 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9364 return ec.marshalNString2string(ctx, field.Selections, res)
9365}
9366
9367func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9368 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9369 defer func() {
9370 if r := recover(); r != nil {
9371 ec.Error(ctx, ec.Recover(ctx, r))
9372 ret = graphql.Null
9373 }
9374 ec.Tracer.EndFieldExecution(ctx)
9375 }()
9376 rctx := &graphql.ResolverContext{
9377 Object: "__Directive",
9378 Field: field,
9379 Args: nil,
9380 IsMethod: false,
9381 }
9382 ctx = graphql.WithResolverContext(ctx, rctx)
9383 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9384 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9385 ctx = rctx // use context from middleware stack in children
9386 return obj.Description, nil
9387 })
9388 if err != nil {
9389 ec.Error(ctx, err)
9390 return graphql.Null
9391 }
9392 if resTmp == nil {
9393 return graphql.Null
9394 }
9395 res := resTmp.(string)
9396 rctx.Result = res
9397 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9398 return ec.marshalOString2string(ctx, field.Selections, res)
9399}
9400
9401func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9402 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9403 defer func() {
9404 if r := recover(); r != nil {
9405 ec.Error(ctx, ec.Recover(ctx, r))
9406 ret = graphql.Null
9407 }
9408 ec.Tracer.EndFieldExecution(ctx)
9409 }()
9410 rctx := &graphql.ResolverContext{
9411 Object: "__Directive",
9412 Field: field,
9413 Args: nil,
9414 IsMethod: false,
9415 }
9416 ctx = graphql.WithResolverContext(ctx, rctx)
9417 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9418 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9419 ctx = rctx // use context from middleware stack in children
9420 return obj.Locations, nil
9421 })
9422 if err != nil {
9423 ec.Error(ctx, err)
9424 return graphql.Null
9425 }
9426 if resTmp == nil {
9427 if !ec.HasError(rctx) {
9428 ec.Errorf(ctx, "must not be null")
9429 }
9430 return graphql.Null
9431 }
9432 res := resTmp.([]string)
9433 rctx.Result = res
9434 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9435 return ec.marshalN__DirectiveLocation2ᚕstring(ctx, field.Selections, res)
9436}
9437
9438func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9439 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9440 defer func() {
9441 if r := recover(); r != nil {
9442 ec.Error(ctx, ec.Recover(ctx, r))
9443 ret = graphql.Null
9444 }
9445 ec.Tracer.EndFieldExecution(ctx)
9446 }()
9447 rctx := &graphql.ResolverContext{
9448 Object: "__Directive",
9449 Field: field,
9450 Args: nil,
9451 IsMethod: false,
9452 }
9453 ctx = graphql.WithResolverContext(ctx, rctx)
9454 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9455 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9456 ctx = rctx // use context from middleware stack in children
9457 return obj.Args, nil
9458 })
9459 if err != nil {
9460 ec.Error(ctx, err)
9461 return graphql.Null
9462 }
9463 if resTmp == nil {
9464 if !ec.HasError(rctx) {
9465 ec.Errorf(ctx, "must not be null")
9466 }
9467 return graphql.Null
9468 }
9469 res := resTmp.([]introspection.InputValue)
9470 rctx.Result = res
9471 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9472 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
9473}
9474
9475func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9476 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9477 defer func() {
9478 if r := recover(); r != nil {
9479 ec.Error(ctx, ec.Recover(ctx, r))
9480 ret = graphql.Null
9481 }
9482 ec.Tracer.EndFieldExecution(ctx)
9483 }()
9484 rctx := &graphql.ResolverContext{
9485 Object: "__EnumValue",
9486 Field: field,
9487 Args: nil,
9488 IsMethod: false,
9489 }
9490 ctx = graphql.WithResolverContext(ctx, rctx)
9491 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9492 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9493 ctx = rctx // use context from middleware stack in children
9494 return obj.Name, nil
9495 })
9496 if err != nil {
9497 ec.Error(ctx, err)
9498 return graphql.Null
9499 }
9500 if resTmp == nil {
9501 if !ec.HasError(rctx) {
9502 ec.Errorf(ctx, "must not be null")
9503 }
9504 return graphql.Null
9505 }
9506 res := resTmp.(string)
9507 rctx.Result = res
9508 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9509 return ec.marshalNString2string(ctx, field.Selections, res)
9510}
9511
9512func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9513 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9514 defer func() {
9515 if r := recover(); r != nil {
9516 ec.Error(ctx, ec.Recover(ctx, r))
9517 ret = graphql.Null
9518 }
9519 ec.Tracer.EndFieldExecution(ctx)
9520 }()
9521 rctx := &graphql.ResolverContext{
9522 Object: "__EnumValue",
9523 Field: field,
9524 Args: nil,
9525 IsMethod: false,
9526 }
9527 ctx = graphql.WithResolverContext(ctx, rctx)
9528 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9529 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9530 ctx = rctx // use context from middleware stack in children
9531 return obj.Description, nil
9532 })
9533 if err != nil {
9534 ec.Error(ctx, err)
9535 return graphql.Null
9536 }
9537 if resTmp == nil {
9538 return graphql.Null
9539 }
9540 res := resTmp.(string)
9541 rctx.Result = res
9542 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9543 return ec.marshalOString2string(ctx, field.Selections, res)
9544}
9545
9546func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9547 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9548 defer func() {
9549 if r := recover(); r != nil {
9550 ec.Error(ctx, ec.Recover(ctx, r))
9551 ret = graphql.Null
9552 }
9553 ec.Tracer.EndFieldExecution(ctx)
9554 }()
9555 rctx := &graphql.ResolverContext{
9556 Object: "__EnumValue",
9557 Field: field,
9558 Args: nil,
9559 IsMethod: true,
9560 }
9561 ctx = graphql.WithResolverContext(ctx, rctx)
9562 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9563 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9564 ctx = rctx // use context from middleware stack in children
9565 return obj.IsDeprecated(), nil
9566 })
9567 if err != nil {
9568 ec.Error(ctx, err)
9569 return graphql.Null
9570 }
9571 if resTmp == nil {
9572 if !ec.HasError(rctx) {
9573 ec.Errorf(ctx, "must not be null")
9574 }
9575 return graphql.Null
9576 }
9577 res := resTmp.(bool)
9578 rctx.Result = res
9579 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9580 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9581}
9582
9583func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9584 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9585 defer func() {
9586 if r := recover(); r != nil {
9587 ec.Error(ctx, ec.Recover(ctx, r))
9588 ret = graphql.Null
9589 }
9590 ec.Tracer.EndFieldExecution(ctx)
9591 }()
9592 rctx := &graphql.ResolverContext{
9593 Object: "__EnumValue",
9594 Field: field,
9595 Args: nil,
9596 IsMethod: true,
9597 }
9598 ctx = graphql.WithResolverContext(ctx, rctx)
9599 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9600 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9601 ctx = rctx // use context from middleware stack in children
9602 return obj.DeprecationReason(), nil
9603 })
9604 if err != nil {
9605 ec.Error(ctx, err)
9606 return graphql.Null
9607 }
9608 if resTmp == nil {
9609 return graphql.Null
9610 }
9611 res := resTmp.(*string)
9612 rctx.Result = res
9613 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9614 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9615}
9616
9617func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9618 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9619 defer func() {
9620 if r := recover(); r != nil {
9621 ec.Error(ctx, ec.Recover(ctx, r))
9622 ret = graphql.Null
9623 }
9624 ec.Tracer.EndFieldExecution(ctx)
9625 }()
9626 rctx := &graphql.ResolverContext{
9627 Object: "__Field",
9628 Field: field,
9629 Args: nil,
9630 IsMethod: false,
9631 }
9632 ctx = graphql.WithResolverContext(ctx, rctx)
9633 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9634 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9635 ctx = rctx // use context from middleware stack in children
9636 return obj.Name, nil
9637 })
9638 if err != nil {
9639 ec.Error(ctx, err)
9640 return graphql.Null
9641 }
9642 if resTmp == nil {
9643 if !ec.HasError(rctx) {
9644 ec.Errorf(ctx, "must not be null")
9645 }
9646 return graphql.Null
9647 }
9648 res := resTmp.(string)
9649 rctx.Result = res
9650 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9651 return ec.marshalNString2string(ctx, field.Selections, res)
9652}
9653
9654func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9655 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9656 defer func() {
9657 if r := recover(); r != nil {
9658 ec.Error(ctx, ec.Recover(ctx, r))
9659 ret = graphql.Null
9660 }
9661 ec.Tracer.EndFieldExecution(ctx)
9662 }()
9663 rctx := &graphql.ResolverContext{
9664 Object: "__Field",
9665 Field: field,
9666 Args: nil,
9667 IsMethod: false,
9668 }
9669 ctx = graphql.WithResolverContext(ctx, rctx)
9670 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9671 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9672 ctx = rctx // use context from middleware stack in children
9673 return obj.Description, nil
9674 })
9675 if err != nil {
9676 ec.Error(ctx, err)
9677 return graphql.Null
9678 }
9679 if resTmp == nil {
9680 return graphql.Null
9681 }
9682 res := resTmp.(string)
9683 rctx.Result = res
9684 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9685 return ec.marshalOString2string(ctx, field.Selections, res)
9686}
9687
9688func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9689 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9690 defer func() {
9691 if r := recover(); r != nil {
9692 ec.Error(ctx, ec.Recover(ctx, r))
9693 ret = graphql.Null
9694 }
9695 ec.Tracer.EndFieldExecution(ctx)
9696 }()
9697 rctx := &graphql.ResolverContext{
9698 Object: "__Field",
9699 Field: field,
9700 Args: nil,
9701 IsMethod: false,
9702 }
9703 ctx = graphql.WithResolverContext(ctx, rctx)
9704 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9705 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9706 ctx = rctx // use context from middleware stack in children
9707 return obj.Args, nil
9708 })
9709 if err != nil {
9710 ec.Error(ctx, err)
9711 return graphql.Null
9712 }
9713 if resTmp == nil {
9714 if !ec.HasError(rctx) {
9715 ec.Errorf(ctx, "must not be null")
9716 }
9717 return graphql.Null
9718 }
9719 res := resTmp.([]introspection.InputValue)
9720 rctx.Result = res
9721 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9722 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
9723}
9724
9725func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9726 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9727 defer func() {
9728 if r := recover(); r != nil {
9729 ec.Error(ctx, ec.Recover(ctx, r))
9730 ret = graphql.Null
9731 }
9732 ec.Tracer.EndFieldExecution(ctx)
9733 }()
9734 rctx := &graphql.ResolverContext{
9735 Object: "__Field",
9736 Field: field,
9737 Args: nil,
9738 IsMethod: false,
9739 }
9740 ctx = graphql.WithResolverContext(ctx, rctx)
9741 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9742 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9743 ctx = rctx // use context from middleware stack in children
9744 return obj.Type, nil
9745 })
9746 if err != nil {
9747 ec.Error(ctx, err)
9748 return graphql.Null
9749 }
9750 if resTmp == nil {
9751 if !ec.HasError(rctx) {
9752 ec.Errorf(ctx, "must not be null")
9753 }
9754 return graphql.Null
9755 }
9756 res := resTmp.(*introspection.Type)
9757 rctx.Result = res
9758 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9759 return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9760}
9761
9762func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9763 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9764 defer func() {
9765 if r := recover(); r != nil {
9766 ec.Error(ctx, ec.Recover(ctx, r))
9767 ret = graphql.Null
9768 }
9769 ec.Tracer.EndFieldExecution(ctx)
9770 }()
9771 rctx := &graphql.ResolverContext{
9772 Object: "__Field",
9773 Field: field,
9774 Args: nil,
9775 IsMethod: true,
9776 }
9777 ctx = graphql.WithResolverContext(ctx, rctx)
9778 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9779 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9780 ctx = rctx // use context from middleware stack in children
9781 return obj.IsDeprecated(), nil
9782 })
9783 if err != nil {
9784 ec.Error(ctx, err)
9785 return graphql.Null
9786 }
9787 if resTmp == nil {
9788 if !ec.HasError(rctx) {
9789 ec.Errorf(ctx, "must not be null")
9790 }
9791 return graphql.Null
9792 }
9793 res := resTmp.(bool)
9794 rctx.Result = res
9795 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9796 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9797}
9798
9799func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9800 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9801 defer func() {
9802 if r := recover(); r != nil {
9803 ec.Error(ctx, ec.Recover(ctx, r))
9804 ret = graphql.Null
9805 }
9806 ec.Tracer.EndFieldExecution(ctx)
9807 }()
9808 rctx := &graphql.ResolverContext{
9809 Object: "__Field",
9810 Field: field,
9811 Args: nil,
9812 IsMethod: true,
9813 }
9814 ctx = graphql.WithResolverContext(ctx, rctx)
9815 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9816 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9817 ctx = rctx // use context from middleware stack in children
9818 return obj.DeprecationReason(), nil
9819 })
9820 if err != nil {
9821 ec.Error(ctx, err)
9822 return graphql.Null
9823 }
9824 if resTmp == nil {
9825 return graphql.Null
9826 }
9827 res := resTmp.(*string)
9828 rctx.Result = res
9829 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9830 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9831}
9832
9833func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9834 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9835 defer func() {
9836 if r := recover(); r != nil {
9837 ec.Error(ctx, ec.Recover(ctx, r))
9838 ret = graphql.Null
9839 }
9840 ec.Tracer.EndFieldExecution(ctx)
9841 }()
9842 rctx := &graphql.ResolverContext{
9843 Object: "__InputValue",
9844 Field: field,
9845 Args: nil,
9846 IsMethod: false,
9847 }
9848 ctx = graphql.WithResolverContext(ctx, rctx)
9849 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9850 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9851 ctx = rctx // use context from middleware stack in children
9852 return obj.Name, nil
9853 })
9854 if err != nil {
9855 ec.Error(ctx, err)
9856 return graphql.Null
9857 }
9858 if resTmp == nil {
9859 if !ec.HasError(rctx) {
9860 ec.Errorf(ctx, "must not be null")
9861 }
9862 return graphql.Null
9863 }
9864 res := resTmp.(string)
9865 rctx.Result = res
9866 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9867 return ec.marshalNString2string(ctx, field.Selections, res)
9868}
9869
9870func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9871 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9872 defer func() {
9873 if r := recover(); r != nil {
9874 ec.Error(ctx, ec.Recover(ctx, r))
9875 ret = graphql.Null
9876 }
9877 ec.Tracer.EndFieldExecution(ctx)
9878 }()
9879 rctx := &graphql.ResolverContext{
9880 Object: "__InputValue",
9881 Field: field,
9882 Args: nil,
9883 IsMethod: false,
9884 }
9885 ctx = graphql.WithResolverContext(ctx, rctx)
9886 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9887 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9888 ctx = rctx // use context from middleware stack in children
9889 return obj.Description, nil
9890 })
9891 if err != nil {
9892 ec.Error(ctx, err)
9893 return graphql.Null
9894 }
9895 if resTmp == nil {
9896 return graphql.Null
9897 }
9898 res := resTmp.(string)
9899 rctx.Result = res
9900 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9901 return ec.marshalOString2string(ctx, field.Selections, res)
9902}
9903
9904func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9905 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9906 defer func() {
9907 if r := recover(); r != nil {
9908 ec.Error(ctx, ec.Recover(ctx, r))
9909 ret = graphql.Null
9910 }
9911 ec.Tracer.EndFieldExecution(ctx)
9912 }()
9913 rctx := &graphql.ResolverContext{
9914 Object: "__InputValue",
9915 Field: field,
9916 Args: nil,
9917 IsMethod: false,
9918 }
9919 ctx = graphql.WithResolverContext(ctx, rctx)
9920 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9921 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9922 ctx = rctx // use context from middleware stack in children
9923 return obj.Type, nil
9924 })
9925 if err != nil {
9926 ec.Error(ctx, err)
9927 return graphql.Null
9928 }
9929 if resTmp == nil {
9930 if !ec.HasError(rctx) {
9931 ec.Errorf(ctx, "must not be null")
9932 }
9933 return graphql.Null
9934 }
9935 res := resTmp.(*introspection.Type)
9936 rctx.Result = res
9937 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9938 return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9939}
9940
9941func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9942 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9943 defer func() {
9944 if r := recover(); r != nil {
9945 ec.Error(ctx, ec.Recover(ctx, r))
9946 ret = graphql.Null
9947 }
9948 ec.Tracer.EndFieldExecution(ctx)
9949 }()
9950 rctx := &graphql.ResolverContext{
9951 Object: "__InputValue",
9952 Field: field,
9953 Args: nil,
9954 IsMethod: false,
9955 }
9956 ctx = graphql.WithResolverContext(ctx, rctx)
9957 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9958 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9959 ctx = rctx // use context from middleware stack in children
9960 return obj.DefaultValue, nil
9961 })
9962 if err != nil {
9963 ec.Error(ctx, err)
9964 return graphql.Null
9965 }
9966 if resTmp == nil {
9967 return graphql.Null
9968 }
9969 res := resTmp.(*string)
9970 rctx.Result = res
9971 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9972 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9973}
9974
9975func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
9976 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9977 defer func() {
9978 if r := recover(); r != nil {
9979 ec.Error(ctx, ec.Recover(ctx, r))
9980 ret = graphql.Null
9981 }
9982 ec.Tracer.EndFieldExecution(ctx)
9983 }()
9984 rctx := &graphql.ResolverContext{
9985 Object: "__Schema",
9986 Field: field,
9987 Args: nil,
9988 IsMethod: true,
9989 }
9990 ctx = graphql.WithResolverContext(ctx, rctx)
9991 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9992 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9993 ctx = rctx // use context from middleware stack in children
9994 return obj.Types(), nil
9995 })
9996 if err != nil {
9997 ec.Error(ctx, err)
9998 return graphql.Null
9999 }
10000 if resTmp == nil {
10001 if !ec.HasError(rctx) {
10002 ec.Errorf(ctx, "must not be null")
10003 }
10004 return graphql.Null
10005 }
10006 res := resTmp.([]introspection.Type)
10007 rctx.Result = res
10008 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10009 return ec.marshalN__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10010}
10011
10012func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10013 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10014 defer func() {
10015 if r := recover(); r != nil {
10016 ec.Error(ctx, ec.Recover(ctx, r))
10017 ret = graphql.Null
10018 }
10019 ec.Tracer.EndFieldExecution(ctx)
10020 }()
10021 rctx := &graphql.ResolverContext{
10022 Object: "__Schema",
10023 Field: field,
10024 Args: nil,
10025 IsMethod: true,
10026 }
10027 ctx = graphql.WithResolverContext(ctx, rctx)
10028 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10029 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10030 ctx = rctx // use context from middleware stack in children
10031 return obj.QueryType(), nil
10032 })
10033 if err != nil {
10034 ec.Error(ctx, err)
10035 return graphql.Null
10036 }
10037 if resTmp == nil {
10038 if !ec.HasError(rctx) {
10039 ec.Errorf(ctx, "must not be null")
10040 }
10041 return graphql.Null
10042 }
10043 res := resTmp.(*introspection.Type)
10044 rctx.Result = res
10045 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10046 return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10047}
10048
10049func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10050 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10051 defer func() {
10052 if r := recover(); r != nil {
10053 ec.Error(ctx, ec.Recover(ctx, r))
10054 ret = graphql.Null
10055 }
10056 ec.Tracer.EndFieldExecution(ctx)
10057 }()
10058 rctx := &graphql.ResolverContext{
10059 Object: "__Schema",
10060 Field: field,
10061 Args: nil,
10062 IsMethod: true,
10063 }
10064 ctx = graphql.WithResolverContext(ctx, rctx)
10065 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10066 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10067 ctx = rctx // use context from middleware stack in children
10068 return obj.MutationType(), nil
10069 })
10070 if err != nil {
10071 ec.Error(ctx, err)
10072 return graphql.Null
10073 }
10074 if resTmp == nil {
10075 return graphql.Null
10076 }
10077 res := resTmp.(*introspection.Type)
10078 rctx.Result = res
10079 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10080 return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10081}
10082
10083func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10084 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10085 defer func() {
10086 if r := recover(); r != nil {
10087 ec.Error(ctx, ec.Recover(ctx, r))
10088 ret = graphql.Null
10089 }
10090 ec.Tracer.EndFieldExecution(ctx)
10091 }()
10092 rctx := &graphql.ResolverContext{
10093 Object: "__Schema",
10094 Field: field,
10095 Args: nil,
10096 IsMethod: true,
10097 }
10098 ctx = graphql.WithResolverContext(ctx, rctx)
10099 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10100 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10101 ctx = rctx // use context from middleware stack in children
10102 return obj.SubscriptionType(), nil
10103 })
10104 if err != nil {
10105 ec.Error(ctx, err)
10106 return graphql.Null
10107 }
10108 if resTmp == nil {
10109 return graphql.Null
10110 }
10111 res := resTmp.(*introspection.Type)
10112 rctx.Result = res
10113 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10114 return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10115}
10116
10117func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10118 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10119 defer func() {
10120 if r := recover(); r != nil {
10121 ec.Error(ctx, ec.Recover(ctx, r))
10122 ret = graphql.Null
10123 }
10124 ec.Tracer.EndFieldExecution(ctx)
10125 }()
10126 rctx := &graphql.ResolverContext{
10127 Object: "__Schema",
10128 Field: field,
10129 Args: nil,
10130 IsMethod: true,
10131 }
10132 ctx = graphql.WithResolverContext(ctx, rctx)
10133 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10134 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10135 ctx = rctx // use context from middleware stack in children
10136 return obj.Directives(), nil
10137 })
10138 if err != nil {
10139 ec.Error(ctx, err)
10140 return graphql.Null
10141 }
10142 if resTmp == nil {
10143 if !ec.HasError(rctx) {
10144 ec.Errorf(ctx, "must not be null")
10145 }
10146 return graphql.Null
10147 }
10148 res := resTmp.([]introspection.Directive)
10149 rctx.Result = res
10150 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10151 return ec.marshalN__Directive2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, field.Selections, res)
10152}
10153
10154func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10155 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10156 defer func() {
10157 if r := recover(); r != nil {
10158 ec.Error(ctx, ec.Recover(ctx, r))
10159 ret = graphql.Null
10160 }
10161 ec.Tracer.EndFieldExecution(ctx)
10162 }()
10163 rctx := &graphql.ResolverContext{
10164 Object: "__Type",
10165 Field: field,
10166 Args: nil,
10167 IsMethod: true,
10168 }
10169 ctx = graphql.WithResolverContext(ctx, rctx)
10170 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10171 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10172 ctx = rctx // use context from middleware stack in children
10173 return obj.Kind(), nil
10174 })
10175 if err != nil {
10176 ec.Error(ctx, err)
10177 return graphql.Null
10178 }
10179 if resTmp == nil {
10180 if !ec.HasError(rctx) {
10181 ec.Errorf(ctx, "must not be null")
10182 }
10183 return graphql.Null
10184 }
10185 res := resTmp.(string)
10186 rctx.Result = res
10187 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10188 return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
10189}
10190
10191func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10192 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10193 defer func() {
10194 if r := recover(); r != nil {
10195 ec.Error(ctx, ec.Recover(ctx, r))
10196 ret = graphql.Null
10197 }
10198 ec.Tracer.EndFieldExecution(ctx)
10199 }()
10200 rctx := &graphql.ResolverContext{
10201 Object: "__Type",
10202 Field: field,
10203 Args: nil,
10204 IsMethod: true,
10205 }
10206 ctx = graphql.WithResolverContext(ctx, rctx)
10207 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10208 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10209 ctx = rctx // use context from middleware stack in children
10210 return obj.Name(), nil
10211 })
10212 if err != nil {
10213 ec.Error(ctx, err)
10214 return graphql.Null
10215 }
10216 if resTmp == nil {
10217 return graphql.Null
10218 }
10219 res := resTmp.(*string)
10220 rctx.Result = res
10221 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10222 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10223}
10224
10225func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10226 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10227 defer func() {
10228 if r := recover(); r != nil {
10229 ec.Error(ctx, ec.Recover(ctx, r))
10230 ret = graphql.Null
10231 }
10232 ec.Tracer.EndFieldExecution(ctx)
10233 }()
10234 rctx := &graphql.ResolverContext{
10235 Object: "__Type",
10236 Field: field,
10237 Args: nil,
10238 IsMethod: true,
10239 }
10240 ctx = graphql.WithResolverContext(ctx, rctx)
10241 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10242 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10243 ctx = rctx // use context from middleware stack in children
10244 return obj.Description(), nil
10245 })
10246 if err != nil {
10247 ec.Error(ctx, err)
10248 return graphql.Null
10249 }
10250 if resTmp == nil {
10251 return graphql.Null
10252 }
10253 res := resTmp.(string)
10254 rctx.Result = res
10255 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10256 return ec.marshalOString2string(ctx, field.Selections, res)
10257}
10258
10259func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10260 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10261 defer func() {
10262 if r := recover(); r != nil {
10263 ec.Error(ctx, ec.Recover(ctx, r))
10264 ret = graphql.Null
10265 }
10266 ec.Tracer.EndFieldExecution(ctx)
10267 }()
10268 rctx := &graphql.ResolverContext{
10269 Object: "__Type",
10270 Field: field,
10271 Args: nil,
10272 IsMethod: true,
10273 }
10274 ctx = graphql.WithResolverContext(ctx, rctx)
10275 rawArgs := field.ArgumentMap(ec.Variables)
10276 args, err := ec.field___Type_fields_args(ctx, rawArgs)
10277 if err != nil {
10278 ec.Error(ctx, err)
10279 return graphql.Null
10280 }
10281 rctx.Args = args
10282 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10283 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10284 ctx = rctx // use context from middleware stack in children
10285 return obj.Fields(args["includeDeprecated"].(bool)), nil
10286 })
10287 if err != nil {
10288 ec.Error(ctx, err)
10289 return graphql.Null
10290 }
10291 if resTmp == nil {
10292 return graphql.Null
10293 }
10294 res := resTmp.([]introspection.Field)
10295 rctx.Result = res
10296 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10297 return ec.marshalO__Field2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, field.Selections, res)
10298}
10299
10300func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10301 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10302 defer func() {
10303 if r := recover(); r != nil {
10304 ec.Error(ctx, ec.Recover(ctx, r))
10305 ret = graphql.Null
10306 }
10307 ec.Tracer.EndFieldExecution(ctx)
10308 }()
10309 rctx := &graphql.ResolverContext{
10310 Object: "__Type",
10311 Field: field,
10312 Args: nil,
10313 IsMethod: true,
10314 }
10315 ctx = graphql.WithResolverContext(ctx, rctx)
10316 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10317 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10318 ctx = rctx // use context from middleware stack in children
10319 return obj.Interfaces(), nil
10320 })
10321 if err != nil {
10322 ec.Error(ctx, err)
10323 return graphql.Null
10324 }
10325 if resTmp == nil {
10326 return graphql.Null
10327 }
10328 res := resTmp.([]introspection.Type)
10329 rctx.Result = res
10330 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10331 return ec.marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10332}
10333
10334func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10335 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10336 defer func() {
10337 if r := recover(); r != nil {
10338 ec.Error(ctx, ec.Recover(ctx, r))
10339 ret = graphql.Null
10340 }
10341 ec.Tracer.EndFieldExecution(ctx)
10342 }()
10343 rctx := &graphql.ResolverContext{
10344 Object: "__Type",
10345 Field: field,
10346 Args: nil,
10347 IsMethod: true,
10348 }
10349 ctx = graphql.WithResolverContext(ctx, rctx)
10350 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10351 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10352 ctx = rctx // use context from middleware stack in children
10353 return obj.PossibleTypes(), nil
10354 })
10355 if err != nil {
10356 ec.Error(ctx, err)
10357 return graphql.Null
10358 }
10359 if resTmp == nil {
10360 return graphql.Null
10361 }
10362 res := resTmp.([]introspection.Type)
10363 rctx.Result = res
10364 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10365 return ec.marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10366}
10367
10368func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10369 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10370 defer func() {
10371 if r := recover(); r != nil {
10372 ec.Error(ctx, ec.Recover(ctx, r))
10373 ret = graphql.Null
10374 }
10375 ec.Tracer.EndFieldExecution(ctx)
10376 }()
10377 rctx := &graphql.ResolverContext{
10378 Object: "__Type",
10379 Field: field,
10380 Args: nil,
10381 IsMethod: true,
10382 }
10383 ctx = graphql.WithResolverContext(ctx, rctx)
10384 rawArgs := field.ArgumentMap(ec.Variables)
10385 args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
10386 if err != nil {
10387 ec.Error(ctx, err)
10388 return graphql.Null
10389 }
10390 rctx.Args = args
10391 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10392 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10393 ctx = rctx // use context from middleware stack in children
10394 return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10395 })
10396 if err != nil {
10397 ec.Error(ctx, err)
10398 return graphql.Null
10399 }
10400 if resTmp == nil {
10401 return graphql.Null
10402 }
10403 res := resTmp.([]introspection.EnumValue)
10404 rctx.Result = res
10405 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10406 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, field.Selections, res)
10407}
10408
10409func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10410 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10411 defer func() {
10412 if r := recover(); r != nil {
10413 ec.Error(ctx, ec.Recover(ctx, r))
10414 ret = graphql.Null
10415 }
10416 ec.Tracer.EndFieldExecution(ctx)
10417 }()
10418 rctx := &graphql.ResolverContext{
10419 Object: "__Type",
10420 Field: field,
10421 Args: nil,
10422 IsMethod: true,
10423 }
10424 ctx = graphql.WithResolverContext(ctx, rctx)
10425 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10426 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10427 ctx = rctx // use context from middleware stack in children
10428 return obj.InputFields(), nil
10429 })
10430 if err != nil {
10431 ec.Error(ctx, err)
10432 return graphql.Null
10433 }
10434 if resTmp == nil {
10435 return graphql.Null
10436 }
10437 res := resTmp.([]introspection.InputValue)
10438 rctx.Result = res
10439 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10440 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
10441}
10442
10443func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10444 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10445 defer func() {
10446 if r := recover(); r != nil {
10447 ec.Error(ctx, ec.Recover(ctx, r))
10448 ret = graphql.Null
10449 }
10450 ec.Tracer.EndFieldExecution(ctx)
10451 }()
10452 rctx := &graphql.ResolverContext{
10453 Object: "__Type",
10454 Field: field,
10455 Args: nil,
10456 IsMethod: true,
10457 }
10458 ctx = graphql.WithResolverContext(ctx, rctx)
10459 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10460 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10461 ctx = rctx // use context from middleware stack in children
10462 return obj.OfType(), nil
10463 })
10464 if err != nil {
10465 ec.Error(ctx, err)
10466 return graphql.Null
10467 }
10468 if resTmp == nil {
10469 return graphql.Null
10470 }
10471 res := resTmp.(*introspection.Type)
10472 rctx.Result = res
10473 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10474 return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10475}
10476
10477// endregion **************************** field.gotpl *****************************
10478
10479// region **************************** input.gotpl *****************************
10480
10481func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
10482 var it models.AddCommentInput
10483 var asMap = obj.(map[string]interface{})
10484
10485 for k, v := range asMap {
10486 switch k {
10487 case "clientMutationId":
10488 var err error
10489 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10490 if err != nil {
10491 return it, err
10492 }
10493 case "repoRef":
10494 var err error
10495 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10496 if err != nil {
10497 return it, err
10498 }
10499 case "prefix":
10500 var err error
10501 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10502 if err != nil {
10503 return it, err
10504 }
10505 case "message":
10506 var err error
10507 it.Message, err = ec.unmarshalNString2string(ctx, v)
10508 if err != nil {
10509 return it, err
10510 }
10511 case "files":
10512 var err error
10513 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, v)
10514 if err != nil {
10515 return it, err
10516 }
10517 }
10518 }
10519
10520 return it, nil
10521}
10522
10523func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
10524 var it models.ChangeLabelInput
10525 var asMap = obj.(map[string]interface{})
10526
10527 for k, v := range asMap {
10528 switch k {
10529 case "clientMutationId":
10530 var err error
10531 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10532 if err != nil {
10533 return it, err
10534 }
10535 case "repoRef":
10536 var err error
10537 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10538 if err != nil {
10539 return it, err
10540 }
10541 case "prefix":
10542 var err error
10543 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10544 if err != nil {
10545 return it, err
10546 }
10547 case "added":
10548 var err error
10549 it.Added, err = ec.unmarshalOString2ᚕstring(ctx, v)
10550 if err != nil {
10551 return it, err
10552 }
10553 case "Removed":
10554 var err error
10555 it.Removed, err = ec.unmarshalOString2ᚕstring(ctx, v)
10556 if err != nil {
10557 return it, err
10558 }
10559 }
10560 }
10561
10562 return it, nil
10563}
10564
10565func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
10566 var it models.CloseBugInput
10567 var asMap = obj.(map[string]interface{})
10568
10569 for k, v := range asMap {
10570 switch k {
10571 case "clientMutationId":
10572 var err error
10573 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10574 if err != nil {
10575 return it, err
10576 }
10577 case "repoRef":
10578 var err error
10579 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10580 if err != nil {
10581 return it, err
10582 }
10583 case "prefix":
10584 var err error
10585 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10586 if err != nil {
10587 return it, err
10588 }
10589 }
10590 }
10591
10592 return it, nil
10593}
10594
10595func (ec *executionContext) unmarshalInputCommitAsNeededInput(ctx context.Context, obj interface{}) (models.CommitAsNeededInput, error) {
10596 var it models.CommitAsNeededInput
10597 var asMap = obj.(map[string]interface{})
10598
10599 for k, v := range asMap {
10600 switch k {
10601 case "clientMutationId":
10602 var err error
10603 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10604 if err != nil {
10605 return it, err
10606 }
10607 case "repoRef":
10608 var err error
10609 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10610 if err != nil {
10611 return it, err
10612 }
10613 case "prefix":
10614 var err error
10615 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10616 if err != nil {
10617 return it, err
10618 }
10619 }
10620 }
10621
10622 return it, nil
10623}
10624
10625func (ec *executionContext) unmarshalInputCommitInput(ctx context.Context, obj interface{}) (models.CommitInput, error) {
10626 var it models.CommitInput
10627 var asMap = obj.(map[string]interface{})
10628
10629 for k, v := range asMap {
10630 switch k {
10631 case "clientMutationId":
10632 var err error
10633 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10634 if err != nil {
10635 return it, err
10636 }
10637 case "repoRef":
10638 var err error
10639 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10640 if err != nil {
10641 return it, err
10642 }
10643 case "prefix":
10644 var err error
10645 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10646 if err != nil {
10647 return it, err
10648 }
10649 }
10650 }
10651
10652 return it, nil
10653}
10654
10655func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
10656 var it models.NewBugInput
10657 var asMap = obj.(map[string]interface{})
10658
10659 for k, v := range asMap {
10660 switch k {
10661 case "clientMutationId":
10662 var err error
10663 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10664 if err != nil {
10665 return it, err
10666 }
10667 case "repoRef":
10668 var err error
10669 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10670 if err != nil {
10671 return it, err
10672 }
10673 case "title":
10674 var err error
10675 it.Title, err = ec.unmarshalNString2string(ctx, v)
10676 if err != nil {
10677 return it, err
10678 }
10679 case "message":
10680 var err error
10681 it.Message, err = ec.unmarshalNString2string(ctx, v)
10682 if err != nil {
10683 return it, err
10684 }
10685 case "files":
10686 var err error
10687 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, v)
10688 if err != nil {
10689 return it, err
10690 }
10691 }
10692 }
10693
10694 return it, nil
10695}
10696
10697func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10698 var it models.OpenBugInput
10699 var asMap = obj.(map[string]interface{})
10700
10701 for k, v := range asMap {
10702 switch k {
10703 case "clientMutationId":
10704 var err error
10705 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10706 if err != nil {
10707 return it, err
10708 }
10709 case "repoRef":
10710 var err error
10711 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10712 if err != nil {
10713 return it, err
10714 }
10715 case "prefix":
10716 var err error
10717 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10718 if err != nil {
10719 return it, err
10720 }
10721 }
10722 }
10723
10724 return it, nil
10725}
10726
10727func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10728 var it models.SetTitleInput
10729 var asMap = obj.(map[string]interface{})
10730
10731 for k, v := range asMap {
10732 switch k {
10733 case "clientMutationId":
10734 var err error
10735 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10736 if err != nil {
10737 return it, err
10738 }
10739 case "repoRef":
10740 var err error
10741 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10742 if err != nil {
10743 return it, err
10744 }
10745 case "prefix":
10746 var err error
10747 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10748 if err != nil {
10749 return it, err
10750 }
10751 case "title":
10752 var err error
10753 it.Title, err = ec.unmarshalNString2string(ctx, v)
10754 if err != nil {
10755 return it, err
10756 }
10757 }
10758 }
10759
10760 return it, nil
10761}
10762
10763// endregion **************************** input.gotpl *****************************
10764
10765// region ************************** interface.gotpl ***************************
10766
10767func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj *models.Authored) graphql.Marshaler {
10768 switch obj := (*obj).(type) {
10769 case nil:
10770 return graphql.Null
10771 case bug.Comment:
10772 return ec._Comment(ctx, sel, &obj)
10773 case *bug.Comment:
10774 return ec._Comment(ctx, sel, obj)
10775 case *bug.Snapshot:
10776 return ec._Bug(ctx, sel, obj)
10777 case *bug.CreateOperation:
10778 return ec._CreateOperation(ctx, sel, obj)
10779 case *bug.SetTitleOperation:
10780 return ec._SetTitleOperation(ctx, sel, obj)
10781 case *bug.AddCommentOperation:
10782 return ec._AddCommentOperation(ctx, sel, obj)
10783 case *bug.EditCommentOperation:
10784 return ec._EditCommentOperation(ctx, sel, obj)
10785 case *bug.SetStatusOperation:
10786 return ec._SetStatusOperation(ctx, sel, obj)
10787 case *bug.LabelChangeOperation:
10788 return ec._LabelChangeOperation(ctx, sel, obj)
10789 case *bug.CreateTimelineItem:
10790 return ec._CreateTimelineItem(ctx, sel, obj)
10791 case *bug.AddCommentTimelineItem:
10792 return ec._AddCommentTimelineItem(ctx, sel, obj)
10793 case *bug.LabelChangeTimelineItem:
10794 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10795 case *bug.SetStatusTimelineItem:
10796 return ec._SetStatusTimelineItem(ctx, sel, obj)
10797 case *bug.SetTitleTimelineItem:
10798 return ec._SetTitleTimelineItem(ctx, sel, obj)
10799 default:
10800 panic(fmt.Errorf("unexpected type %T", obj))
10801 }
10802}
10803
10804func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj *bug.Operation) graphql.Marshaler {
10805 switch obj := (*obj).(type) {
10806 case nil:
10807 return graphql.Null
10808 case *bug.CreateOperation:
10809 return ec._CreateOperation(ctx, sel, obj)
10810 case *bug.SetTitleOperation:
10811 return ec._SetTitleOperation(ctx, sel, obj)
10812 case *bug.AddCommentOperation:
10813 return ec._AddCommentOperation(ctx, sel, obj)
10814 case *bug.EditCommentOperation:
10815 return ec._EditCommentOperation(ctx, sel, obj)
10816 case *bug.SetStatusOperation:
10817 return ec._SetStatusOperation(ctx, sel, obj)
10818 case *bug.LabelChangeOperation:
10819 return ec._LabelChangeOperation(ctx, sel, obj)
10820 default:
10821 panic(fmt.Errorf("unexpected type %T", obj))
10822 }
10823}
10824
10825func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.TimelineItem) graphql.Marshaler {
10826 switch obj := (*obj).(type) {
10827 case nil:
10828 return graphql.Null
10829 case *bug.CreateTimelineItem:
10830 return ec._CreateTimelineItem(ctx, sel, obj)
10831 case *bug.AddCommentTimelineItem:
10832 return ec._AddCommentTimelineItem(ctx, sel, obj)
10833 case bug.LabelChangeTimelineItem:
10834 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10835 case *bug.LabelChangeTimelineItem:
10836 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10837 case bug.SetStatusTimelineItem:
10838 return ec._SetStatusTimelineItem(ctx, sel, &obj)
10839 case *bug.SetStatusTimelineItem:
10840 return ec._SetStatusTimelineItem(ctx, sel, obj)
10841 case bug.SetTitleTimelineItem:
10842 return ec._SetTitleTimelineItem(ctx, sel, &obj)
10843 case *bug.SetTitleTimelineItem:
10844 return ec._SetTitleTimelineItem(ctx, sel, obj)
10845 default:
10846 panic(fmt.Errorf("unexpected type %T", obj))
10847 }
10848}
10849
10850// endregion ************************** interface.gotpl ***************************
10851
10852// region **************************** object.gotpl ****************************
10853
10854var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10855
10856func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10857 fields := graphql.CollectFields(ec.RequestContext, sel, addCommentOperationImplementors)
10858
10859 out := graphql.NewFieldSet(fields)
10860 var invalids uint32
10861 for i, field := range fields {
10862 switch field.Name {
10863 case "__typename":
10864 out.Values[i] = graphql.MarshalString("AddCommentOperation")
10865 case "id":
10866 field := field
10867 out.Concurrently(i, func() (res graphql.Marshaler) {
10868 defer func() {
10869 if r := recover(); r != nil {
10870 ec.Error(ctx, ec.Recover(ctx, r))
10871 }
10872 }()
10873 res = ec._AddCommentOperation_id(ctx, field, obj)
10874 if res == graphql.Null {
10875 atomic.AddUint32(&invalids, 1)
10876 }
10877 return res
10878 })
10879 case "author":
10880 out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
10881 if out.Values[i] == graphql.Null {
10882 atomic.AddUint32(&invalids, 1)
10883 }
10884 case "date":
10885 field := field
10886 out.Concurrently(i, func() (res graphql.Marshaler) {
10887 defer func() {
10888 if r := recover(); r != nil {
10889 ec.Error(ctx, ec.Recover(ctx, r))
10890 }
10891 }()
10892 res = ec._AddCommentOperation_date(ctx, field, obj)
10893 if res == graphql.Null {
10894 atomic.AddUint32(&invalids, 1)
10895 }
10896 return res
10897 })
10898 case "message":
10899 out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10900 if out.Values[i] == graphql.Null {
10901 atomic.AddUint32(&invalids, 1)
10902 }
10903 case "files":
10904 out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10905 if out.Values[i] == graphql.Null {
10906 atomic.AddUint32(&invalids, 1)
10907 }
10908 default:
10909 panic("unknown field " + strconv.Quote(field.Name))
10910 }
10911 }
10912 out.Dispatch()
10913 if invalids > 0 {
10914 return graphql.Null
10915 }
10916 return out
10917}
10918
10919var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10920
10921func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10922 fields := graphql.CollectFields(ec.RequestContext, sel, addCommentPayloadImplementors)
10923
10924 out := graphql.NewFieldSet(fields)
10925 var invalids uint32
10926 for i, field := range fields {
10927 switch field.Name {
10928 case "__typename":
10929 out.Values[i] = graphql.MarshalString("AddCommentPayload")
10930 case "clientMutationId":
10931 out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10932 case "bug":
10933 out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10934 if out.Values[i] == graphql.Null {
10935 invalids++
10936 }
10937 case "operation":
10938 out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10939 if out.Values[i] == graphql.Null {
10940 invalids++
10941 }
10942 default:
10943 panic("unknown field " + strconv.Quote(field.Name))
10944 }
10945 }
10946 out.Dispatch()
10947 if invalids > 0 {
10948 return graphql.Null
10949 }
10950 return out
10951}
10952
10953var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10954
10955func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10956 fields := graphql.CollectFields(ec.RequestContext, sel, addCommentTimelineItemImplementors)
10957
10958 out := graphql.NewFieldSet(fields)
10959 var invalids uint32
10960 for i, field := range fields {
10961 switch field.Name {
10962 case "__typename":
10963 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10964 case "id":
10965 field := field
10966 out.Concurrently(i, func() (res graphql.Marshaler) {
10967 defer func() {
10968 if r := recover(); r != nil {
10969 ec.Error(ctx, ec.Recover(ctx, r))
10970 }
10971 }()
10972 res = ec._AddCommentTimelineItem_id(ctx, field, obj)
10973 if res == graphql.Null {
10974 atomic.AddUint32(&invalids, 1)
10975 }
10976 return res
10977 })
10978 case "author":
10979 out.Values[i] = ec._AddCommentTimelineItem_author(ctx, field, obj)
10980 if out.Values[i] == graphql.Null {
10981 atomic.AddUint32(&invalids, 1)
10982 }
10983 case "message":
10984 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
10985 if out.Values[i] == graphql.Null {
10986 atomic.AddUint32(&invalids, 1)
10987 }
10988 case "messageIsEmpty":
10989 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
10990 if out.Values[i] == graphql.Null {
10991 atomic.AddUint32(&invalids, 1)
10992 }
10993 case "files":
10994 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
10995 if out.Values[i] == graphql.Null {
10996 atomic.AddUint32(&invalids, 1)
10997 }
10998 case "createdAt":
10999 field := field
11000 out.Concurrently(i, func() (res graphql.Marshaler) {
11001 defer func() {
11002 if r := recover(); r != nil {
11003 ec.Error(ctx, ec.Recover(ctx, r))
11004 }
11005 }()
11006 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
11007 if res == graphql.Null {
11008 atomic.AddUint32(&invalids, 1)
11009 }
11010 return res
11011 })
11012 case "lastEdit":
11013 field := field
11014 out.Concurrently(i, func() (res graphql.Marshaler) {
11015 defer func() {
11016 if r := recover(); r != nil {
11017 ec.Error(ctx, ec.Recover(ctx, r))
11018 }
11019 }()
11020 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
11021 if res == graphql.Null {
11022 atomic.AddUint32(&invalids, 1)
11023 }
11024 return res
11025 })
11026 case "edited":
11027 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
11028 if out.Values[i] == graphql.Null {
11029 atomic.AddUint32(&invalids, 1)
11030 }
11031 case "history":
11032 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
11033 if out.Values[i] == graphql.Null {
11034 atomic.AddUint32(&invalids, 1)
11035 }
11036 default:
11037 panic("unknown field " + strconv.Quote(field.Name))
11038 }
11039 }
11040 out.Dispatch()
11041 if invalids > 0 {
11042 return graphql.Null
11043 }
11044 return out
11045}
11046
11047var bugImplementors = []string{"Bug", "Authored"}
11048
11049func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
11050 fields := graphql.CollectFields(ec.RequestContext, sel, bugImplementors)
11051
11052 out := graphql.NewFieldSet(fields)
11053 var invalids uint32
11054 for i, field := range fields {
11055 switch field.Name {
11056 case "__typename":
11057 out.Values[i] = graphql.MarshalString("Bug")
11058 case "id":
11059 field := field
11060 out.Concurrently(i, func() (res graphql.Marshaler) {
11061 defer func() {
11062 if r := recover(); r != nil {
11063 ec.Error(ctx, ec.Recover(ctx, r))
11064 }
11065 }()
11066 res = ec._Bug_id(ctx, field, obj)
11067 if res == graphql.Null {
11068 atomic.AddUint32(&invalids, 1)
11069 }
11070 return res
11071 })
11072 case "humanId":
11073 field := field
11074 out.Concurrently(i, func() (res graphql.Marshaler) {
11075 defer func() {
11076 if r := recover(); r != nil {
11077 ec.Error(ctx, ec.Recover(ctx, r))
11078 }
11079 }()
11080 res = ec._Bug_humanId(ctx, field, obj)
11081 if res == graphql.Null {
11082 atomic.AddUint32(&invalids, 1)
11083 }
11084 return res
11085 })
11086 case "status":
11087 field := field
11088 out.Concurrently(i, func() (res graphql.Marshaler) {
11089 defer func() {
11090 if r := recover(); r != nil {
11091 ec.Error(ctx, ec.Recover(ctx, r))
11092 }
11093 }()
11094 res = ec._Bug_status(ctx, field, obj)
11095 if res == graphql.Null {
11096 atomic.AddUint32(&invalids, 1)
11097 }
11098 return res
11099 })
11100 case "title":
11101 out.Values[i] = ec._Bug_title(ctx, field, obj)
11102 if out.Values[i] == graphql.Null {
11103 atomic.AddUint32(&invalids, 1)
11104 }
11105 case "labels":
11106 out.Values[i] = ec._Bug_labels(ctx, field, obj)
11107 if out.Values[i] == graphql.Null {
11108 atomic.AddUint32(&invalids, 1)
11109 }
11110 case "author":
11111 out.Values[i] = ec._Bug_author(ctx, field, obj)
11112 if out.Values[i] == graphql.Null {
11113 atomic.AddUint32(&invalids, 1)
11114 }
11115 case "createdAt":
11116 out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
11117 if out.Values[i] == graphql.Null {
11118 atomic.AddUint32(&invalids, 1)
11119 }
11120 case "lastEdit":
11121 field := field
11122 out.Concurrently(i, func() (res graphql.Marshaler) {
11123 defer func() {
11124 if r := recover(); r != nil {
11125 ec.Error(ctx, ec.Recover(ctx, r))
11126 }
11127 }()
11128 res = ec._Bug_lastEdit(ctx, field, obj)
11129 if res == graphql.Null {
11130 atomic.AddUint32(&invalids, 1)
11131 }
11132 return res
11133 })
11134 case "actors":
11135 field := field
11136 out.Concurrently(i, func() (res graphql.Marshaler) {
11137 defer func() {
11138 if r := recover(); r != nil {
11139 ec.Error(ctx, ec.Recover(ctx, r))
11140 }
11141 }()
11142 res = ec._Bug_actors(ctx, field, obj)
11143 if res == graphql.Null {
11144 atomic.AddUint32(&invalids, 1)
11145 }
11146 return res
11147 })
11148 case "participants":
11149 field := field
11150 out.Concurrently(i, func() (res graphql.Marshaler) {
11151 defer func() {
11152 if r := recover(); r != nil {
11153 ec.Error(ctx, ec.Recover(ctx, r))
11154 }
11155 }()
11156 res = ec._Bug_participants(ctx, field, obj)
11157 if res == graphql.Null {
11158 atomic.AddUint32(&invalids, 1)
11159 }
11160 return res
11161 })
11162 case "comments":
11163 field := field
11164 out.Concurrently(i, func() (res graphql.Marshaler) {
11165 defer func() {
11166 if r := recover(); r != nil {
11167 ec.Error(ctx, ec.Recover(ctx, r))
11168 }
11169 }()
11170 res = ec._Bug_comments(ctx, field, obj)
11171 if res == graphql.Null {
11172 atomic.AddUint32(&invalids, 1)
11173 }
11174 return res
11175 })
11176 case "timeline":
11177 field := field
11178 out.Concurrently(i, func() (res graphql.Marshaler) {
11179 defer func() {
11180 if r := recover(); r != nil {
11181 ec.Error(ctx, ec.Recover(ctx, r))
11182 }
11183 }()
11184 res = ec._Bug_timeline(ctx, field, obj)
11185 if res == graphql.Null {
11186 atomic.AddUint32(&invalids, 1)
11187 }
11188 return res
11189 })
11190 case "operations":
11191 field := field
11192 out.Concurrently(i, func() (res graphql.Marshaler) {
11193 defer func() {
11194 if r := recover(); r != nil {
11195 ec.Error(ctx, ec.Recover(ctx, r))
11196 }
11197 }()
11198 res = ec._Bug_operations(ctx, field, obj)
11199 if res == graphql.Null {
11200 atomic.AddUint32(&invalids, 1)
11201 }
11202 return res
11203 })
11204 default:
11205 panic("unknown field " + strconv.Quote(field.Name))
11206 }
11207 }
11208 out.Dispatch()
11209 if invalids > 0 {
11210 return graphql.Null
11211 }
11212 return out
11213}
11214
11215var bugConnectionImplementors = []string{"BugConnection"}
11216
11217func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
11218 fields := graphql.CollectFields(ec.RequestContext, sel, bugConnectionImplementors)
11219
11220 out := graphql.NewFieldSet(fields)
11221 var invalids uint32
11222 for i, field := range fields {
11223 switch field.Name {
11224 case "__typename":
11225 out.Values[i] = graphql.MarshalString("BugConnection")
11226 case "edges":
11227 out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
11228 if out.Values[i] == graphql.Null {
11229 invalids++
11230 }
11231 case "nodes":
11232 out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
11233 if out.Values[i] == graphql.Null {
11234 invalids++
11235 }
11236 case "pageInfo":
11237 out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
11238 if out.Values[i] == graphql.Null {
11239 invalids++
11240 }
11241 case "totalCount":
11242 out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
11243 if out.Values[i] == graphql.Null {
11244 invalids++
11245 }
11246 default:
11247 panic("unknown field " + strconv.Quote(field.Name))
11248 }
11249 }
11250 out.Dispatch()
11251 if invalids > 0 {
11252 return graphql.Null
11253 }
11254 return out
11255}
11256
11257var bugEdgeImplementors = []string{"BugEdge"}
11258
11259func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
11260 fields := graphql.CollectFields(ec.RequestContext, sel, bugEdgeImplementors)
11261
11262 out := graphql.NewFieldSet(fields)
11263 var invalids uint32
11264 for i, field := range fields {
11265 switch field.Name {
11266 case "__typename":
11267 out.Values[i] = graphql.MarshalString("BugEdge")
11268 case "cursor":
11269 out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
11270 if out.Values[i] == graphql.Null {
11271 invalids++
11272 }
11273 case "node":
11274 out.Values[i] = ec._BugEdge_node(ctx, field, obj)
11275 if out.Values[i] == graphql.Null {
11276 invalids++
11277 }
11278 default:
11279 panic("unknown field " + strconv.Quote(field.Name))
11280 }
11281 }
11282 out.Dispatch()
11283 if invalids > 0 {
11284 return graphql.Null
11285 }
11286 return out
11287}
11288
11289var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
11290
11291func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
11292 fields := graphql.CollectFields(ec.RequestContext, sel, changeLabelPayloadImplementors)
11293
11294 out := graphql.NewFieldSet(fields)
11295 var invalids uint32
11296 for i, field := range fields {
11297 switch field.Name {
11298 case "__typename":
11299 out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
11300 case "clientMutationId":
11301 out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
11302 case "bug":
11303 out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
11304 if out.Values[i] == graphql.Null {
11305 invalids++
11306 }
11307 case "operation":
11308 out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
11309 if out.Values[i] == graphql.Null {
11310 invalids++
11311 }
11312 case "results":
11313 out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
11314 if out.Values[i] == graphql.Null {
11315 invalids++
11316 }
11317 default:
11318 panic("unknown field " + strconv.Quote(field.Name))
11319 }
11320 }
11321 out.Dispatch()
11322 if invalids > 0 {
11323 return graphql.Null
11324 }
11325 return out
11326}
11327
11328var closeBugPayloadImplementors = []string{"CloseBugPayload"}
11329
11330func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11331 fields := graphql.CollectFields(ec.RequestContext, sel, closeBugPayloadImplementors)
11332
11333 out := graphql.NewFieldSet(fields)
11334 var invalids uint32
11335 for i, field := range fields {
11336 switch field.Name {
11337 case "__typename":
11338 out.Values[i] = graphql.MarshalString("CloseBugPayload")
11339 case "clientMutationId":
11340 out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11341 case "bug":
11342 out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11343 if out.Values[i] == graphql.Null {
11344 invalids++
11345 }
11346 case "operation":
11347 out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11348 if out.Values[i] == graphql.Null {
11349 invalids++
11350 }
11351 default:
11352 panic("unknown field " + strconv.Quote(field.Name))
11353 }
11354 }
11355 out.Dispatch()
11356 if invalids > 0 {
11357 return graphql.Null
11358 }
11359 return out
11360}
11361
11362var colorImplementors = []string{"Color"}
11363
11364func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11365 fields := graphql.CollectFields(ec.RequestContext, sel, colorImplementors)
11366
11367 out := graphql.NewFieldSet(fields)
11368 var invalids uint32
11369 for i, field := range fields {
11370 switch field.Name {
11371 case "__typename":
11372 out.Values[i] = graphql.MarshalString("Color")
11373 case "R":
11374 field := field
11375 out.Concurrently(i, func() (res graphql.Marshaler) {
11376 defer func() {
11377 if r := recover(); r != nil {
11378 ec.Error(ctx, ec.Recover(ctx, r))
11379 }
11380 }()
11381 res = ec._Color_R(ctx, field, obj)
11382 if res == graphql.Null {
11383 atomic.AddUint32(&invalids, 1)
11384 }
11385 return res
11386 })
11387 case "G":
11388 field := field
11389 out.Concurrently(i, func() (res graphql.Marshaler) {
11390 defer func() {
11391 if r := recover(); r != nil {
11392 ec.Error(ctx, ec.Recover(ctx, r))
11393 }
11394 }()
11395 res = ec._Color_G(ctx, field, obj)
11396 if res == graphql.Null {
11397 atomic.AddUint32(&invalids, 1)
11398 }
11399 return res
11400 })
11401 case "B":
11402 field := field
11403 out.Concurrently(i, func() (res graphql.Marshaler) {
11404 defer func() {
11405 if r := recover(); r != nil {
11406 ec.Error(ctx, ec.Recover(ctx, r))
11407 }
11408 }()
11409 res = ec._Color_B(ctx, field, obj)
11410 if res == graphql.Null {
11411 atomic.AddUint32(&invalids, 1)
11412 }
11413 return res
11414 })
11415 default:
11416 panic("unknown field " + strconv.Quote(field.Name))
11417 }
11418 }
11419 out.Dispatch()
11420 if invalids > 0 {
11421 return graphql.Null
11422 }
11423 return out
11424}
11425
11426var commentImplementors = []string{"Comment", "Authored"}
11427
11428func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11429 fields := graphql.CollectFields(ec.RequestContext, sel, commentImplementors)
11430
11431 out := graphql.NewFieldSet(fields)
11432 var invalids uint32
11433 for i, field := range fields {
11434 switch field.Name {
11435 case "__typename":
11436 out.Values[i] = graphql.MarshalString("Comment")
11437 case "author":
11438 out.Values[i] = ec._Comment_author(ctx, field, obj)
11439 if out.Values[i] == graphql.Null {
11440 invalids++
11441 }
11442 case "message":
11443 out.Values[i] = ec._Comment_message(ctx, field, obj)
11444 if out.Values[i] == graphql.Null {
11445 invalids++
11446 }
11447 case "files":
11448 out.Values[i] = ec._Comment_files(ctx, field, obj)
11449 if out.Values[i] == graphql.Null {
11450 invalids++
11451 }
11452 default:
11453 panic("unknown field " + strconv.Quote(field.Name))
11454 }
11455 }
11456 out.Dispatch()
11457 if invalids > 0 {
11458 return graphql.Null
11459 }
11460 return out
11461}
11462
11463var commentConnectionImplementors = []string{"CommentConnection"}
11464
11465func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11466 fields := graphql.CollectFields(ec.RequestContext, sel, commentConnectionImplementors)
11467
11468 out := graphql.NewFieldSet(fields)
11469 var invalids uint32
11470 for i, field := range fields {
11471 switch field.Name {
11472 case "__typename":
11473 out.Values[i] = graphql.MarshalString("CommentConnection")
11474 case "edges":
11475 out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11476 if out.Values[i] == graphql.Null {
11477 invalids++
11478 }
11479 case "nodes":
11480 out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11481 if out.Values[i] == graphql.Null {
11482 invalids++
11483 }
11484 case "pageInfo":
11485 out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11486 if out.Values[i] == graphql.Null {
11487 invalids++
11488 }
11489 case "totalCount":
11490 out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11491 if out.Values[i] == graphql.Null {
11492 invalids++
11493 }
11494 default:
11495 panic("unknown field " + strconv.Quote(field.Name))
11496 }
11497 }
11498 out.Dispatch()
11499 if invalids > 0 {
11500 return graphql.Null
11501 }
11502 return out
11503}
11504
11505var commentEdgeImplementors = []string{"CommentEdge"}
11506
11507func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11508 fields := graphql.CollectFields(ec.RequestContext, sel, commentEdgeImplementors)
11509
11510 out := graphql.NewFieldSet(fields)
11511 var invalids uint32
11512 for i, field := range fields {
11513 switch field.Name {
11514 case "__typename":
11515 out.Values[i] = graphql.MarshalString("CommentEdge")
11516 case "cursor":
11517 out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11518 if out.Values[i] == graphql.Null {
11519 invalids++
11520 }
11521 case "node":
11522 out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11523 if out.Values[i] == graphql.Null {
11524 invalids++
11525 }
11526 default:
11527 panic("unknown field " + strconv.Quote(field.Name))
11528 }
11529 }
11530 out.Dispatch()
11531 if invalids > 0 {
11532 return graphql.Null
11533 }
11534 return out
11535}
11536
11537var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11538
11539func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11540 fields := graphql.CollectFields(ec.RequestContext, sel, commentHistoryStepImplementors)
11541
11542 out := graphql.NewFieldSet(fields)
11543 var invalids uint32
11544 for i, field := range fields {
11545 switch field.Name {
11546 case "__typename":
11547 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11548 case "message":
11549 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11550 if out.Values[i] == graphql.Null {
11551 atomic.AddUint32(&invalids, 1)
11552 }
11553 case "date":
11554 field := field
11555 out.Concurrently(i, func() (res graphql.Marshaler) {
11556 defer func() {
11557 if r := recover(); r != nil {
11558 ec.Error(ctx, ec.Recover(ctx, r))
11559 }
11560 }()
11561 res = ec._CommentHistoryStep_date(ctx, field, obj)
11562 if res == graphql.Null {
11563 atomic.AddUint32(&invalids, 1)
11564 }
11565 return res
11566 })
11567 default:
11568 panic("unknown field " + strconv.Quote(field.Name))
11569 }
11570 }
11571 out.Dispatch()
11572 if invalids > 0 {
11573 return graphql.Null
11574 }
11575 return out
11576}
11577
11578var commitAsNeededPayloadImplementors = []string{"CommitAsNeededPayload"}
11579
11580func (ec *executionContext) _CommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitAsNeededPayload) graphql.Marshaler {
11581 fields := graphql.CollectFields(ec.RequestContext, sel, commitAsNeededPayloadImplementors)
11582
11583 out := graphql.NewFieldSet(fields)
11584 var invalids uint32
11585 for i, field := range fields {
11586 switch field.Name {
11587 case "__typename":
11588 out.Values[i] = graphql.MarshalString("CommitAsNeededPayload")
11589 case "clientMutationId":
11590 out.Values[i] = ec._CommitAsNeededPayload_clientMutationId(ctx, field, obj)
11591 case "bug":
11592 out.Values[i] = ec._CommitAsNeededPayload_bug(ctx, field, obj)
11593 if out.Values[i] == graphql.Null {
11594 invalids++
11595 }
11596 default:
11597 panic("unknown field " + strconv.Quote(field.Name))
11598 }
11599 }
11600 out.Dispatch()
11601 if invalids > 0 {
11602 return graphql.Null
11603 }
11604 return out
11605}
11606
11607var commitPayloadImplementors = []string{"CommitPayload"}
11608
11609func (ec *executionContext) _CommitPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitPayload) graphql.Marshaler {
11610 fields := graphql.CollectFields(ec.RequestContext, sel, commitPayloadImplementors)
11611
11612 out := graphql.NewFieldSet(fields)
11613 var invalids uint32
11614 for i, field := range fields {
11615 switch field.Name {
11616 case "__typename":
11617 out.Values[i] = graphql.MarshalString("CommitPayload")
11618 case "clientMutationId":
11619 out.Values[i] = ec._CommitPayload_clientMutationId(ctx, field, obj)
11620 case "bug":
11621 out.Values[i] = ec._CommitPayload_bug(ctx, field, obj)
11622 if out.Values[i] == graphql.Null {
11623 invalids++
11624 }
11625 default:
11626 panic("unknown field " + strconv.Quote(field.Name))
11627 }
11628 }
11629 out.Dispatch()
11630 if invalids > 0 {
11631 return graphql.Null
11632 }
11633 return out
11634}
11635
11636var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11637
11638func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11639 fields := graphql.CollectFields(ec.RequestContext, sel, createOperationImplementors)
11640
11641 out := graphql.NewFieldSet(fields)
11642 var invalids uint32
11643 for i, field := range fields {
11644 switch field.Name {
11645 case "__typename":
11646 out.Values[i] = graphql.MarshalString("CreateOperation")
11647 case "id":
11648 field := field
11649 out.Concurrently(i, func() (res graphql.Marshaler) {
11650 defer func() {
11651 if r := recover(); r != nil {
11652 ec.Error(ctx, ec.Recover(ctx, r))
11653 }
11654 }()
11655 res = ec._CreateOperation_id(ctx, field, obj)
11656 if res == graphql.Null {
11657 atomic.AddUint32(&invalids, 1)
11658 }
11659 return res
11660 })
11661 case "author":
11662 out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
11663 if out.Values[i] == graphql.Null {
11664 atomic.AddUint32(&invalids, 1)
11665 }
11666 case "date":
11667 field := field
11668 out.Concurrently(i, func() (res graphql.Marshaler) {
11669 defer func() {
11670 if r := recover(); r != nil {
11671 ec.Error(ctx, ec.Recover(ctx, r))
11672 }
11673 }()
11674 res = ec._CreateOperation_date(ctx, field, obj)
11675 if res == graphql.Null {
11676 atomic.AddUint32(&invalids, 1)
11677 }
11678 return res
11679 })
11680 case "title":
11681 out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11682 if out.Values[i] == graphql.Null {
11683 atomic.AddUint32(&invalids, 1)
11684 }
11685 case "message":
11686 out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11687 if out.Values[i] == graphql.Null {
11688 atomic.AddUint32(&invalids, 1)
11689 }
11690 case "files":
11691 out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11692 if out.Values[i] == graphql.Null {
11693 atomic.AddUint32(&invalids, 1)
11694 }
11695 default:
11696 panic("unknown field " + strconv.Quote(field.Name))
11697 }
11698 }
11699 out.Dispatch()
11700 if invalids > 0 {
11701 return graphql.Null
11702 }
11703 return out
11704}
11705
11706var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11707
11708func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11709 fields := graphql.CollectFields(ec.RequestContext, sel, createTimelineItemImplementors)
11710
11711 out := graphql.NewFieldSet(fields)
11712 var invalids uint32
11713 for i, field := range fields {
11714 switch field.Name {
11715 case "__typename":
11716 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11717 case "id":
11718 field := field
11719 out.Concurrently(i, func() (res graphql.Marshaler) {
11720 defer func() {
11721 if r := recover(); r != nil {
11722 ec.Error(ctx, ec.Recover(ctx, r))
11723 }
11724 }()
11725 res = ec._CreateTimelineItem_id(ctx, field, obj)
11726 if res == graphql.Null {
11727 atomic.AddUint32(&invalids, 1)
11728 }
11729 return res
11730 })
11731 case "author":
11732 out.Values[i] = ec._CreateTimelineItem_author(ctx, field, obj)
11733 if out.Values[i] == graphql.Null {
11734 atomic.AddUint32(&invalids, 1)
11735 }
11736 case "message":
11737 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11738 if out.Values[i] == graphql.Null {
11739 atomic.AddUint32(&invalids, 1)
11740 }
11741 case "messageIsEmpty":
11742 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11743 if out.Values[i] == graphql.Null {
11744 atomic.AddUint32(&invalids, 1)
11745 }
11746 case "files":
11747 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11748 if out.Values[i] == graphql.Null {
11749 atomic.AddUint32(&invalids, 1)
11750 }
11751 case "createdAt":
11752 field := field
11753 out.Concurrently(i, func() (res graphql.Marshaler) {
11754 defer func() {
11755 if r := recover(); r != nil {
11756 ec.Error(ctx, ec.Recover(ctx, r))
11757 }
11758 }()
11759 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11760 if res == graphql.Null {
11761 atomic.AddUint32(&invalids, 1)
11762 }
11763 return res
11764 })
11765 case "lastEdit":
11766 field := field
11767 out.Concurrently(i, func() (res graphql.Marshaler) {
11768 defer func() {
11769 if r := recover(); r != nil {
11770 ec.Error(ctx, ec.Recover(ctx, r))
11771 }
11772 }()
11773 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11774 if res == graphql.Null {
11775 atomic.AddUint32(&invalids, 1)
11776 }
11777 return res
11778 })
11779 case "edited":
11780 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11781 if out.Values[i] == graphql.Null {
11782 atomic.AddUint32(&invalids, 1)
11783 }
11784 case "history":
11785 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11786 if out.Values[i] == graphql.Null {
11787 atomic.AddUint32(&invalids, 1)
11788 }
11789 default:
11790 panic("unknown field " + strconv.Quote(field.Name))
11791 }
11792 }
11793 out.Dispatch()
11794 if invalids > 0 {
11795 return graphql.Null
11796 }
11797 return out
11798}
11799
11800var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11801
11802func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11803 fields := graphql.CollectFields(ec.RequestContext, sel, editCommentOperationImplementors)
11804
11805 out := graphql.NewFieldSet(fields)
11806 var invalids uint32
11807 for i, field := range fields {
11808 switch field.Name {
11809 case "__typename":
11810 out.Values[i] = graphql.MarshalString("EditCommentOperation")
11811 case "id":
11812 field := field
11813 out.Concurrently(i, func() (res graphql.Marshaler) {
11814 defer func() {
11815 if r := recover(); r != nil {
11816 ec.Error(ctx, ec.Recover(ctx, r))
11817 }
11818 }()
11819 res = ec._EditCommentOperation_id(ctx, field, obj)
11820 if res == graphql.Null {
11821 atomic.AddUint32(&invalids, 1)
11822 }
11823 return res
11824 })
11825 case "author":
11826 out.Values[i] = ec._EditCommentOperation_author(ctx, field, obj)
11827 if out.Values[i] == graphql.Null {
11828 atomic.AddUint32(&invalids, 1)
11829 }
11830 case "date":
11831 field := field
11832 out.Concurrently(i, func() (res graphql.Marshaler) {
11833 defer func() {
11834 if r := recover(); r != nil {
11835 ec.Error(ctx, ec.Recover(ctx, r))
11836 }
11837 }()
11838 res = ec._EditCommentOperation_date(ctx, field, obj)
11839 if res == graphql.Null {
11840 atomic.AddUint32(&invalids, 1)
11841 }
11842 return res
11843 })
11844 case "target":
11845 field := field
11846 out.Concurrently(i, func() (res graphql.Marshaler) {
11847 defer func() {
11848 if r := recover(); r != nil {
11849 ec.Error(ctx, ec.Recover(ctx, r))
11850 }
11851 }()
11852 res = ec._EditCommentOperation_target(ctx, field, obj)
11853 if res == graphql.Null {
11854 atomic.AddUint32(&invalids, 1)
11855 }
11856 return res
11857 })
11858 case "message":
11859 out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11860 if out.Values[i] == graphql.Null {
11861 atomic.AddUint32(&invalids, 1)
11862 }
11863 case "files":
11864 out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11865 if out.Values[i] == graphql.Null {
11866 atomic.AddUint32(&invalids, 1)
11867 }
11868 default:
11869 panic("unknown field " + strconv.Quote(field.Name))
11870 }
11871 }
11872 out.Dispatch()
11873 if invalids > 0 {
11874 return graphql.Null
11875 }
11876 return out
11877}
11878
11879var identityImplementors = []string{"Identity"}
11880
11881func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj *identity.Interface) graphql.Marshaler {
11882 fields := graphql.CollectFields(ec.RequestContext, sel, identityImplementors)
11883
11884 out := graphql.NewFieldSet(fields)
11885 var invalids uint32
11886 for i, field := range fields {
11887 switch field.Name {
11888 case "__typename":
11889 out.Values[i] = graphql.MarshalString("Identity")
11890 case "id":
11891 field := field
11892 out.Concurrently(i, func() (res graphql.Marshaler) {
11893 defer func() {
11894 if r := recover(); r != nil {
11895 ec.Error(ctx, ec.Recover(ctx, r))
11896 }
11897 }()
11898 res = ec._Identity_id(ctx, field, obj)
11899 if res == graphql.Null {
11900 atomic.AddUint32(&invalids, 1)
11901 }
11902 return res
11903 })
11904 case "humanId":
11905 field := field
11906 out.Concurrently(i, func() (res graphql.Marshaler) {
11907 defer func() {
11908 if r := recover(); r != nil {
11909 ec.Error(ctx, ec.Recover(ctx, r))
11910 }
11911 }()
11912 res = ec._Identity_humanId(ctx, field, obj)
11913 if res == graphql.Null {
11914 atomic.AddUint32(&invalids, 1)
11915 }
11916 return res
11917 })
11918 case "name":
11919 field := field
11920 out.Concurrently(i, func() (res graphql.Marshaler) {
11921 defer func() {
11922 if r := recover(); r != nil {
11923 ec.Error(ctx, ec.Recover(ctx, r))
11924 }
11925 }()
11926 res = ec._Identity_name(ctx, field, obj)
11927 return res
11928 })
11929 case "email":
11930 field := field
11931 out.Concurrently(i, func() (res graphql.Marshaler) {
11932 defer func() {
11933 if r := recover(); r != nil {
11934 ec.Error(ctx, ec.Recover(ctx, r))
11935 }
11936 }()
11937 res = ec._Identity_email(ctx, field, obj)
11938 return res
11939 })
11940 case "login":
11941 field := field
11942 out.Concurrently(i, func() (res graphql.Marshaler) {
11943 defer func() {
11944 if r := recover(); r != nil {
11945 ec.Error(ctx, ec.Recover(ctx, r))
11946 }
11947 }()
11948 res = ec._Identity_login(ctx, field, obj)
11949 return res
11950 })
11951 case "displayName":
11952 field := field
11953 out.Concurrently(i, func() (res graphql.Marshaler) {
11954 defer func() {
11955 if r := recover(); r != nil {
11956 ec.Error(ctx, ec.Recover(ctx, r))
11957 }
11958 }()
11959 res = ec._Identity_displayName(ctx, field, obj)
11960 if res == graphql.Null {
11961 atomic.AddUint32(&invalids, 1)
11962 }
11963 return res
11964 })
11965 case "avatarUrl":
11966 field := field
11967 out.Concurrently(i, func() (res graphql.Marshaler) {
11968 defer func() {
11969 if r := recover(); r != nil {
11970 ec.Error(ctx, ec.Recover(ctx, r))
11971 }
11972 }()
11973 res = ec._Identity_avatarUrl(ctx, field, obj)
11974 return res
11975 })
11976 case "isProtected":
11977 field := field
11978 out.Concurrently(i, func() (res graphql.Marshaler) {
11979 defer func() {
11980 if r := recover(); r != nil {
11981 ec.Error(ctx, ec.Recover(ctx, r))
11982 }
11983 }()
11984 res = ec._Identity_isProtected(ctx, field, obj)
11985 if res == graphql.Null {
11986 atomic.AddUint32(&invalids, 1)
11987 }
11988 return res
11989 })
11990 default:
11991 panic("unknown field " + strconv.Quote(field.Name))
11992 }
11993 }
11994 out.Dispatch()
11995 if invalids > 0 {
11996 return graphql.Null
11997 }
11998 return out
11999}
12000
12001var identityConnectionImplementors = []string{"IdentityConnection"}
12002
12003func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
12004 fields := graphql.CollectFields(ec.RequestContext, sel, identityConnectionImplementors)
12005
12006 out := graphql.NewFieldSet(fields)
12007 var invalids uint32
12008 for i, field := range fields {
12009 switch field.Name {
12010 case "__typename":
12011 out.Values[i] = graphql.MarshalString("IdentityConnection")
12012 case "edges":
12013 out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
12014 if out.Values[i] == graphql.Null {
12015 invalids++
12016 }
12017 case "nodes":
12018 out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
12019 if out.Values[i] == graphql.Null {
12020 invalids++
12021 }
12022 case "pageInfo":
12023 out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
12024 if out.Values[i] == graphql.Null {
12025 invalids++
12026 }
12027 case "totalCount":
12028 out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
12029 if out.Values[i] == graphql.Null {
12030 invalids++
12031 }
12032 default:
12033 panic("unknown field " + strconv.Quote(field.Name))
12034 }
12035 }
12036 out.Dispatch()
12037 if invalids > 0 {
12038 return graphql.Null
12039 }
12040 return out
12041}
12042
12043var identityEdgeImplementors = []string{"IdentityEdge"}
12044
12045func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
12046 fields := graphql.CollectFields(ec.RequestContext, sel, identityEdgeImplementors)
12047
12048 out := graphql.NewFieldSet(fields)
12049 var invalids uint32
12050 for i, field := range fields {
12051 switch field.Name {
12052 case "__typename":
12053 out.Values[i] = graphql.MarshalString("IdentityEdge")
12054 case "cursor":
12055 out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
12056 if out.Values[i] == graphql.Null {
12057 invalids++
12058 }
12059 case "node":
12060 out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
12061 if out.Values[i] == graphql.Null {
12062 invalids++
12063 }
12064 default:
12065 panic("unknown field " + strconv.Quote(field.Name))
12066 }
12067 }
12068 out.Dispatch()
12069 if invalids > 0 {
12070 return graphql.Null
12071 }
12072 return out
12073}
12074
12075var labelImplementors = []string{"Label"}
12076
12077func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
12078 fields := graphql.CollectFields(ec.RequestContext, sel, labelImplementors)
12079
12080 out := graphql.NewFieldSet(fields)
12081 var invalids uint32
12082 for i, field := range fields {
12083 switch field.Name {
12084 case "__typename":
12085 out.Values[i] = graphql.MarshalString("Label")
12086 case "name":
12087 field := field
12088 out.Concurrently(i, func() (res graphql.Marshaler) {
12089 defer func() {
12090 if r := recover(); r != nil {
12091 ec.Error(ctx, ec.Recover(ctx, r))
12092 }
12093 }()
12094 res = ec._Label_name(ctx, field, obj)
12095 if res == graphql.Null {
12096 atomic.AddUint32(&invalids, 1)
12097 }
12098 return res
12099 })
12100 case "color":
12101 field := field
12102 out.Concurrently(i, func() (res graphql.Marshaler) {
12103 defer func() {
12104 if r := recover(); r != nil {
12105 ec.Error(ctx, ec.Recover(ctx, r))
12106 }
12107 }()
12108 res = ec._Label_color(ctx, field, obj)
12109 if res == graphql.Null {
12110 atomic.AddUint32(&invalids, 1)
12111 }
12112 return res
12113 })
12114 default:
12115 panic("unknown field " + strconv.Quote(field.Name))
12116 }
12117 }
12118 out.Dispatch()
12119 if invalids > 0 {
12120 return graphql.Null
12121 }
12122 return out
12123}
12124
12125var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
12126
12127func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
12128 fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeOperationImplementors)
12129
12130 out := graphql.NewFieldSet(fields)
12131 var invalids uint32
12132 for i, field := range fields {
12133 switch field.Name {
12134 case "__typename":
12135 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
12136 case "id":
12137 field := field
12138 out.Concurrently(i, func() (res graphql.Marshaler) {
12139 defer func() {
12140 if r := recover(); r != nil {
12141 ec.Error(ctx, ec.Recover(ctx, r))
12142 }
12143 }()
12144 res = ec._LabelChangeOperation_id(ctx, field, obj)
12145 if res == graphql.Null {
12146 atomic.AddUint32(&invalids, 1)
12147 }
12148 return res
12149 })
12150 case "author":
12151 out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
12152 if out.Values[i] == graphql.Null {
12153 atomic.AddUint32(&invalids, 1)
12154 }
12155 case "date":
12156 field := field
12157 out.Concurrently(i, func() (res graphql.Marshaler) {
12158 defer func() {
12159 if r := recover(); r != nil {
12160 ec.Error(ctx, ec.Recover(ctx, r))
12161 }
12162 }()
12163 res = ec._LabelChangeOperation_date(ctx, field, obj)
12164 if res == graphql.Null {
12165 atomic.AddUint32(&invalids, 1)
12166 }
12167 return res
12168 })
12169 case "added":
12170 out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
12171 if out.Values[i] == graphql.Null {
12172 atomic.AddUint32(&invalids, 1)
12173 }
12174 case "removed":
12175 out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
12176 if out.Values[i] == graphql.Null {
12177 atomic.AddUint32(&invalids, 1)
12178 }
12179 default:
12180 panic("unknown field " + strconv.Quote(field.Name))
12181 }
12182 }
12183 out.Dispatch()
12184 if invalids > 0 {
12185 return graphql.Null
12186 }
12187 return out
12188}
12189
12190var labelChangeResultImplementors = []string{"LabelChangeResult"}
12191
12192func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
12193 fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeResultImplementors)
12194
12195 out := graphql.NewFieldSet(fields)
12196 var invalids uint32
12197 for i, field := range fields {
12198 switch field.Name {
12199 case "__typename":
12200 out.Values[i] = graphql.MarshalString("LabelChangeResult")
12201 case "label":
12202 out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
12203 if out.Values[i] == graphql.Null {
12204 atomic.AddUint32(&invalids, 1)
12205 }
12206 case "status":
12207 field := field
12208 out.Concurrently(i, func() (res graphql.Marshaler) {
12209 defer func() {
12210 if r := recover(); r != nil {
12211 ec.Error(ctx, ec.Recover(ctx, r))
12212 }
12213 }()
12214 res = ec._LabelChangeResult_status(ctx, field, obj)
12215 if res == graphql.Null {
12216 atomic.AddUint32(&invalids, 1)
12217 }
12218 return res
12219 })
12220 default:
12221 panic("unknown field " + strconv.Quote(field.Name))
12222 }
12223 }
12224 out.Dispatch()
12225 if invalids > 0 {
12226 return graphql.Null
12227 }
12228 return out
12229}
12230
12231var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
12232
12233func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
12234 fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeTimelineItemImplementors)
12235
12236 out := graphql.NewFieldSet(fields)
12237 var invalids uint32
12238 for i, field := range fields {
12239 switch field.Name {
12240 case "__typename":
12241 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
12242 case "id":
12243 field := field
12244 out.Concurrently(i, func() (res graphql.Marshaler) {
12245 defer func() {
12246 if r := recover(); r != nil {
12247 ec.Error(ctx, ec.Recover(ctx, r))
12248 }
12249 }()
12250 res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
12251 if res == graphql.Null {
12252 atomic.AddUint32(&invalids, 1)
12253 }
12254 return res
12255 })
12256 case "author":
12257 out.Values[i] = ec._LabelChangeTimelineItem_author(ctx, field, obj)
12258 if out.Values[i] == graphql.Null {
12259 atomic.AddUint32(&invalids, 1)
12260 }
12261 case "date":
12262 field := field
12263 out.Concurrently(i, func() (res graphql.Marshaler) {
12264 defer func() {
12265 if r := recover(); r != nil {
12266 ec.Error(ctx, ec.Recover(ctx, r))
12267 }
12268 }()
12269 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
12270 if res == graphql.Null {
12271 atomic.AddUint32(&invalids, 1)
12272 }
12273 return res
12274 })
12275 case "added":
12276 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
12277 if out.Values[i] == graphql.Null {
12278 atomic.AddUint32(&invalids, 1)
12279 }
12280 case "removed":
12281 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
12282 if out.Values[i] == graphql.Null {
12283 atomic.AddUint32(&invalids, 1)
12284 }
12285 default:
12286 panic("unknown field " + strconv.Quote(field.Name))
12287 }
12288 }
12289 out.Dispatch()
12290 if invalids > 0 {
12291 return graphql.Null
12292 }
12293 return out
12294}
12295
12296var mutationImplementors = []string{"Mutation"}
12297
12298func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12299 fields := graphql.CollectFields(ec.RequestContext, sel, mutationImplementors)
12300
12301 ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
12302 Object: "Mutation",
12303 })
12304
12305 out := graphql.NewFieldSet(fields)
12306 var invalids uint32
12307 for i, field := range fields {
12308 switch field.Name {
12309 case "__typename":
12310 out.Values[i] = graphql.MarshalString("Mutation")
12311 case "newBug":
12312 out.Values[i] = ec._Mutation_newBug(ctx, field)
12313 if out.Values[i] == graphql.Null {
12314 invalids++
12315 }
12316 case "addComment":
12317 out.Values[i] = ec._Mutation_addComment(ctx, field)
12318 if out.Values[i] == graphql.Null {
12319 invalids++
12320 }
12321 case "changeLabels":
12322 out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12323 if out.Values[i] == graphql.Null {
12324 invalids++
12325 }
12326 case "openBug":
12327 out.Values[i] = ec._Mutation_openBug(ctx, field)
12328 if out.Values[i] == graphql.Null {
12329 invalids++
12330 }
12331 case "closeBug":
12332 out.Values[i] = ec._Mutation_closeBug(ctx, field)
12333 if out.Values[i] == graphql.Null {
12334 invalids++
12335 }
12336 case "setTitle":
12337 out.Values[i] = ec._Mutation_setTitle(ctx, field)
12338 if out.Values[i] == graphql.Null {
12339 invalids++
12340 }
12341 case "commit":
12342 out.Values[i] = ec._Mutation_commit(ctx, field)
12343 if out.Values[i] == graphql.Null {
12344 invalids++
12345 }
12346 case "commitAsNeeded":
12347 out.Values[i] = ec._Mutation_commitAsNeeded(ctx, field)
12348 if out.Values[i] == graphql.Null {
12349 invalids++
12350 }
12351 default:
12352 panic("unknown field " + strconv.Quote(field.Name))
12353 }
12354 }
12355 out.Dispatch()
12356 if invalids > 0 {
12357 return graphql.Null
12358 }
12359 return out
12360}
12361
12362var newBugPayloadImplementors = []string{"NewBugPayload"}
12363
12364func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12365 fields := graphql.CollectFields(ec.RequestContext, sel, newBugPayloadImplementors)
12366
12367 out := graphql.NewFieldSet(fields)
12368 var invalids uint32
12369 for i, field := range fields {
12370 switch field.Name {
12371 case "__typename":
12372 out.Values[i] = graphql.MarshalString("NewBugPayload")
12373 case "clientMutationId":
12374 out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12375 case "bug":
12376 out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12377 if out.Values[i] == graphql.Null {
12378 invalids++
12379 }
12380 case "operation":
12381 out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
12382 if out.Values[i] == graphql.Null {
12383 invalids++
12384 }
12385 default:
12386 panic("unknown field " + strconv.Quote(field.Name))
12387 }
12388 }
12389 out.Dispatch()
12390 if invalids > 0 {
12391 return graphql.Null
12392 }
12393 return out
12394}
12395
12396var openBugPayloadImplementors = []string{"OpenBugPayload"}
12397
12398func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12399 fields := graphql.CollectFields(ec.RequestContext, sel, openBugPayloadImplementors)
12400
12401 out := graphql.NewFieldSet(fields)
12402 var invalids uint32
12403 for i, field := range fields {
12404 switch field.Name {
12405 case "__typename":
12406 out.Values[i] = graphql.MarshalString("OpenBugPayload")
12407 case "clientMutationId":
12408 out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12409 case "bug":
12410 out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12411 if out.Values[i] == graphql.Null {
12412 invalids++
12413 }
12414 case "operation":
12415 out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12416 if out.Values[i] == graphql.Null {
12417 invalids++
12418 }
12419 default:
12420 panic("unknown field " + strconv.Quote(field.Name))
12421 }
12422 }
12423 out.Dispatch()
12424 if invalids > 0 {
12425 return graphql.Null
12426 }
12427 return out
12428}
12429
12430var operationConnectionImplementors = []string{"OperationConnection"}
12431
12432func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12433 fields := graphql.CollectFields(ec.RequestContext, sel, operationConnectionImplementors)
12434
12435 out := graphql.NewFieldSet(fields)
12436 var invalids uint32
12437 for i, field := range fields {
12438 switch field.Name {
12439 case "__typename":
12440 out.Values[i] = graphql.MarshalString("OperationConnection")
12441 case "edges":
12442 out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12443 if out.Values[i] == graphql.Null {
12444 invalids++
12445 }
12446 case "nodes":
12447 out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12448 if out.Values[i] == graphql.Null {
12449 invalids++
12450 }
12451 case "pageInfo":
12452 out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12453 if out.Values[i] == graphql.Null {
12454 invalids++
12455 }
12456 case "totalCount":
12457 out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12458 if out.Values[i] == graphql.Null {
12459 invalids++
12460 }
12461 default:
12462 panic("unknown field " + strconv.Quote(field.Name))
12463 }
12464 }
12465 out.Dispatch()
12466 if invalids > 0 {
12467 return graphql.Null
12468 }
12469 return out
12470}
12471
12472var operationEdgeImplementors = []string{"OperationEdge"}
12473
12474func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12475 fields := graphql.CollectFields(ec.RequestContext, sel, operationEdgeImplementors)
12476
12477 out := graphql.NewFieldSet(fields)
12478 var invalids uint32
12479 for i, field := range fields {
12480 switch field.Name {
12481 case "__typename":
12482 out.Values[i] = graphql.MarshalString("OperationEdge")
12483 case "cursor":
12484 out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12485 if out.Values[i] == graphql.Null {
12486 invalids++
12487 }
12488 case "node":
12489 out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12490 if out.Values[i] == graphql.Null {
12491 invalids++
12492 }
12493 default:
12494 panic("unknown field " + strconv.Quote(field.Name))
12495 }
12496 }
12497 out.Dispatch()
12498 if invalids > 0 {
12499 return graphql.Null
12500 }
12501 return out
12502}
12503
12504var pageInfoImplementors = []string{"PageInfo"}
12505
12506func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12507 fields := graphql.CollectFields(ec.RequestContext, sel, pageInfoImplementors)
12508
12509 out := graphql.NewFieldSet(fields)
12510 var invalids uint32
12511 for i, field := range fields {
12512 switch field.Name {
12513 case "__typename":
12514 out.Values[i] = graphql.MarshalString("PageInfo")
12515 case "hasNextPage":
12516 out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12517 if out.Values[i] == graphql.Null {
12518 invalids++
12519 }
12520 case "hasPreviousPage":
12521 out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12522 if out.Values[i] == graphql.Null {
12523 invalids++
12524 }
12525 case "startCursor":
12526 out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12527 if out.Values[i] == graphql.Null {
12528 invalids++
12529 }
12530 case "endCursor":
12531 out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12532 if out.Values[i] == graphql.Null {
12533 invalids++
12534 }
12535 default:
12536 panic("unknown field " + strconv.Quote(field.Name))
12537 }
12538 }
12539 out.Dispatch()
12540 if invalids > 0 {
12541 return graphql.Null
12542 }
12543 return out
12544}
12545
12546var queryImplementors = []string{"Query"}
12547
12548func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12549 fields := graphql.CollectFields(ec.RequestContext, sel, queryImplementors)
12550
12551 ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
12552 Object: "Query",
12553 })
12554
12555 out := graphql.NewFieldSet(fields)
12556 var invalids uint32
12557 for i, field := range fields {
12558 switch field.Name {
12559 case "__typename":
12560 out.Values[i] = graphql.MarshalString("Query")
12561 case "defaultRepository":
12562 field := field
12563 out.Concurrently(i, func() (res graphql.Marshaler) {
12564 defer func() {
12565 if r := recover(); r != nil {
12566 ec.Error(ctx, ec.Recover(ctx, r))
12567 }
12568 }()
12569 res = ec._Query_defaultRepository(ctx, field)
12570 return res
12571 })
12572 case "repository":
12573 field := field
12574 out.Concurrently(i, func() (res graphql.Marshaler) {
12575 defer func() {
12576 if r := recover(); r != nil {
12577 ec.Error(ctx, ec.Recover(ctx, r))
12578 }
12579 }()
12580 res = ec._Query_repository(ctx, field)
12581 return res
12582 })
12583 case "__type":
12584 out.Values[i] = ec._Query___type(ctx, field)
12585 case "__schema":
12586 out.Values[i] = ec._Query___schema(ctx, field)
12587 default:
12588 panic("unknown field " + strconv.Quote(field.Name))
12589 }
12590 }
12591 out.Dispatch()
12592 if invalids > 0 {
12593 return graphql.Null
12594 }
12595 return out
12596}
12597
12598var repositoryImplementors = []string{"Repository"}
12599
12600func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
12601 fields := graphql.CollectFields(ec.RequestContext, sel, repositoryImplementors)
12602
12603 out := graphql.NewFieldSet(fields)
12604 var invalids uint32
12605 for i, field := range fields {
12606 switch field.Name {
12607 case "__typename":
12608 out.Values[i] = graphql.MarshalString("Repository")
12609 case "allBugs":
12610 field := field
12611 out.Concurrently(i, func() (res graphql.Marshaler) {
12612 defer func() {
12613 if r := recover(); r != nil {
12614 ec.Error(ctx, ec.Recover(ctx, r))
12615 }
12616 }()
12617 res = ec._Repository_allBugs(ctx, field, obj)
12618 if res == graphql.Null {
12619 atomic.AddUint32(&invalids, 1)
12620 }
12621 return res
12622 })
12623 case "bug":
12624 field := field
12625 out.Concurrently(i, func() (res graphql.Marshaler) {
12626 defer func() {
12627 if r := recover(); r != nil {
12628 ec.Error(ctx, ec.Recover(ctx, r))
12629 }
12630 }()
12631 res = ec._Repository_bug(ctx, field, obj)
12632 return res
12633 })
12634 case "allIdentities":
12635 field := field
12636 out.Concurrently(i, func() (res graphql.Marshaler) {
12637 defer func() {
12638 if r := recover(); r != nil {
12639 ec.Error(ctx, ec.Recover(ctx, r))
12640 }
12641 }()
12642 res = ec._Repository_allIdentities(ctx, field, obj)
12643 if res == graphql.Null {
12644 atomic.AddUint32(&invalids, 1)
12645 }
12646 return res
12647 })
12648 case "identity":
12649 field := field
12650 out.Concurrently(i, func() (res graphql.Marshaler) {
12651 defer func() {
12652 if r := recover(); r != nil {
12653 ec.Error(ctx, ec.Recover(ctx, r))
12654 }
12655 }()
12656 res = ec._Repository_identity(ctx, field, obj)
12657 return res
12658 })
12659 case "userIdentity":
12660 field := field
12661 out.Concurrently(i, func() (res graphql.Marshaler) {
12662 defer func() {
12663 if r := recover(); r != nil {
12664 ec.Error(ctx, ec.Recover(ctx, r))
12665 }
12666 }()
12667 res = ec._Repository_userIdentity(ctx, field, obj)
12668 return res
12669 })
12670 case "validLabels":
12671 field := field
12672 out.Concurrently(i, func() (res graphql.Marshaler) {
12673 defer func() {
12674 if r := recover(); r != nil {
12675 ec.Error(ctx, ec.Recover(ctx, r))
12676 }
12677 }()
12678 res = ec._Repository_validLabels(ctx, field, obj)
12679 if res == graphql.Null {
12680 atomic.AddUint32(&invalids, 1)
12681 }
12682 return res
12683 })
12684 default:
12685 panic("unknown field " + strconv.Quote(field.Name))
12686 }
12687 }
12688 out.Dispatch()
12689 if invalids > 0 {
12690 return graphql.Null
12691 }
12692 return out
12693}
12694
12695var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12696
12697func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12698 fields := graphql.CollectFields(ec.RequestContext, sel, setStatusOperationImplementors)
12699
12700 out := graphql.NewFieldSet(fields)
12701 var invalids uint32
12702 for i, field := range fields {
12703 switch field.Name {
12704 case "__typename":
12705 out.Values[i] = graphql.MarshalString("SetStatusOperation")
12706 case "id":
12707 field := field
12708 out.Concurrently(i, func() (res graphql.Marshaler) {
12709 defer func() {
12710 if r := recover(); r != nil {
12711 ec.Error(ctx, ec.Recover(ctx, r))
12712 }
12713 }()
12714 res = ec._SetStatusOperation_id(ctx, field, obj)
12715 if res == graphql.Null {
12716 atomic.AddUint32(&invalids, 1)
12717 }
12718 return res
12719 })
12720 case "author":
12721 out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
12722 if out.Values[i] == graphql.Null {
12723 atomic.AddUint32(&invalids, 1)
12724 }
12725 case "date":
12726 field := field
12727 out.Concurrently(i, func() (res graphql.Marshaler) {
12728 defer func() {
12729 if r := recover(); r != nil {
12730 ec.Error(ctx, ec.Recover(ctx, r))
12731 }
12732 }()
12733 res = ec._SetStatusOperation_date(ctx, field, obj)
12734 if res == graphql.Null {
12735 atomic.AddUint32(&invalids, 1)
12736 }
12737 return res
12738 })
12739 case "status":
12740 field := field
12741 out.Concurrently(i, func() (res graphql.Marshaler) {
12742 defer func() {
12743 if r := recover(); r != nil {
12744 ec.Error(ctx, ec.Recover(ctx, r))
12745 }
12746 }()
12747 res = ec._SetStatusOperation_status(ctx, field, obj)
12748 if res == graphql.Null {
12749 atomic.AddUint32(&invalids, 1)
12750 }
12751 return res
12752 })
12753 default:
12754 panic("unknown field " + strconv.Quote(field.Name))
12755 }
12756 }
12757 out.Dispatch()
12758 if invalids > 0 {
12759 return graphql.Null
12760 }
12761 return out
12762}
12763
12764var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12765
12766func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12767 fields := graphql.CollectFields(ec.RequestContext, sel, setStatusTimelineItemImplementors)
12768
12769 out := graphql.NewFieldSet(fields)
12770 var invalids uint32
12771 for i, field := range fields {
12772 switch field.Name {
12773 case "__typename":
12774 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12775 case "id":
12776 field := field
12777 out.Concurrently(i, func() (res graphql.Marshaler) {
12778 defer func() {
12779 if r := recover(); r != nil {
12780 ec.Error(ctx, ec.Recover(ctx, r))
12781 }
12782 }()
12783 res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12784 if res == graphql.Null {
12785 atomic.AddUint32(&invalids, 1)
12786 }
12787 return res
12788 })
12789 case "author":
12790 out.Values[i] = ec._SetStatusTimelineItem_author(ctx, field, obj)
12791 if out.Values[i] == graphql.Null {
12792 atomic.AddUint32(&invalids, 1)
12793 }
12794 case "date":
12795 field := field
12796 out.Concurrently(i, func() (res graphql.Marshaler) {
12797 defer func() {
12798 if r := recover(); r != nil {
12799 ec.Error(ctx, ec.Recover(ctx, r))
12800 }
12801 }()
12802 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12803 if res == graphql.Null {
12804 atomic.AddUint32(&invalids, 1)
12805 }
12806 return res
12807 })
12808 case "status":
12809 field := field
12810 out.Concurrently(i, func() (res graphql.Marshaler) {
12811 defer func() {
12812 if r := recover(); r != nil {
12813 ec.Error(ctx, ec.Recover(ctx, r))
12814 }
12815 }()
12816 res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12817 if res == graphql.Null {
12818 atomic.AddUint32(&invalids, 1)
12819 }
12820 return res
12821 })
12822 default:
12823 panic("unknown field " + strconv.Quote(field.Name))
12824 }
12825 }
12826 out.Dispatch()
12827 if invalids > 0 {
12828 return graphql.Null
12829 }
12830 return out
12831}
12832
12833var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12834
12835func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12836 fields := graphql.CollectFields(ec.RequestContext, sel, setTitleOperationImplementors)
12837
12838 out := graphql.NewFieldSet(fields)
12839 var invalids uint32
12840 for i, field := range fields {
12841 switch field.Name {
12842 case "__typename":
12843 out.Values[i] = graphql.MarshalString("SetTitleOperation")
12844 case "id":
12845 field := field
12846 out.Concurrently(i, func() (res graphql.Marshaler) {
12847 defer func() {
12848 if r := recover(); r != nil {
12849 ec.Error(ctx, ec.Recover(ctx, r))
12850 }
12851 }()
12852 res = ec._SetTitleOperation_id(ctx, field, obj)
12853 if res == graphql.Null {
12854 atomic.AddUint32(&invalids, 1)
12855 }
12856 return res
12857 })
12858 case "author":
12859 out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
12860 if out.Values[i] == graphql.Null {
12861 atomic.AddUint32(&invalids, 1)
12862 }
12863 case "date":
12864 field := field
12865 out.Concurrently(i, func() (res graphql.Marshaler) {
12866 defer func() {
12867 if r := recover(); r != nil {
12868 ec.Error(ctx, ec.Recover(ctx, r))
12869 }
12870 }()
12871 res = ec._SetTitleOperation_date(ctx, field, obj)
12872 if res == graphql.Null {
12873 atomic.AddUint32(&invalids, 1)
12874 }
12875 return res
12876 })
12877 case "title":
12878 out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12879 if out.Values[i] == graphql.Null {
12880 atomic.AddUint32(&invalids, 1)
12881 }
12882 case "was":
12883 out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12884 if out.Values[i] == graphql.Null {
12885 atomic.AddUint32(&invalids, 1)
12886 }
12887 default:
12888 panic("unknown field " + strconv.Quote(field.Name))
12889 }
12890 }
12891 out.Dispatch()
12892 if invalids > 0 {
12893 return graphql.Null
12894 }
12895 return out
12896}
12897
12898var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12899
12900func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12901 fields := graphql.CollectFields(ec.RequestContext, sel, setTitlePayloadImplementors)
12902
12903 out := graphql.NewFieldSet(fields)
12904 var invalids uint32
12905 for i, field := range fields {
12906 switch field.Name {
12907 case "__typename":
12908 out.Values[i] = graphql.MarshalString("SetTitlePayload")
12909 case "clientMutationId":
12910 out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
12911 case "bug":
12912 out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
12913 if out.Values[i] == graphql.Null {
12914 invalids++
12915 }
12916 case "operation":
12917 out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
12918 if out.Values[i] == graphql.Null {
12919 invalids++
12920 }
12921 default:
12922 panic("unknown field " + strconv.Quote(field.Name))
12923 }
12924 }
12925 out.Dispatch()
12926 if invalids > 0 {
12927 return graphql.Null
12928 }
12929 return out
12930}
12931
12932var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
12933
12934func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
12935 fields := graphql.CollectFields(ec.RequestContext, sel, setTitleTimelineItemImplementors)
12936
12937 out := graphql.NewFieldSet(fields)
12938 var invalids uint32
12939 for i, field := range fields {
12940 switch field.Name {
12941 case "__typename":
12942 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
12943 case "id":
12944 field := field
12945 out.Concurrently(i, func() (res graphql.Marshaler) {
12946 defer func() {
12947 if r := recover(); r != nil {
12948 ec.Error(ctx, ec.Recover(ctx, r))
12949 }
12950 }()
12951 res = ec._SetTitleTimelineItem_id(ctx, field, obj)
12952 if res == graphql.Null {
12953 atomic.AddUint32(&invalids, 1)
12954 }
12955 return res
12956 })
12957 case "author":
12958 out.Values[i] = ec._SetTitleTimelineItem_author(ctx, field, obj)
12959 if out.Values[i] == graphql.Null {
12960 atomic.AddUint32(&invalids, 1)
12961 }
12962 case "date":
12963 field := field
12964 out.Concurrently(i, func() (res graphql.Marshaler) {
12965 defer func() {
12966 if r := recover(); r != nil {
12967 ec.Error(ctx, ec.Recover(ctx, r))
12968 }
12969 }()
12970 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
12971 if res == graphql.Null {
12972 atomic.AddUint32(&invalids, 1)
12973 }
12974 return res
12975 })
12976 case "title":
12977 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
12978 if out.Values[i] == graphql.Null {
12979 atomic.AddUint32(&invalids, 1)
12980 }
12981 case "was":
12982 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
12983 if out.Values[i] == graphql.Null {
12984 atomic.AddUint32(&invalids, 1)
12985 }
12986 default:
12987 panic("unknown field " + strconv.Quote(field.Name))
12988 }
12989 }
12990 out.Dispatch()
12991 if invalids > 0 {
12992 return graphql.Null
12993 }
12994 return out
12995}
12996
12997var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
12998
12999func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
13000 fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemConnectionImplementors)
13001
13002 out := graphql.NewFieldSet(fields)
13003 var invalids uint32
13004 for i, field := range fields {
13005 switch field.Name {
13006 case "__typename":
13007 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
13008 case "edges":
13009 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
13010 if out.Values[i] == graphql.Null {
13011 invalids++
13012 }
13013 case "nodes":
13014 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
13015 if out.Values[i] == graphql.Null {
13016 invalids++
13017 }
13018 case "pageInfo":
13019 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
13020 if out.Values[i] == graphql.Null {
13021 invalids++
13022 }
13023 case "totalCount":
13024 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
13025 if out.Values[i] == graphql.Null {
13026 invalids++
13027 }
13028 default:
13029 panic("unknown field " + strconv.Quote(field.Name))
13030 }
13031 }
13032 out.Dispatch()
13033 if invalids > 0 {
13034 return graphql.Null
13035 }
13036 return out
13037}
13038
13039var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
13040
13041func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
13042 fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemEdgeImplementors)
13043
13044 out := graphql.NewFieldSet(fields)
13045 var invalids uint32
13046 for i, field := range fields {
13047 switch field.Name {
13048 case "__typename":
13049 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
13050 case "cursor":
13051 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
13052 if out.Values[i] == graphql.Null {
13053 invalids++
13054 }
13055 case "node":
13056 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
13057 if out.Values[i] == graphql.Null {
13058 invalids++
13059 }
13060 default:
13061 panic("unknown field " + strconv.Quote(field.Name))
13062 }
13063 }
13064 out.Dispatch()
13065 if invalids > 0 {
13066 return graphql.Null
13067 }
13068 return out
13069}
13070
13071var __DirectiveImplementors = []string{"__Directive"}
13072
13073func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
13074 fields := graphql.CollectFields(ec.RequestContext, sel, __DirectiveImplementors)
13075
13076 out := graphql.NewFieldSet(fields)
13077 var invalids uint32
13078 for i, field := range fields {
13079 switch field.Name {
13080 case "__typename":
13081 out.Values[i] = graphql.MarshalString("__Directive")
13082 case "name":
13083 out.Values[i] = ec.___Directive_name(ctx, field, obj)
13084 if out.Values[i] == graphql.Null {
13085 invalids++
13086 }
13087 case "description":
13088 out.Values[i] = ec.___Directive_description(ctx, field, obj)
13089 case "locations":
13090 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
13091 if out.Values[i] == graphql.Null {
13092 invalids++
13093 }
13094 case "args":
13095 out.Values[i] = ec.___Directive_args(ctx, field, obj)
13096 if out.Values[i] == graphql.Null {
13097 invalids++
13098 }
13099 default:
13100 panic("unknown field " + strconv.Quote(field.Name))
13101 }
13102 }
13103 out.Dispatch()
13104 if invalids > 0 {
13105 return graphql.Null
13106 }
13107 return out
13108}
13109
13110var __EnumValueImplementors = []string{"__EnumValue"}
13111
13112func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
13113 fields := graphql.CollectFields(ec.RequestContext, sel, __EnumValueImplementors)
13114
13115 out := graphql.NewFieldSet(fields)
13116 var invalids uint32
13117 for i, field := range fields {
13118 switch field.Name {
13119 case "__typename":
13120 out.Values[i] = graphql.MarshalString("__EnumValue")
13121 case "name":
13122 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
13123 if out.Values[i] == graphql.Null {
13124 invalids++
13125 }
13126 case "description":
13127 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
13128 case "isDeprecated":
13129 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
13130 if out.Values[i] == graphql.Null {
13131 invalids++
13132 }
13133 case "deprecationReason":
13134 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
13135 default:
13136 panic("unknown field " + strconv.Quote(field.Name))
13137 }
13138 }
13139 out.Dispatch()
13140 if invalids > 0 {
13141 return graphql.Null
13142 }
13143 return out
13144}
13145
13146var __FieldImplementors = []string{"__Field"}
13147
13148func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
13149 fields := graphql.CollectFields(ec.RequestContext, sel, __FieldImplementors)
13150
13151 out := graphql.NewFieldSet(fields)
13152 var invalids uint32
13153 for i, field := range fields {
13154 switch field.Name {
13155 case "__typename":
13156 out.Values[i] = graphql.MarshalString("__Field")
13157 case "name":
13158 out.Values[i] = ec.___Field_name(ctx, field, obj)
13159 if out.Values[i] == graphql.Null {
13160 invalids++
13161 }
13162 case "description":
13163 out.Values[i] = ec.___Field_description(ctx, field, obj)
13164 case "args":
13165 out.Values[i] = ec.___Field_args(ctx, field, obj)
13166 if out.Values[i] == graphql.Null {
13167 invalids++
13168 }
13169 case "type":
13170 out.Values[i] = ec.___Field_type(ctx, field, obj)
13171 if out.Values[i] == graphql.Null {
13172 invalids++
13173 }
13174 case "isDeprecated":
13175 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
13176 if out.Values[i] == graphql.Null {
13177 invalids++
13178 }
13179 case "deprecationReason":
13180 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
13181 default:
13182 panic("unknown field " + strconv.Quote(field.Name))
13183 }
13184 }
13185 out.Dispatch()
13186 if invalids > 0 {
13187 return graphql.Null
13188 }
13189 return out
13190}
13191
13192var __InputValueImplementors = []string{"__InputValue"}
13193
13194func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
13195 fields := graphql.CollectFields(ec.RequestContext, sel, __InputValueImplementors)
13196
13197 out := graphql.NewFieldSet(fields)
13198 var invalids uint32
13199 for i, field := range fields {
13200 switch field.Name {
13201 case "__typename":
13202 out.Values[i] = graphql.MarshalString("__InputValue")
13203 case "name":
13204 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
13205 if out.Values[i] == graphql.Null {
13206 invalids++
13207 }
13208 case "description":
13209 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
13210 case "type":
13211 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
13212 if out.Values[i] == graphql.Null {
13213 invalids++
13214 }
13215 case "defaultValue":
13216 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
13217 default:
13218 panic("unknown field " + strconv.Quote(field.Name))
13219 }
13220 }
13221 out.Dispatch()
13222 if invalids > 0 {
13223 return graphql.Null
13224 }
13225 return out
13226}
13227
13228var __SchemaImplementors = []string{"__Schema"}
13229
13230func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
13231 fields := graphql.CollectFields(ec.RequestContext, sel, __SchemaImplementors)
13232
13233 out := graphql.NewFieldSet(fields)
13234 var invalids uint32
13235 for i, field := range fields {
13236 switch field.Name {
13237 case "__typename":
13238 out.Values[i] = graphql.MarshalString("__Schema")
13239 case "types":
13240 out.Values[i] = ec.___Schema_types(ctx, field, obj)
13241 if out.Values[i] == graphql.Null {
13242 invalids++
13243 }
13244 case "queryType":
13245 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
13246 if out.Values[i] == graphql.Null {
13247 invalids++
13248 }
13249 case "mutationType":
13250 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13251 case "subscriptionType":
13252 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13253 case "directives":
13254 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13255 if out.Values[i] == graphql.Null {
13256 invalids++
13257 }
13258 default:
13259 panic("unknown field " + strconv.Quote(field.Name))
13260 }
13261 }
13262 out.Dispatch()
13263 if invalids > 0 {
13264 return graphql.Null
13265 }
13266 return out
13267}
13268
13269var __TypeImplementors = []string{"__Type"}
13270
13271func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13272 fields := graphql.CollectFields(ec.RequestContext, sel, __TypeImplementors)
13273
13274 out := graphql.NewFieldSet(fields)
13275 var invalids uint32
13276 for i, field := range fields {
13277 switch field.Name {
13278 case "__typename":
13279 out.Values[i] = graphql.MarshalString("__Type")
13280 case "kind":
13281 out.Values[i] = ec.___Type_kind(ctx, field, obj)
13282 if out.Values[i] == graphql.Null {
13283 invalids++
13284 }
13285 case "name":
13286 out.Values[i] = ec.___Type_name(ctx, field, obj)
13287 case "description":
13288 out.Values[i] = ec.___Type_description(ctx, field, obj)
13289 case "fields":
13290 out.Values[i] = ec.___Type_fields(ctx, field, obj)
13291 case "interfaces":
13292 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13293 case "possibleTypes":
13294 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13295 case "enumValues":
13296 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13297 case "inputFields":
13298 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13299 case "ofType":
13300 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13301 default:
13302 panic("unknown field " + strconv.Quote(field.Name))
13303 }
13304 }
13305 out.Dispatch()
13306 if invalids > 0 {
13307 return graphql.Null
13308 }
13309 return out
13310}
13311
13312// endregion **************************** object.gotpl ****************************
13313
13314// region ***************************** type.gotpl *****************************
13315
13316func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13317 return ec.unmarshalInputAddCommentInput(ctx, v)
13318}
13319
13320func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13321 return ec._AddCommentOperation(ctx, sel, &v)
13322}
13323
13324func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
13325 if v == nil {
13326 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13327 ec.Errorf(ctx, "must not be null")
13328 }
13329 return graphql.Null
13330 }
13331 return ec._AddCommentOperation(ctx, sel, v)
13332}
13333
13334func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13335 return ec._AddCommentPayload(ctx, sel, &v)
13336}
13337
13338func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13339 if v == nil {
13340 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13341 ec.Errorf(ctx, "must not be null")
13342 }
13343 return graphql.Null
13344 }
13345 return ec._AddCommentPayload(ctx, sel, v)
13346}
13347
13348func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13349 return graphql.UnmarshalBoolean(v)
13350}
13351
13352func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13353 res := graphql.MarshalBoolean(v)
13354 if res == graphql.Null {
13355 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13356 ec.Errorf(ctx, "must not be null")
13357 }
13358 }
13359 return res
13360}
13361
13362func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
13363 return ec._Bug(ctx, sel, &v)
13364}
13365
13366func (ec *executionContext) marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v []*bug.Snapshot) graphql.Marshaler {
13367 ret := make(graphql.Array, len(v))
13368 var wg sync.WaitGroup
13369 isLen1 := len(v) == 1
13370 if !isLen1 {
13371 wg.Add(len(v))
13372 }
13373 for i := range v {
13374 i := i
13375 rctx := &graphql.ResolverContext{
13376 Index: &i,
13377 Result: &v[i],
13378 }
13379 ctx := graphql.WithResolverContext(ctx, rctx)
13380 f := func(i int) {
13381 defer func() {
13382 if r := recover(); r != nil {
13383 ec.Error(ctx, ec.Recover(ctx, r))
13384 ret = nil
13385 }
13386 }()
13387 if !isLen1 {
13388 defer wg.Done()
13389 }
13390 ret[i] = ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, sel, v[i])
13391 }
13392 if isLen1 {
13393 f(i)
13394 } else {
13395 go f(i)
13396 }
13397
13398 }
13399 wg.Wait()
13400 return ret
13401}
13402
13403func (ec *executionContext) marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
13404 if v == nil {
13405 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13406 ec.Errorf(ctx, "must not be null")
13407 }
13408 return graphql.Null
13409 }
13410 return ec._Bug(ctx, sel, v)
13411}
13412
13413func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13414 return ec._BugConnection(ctx, sel, &v)
13415}
13416
13417func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
13418 if v == nil {
13419 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13420 ec.Errorf(ctx, "must not be null")
13421 }
13422 return graphql.Null
13423 }
13424 return ec._BugConnection(ctx, sel, v)
13425}
13426
13427func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13428 return ec._BugEdge(ctx, sel, &v)
13429}
13430
13431func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13432 ret := make(graphql.Array, len(v))
13433 var wg sync.WaitGroup
13434 isLen1 := len(v) == 1
13435 if !isLen1 {
13436 wg.Add(len(v))
13437 }
13438 for i := range v {
13439 i := i
13440 rctx := &graphql.ResolverContext{
13441 Index: &i,
13442 Result: &v[i],
13443 }
13444 ctx := graphql.WithResolverContext(ctx, rctx)
13445 f := func(i int) {
13446 defer func() {
13447 if r := recover(); r != nil {
13448 ec.Error(ctx, ec.Recover(ctx, r))
13449 ret = nil
13450 }
13451 }()
13452 if !isLen1 {
13453 defer wg.Done()
13454 }
13455 ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13456 }
13457 if isLen1 {
13458 f(i)
13459 } else {
13460 go f(i)
13461 }
13462
13463 }
13464 wg.Wait()
13465 return ret
13466}
13467
13468func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13469 if v == nil {
13470 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13471 ec.Errorf(ctx, "must not be null")
13472 }
13473 return graphql.Null
13474 }
13475 return ec._BugEdge(ctx, sel, v)
13476}
13477
13478func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13479 return ec._ChangeLabelPayload(ctx, sel, &v)
13480}
13481
13482func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13483 if v == nil {
13484 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13485 ec.Errorf(ctx, "must not be null")
13486 }
13487 return graphql.Null
13488 }
13489 return ec._ChangeLabelPayload(ctx, sel, v)
13490}
13491
13492func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13493 return ec.unmarshalInputCloseBugInput(ctx, v)
13494}
13495
13496func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13497 return ec._CloseBugPayload(ctx, sel, &v)
13498}
13499
13500func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
13501 if v == nil {
13502 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13503 ec.Errorf(ctx, "must not be null")
13504 }
13505 return graphql.Null
13506 }
13507 return ec._CloseBugPayload(ctx, sel, v)
13508}
13509
13510func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13511 return ec._Color(ctx, sel, &v)
13512}
13513
13514func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
13515 if v == nil {
13516 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13517 ec.Errorf(ctx, "must not be null")
13518 }
13519 return graphql.Null
13520 }
13521 return ec._Color(ctx, sel, v)
13522}
13523
13524func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
13525 return ec._Comment(ctx, sel, &v)
13526}
13527
13528func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
13529 ret := make(graphql.Array, len(v))
13530 var wg sync.WaitGroup
13531 isLen1 := len(v) == 1
13532 if !isLen1 {
13533 wg.Add(len(v))
13534 }
13535 for i := range v {
13536 i := i
13537 rctx := &graphql.ResolverContext{
13538 Index: &i,
13539 Result: &v[i],
13540 }
13541 ctx := graphql.WithResolverContext(ctx, rctx)
13542 f := func(i int) {
13543 defer func() {
13544 if r := recover(); r != nil {
13545 ec.Error(ctx, ec.Recover(ctx, r))
13546 ret = nil
13547 }
13548 }()
13549 if !isLen1 {
13550 defer wg.Done()
13551 }
13552 ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
13553 }
13554 if isLen1 {
13555 f(i)
13556 } else {
13557 go f(i)
13558 }
13559
13560 }
13561 wg.Wait()
13562 return ret
13563}
13564
13565func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13566 if v == nil {
13567 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13568 ec.Errorf(ctx, "must not be null")
13569 }
13570 return graphql.Null
13571 }
13572 return ec._Comment(ctx, sel, v)
13573}
13574
13575func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13576 return ec._CommentConnection(ctx, sel, &v)
13577}
13578
13579func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13580 if v == nil {
13581 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13582 ec.Errorf(ctx, "must not be null")
13583 }
13584 return graphql.Null
13585 }
13586 return ec._CommentConnection(ctx, sel, v)
13587}
13588
13589func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13590 return ec._CommentEdge(ctx, sel, &v)
13591}
13592
13593func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13594 ret := make(graphql.Array, len(v))
13595 var wg sync.WaitGroup
13596 isLen1 := len(v) == 1
13597 if !isLen1 {
13598 wg.Add(len(v))
13599 }
13600 for i := range v {
13601 i := i
13602 rctx := &graphql.ResolverContext{
13603 Index: &i,
13604 Result: &v[i],
13605 }
13606 ctx := graphql.WithResolverContext(ctx, rctx)
13607 f := func(i int) {
13608 defer func() {
13609 if r := recover(); r != nil {
13610 ec.Error(ctx, ec.Recover(ctx, r))
13611 ret = nil
13612 }
13613 }()
13614 if !isLen1 {
13615 defer wg.Done()
13616 }
13617 ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13618 }
13619 if isLen1 {
13620 f(i)
13621 } else {
13622 go f(i)
13623 }
13624
13625 }
13626 wg.Wait()
13627 return ret
13628}
13629
13630func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13631 if v == nil {
13632 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13633 ec.Errorf(ctx, "must not be null")
13634 }
13635 return graphql.Null
13636 }
13637 return ec._CommentEdge(ctx, sel, v)
13638}
13639
13640func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13641 return ec._CommentHistoryStep(ctx, sel, &v)
13642}
13643
13644func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13645 ret := make(graphql.Array, len(v))
13646 var wg sync.WaitGroup
13647 isLen1 := len(v) == 1
13648 if !isLen1 {
13649 wg.Add(len(v))
13650 }
13651 for i := range v {
13652 i := i
13653 rctx := &graphql.ResolverContext{
13654 Index: &i,
13655 Result: &v[i],
13656 }
13657 ctx := graphql.WithResolverContext(ctx, rctx)
13658 f := func(i int) {
13659 defer func() {
13660 if r := recover(); r != nil {
13661 ec.Error(ctx, ec.Recover(ctx, r))
13662 ret = nil
13663 }
13664 }()
13665 if !isLen1 {
13666 defer wg.Done()
13667 }
13668 ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13669 }
13670 if isLen1 {
13671 f(i)
13672 } else {
13673 go f(i)
13674 }
13675
13676 }
13677 wg.Wait()
13678 return ret
13679}
13680
13681func (ec *executionContext) unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
13682 return ec.unmarshalInputCommitAsNeededInput(ctx, v)
13683}
13684
13685func (ec *executionContext) marshalNCommitAsNeededPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitAsNeededPayload) graphql.Marshaler {
13686 return ec._CommitAsNeededPayload(ctx, sel, &v)
13687}
13688
13689func (ec *executionContext) marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitAsNeededPayload) graphql.Marshaler {
13690 if v == nil {
13691 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13692 ec.Errorf(ctx, "must not be null")
13693 }
13694 return graphql.Null
13695 }
13696 return ec._CommitAsNeededPayload(ctx, sel, v)
13697}
13698
13699func (ec *executionContext) unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
13700 return ec.unmarshalInputCommitInput(ctx, v)
13701}
13702
13703func (ec *executionContext) marshalNCommitPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitPayload) graphql.Marshaler {
13704 return ec._CommitPayload(ctx, sel, &v)
13705}
13706
13707func (ec *executionContext) marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitPayload) graphql.Marshaler {
13708 if v == nil {
13709 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13710 ec.Errorf(ctx, "must not be null")
13711 }
13712 return graphql.Null
13713 }
13714 return ec._CommitPayload(ctx, sel, v)
13715}
13716
13717func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13718 return ec._CreateOperation(ctx, sel, &v)
13719}
13720
13721func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13722 if v == nil {
13723 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13724 ec.Errorf(ctx, "must not be null")
13725 }
13726 return graphql.Null
13727 }
13728 return ec._CreateOperation(ctx, sel, v)
13729}
13730
13731func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
13732 var res git.Hash
13733 return res, res.UnmarshalGQL(v)
13734}
13735
13736func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
13737 return v
13738}
13739
13740func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
13741 var vSlice []interface{}
13742 if v != nil {
13743 if tmp1, ok := v.([]interface{}); ok {
13744 vSlice = tmp1
13745 } else {
13746 vSlice = []interface{}{v}
13747 }
13748 }
13749 var err error
13750 res := make([]git.Hash, len(vSlice))
13751 for i := range vSlice {
13752 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
13753 if err != nil {
13754 return nil, err
13755 }
13756 }
13757 return res, nil
13758}
13759
13760func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
13761 ret := make(graphql.Array, len(v))
13762 for i := range v {
13763 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
13764 }
13765
13766 return ret
13767}
13768
13769func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
13770 return ec._Identity(ctx, sel, &v)
13771}
13772
13773func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v []identity.Interface) graphql.Marshaler {
13774 ret := make(graphql.Array, len(v))
13775 var wg sync.WaitGroup
13776 isLen1 := len(v) == 1
13777 if !isLen1 {
13778 wg.Add(len(v))
13779 }
13780 for i := range v {
13781 i := i
13782 rctx := &graphql.ResolverContext{
13783 Index: &i,
13784 Result: &v[i],
13785 }
13786 ctx := graphql.WithResolverContext(ctx, rctx)
13787 f := func(i int) {
13788 defer func() {
13789 if r := recover(); r != nil {
13790 ec.Error(ctx, ec.Recover(ctx, r))
13791 ret = nil
13792 }
13793 }()
13794 if !isLen1 {
13795 defer wg.Done()
13796 }
13797 ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, sel, v[i])
13798 }
13799 if isLen1 {
13800 f(i)
13801 } else {
13802 go f(i)
13803 }
13804
13805 }
13806 wg.Wait()
13807 return ret
13808}
13809
13810func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13811 return ec._IdentityConnection(ctx, sel, &v)
13812}
13813
13814func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13815 if v == nil {
13816 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13817 ec.Errorf(ctx, "must not be null")
13818 }
13819 return graphql.Null
13820 }
13821 return ec._IdentityConnection(ctx, sel, v)
13822}
13823
13824func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13825 return ec._IdentityEdge(ctx, sel, &v)
13826}
13827
13828func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13829 ret := make(graphql.Array, len(v))
13830 var wg sync.WaitGroup
13831 isLen1 := len(v) == 1
13832 if !isLen1 {
13833 wg.Add(len(v))
13834 }
13835 for i := range v {
13836 i := i
13837 rctx := &graphql.ResolverContext{
13838 Index: &i,
13839 Result: &v[i],
13840 }
13841 ctx := graphql.WithResolverContext(ctx, rctx)
13842 f := func(i int) {
13843 defer func() {
13844 if r := recover(); r != nil {
13845 ec.Error(ctx, ec.Recover(ctx, r))
13846 ret = nil
13847 }
13848 }()
13849 if !isLen1 {
13850 defer wg.Done()
13851 }
13852 ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13853 }
13854 if isLen1 {
13855 f(i)
13856 } else {
13857 go f(i)
13858 }
13859
13860 }
13861 wg.Wait()
13862 return ret
13863}
13864
13865func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
13866 if v == nil {
13867 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13868 ec.Errorf(ctx, "must not be null")
13869 }
13870 return graphql.Null
13871 }
13872 return ec._IdentityEdge(ctx, sel, v)
13873}
13874
13875func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13876 return graphql.UnmarshalInt(v)
13877}
13878
13879func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13880 res := graphql.MarshalInt(v)
13881 if res == graphql.Null {
13882 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13883 ec.Errorf(ctx, "must not be null")
13884 }
13885 }
13886 return res
13887}
13888
13889func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
13890 return ec._Label(ctx, sel, &v)
13891}
13892
13893func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
13894 ret := make(graphql.Array, len(v))
13895 var wg sync.WaitGroup
13896 isLen1 := len(v) == 1
13897 if !isLen1 {
13898 wg.Add(len(v))
13899 }
13900 for i := range v {
13901 i := i
13902 rctx := &graphql.ResolverContext{
13903 Index: &i,
13904 Result: &v[i],
13905 }
13906 ctx := graphql.WithResolverContext(ctx, rctx)
13907 f := func(i int) {
13908 defer func() {
13909 if r := recover(); r != nil {
13910 ec.Error(ctx, ec.Recover(ctx, r))
13911 ret = nil
13912 }
13913 }()
13914 if !isLen1 {
13915 defer wg.Done()
13916 }
13917 ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
13918 }
13919 if isLen1 {
13920 f(i)
13921 } else {
13922 go f(i)
13923 }
13924
13925 }
13926 wg.Wait()
13927 return ret
13928}
13929
13930func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
13931 return ec._LabelChangeOperation(ctx, sel, &v)
13932}
13933
13934func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
13935 if v == nil {
13936 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13937 ec.Errorf(ctx, "must not be null")
13938 }
13939 return graphql.Null
13940 }
13941 return ec._LabelChangeOperation(ctx, sel, v)
13942}
13943
13944func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
13945 ret := make(graphql.Array, len(v))
13946 var wg sync.WaitGroup
13947 isLen1 := len(v) == 1
13948 if !isLen1 {
13949 wg.Add(len(v))
13950 }
13951 for i := range v {
13952 i := i
13953 rctx := &graphql.ResolverContext{
13954 Index: &i,
13955 Result: &v[i],
13956 }
13957 ctx := graphql.WithResolverContext(ctx, rctx)
13958 f := func(i int) {
13959 defer func() {
13960 if r := recover(); r != nil {
13961 ec.Error(ctx, ec.Recover(ctx, r))
13962 ret = nil
13963 }
13964 }()
13965 if !isLen1 {
13966 defer wg.Done()
13967 }
13968 ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
13969 }
13970 if isLen1 {
13971 f(i)
13972 } else {
13973 go f(i)
13974 }
13975
13976 }
13977 wg.Wait()
13978 return ret
13979}
13980
13981func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
13982 var res models.LabelChangeStatus
13983 return res, res.UnmarshalGQL(v)
13984}
13985
13986func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
13987 return v
13988}
13989
13990func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
13991 return ec.unmarshalInputNewBugInput(ctx, v)
13992}
13993
13994func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
13995 return ec._NewBugPayload(ctx, sel, &v)
13996}
13997
13998func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
13999 if v == nil {
14000 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14001 ec.Errorf(ctx, "must not be null")
14002 }
14003 return graphql.Null
14004 }
14005 return ec._NewBugPayload(ctx, sel, v)
14006}
14007
14008func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
14009 return ec.unmarshalInputOpenBugInput(ctx, v)
14010}
14011
14012func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
14013 return ec._OpenBugPayload(ctx, sel, &v)
14014}
14015
14016func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
14017 if v == nil {
14018 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14019 ec.Errorf(ctx, "must not be null")
14020 }
14021 return graphql.Null
14022 }
14023 return ec._OpenBugPayload(ctx, sel, v)
14024}
14025
14026func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
14027 return ec._Operation(ctx, sel, &v)
14028}
14029
14030func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
14031 ret := make(graphql.Array, len(v))
14032 var wg sync.WaitGroup
14033 isLen1 := len(v) == 1
14034 if !isLen1 {
14035 wg.Add(len(v))
14036 }
14037 for i := range v {
14038 i := i
14039 rctx := &graphql.ResolverContext{
14040 Index: &i,
14041 Result: &v[i],
14042 }
14043 ctx := graphql.WithResolverContext(ctx, rctx)
14044 f := func(i int) {
14045 defer func() {
14046 if r := recover(); r != nil {
14047 ec.Error(ctx, ec.Recover(ctx, r))
14048 ret = nil
14049 }
14050 }()
14051 if !isLen1 {
14052 defer wg.Done()
14053 }
14054 ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
14055 }
14056 if isLen1 {
14057 f(i)
14058 } else {
14059 go f(i)
14060 }
14061
14062 }
14063 wg.Wait()
14064 return ret
14065}
14066
14067func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
14068 return ec._OperationConnection(ctx, sel, &v)
14069}
14070
14071func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
14072 if v == nil {
14073 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14074 ec.Errorf(ctx, "must not be null")
14075 }
14076 return graphql.Null
14077 }
14078 return ec._OperationConnection(ctx, sel, v)
14079}
14080
14081func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
14082 return ec._OperationEdge(ctx, sel, &v)
14083}
14084
14085func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
14086 ret := make(graphql.Array, len(v))
14087 var wg sync.WaitGroup
14088 isLen1 := len(v) == 1
14089 if !isLen1 {
14090 wg.Add(len(v))
14091 }
14092 for i := range v {
14093 i := i
14094 rctx := &graphql.ResolverContext{
14095 Index: &i,
14096 Result: &v[i],
14097 }
14098 ctx := graphql.WithResolverContext(ctx, rctx)
14099 f := func(i int) {
14100 defer func() {
14101 if r := recover(); r != nil {
14102 ec.Error(ctx, ec.Recover(ctx, r))
14103 ret = nil
14104 }
14105 }()
14106 if !isLen1 {
14107 defer wg.Done()
14108 }
14109 ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
14110 }
14111 if isLen1 {
14112 f(i)
14113 } else {
14114 go f(i)
14115 }
14116
14117 }
14118 wg.Wait()
14119 return ret
14120}
14121
14122func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
14123 if v == nil {
14124 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14125 ec.Errorf(ctx, "must not be null")
14126 }
14127 return graphql.Null
14128 }
14129 return ec._OperationEdge(ctx, sel, v)
14130}
14131
14132func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
14133 return ec._PageInfo(ctx, sel, &v)
14134}
14135
14136func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
14137 if v == nil {
14138 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14139 ec.Errorf(ctx, "must not be null")
14140 }
14141 return graphql.Null
14142 }
14143 return ec._PageInfo(ctx, sel, v)
14144}
14145
14146func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
14147 return ec._SetStatusOperation(ctx, sel, &v)
14148}
14149
14150func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
14151 if v == nil {
14152 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14153 ec.Errorf(ctx, "must not be null")
14154 }
14155 return graphql.Null
14156 }
14157 return ec._SetStatusOperation(ctx, sel, v)
14158}
14159
14160func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
14161 return ec.unmarshalInputSetTitleInput(ctx, v)
14162}
14163
14164func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
14165 return ec._SetTitleOperation(ctx, sel, &v)
14166}
14167
14168func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
14169 if v == nil {
14170 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14171 ec.Errorf(ctx, "must not be null")
14172 }
14173 return graphql.Null
14174 }
14175 return ec._SetTitleOperation(ctx, sel, v)
14176}
14177
14178func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
14179 return ec._SetTitlePayload(ctx, sel, &v)
14180}
14181
14182func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14183 if v == nil {
14184 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14185 ec.Errorf(ctx, "must not be null")
14186 }
14187 return graphql.Null
14188 }
14189 return ec._SetTitlePayload(ctx, sel, v)
14190}
14191
14192func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14193 var res models.Status
14194 return res, res.UnmarshalGQL(v)
14195}
14196
14197func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14198 return v
14199}
14200
14201func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14202 return graphql.UnmarshalString(v)
14203}
14204
14205func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14206 res := graphql.MarshalString(v)
14207 if res == graphql.Null {
14208 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14209 ec.Errorf(ctx, "must not be null")
14210 }
14211 }
14212 return res
14213}
14214
14215func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14216 return graphql.UnmarshalTime(v)
14217}
14218
14219func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14220 res := graphql.MarshalTime(v)
14221 if res == graphql.Null {
14222 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14223 ec.Errorf(ctx, "must not be null")
14224 }
14225 }
14226 return res
14227}
14228
14229func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14230 if v == nil {
14231 return nil, nil
14232 }
14233 res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14234 return &res, err
14235}
14236
14237func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14238 if v == nil {
14239 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14240 ec.Errorf(ctx, "must not be null")
14241 }
14242 return graphql.Null
14243 }
14244 return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14245}
14246
14247func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14248 return ec._TimelineItem(ctx, sel, &v)
14249}
14250
14251func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14252 ret := make(graphql.Array, len(v))
14253 var wg sync.WaitGroup
14254 isLen1 := len(v) == 1
14255 if !isLen1 {
14256 wg.Add(len(v))
14257 }
14258 for i := range v {
14259 i := i
14260 rctx := &graphql.ResolverContext{
14261 Index: &i,
14262 Result: &v[i],
14263 }
14264 ctx := graphql.WithResolverContext(ctx, rctx)
14265 f := func(i int) {
14266 defer func() {
14267 if r := recover(); r != nil {
14268 ec.Error(ctx, ec.Recover(ctx, r))
14269 ret = nil
14270 }
14271 }()
14272 if !isLen1 {
14273 defer wg.Done()
14274 }
14275 ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14276 }
14277 if isLen1 {
14278 f(i)
14279 } else {
14280 go f(i)
14281 }
14282
14283 }
14284 wg.Wait()
14285 return ret
14286}
14287
14288func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14289 return ec._TimelineItemConnection(ctx, sel, &v)
14290}
14291
14292func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14293 if v == nil {
14294 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14295 ec.Errorf(ctx, "must not be null")
14296 }
14297 return graphql.Null
14298 }
14299 return ec._TimelineItemConnection(ctx, sel, v)
14300}
14301
14302func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14303 return ec._TimelineItemEdge(ctx, sel, &v)
14304}
14305
14306func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14307 ret := make(graphql.Array, len(v))
14308 var wg sync.WaitGroup
14309 isLen1 := len(v) == 1
14310 if !isLen1 {
14311 wg.Add(len(v))
14312 }
14313 for i := range v {
14314 i := i
14315 rctx := &graphql.ResolverContext{
14316 Index: &i,
14317 Result: &v[i],
14318 }
14319 ctx := graphql.WithResolverContext(ctx, rctx)
14320 f := func(i int) {
14321 defer func() {
14322 if r := recover(); r != nil {
14323 ec.Error(ctx, ec.Recover(ctx, r))
14324 ret = nil
14325 }
14326 }()
14327 if !isLen1 {
14328 defer wg.Done()
14329 }
14330 ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14331 }
14332 if isLen1 {
14333 f(i)
14334 } else {
14335 go f(i)
14336 }
14337
14338 }
14339 wg.Wait()
14340 return ret
14341}
14342
14343func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
14344 if v == nil {
14345 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14346 ec.Errorf(ctx, "must not be null")
14347 }
14348 return graphql.Null
14349 }
14350 return ec._TimelineItemEdge(ctx, sel, v)
14351}
14352
14353func (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 {
14354 return ec.___Directive(ctx, sel, &v)
14355}
14356
14357func (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 {
14358 ret := make(graphql.Array, len(v))
14359 var wg sync.WaitGroup
14360 isLen1 := len(v) == 1
14361 if !isLen1 {
14362 wg.Add(len(v))
14363 }
14364 for i := range v {
14365 i := i
14366 rctx := &graphql.ResolverContext{
14367 Index: &i,
14368 Result: &v[i],
14369 }
14370 ctx := graphql.WithResolverContext(ctx, rctx)
14371 f := func(i int) {
14372 defer func() {
14373 if r := recover(); r != nil {
14374 ec.Error(ctx, ec.Recover(ctx, r))
14375 ret = nil
14376 }
14377 }()
14378 if !isLen1 {
14379 defer wg.Done()
14380 }
14381 ret[i] = ec.marshalN__Directive2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14382 }
14383 if isLen1 {
14384 f(i)
14385 } else {
14386 go f(i)
14387 }
14388
14389 }
14390 wg.Wait()
14391 return ret
14392}
14393
14394func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14395 return graphql.UnmarshalString(v)
14396}
14397
14398func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14399 res := graphql.MarshalString(v)
14400 if res == graphql.Null {
14401 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14402 ec.Errorf(ctx, "must not be null")
14403 }
14404 }
14405 return res
14406}
14407
14408func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
14409 var vSlice []interface{}
14410 if v != nil {
14411 if tmp1, ok := v.([]interface{}); ok {
14412 vSlice = tmp1
14413 } else {
14414 vSlice = []interface{}{v}
14415 }
14416 }
14417 var err error
14418 res := make([]string, len(vSlice))
14419 for i := range vSlice {
14420 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14421 if err != nil {
14422 return nil, err
14423 }
14424 }
14425 return res, nil
14426}
14427
14428func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14429 ret := make(graphql.Array, len(v))
14430 var wg sync.WaitGroup
14431 isLen1 := len(v) == 1
14432 if !isLen1 {
14433 wg.Add(len(v))
14434 }
14435 for i := range v {
14436 i := i
14437 rctx := &graphql.ResolverContext{
14438 Index: &i,
14439 Result: &v[i],
14440 }
14441 ctx := graphql.WithResolverContext(ctx, rctx)
14442 f := func(i int) {
14443 defer func() {
14444 if r := recover(); r != nil {
14445 ec.Error(ctx, ec.Recover(ctx, r))
14446 ret = nil
14447 }
14448 }()
14449 if !isLen1 {
14450 defer wg.Done()
14451 }
14452 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
14453 }
14454 if isLen1 {
14455 f(i)
14456 } else {
14457 go f(i)
14458 }
14459
14460 }
14461 wg.Wait()
14462 return ret
14463}
14464
14465func (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 {
14466 return ec.___EnumValue(ctx, sel, &v)
14467}
14468
14469func (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 {
14470 return ec.___Field(ctx, sel, &v)
14471}
14472
14473func (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 {
14474 return ec.___InputValue(ctx, sel, &v)
14475}
14476
14477func (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 {
14478 ret := make(graphql.Array, len(v))
14479 var wg sync.WaitGroup
14480 isLen1 := len(v) == 1
14481 if !isLen1 {
14482 wg.Add(len(v))
14483 }
14484 for i := range v {
14485 i := i
14486 rctx := &graphql.ResolverContext{
14487 Index: &i,
14488 Result: &v[i],
14489 }
14490 ctx := graphql.WithResolverContext(ctx, rctx)
14491 f := func(i int) {
14492 defer func() {
14493 if r := recover(); r != nil {
14494 ec.Error(ctx, ec.Recover(ctx, r))
14495 ret = nil
14496 }
14497 }()
14498 if !isLen1 {
14499 defer wg.Done()
14500 }
14501 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14502 }
14503 if isLen1 {
14504 f(i)
14505 } else {
14506 go f(i)
14507 }
14508
14509 }
14510 wg.Wait()
14511 return ret
14512}
14513
14514func (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 {
14515 return ec.___Type(ctx, sel, &v)
14516}
14517
14518func (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 {
14519 ret := make(graphql.Array, len(v))
14520 var wg sync.WaitGroup
14521 isLen1 := len(v) == 1
14522 if !isLen1 {
14523 wg.Add(len(v))
14524 }
14525 for i := range v {
14526 i := i
14527 rctx := &graphql.ResolverContext{
14528 Index: &i,
14529 Result: &v[i],
14530 }
14531 ctx := graphql.WithResolverContext(ctx, rctx)
14532 f := func(i int) {
14533 defer func() {
14534 if r := recover(); r != nil {
14535 ec.Error(ctx, ec.Recover(ctx, r))
14536 ret = nil
14537 }
14538 }()
14539 if !isLen1 {
14540 defer wg.Done()
14541 }
14542 ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14543 }
14544 if isLen1 {
14545 f(i)
14546 } else {
14547 go f(i)
14548 }
14549
14550 }
14551 wg.Wait()
14552 return ret
14553}
14554
14555func (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 {
14556 if v == nil {
14557 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14558 ec.Errorf(ctx, "must not be null")
14559 }
14560 return graphql.Null
14561 }
14562 return ec.___Type(ctx, sel, v)
14563}
14564
14565func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14566 return graphql.UnmarshalString(v)
14567}
14568
14569func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14570 res := graphql.MarshalString(v)
14571 if res == graphql.Null {
14572 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14573 ec.Errorf(ctx, "must not be null")
14574 }
14575 }
14576 return res
14577}
14578
14579func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14580 return graphql.UnmarshalBoolean(v)
14581}
14582
14583func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14584 return graphql.MarshalBoolean(v)
14585}
14586
14587func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14588 if v == nil {
14589 return nil, nil
14590 }
14591 res, err := ec.unmarshalOBoolean2bool(ctx, v)
14592 return &res, err
14593}
14594
14595func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14596 if v == nil {
14597 return graphql.Null
14598 }
14599 return ec.marshalOBoolean2bool(ctx, sel, *v)
14600}
14601
14602func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
14603 return ec._Bug(ctx, sel, &v)
14604}
14605
14606func (ec *executionContext) marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
14607 if v == nil {
14608 return graphql.Null
14609 }
14610 return ec._Bug(ctx, sel, v)
14611}
14612
14613func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14614 return ec.unmarshalInputChangeLabelInput(ctx, v)
14615}
14616
14617func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14618 if v == nil {
14619 return nil, nil
14620 }
14621 res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14622 return &res, err
14623}
14624
14625func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
14626 var vSlice []interface{}
14627 if v != nil {
14628 if tmp1, ok := v.([]interface{}); ok {
14629 vSlice = tmp1
14630 } else {
14631 vSlice = []interface{}{v}
14632 }
14633 }
14634 var err error
14635 res := make([]git.Hash, len(vSlice))
14636 for i := range vSlice {
14637 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14638 if err != nil {
14639 return nil, err
14640 }
14641 }
14642 return res, nil
14643}
14644
14645func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14646 if v == nil {
14647 return graphql.Null
14648 }
14649 ret := make(graphql.Array, len(v))
14650 for i := range v {
14651 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14652 }
14653
14654 return ret
14655}
14656
14657func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
14658 return ec._Identity(ctx, sel, &v)
14659}
14660
14661func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14662 return graphql.UnmarshalInt(v)
14663}
14664
14665func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14666 return graphql.MarshalInt(v)
14667}
14668
14669func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14670 if v == nil {
14671 return nil, nil
14672 }
14673 res, err := ec.unmarshalOInt2int(ctx, v)
14674 return &res, err
14675}
14676
14677func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14678 if v == nil {
14679 return graphql.Null
14680 }
14681 return ec.marshalOInt2int(ctx, sel, *v)
14682}
14683
14684func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14685 return ec._LabelChangeResult(ctx, sel, &v)
14686}
14687
14688func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14689 if v == nil {
14690 return graphql.Null
14691 }
14692 return ec._LabelChangeResult(ctx, sel, v)
14693}
14694
14695func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14696 return ec._Repository(ctx, sel, &v)
14697}
14698
14699func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14700 if v == nil {
14701 return graphql.Null
14702 }
14703 return ec._Repository(ctx, sel, v)
14704}
14705
14706func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14707 return graphql.UnmarshalString(v)
14708}
14709
14710func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14711 return graphql.MarshalString(v)
14712}
14713
14714func (ec *executionContext) unmarshalOString2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
14715 var vSlice []interface{}
14716 if v != nil {
14717 if tmp1, ok := v.([]interface{}); ok {
14718 vSlice = tmp1
14719 } else {
14720 vSlice = []interface{}{v}
14721 }
14722 }
14723 var err error
14724 res := make([]string, len(vSlice))
14725 for i := range vSlice {
14726 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14727 if err != nil {
14728 return nil, err
14729 }
14730 }
14731 return res, nil
14732}
14733
14734func (ec *executionContext) marshalOString2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14735 if v == nil {
14736 return graphql.Null
14737 }
14738 ret := make(graphql.Array, len(v))
14739 for i := range v {
14740 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14741 }
14742
14743 return ret
14744}
14745
14746func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14747 if v == nil {
14748 return nil, nil
14749 }
14750 res, err := ec.unmarshalOString2string(ctx, v)
14751 return &res, err
14752}
14753
14754func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14755 if v == nil {
14756 return graphql.Null
14757 }
14758 return ec.marshalOString2string(ctx, sel, *v)
14759}
14760
14761func (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 {
14762 if v == nil {
14763 return graphql.Null
14764 }
14765 ret := make(graphql.Array, len(v))
14766 var wg sync.WaitGroup
14767 isLen1 := len(v) == 1
14768 if !isLen1 {
14769 wg.Add(len(v))
14770 }
14771 for i := range v {
14772 i := i
14773 rctx := &graphql.ResolverContext{
14774 Index: &i,
14775 Result: &v[i],
14776 }
14777 ctx := graphql.WithResolverContext(ctx, rctx)
14778 f := func(i int) {
14779 defer func() {
14780 if r := recover(); r != nil {
14781 ec.Error(ctx, ec.Recover(ctx, r))
14782 ret = nil
14783 }
14784 }()
14785 if !isLen1 {
14786 defer wg.Done()
14787 }
14788 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14789 }
14790 if isLen1 {
14791 f(i)
14792 } else {
14793 go f(i)
14794 }
14795
14796 }
14797 wg.Wait()
14798 return ret
14799}
14800
14801func (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 {
14802 if v == nil {
14803 return graphql.Null
14804 }
14805 ret := make(graphql.Array, len(v))
14806 var wg sync.WaitGroup
14807 isLen1 := len(v) == 1
14808 if !isLen1 {
14809 wg.Add(len(v))
14810 }
14811 for i := range v {
14812 i := i
14813 rctx := &graphql.ResolverContext{
14814 Index: &i,
14815 Result: &v[i],
14816 }
14817 ctx := graphql.WithResolverContext(ctx, rctx)
14818 f := func(i int) {
14819 defer func() {
14820 if r := recover(); r != nil {
14821 ec.Error(ctx, ec.Recover(ctx, r))
14822 ret = nil
14823 }
14824 }()
14825 if !isLen1 {
14826 defer wg.Done()
14827 }
14828 ret[i] = ec.marshalN__Field2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
14829 }
14830 if isLen1 {
14831 f(i)
14832 } else {
14833 go f(i)
14834 }
14835
14836 }
14837 wg.Wait()
14838 return ret
14839}
14840
14841func (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 {
14842 if v == nil {
14843 return graphql.Null
14844 }
14845 ret := make(graphql.Array, len(v))
14846 var wg sync.WaitGroup
14847 isLen1 := len(v) == 1
14848 if !isLen1 {
14849 wg.Add(len(v))
14850 }
14851 for i := range v {
14852 i := i
14853 rctx := &graphql.ResolverContext{
14854 Index: &i,
14855 Result: &v[i],
14856 }
14857 ctx := graphql.WithResolverContext(ctx, rctx)
14858 f := func(i int) {
14859 defer func() {
14860 if r := recover(); r != nil {
14861 ec.Error(ctx, ec.Recover(ctx, r))
14862 ret = nil
14863 }
14864 }()
14865 if !isLen1 {
14866 defer wg.Done()
14867 }
14868 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14869 }
14870 if isLen1 {
14871 f(i)
14872 } else {
14873 go f(i)
14874 }
14875
14876 }
14877 wg.Wait()
14878 return ret
14879}
14880
14881func (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 {
14882 return ec.___Schema(ctx, sel, &v)
14883}
14884
14885func (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 {
14886 if v == nil {
14887 return graphql.Null
14888 }
14889 return ec.___Schema(ctx, sel, v)
14890}
14891
14892func (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 {
14893 return ec.___Type(ctx, sel, &v)
14894}
14895
14896func (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 {
14897 if v == nil {
14898 return graphql.Null
14899 }
14900 ret := make(graphql.Array, len(v))
14901 var wg sync.WaitGroup
14902 isLen1 := len(v) == 1
14903 if !isLen1 {
14904 wg.Add(len(v))
14905 }
14906 for i := range v {
14907 i := i
14908 rctx := &graphql.ResolverContext{
14909 Index: &i,
14910 Result: &v[i],
14911 }
14912 ctx := graphql.WithResolverContext(ctx, rctx)
14913 f := func(i int) {
14914 defer func() {
14915 if r := recover(); r != nil {
14916 ec.Error(ctx, ec.Recover(ctx, r))
14917 ret = nil
14918 }
14919 }()
14920 if !isLen1 {
14921 defer wg.Done()
14922 }
14923 ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14924 }
14925 if isLen1 {
14926 f(i)
14927 } else {
14928 go f(i)
14929 }
14930
14931 }
14932 wg.Wait()
14933 return ret
14934}
14935
14936func (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 {
14937 if v == nil {
14938 return graphql.Null
14939 }
14940 return ec.___Type(ctx, sel, v)
14941}
14942
14943// endregion ***************************** type.gotpl *****************************