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 LabelConnection struct {
256 Edges func(childComplexity int) int
257 Nodes func(childComplexity int) int
258 PageInfo func(childComplexity int) int
259 TotalCount func(childComplexity int) int
260 }
261
262 LabelEdge struct {
263 Cursor func(childComplexity int) int
264 Node func(childComplexity int) int
265 }
266
267 Mutation struct {
268 AddComment func(childComplexity int, input models.AddCommentInput) int
269 ChangeLabels func(childComplexity int, input *models.ChangeLabelInput) int
270 CloseBug func(childComplexity int, input models.CloseBugInput) int
271 Commit func(childComplexity int, input models.CommitInput) int
272 CommitAsNeeded func(childComplexity int, input models.CommitAsNeededInput) int
273 NewBug func(childComplexity int, input models.NewBugInput) int
274 OpenBug func(childComplexity int, input models.OpenBugInput) int
275 SetTitle func(childComplexity int, input models.SetTitleInput) int
276 }
277
278 NewBugPayload struct {
279 Bug func(childComplexity int) int
280 ClientMutationID func(childComplexity int) int
281 Operation func(childComplexity int) int
282 }
283
284 OpenBugPayload struct {
285 Bug func(childComplexity int) int
286 ClientMutationID func(childComplexity int) int
287 Operation func(childComplexity int) int
288 }
289
290 OperationConnection struct {
291 Edges func(childComplexity int) int
292 Nodes func(childComplexity int) int
293 PageInfo func(childComplexity int) int
294 TotalCount func(childComplexity int) int
295 }
296
297 OperationEdge struct {
298 Cursor func(childComplexity int) int
299 Node func(childComplexity int) int
300 }
301
302 PageInfo struct {
303 EndCursor func(childComplexity int) int
304 HasNextPage func(childComplexity int) int
305 HasPreviousPage func(childComplexity int) int
306 StartCursor func(childComplexity int) int
307 }
308
309 Query struct {
310 DefaultRepository func(childComplexity int) int
311 Repository func(childComplexity int, ref string) int
312 }
313
314 Repository struct {
315 AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
316 AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
317 Bug func(childComplexity int, prefix string) int
318 Identity func(childComplexity int, prefix string) int
319 UserIdentity func(childComplexity int) int
320 ValidLabels func(childComplexity int, after *string, before *string, first *int, last *int) int
321 }
322
323 SetStatusOperation struct {
324 Author func(childComplexity int) int
325 Date func(childComplexity int) int
326 ID func(childComplexity int) int
327 Status func(childComplexity int) int
328 }
329
330 SetStatusTimelineItem struct {
331 Author func(childComplexity int) int
332 Date func(childComplexity int) int
333 ID func(childComplexity int) int
334 Status func(childComplexity int) int
335 }
336
337 SetTitleOperation struct {
338 Author func(childComplexity int) int
339 Date func(childComplexity int) int
340 ID func(childComplexity int) int
341 Title func(childComplexity int) int
342 Was func(childComplexity int) int
343 }
344
345 SetTitlePayload struct {
346 Bug func(childComplexity int) int
347 ClientMutationID func(childComplexity int) int
348 Operation func(childComplexity int) int
349 }
350
351 SetTitleTimelineItem struct {
352 Author func(childComplexity int) int
353 Date func(childComplexity int) int
354 ID func(childComplexity int) int
355 Title func(childComplexity int) int
356 Was func(childComplexity int) int
357 }
358
359 TimelineItemConnection struct {
360 Edges func(childComplexity int) int
361 Nodes func(childComplexity int) int
362 PageInfo func(childComplexity int) int
363 TotalCount func(childComplexity int) int
364 }
365
366 TimelineItemEdge struct {
367 Cursor func(childComplexity int) int
368 Node func(childComplexity int) int
369 }
370}
371
372type AddCommentOperationResolver interface {
373 ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
374
375 Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
376}
377type AddCommentTimelineItemResolver interface {
378 ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
379
380 CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
381 LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
382}
383type BugResolver interface {
384 ID(ctx context.Context, obj *bug.Snapshot) (string, error)
385 HumanID(ctx context.Context, obj *bug.Snapshot) (string, error)
386 Status(ctx context.Context, obj *bug.Snapshot) (models.Status, error)
387
388 LastEdit(ctx context.Context, obj *bug.Snapshot) (*time.Time, error)
389 Actors(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
390 Participants(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
391 Comments(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
392 Timeline(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
393 Operations(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
394}
395type ColorResolver interface {
396 R(ctx context.Context, obj *color.RGBA) (int, error)
397 G(ctx context.Context, obj *color.RGBA) (int, error)
398 B(ctx context.Context, obj *color.RGBA) (int, error)
399}
400type CommentHistoryStepResolver interface {
401 Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
402}
403type CreateOperationResolver interface {
404 ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
405
406 Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
407}
408type CreateTimelineItemResolver interface {
409 ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
410
411 CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
412 LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
413}
414type EditCommentOperationResolver interface {
415 ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
416
417 Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
418 Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
419}
420type IdentityResolver interface {
421 ID(ctx context.Context, obj *identity.Interface) (string, error)
422 HumanID(ctx context.Context, obj *identity.Interface) (string, error)
423 Name(ctx context.Context, obj *identity.Interface) (*string, error)
424 Email(ctx context.Context, obj *identity.Interface) (*string, error)
425 Login(ctx context.Context, obj *identity.Interface) (*string, error)
426 DisplayName(ctx context.Context, obj *identity.Interface) (string, error)
427 AvatarURL(ctx context.Context, obj *identity.Interface) (*string, error)
428 IsProtected(ctx context.Context, obj *identity.Interface) (bool, error)
429}
430type LabelResolver interface {
431 Name(ctx context.Context, obj *bug.Label) (string, error)
432 Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
433}
434type LabelChangeOperationResolver interface {
435 ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
436
437 Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
438}
439type LabelChangeResultResolver interface {
440 Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
441}
442type LabelChangeTimelineItemResolver interface {
443 ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
444
445 Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
446}
447type MutationResolver interface {
448 NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
449 AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
450 ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
451 OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
452 CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
453 SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
454 Commit(ctx context.Context, input models.CommitInput) (*models.CommitPayload, error)
455 CommitAsNeeded(ctx context.Context, input models.CommitAsNeededInput) (*models.CommitAsNeededPayload, error)
456}
457type QueryResolver interface {
458 DefaultRepository(ctx context.Context) (*models.Repository, error)
459 Repository(ctx context.Context, ref string) (*models.Repository, error)
460}
461type RepositoryResolver interface {
462 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
463 Bug(ctx context.Context, obj *models.Repository, prefix string) (*bug.Snapshot, error)
464 AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
465 Identity(ctx context.Context, obj *models.Repository, prefix string) (identity.Interface, error)
466 UserIdentity(ctx context.Context, obj *models.Repository) (identity.Interface, error)
467 ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
468}
469type SetStatusOperationResolver interface {
470 ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
471
472 Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
473 Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
474}
475type SetStatusTimelineItemResolver interface {
476 ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
477
478 Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
479 Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
480}
481type SetTitleOperationResolver interface {
482 ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
483
484 Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
485}
486type SetTitleTimelineItemResolver interface {
487 ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
488
489 Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
490}
491
492type executableSchema struct {
493 resolvers ResolverRoot
494 directives DirectiveRoot
495 complexity ComplexityRoot
496}
497
498func (e *executableSchema) Schema() *ast.Schema {
499 return parsedSchema
500}
501
502func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
503 ec := executionContext{nil, e}
504 _ = ec
505 switch typeName + "." + field {
506
507 case "AddCommentOperation.author":
508 if e.complexity.AddCommentOperation.Author == nil {
509 break
510 }
511
512 return e.complexity.AddCommentOperation.Author(childComplexity), true
513
514 case "AddCommentOperation.date":
515 if e.complexity.AddCommentOperation.Date == nil {
516 break
517 }
518
519 return e.complexity.AddCommentOperation.Date(childComplexity), true
520
521 case "AddCommentOperation.files":
522 if e.complexity.AddCommentOperation.Files == nil {
523 break
524 }
525
526 return e.complexity.AddCommentOperation.Files(childComplexity), true
527
528 case "AddCommentOperation.id":
529 if e.complexity.AddCommentOperation.ID == nil {
530 break
531 }
532
533 return e.complexity.AddCommentOperation.ID(childComplexity), true
534
535 case "AddCommentOperation.message":
536 if e.complexity.AddCommentOperation.Message == nil {
537 break
538 }
539
540 return e.complexity.AddCommentOperation.Message(childComplexity), true
541
542 case "AddCommentPayload.bug":
543 if e.complexity.AddCommentPayload.Bug == nil {
544 break
545 }
546
547 return e.complexity.AddCommentPayload.Bug(childComplexity), true
548
549 case "AddCommentPayload.clientMutationId":
550 if e.complexity.AddCommentPayload.ClientMutationID == nil {
551 break
552 }
553
554 return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
555
556 case "AddCommentPayload.operation":
557 if e.complexity.AddCommentPayload.Operation == nil {
558 break
559 }
560
561 return e.complexity.AddCommentPayload.Operation(childComplexity), true
562
563 case "AddCommentTimelineItem.author":
564 if e.complexity.AddCommentTimelineItem.Author == nil {
565 break
566 }
567
568 return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
569
570 case "AddCommentTimelineItem.createdAt":
571 if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
572 break
573 }
574
575 return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
576
577 case "AddCommentTimelineItem.edited":
578 if e.complexity.AddCommentTimelineItem.Edited == nil {
579 break
580 }
581
582 return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
583
584 case "AddCommentTimelineItem.files":
585 if e.complexity.AddCommentTimelineItem.Files == nil {
586 break
587 }
588
589 return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
590
591 case "AddCommentTimelineItem.history":
592 if e.complexity.AddCommentTimelineItem.History == nil {
593 break
594 }
595
596 return e.complexity.AddCommentTimelineItem.History(childComplexity), true
597
598 case "AddCommentTimelineItem.id":
599 if e.complexity.AddCommentTimelineItem.ID == nil {
600 break
601 }
602
603 return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
604
605 case "AddCommentTimelineItem.lastEdit":
606 if e.complexity.AddCommentTimelineItem.LastEdit == nil {
607 break
608 }
609
610 return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
611
612 case "AddCommentTimelineItem.message":
613 if e.complexity.AddCommentTimelineItem.Message == nil {
614 break
615 }
616
617 return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
618
619 case "AddCommentTimelineItem.messageIsEmpty":
620 if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
621 break
622 }
623
624 return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
625
626 case "Bug.actors":
627 if e.complexity.Bug.Actors == nil {
628 break
629 }
630
631 args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
632 if err != nil {
633 return 0, false
634 }
635
636 return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
637
638 case "Bug.author":
639 if e.complexity.Bug.Author == nil {
640 break
641 }
642
643 return e.complexity.Bug.Author(childComplexity), true
644
645 case "Bug.comments":
646 if e.complexity.Bug.Comments == nil {
647 break
648 }
649
650 args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
651 if err != nil {
652 return 0, false
653 }
654
655 return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
656
657 case "Bug.createdAt":
658 if e.complexity.Bug.CreatedAt == nil {
659 break
660 }
661
662 return e.complexity.Bug.CreatedAt(childComplexity), true
663
664 case "Bug.humanId":
665 if e.complexity.Bug.HumanID == nil {
666 break
667 }
668
669 return e.complexity.Bug.HumanID(childComplexity), true
670
671 case "Bug.id":
672 if e.complexity.Bug.ID == nil {
673 break
674 }
675
676 return e.complexity.Bug.ID(childComplexity), true
677
678 case "Bug.labels":
679 if e.complexity.Bug.Labels == nil {
680 break
681 }
682
683 return e.complexity.Bug.Labels(childComplexity), true
684
685 case "Bug.lastEdit":
686 if e.complexity.Bug.LastEdit == nil {
687 break
688 }
689
690 return e.complexity.Bug.LastEdit(childComplexity), true
691
692 case "Bug.operations":
693 if e.complexity.Bug.Operations == nil {
694 break
695 }
696
697 args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
698 if err != nil {
699 return 0, false
700 }
701
702 return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
703
704 case "Bug.participants":
705 if e.complexity.Bug.Participants == nil {
706 break
707 }
708
709 args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
710 if err != nil {
711 return 0, false
712 }
713
714 return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
715
716 case "Bug.status":
717 if e.complexity.Bug.Status == nil {
718 break
719 }
720
721 return e.complexity.Bug.Status(childComplexity), true
722
723 case "Bug.timeline":
724 if e.complexity.Bug.Timeline == nil {
725 break
726 }
727
728 args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
729 if err != nil {
730 return 0, false
731 }
732
733 return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
734
735 case "Bug.title":
736 if e.complexity.Bug.Title == nil {
737 break
738 }
739
740 return e.complexity.Bug.Title(childComplexity), true
741
742 case "BugConnection.edges":
743 if e.complexity.BugConnection.Edges == nil {
744 break
745 }
746
747 return e.complexity.BugConnection.Edges(childComplexity), true
748
749 case "BugConnection.nodes":
750 if e.complexity.BugConnection.Nodes == nil {
751 break
752 }
753
754 return e.complexity.BugConnection.Nodes(childComplexity), true
755
756 case "BugConnection.pageInfo":
757 if e.complexity.BugConnection.PageInfo == nil {
758 break
759 }
760
761 return e.complexity.BugConnection.PageInfo(childComplexity), true
762
763 case "BugConnection.totalCount":
764 if e.complexity.BugConnection.TotalCount == nil {
765 break
766 }
767
768 return e.complexity.BugConnection.TotalCount(childComplexity), true
769
770 case "BugEdge.cursor":
771 if e.complexity.BugEdge.Cursor == nil {
772 break
773 }
774
775 return e.complexity.BugEdge.Cursor(childComplexity), true
776
777 case "BugEdge.node":
778 if e.complexity.BugEdge.Node == nil {
779 break
780 }
781
782 return e.complexity.BugEdge.Node(childComplexity), true
783
784 case "ChangeLabelPayload.bug":
785 if e.complexity.ChangeLabelPayload.Bug == nil {
786 break
787 }
788
789 return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
790
791 case "ChangeLabelPayload.clientMutationId":
792 if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
793 break
794 }
795
796 return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
797
798 case "ChangeLabelPayload.operation":
799 if e.complexity.ChangeLabelPayload.Operation == nil {
800 break
801 }
802
803 return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
804
805 case "ChangeLabelPayload.results":
806 if e.complexity.ChangeLabelPayload.Results == nil {
807 break
808 }
809
810 return e.complexity.ChangeLabelPayload.Results(childComplexity), true
811
812 case "CloseBugPayload.bug":
813 if e.complexity.CloseBugPayload.Bug == nil {
814 break
815 }
816
817 return e.complexity.CloseBugPayload.Bug(childComplexity), true
818
819 case "CloseBugPayload.clientMutationId":
820 if e.complexity.CloseBugPayload.ClientMutationID == nil {
821 break
822 }
823
824 return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
825
826 case "CloseBugPayload.operation":
827 if e.complexity.CloseBugPayload.Operation == nil {
828 break
829 }
830
831 return e.complexity.CloseBugPayload.Operation(childComplexity), true
832
833 case "Color.B":
834 if e.complexity.Color.B == nil {
835 break
836 }
837
838 return e.complexity.Color.B(childComplexity), true
839
840 case "Color.G":
841 if e.complexity.Color.G == nil {
842 break
843 }
844
845 return e.complexity.Color.G(childComplexity), true
846
847 case "Color.R":
848 if e.complexity.Color.R == nil {
849 break
850 }
851
852 return e.complexity.Color.R(childComplexity), true
853
854 case "Comment.author":
855 if e.complexity.Comment.Author == nil {
856 break
857 }
858
859 return e.complexity.Comment.Author(childComplexity), true
860
861 case "Comment.files":
862 if e.complexity.Comment.Files == nil {
863 break
864 }
865
866 return e.complexity.Comment.Files(childComplexity), true
867
868 case "Comment.message":
869 if e.complexity.Comment.Message == nil {
870 break
871 }
872
873 return e.complexity.Comment.Message(childComplexity), true
874
875 case "CommentConnection.edges":
876 if e.complexity.CommentConnection.Edges == nil {
877 break
878 }
879
880 return e.complexity.CommentConnection.Edges(childComplexity), true
881
882 case "CommentConnection.nodes":
883 if e.complexity.CommentConnection.Nodes == nil {
884 break
885 }
886
887 return e.complexity.CommentConnection.Nodes(childComplexity), true
888
889 case "CommentConnection.pageInfo":
890 if e.complexity.CommentConnection.PageInfo == nil {
891 break
892 }
893
894 return e.complexity.CommentConnection.PageInfo(childComplexity), true
895
896 case "CommentConnection.totalCount":
897 if e.complexity.CommentConnection.TotalCount == nil {
898 break
899 }
900
901 return e.complexity.CommentConnection.TotalCount(childComplexity), true
902
903 case "CommentEdge.cursor":
904 if e.complexity.CommentEdge.Cursor == nil {
905 break
906 }
907
908 return e.complexity.CommentEdge.Cursor(childComplexity), true
909
910 case "CommentEdge.node":
911 if e.complexity.CommentEdge.Node == nil {
912 break
913 }
914
915 return e.complexity.CommentEdge.Node(childComplexity), true
916
917 case "CommentHistoryStep.date":
918 if e.complexity.CommentHistoryStep.Date == nil {
919 break
920 }
921
922 return e.complexity.CommentHistoryStep.Date(childComplexity), true
923
924 case "CommentHistoryStep.message":
925 if e.complexity.CommentHistoryStep.Message == nil {
926 break
927 }
928
929 return e.complexity.CommentHistoryStep.Message(childComplexity), true
930
931 case "CommitAsNeededPayload.bug":
932 if e.complexity.CommitAsNeededPayload.Bug == nil {
933 break
934 }
935
936 return e.complexity.CommitAsNeededPayload.Bug(childComplexity), true
937
938 case "CommitAsNeededPayload.clientMutationId":
939 if e.complexity.CommitAsNeededPayload.ClientMutationID == nil {
940 break
941 }
942
943 return e.complexity.CommitAsNeededPayload.ClientMutationID(childComplexity), true
944
945 case "CommitPayload.bug":
946 if e.complexity.CommitPayload.Bug == nil {
947 break
948 }
949
950 return e.complexity.CommitPayload.Bug(childComplexity), true
951
952 case "CommitPayload.clientMutationId":
953 if e.complexity.CommitPayload.ClientMutationID == nil {
954 break
955 }
956
957 return e.complexity.CommitPayload.ClientMutationID(childComplexity), true
958
959 case "CreateOperation.author":
960 if e.complexity.CreateOperation.Author == nil {
961 break
962 }
963
964 return e.complexity.CreateOperation.Author(childComplexity), true
965
966 case "CreateOperation.date":
967 if e.complexity.CreateOperation.Date == nil {
968 break
969 }
970
971 return e.complexity.CreateOperation.Date(childComplexity), true
972
973 case "CreateOperation.files":
974 if e.complexity.CreateOperation.Files == nil {
975 break
976 }
977
978 return e.complexity.CreateOperation.Files(childComplexity), true
979
980 case "CreateOperation.id":
981 if e.complexity.CreateOperation.ID == nil {
982 break
983 }
984
985 return e.complexity.CreateOperation.ID(childComplexity), true
986
987 case "CreateOperation.message":
988 if e.complexity.CreateOperation.Message == nil {
989 break
990 }
991
992 return e.complexity.CreateOperation.Message(childComplexity), true
993
994 case "CreateOperation.title":
995 if e.complexity.CreateOperation.Title == nil {
996 break
997 }
998
999 return e.complexity.CreateOperation.Title(childComplexity), true
1000
1001 case "CreateTimelineItem.author":
1002 if e.complexity.CreateTimelineItem.Author == nil {
1003 break
1004 }
1005
1006 return e.complexity.CreateTimelineItem.Author(childComplexity), true
1007
1008 case "CreateTimelineItem.createdAt":
1009 if e.complexity.CreateTimelineItem.CreatedAt == nil {
1010 break
1011 }
1012
1013 return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
1014
1015 case "CreateTimelineItem.edited":
1016 if e.complexity.CreateTimelineItem.Edited == nil {
1017 break
1018 }
1019
1020 return e.complexity.CreateTimelineItem.Edited(childComplexity), true
1021
1022 case "CreateTimelineItem.files":
1023 if e.complexity.CreateTimelineItem.Files == nil {
1024 break
1025 }
1026
1027 return e.complexity.CreateTimelineItem.Files(childComplexity), true
1028
1029 case "CreateTimelineItem.history":
1030 if e.complexity.CreateTimelineItem.History == nil {
1031 break
1032 }
1033
1034 return e.complexity.CreateTimelineItem.History(childComplexity), true
1035
1036 case "CreateTimelineItem.id":
1037 if e.complexity.CreateTimelineItem.ID == nil {
1038 break
1039 }
1040
1041 return e.complexity.CreateTimelineItem.ID(childComplexity), true
1042
1043 case "CreateTimelineItem.lastEdit":
1044 if e.complexity.CreateTimelineItem.LastEdit == nil {
1045 break
1046 }
1047
1048 return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
1049
1050 case "CreateTimelineItem.message":
1051 if e.complexity.CreateTimelineItem.Message == nil {
1052 break
1053 }
1054
1055 return e.complexity.CreateTimelineItem.Message(childComplexity), true
1056
1057 case "CreateTimelineItem.messageIsEmpty":
1058 if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
1059 break
1060 }
1061
1062 return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
1063
1064 case "EditCommentOperation.author":
1065 if e.complexity.EditCommentOperation.Author == nil {
1066 break
1067 }
1068
1069 return e.complexity.EditCommentOperation.Author(childComplexity), true
1070
1071 case "EditCommentOperation.date":
1072 if e.complexity.EditCommentOperation.Date == nil {
1073 break
1074 }
1075
1076 return e.complexity.EditCommentOperation.Date(childComplexity), true
1077
1078 case "EditCommentOperation.files":
1079 if e.complexity.EditCommentOperation.Files == nil {
1080 break
1081 }
1082
1083 return e.complexity.EditCommentOperation.Files(childComplexity), true
1084
1085 case "EditCommentOperation.id":
1086 if e.complexity.EditCommentOperation.ID == nil {
1087 break
1088 }
1089
1090 return e.complexity.EditCommentOperation.ID(childComplexity), true
1091
1092 case "EditCommentOperation.message":
1093 if e.complexity.EditCommentOperation.Message == nil {
1094 break
1095 }
1096
1097 return e.complexity.EditCommentOperation.Message(childComplexity), true
1098
1099 case "EditCommentOperation.target":
1100 if e.complexity.EditCommentOperation.Target == nil {
1101 break
1102 }
1103
1104 return e.complexity.EditCommentOperation.Target(childComplexity), true
1105
1106 case "Identity.avatarUrl":
1107 if e.complexity.Identity.AvatarURL == nil {
1108 break
1109 }
1110
1111 return e.complexity.Identity.AvatarURL(childComplexity), true
1112
1113 case "Identity.displayName":
1114 if e.complexity.Identity.DisplayName == nil {
1115 break
1116 }
1117
1118 return e.complexity.Identity.DisplayName(childComplexity), true
1119
1120 case "Identity.email":
1121 if e.complexity.Identity.Email == nil {
1122 break
1123 }
1124
1125 return e.complexity.Identity.Email(childComplexity), true
1126
1127 case "Identity.humanId":
1128 if e.complexity.Identity.HumanID == nil {
1129 break
1130 }
1131
1132 return e.complexity.Identity.HumanID(childComplexity), true
1133
1134 case "Identity.id":
1135 if e.complexity.Identity.ID == nil {
1136 break
1137 }
1138
1139 return e.complexity.Identity.ID(childComplexity), true
1140
1141 case "Identity.isProtected":
1142 if e.complexity.Identity.IsProtected == nil {
1143 break
1144 }
1145
1146 return e.complexity.Identity.IsProtected(childComplexity), true
1147
1148 case "Identity.login":
1149 if e.complexity.Identity.Login == nil {
1150 break
1151 }
1152
1153 return e.complexity.Identity.Login(childComplexity), true
1154
1155 case "Identity.name":
1156 if e.complexity.Identity.Name == nil {
1157 break
1158 }
1159
1160 return e.complexity.Identity.Name(childComplexity), true
1161
1162 case "IdentityConnection.edges":
1163 if e.complexity.IdentityConnection.Edges == nil {
1164 break
1165 }
1166
1167 return e.complexity.IdentityConnection.Edges(childComplexity), true
1168
1169 case "IdentityConnection.nodes":
1170 if e.complexity.IdentityConnection.Nodes == nil {
1171 break
1172 }
1173
1174 return e.complexity.IdentityConnection.Nodes(childComplexity), true
1175
1176 case "IdentityConnection.pageInfo":
1177 if e.complexity.IdentityConnection.PageInfo == nil {
1178 break
1179 }
1180
1181 return e.complexity.IdentityConnection.PageInfo(childComplexity), true
1182
1183 case "IdentityConnection.totalCount":
1184 if e.complexity.IdentityConnection.TotalCount == nil {
1185 break
1186 }
1187
1188 return e.complexity.IdentityConnection.TotalCount(childComplexity), true
1189
1190 case "IdentityEdge.cursor":
1191 if e.complexity.IdentityEdge.Cursor == nil {
1192 break
1193 }
1194
1195 return e.complexity.IdentityEdge.Cursor(childComplexity), true
1196
1197 case "IdentityEdge.node":
1198 if e.complexity.IdentityEdge.Node == nil {
1199 break
1200 }
1201
1202 return e.complexity.IdentityEdge.Node(childComplexity), true
1203
1204 case "Label.color":
1205 if e.complexity.Label.Color == nil {
1206 break
1207 }
1208
1209 return e.complexity.Label.Color(childComplexity), true
1210
1211 case "Label.name":
1212 if e.complexity.Label.Name == nil {
1213 break
1214 }
1215
1216 return e.complexity.Label.Name(childComplexity), true
1217
1218 case "LabelChangeOperation.added":
1219 if e.complexity.LabelChangeOperation.Added == nil {
1220 break
1221 }
1222
1223 return e.complexity.LabelChangeOperation.Added(childComplexity), true
1224
1225 case "LabelChangeOperation.author":
1226 if e.complexity.LabelChangeOperation.Author == nil {
1227 break
1228 }
1229
1230 return e.complexity.LabelChangeOperation.Author(childComplexity), true
1231
1232 case "LabelChangeOperation.date":
1233 if e.complexity.LabelChangeOperation.Date == nil {
1234 break
1235 }
1236
1237 return e.complexity.LabelChangeOperation.Date(childComplexity), true
1238
1239 case "LabelChangeOperation.id":
1240 if e.complexity.LabelChangeOperation.ID == nil {
1241 break
1242 }
1243
1244 return e.complexity.LabelChangeOperation.ID(childComplexity), true
1245
1246 case "LabelChangeOperation.removed":
1247 if e.complexity.LabelChangeOperation.Removed == nil {
1248 break
1249 }
1250
1251 return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1252
1253 case "LabelChangeResult.label":
1254 if e.complexity.LabelChangeResult.Label == nil {
1255 break
1256 }
1257
1258 return e.complexity.LabelChangeResult.Label(childComplexity), true
1259
1260 case "LabelChangeResult.status":
1261 if e.complexity.LabelChangeResult.Status == nil {
1262 break
1263 }
1264
1265 return e.complexity.LabelChangeResult.Status(childComplexity), true
1266
1267 case "LabelChangeTimelineItem.added":
1268 if e.complexity.LabelChangeTimelineItem.Added == nil {
1269 break
1270 }
1271
1272 return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
1273
1274 case "LabelChangeTimelineItem.author":
1275 if e.complexity.LabelChangeTimelineItem.Author == nil {
1276 break
1277 }
1278
1279 return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
1280
1281 case "LabelChangeTimelineItem.date":
1282 if e.complexity.LabelChangeTimelineItem.Date == nil {
1283 break
1284 }
1285
1286 return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
1287
1288 case "LabelChangeTimelineItem.id":
1289 if e.complexity.LabelChangeTimelineItem.ID == nil {
1290 break
1291 }
1292
1293 return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
1294
1295 case "LabelChangeTimelineItem.removed":
1296 if e.complexity.LabelChangeTimelineItem.Removed == nil {
1297 break
1298 }
1299
1300 return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
1301
1302 case "LabelConnection.edges":
1303 if e.complexity.LabelConnection.Edges == nil {
1304 break
1305 }
1306
1307 return e.complexity.LabelConnection.Edges(childComplexity), true
1308
1309 case "LabelConnection.nodes":
1310 if e.complexity.LabelConnection.Nodes == nil {
1311 break
1312 }
1313
1314 return e.complexity.LabelConnection.Nodes(childComplexity), true
1315
1316 case "LabelConnection.pageInfo":
1317 if e.complexity.LabelConnection.PageInfo == nil {
1318 break
1319 }
1320
1321 return e.complexity.LabelConnection.PageInfo(childComplexity), true
1322
1323 case "LabelConnection.totalCount":
1324 if e.complexity.LabelConnection.TotalCount == nil {
1325 break
1326 }
1327
1328 return e.complexity.LabelConnection.TotalCount(childComplexity), true
1329
1330 case "LabelEdge.cursor":
1331 if e.complexity.LabelEdge.Cursor == nil {
1332 break
1333 }
1334
1335 return e.complexity.LabelEdge.Cursor(childComplexity), true
1336
1337 case "LabelEdge.node":
1338 if e.complexity.LabelEdge.Node == nil {
1339 break
1340 }
1341
1342 return e.complexity.LabelEdge.Node(childComplexity), true
1343
1344 case "Mutation.addComment":
1345 if e.complexity.Mutation.AddComment == nil {
1346 break
1347 }
1348
1349 args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
1350 if err != nil {
1351 return 0, false
1352 }
1353
1354 return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
1355
1356 case "Mutation.changeLabels":
1357 if e.complexity.Mutation.ChangeLabels == nil {
1358 break
1359 }
1360
1361 args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
1362 if err != nil {
1363 return 0, false
1364 }
1365
1366 return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
1367
1368 case "Mutation.closeBug":
1369 if e.complexity.Mutation.CloseBug == nil {
1370 break
1371 }
1372
1373 args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
1374 if err != nil {
1375 return 0, false
1376 }
1377
1378 return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
1379
1380 case "Mutation.commit":
1381 if e.complexity.Mutation.Commit == nil {
1382 break
1383 }
1384
1385 args, err := ec.field_Mutation_commit_args(context.TODO(), rawArgs)
1386 if err != nil {
1387 return 0, false
1388 }
1389
1390 return e.complexity.Mutation.Commit(childComplexity, args["input"].(models.CommitInput)), true
1391
1392 case "Mutation.commitAsNeeded":
1393 if e.complexity.Mutation.CommitAsNeeded == nil {
1394 break
1395 }
1396
1397 args, err := ec.field_Mutation_commitAsNeeded_args(context.TODO(), rawArgs)
1398 if err != nil {
1399 return 0, false
1400 }
1401
1402 return e.complexity.Mutation.CommitAsNeeded(childComplexity, args["input"].(models.CommitAsNeededInput)), true
1403
1404 case "Mutation.newBug":
1405 if e.complexity.Mutation.NewBug == nil {
1406 break
1407 }
1408
1409 args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
1410 if err != nil {
1411 return 0, false
1412 }
1413
1414 return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
1415
1416 case "Mutation.openBug":
1417 if e.complexity.Mutation.OpenBug == nil {
1418 break
1419 }
1420
1421 args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
1422 if err != nil {
1423 return 0, false
1424 }
1425
1426 return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
1427
1428 case "Mutation.setTitle":
1429 if e.complexity.Mutation.SetTitle == nil {
1430 break
1431 }
1432
1433 args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
1434 if err != nil {
1435 return 0, false
1436 }
1437
1438 return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
1439
1440 case "NewBugPayload.bug":
1441 if e.complexity.NewBugPayload.Bug == nil {
1442 break
1443 }
1444
1445 return e.complexity.NewBugPayload.Bug(childComplexity), true
1446
1447 case "NewBugPayload.clientMutationId":
1448 if e.complexity.NewBugPayload.ClientMutationID == nil {
1449 break
1450 }
1451
1452 return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
1453
1454 case "NewBugPayload.operation":
1455 if e.complexity.NewBugPayload.Operation == nil {
1456 break
1457 }
1458
1459 return e.complexity.NewBugPayload.Operation(childComplexity), true
1460
1461 case "OpenBugPayload.bug":
1462 if e.complexity.OpenBugPayload.Bug == nil {
1463 break
1464 }
1465
1466 return e.complexity.OpenBugPayload.Bug(childComplexity), true
1467
1468 case "OpenBugPayload.clientMutationId":
1469 if e.complexity.OpenBugPayload.ClientMutationID == nil {
1470 break
1471 }
1472
1473 return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
1474
1475 case "OpenBugPayload.operation":
1476 if e.complexity.OpenBugPayload.Operation == nil {
1477 break
1478 }
1479
1480 return e.complexity.OpenBugPayload.Operation(childComplexity), true
1481
1482 case "OperationConnection.edges":
1483 if e.complexity.OperationConnection.Edges == nil {
1484 break
1485 }
1486
1487 return e.complexity.OperationConnection.Edges(childComplexity), true
1488
1489 case "OperationConnection.nodes":
1490 if e.complexity.OperationConnection.Nodes == nil {
1491 break
1492 }
1493
1494 return e.complexity.OperationConnection.Nodes(childComplexity), true
1495
1496 case "OperationConnection.pageInfo":
1497 if e.complexity.OperationConnection.PageInfo == nil {
1498 break
1499 }
1500
1501 return e.complexity.OperationConnection.PageInfo(childComplexity), true
1502
1503 case "OperationConnection.totalCount":
1504 if e.complexity.OperationConnection.TotalCount == nil {
1505 break
1506 }
1507
1508 return e.complexity.OperationConnection.TotalCount(childComplexity), true
1509
1510 case "OperationEdge.cursor":
1511 if e.complexity.OperationEdge.Cursor == nil {
1512 break
1513 }
1514
1515 return e.complexity.OperationEdge.Cursor(childComplexity), true
1516
1517 case "OperationEdge.node":
1518 if e.complexity.OperationEdge.Node == nil {
1519 break
1520 }
1521
1522 return e.complexity.OperationEdge.Node(childComplexity), true
1523
1524 case "PageInfo.endCursor":
1525 if e.complexity.PageInfo.EndCursor == nil {
1526 break
1527 }
1528
1529 return e.complexity.PageInfo.EndCursor(childComplexity), true
1530
1531 case "PageInfo.hasNextPage":
1532 if e.complexity.PageInfo.HasNextPage == nil {
1533 break
1534 }
1535
1536 return e.complexity.PageInfo.HasNextPage(childComplexity), true
1537
1538 case "PageInfo.hasPreviousPage":
1539 if e.complexity.PageInfo.HasPreviousPage == nil {
1540 break
1541 }
1542
1543 return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1544
1545 case "PageInfo.startCursor":
1546 if e.complexity.PageInfo.StartCursor == nil {
1547 break
1548 }
1549
1550 return e.complexity.PageInfo.StartCursor(childComplexity), true
1551
1552 case "Query.defaultRepository":
1553 if e.complexity.Query.DefaultRepository == nil {
1554 break
1555 }
1556
1557 return e.complexity.Query.DefaultRepository(childComplexity), true
1558
1559 case "Query.repository":
1560 if e.complexity.Query.Repository == nil {
1561 break
1562 }
1563
1564 args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
1565 if err != nil {
1566 return 0, false
1567 }
1568
1569 return e.complexity.Query.Repository(childComplexity, args["ref"].(string)), true
1570
1571 case "Repository.allBugs":
1572 if e.complexity.Repository.AllBugs == nil {
1573 break
1574 }
1575
1576 args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
1577 if err != nil {
1578 return 0, false
1579 }
1580
1581 return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1582
1583 case "Repository.allIdentities":
1584 if e.complexity.Repository.AllIdentities == nil {
1585 break
1586 }
1587
1588 args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
1589 if err != nil {
1590 return 0, false
1591 }
1592
1593 return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1594
1595 case "Repository.bug":
1596 if e.complexity.Repository.Bug == nil {
1597 break
1598 }
1599
1600 args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
1601 if err != nil {
1602 return 0, false
1603 }
1604
1605 return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1606
1607 case "Repository.identity":
1608 if e.complexity.Repository.Identity == nil {
1609 break
1610 }
1611
1612 args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
1613 if err != nil {
1614 return 0, false
1615 }
1616
1617 return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
1618
1619 case "Repository.userIdentity":
1620 if e.complexity.Repository.UserIdentity == nil {
1621 break
1622 }
1623
1624 return e.complexity.Repository.UserIdentity(childComplexity), true
1625
1626 case "Repository.validLabels":
1627 if e.complexity.Repository.ValidLabels == nil {
1628 break
1629 }
1630
1631 args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
1632 if err != nil {
1633 return 0, false
1634 }
1635
1636 return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1637
1638 case "SetStatusOperation.author":
1639 if e.complexity.SetStatusOperation.Author == nil {
1640 break
1641 }
1642
1643 return e.complexity.SetStatusOperation.Author(childComplexity), true
1644
1645 case "SetStatusOperation.date":
1646 if e.complexity.SetStatusOperation.Date == nil {
1647 break
1648 }
1649
1650 return e.complexity.SetStatusOperation.Date(childComplexity), true
1651
1652 case "SetStatusOperation.id":
1653 if e.complexity.SetStatusOperation.ID == nil {
1654 break
1655 }
1656
1657 return e.complexity.SetStatusOperation.ID(childComplexity), true
1658
1659 case "SetStatusOperation.status":
1660 if e.complexity.SetStatusOperation.Status == nil {
1661 break
1662 }
1663
1664 return e.complexity.SetStatusOperation.Status(childComplexity), true
1665
1666 case "SetStatusTimelineItem.author":
1667 if e.complexity.SetStatusTimelineItem.Author == nil {
1668 break
1669 }
1670
1671 return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
1672
1673 case "SetStatusTimelineItem.date":
1674 if e.complexity.SetStatusTimelineItem.Date == nil {
1675 break
1676 }
1677
1678 return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
1679
1680 case "SetStatusTimelineItem.id":
1681 if e.complexity.SetStatusTimelineItem.ID == nil {
1682 break
1683 }
1684
1685 return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
1686
1687 case "SetStatusTimelineItem.status":
1688 if e.complexity.SetStatusTimelineItem.Status == nil {
1689 break
1690 }
1691
1692 return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
1693
1694 case "SetTitleOperation.author":
1695 if e.complexity.SetTitleOperation.Author == nil {
1696 break
1697 }
1698
1699 return e.complexity.SetTitleOperation.Author(childComplexity), true
1700
1701 case "SetTitleOperation.date":
1702 if e.complexity.SetTitleOperation.Date == nil {
1703 break
1704 }
1705
1706 return e.complexity.SetTitleOperation.Date(childComplexity), true
1707
1708 case "SetTitleOperation.id":
1709 if e.complexity.SetTitleOperation.ID == nil {
1710 break
1711 }
1712
1713 return e.complexity.SetTitleOperation.ID(childComplexity), true
1714
1715 case "SetTitleOperation.title":
1716 if e.complexity.SetTitleOperation.Title == nil {
1717 break
1718 }
1719
1720 return e.complexity.SetTitleOperation.Title(childComplexity), true
1721
1722 case "SetTitleOperation.was":
1723 if e.complexity.SetTitleOperation.Was == nil {
1724 break
1725 }
1726
1727 return e.complexity.SetTitleOperation.Was(childComplexity), true
1728
1729 case "SetTitlePayload.bug":
1730 if e.complexity.SetTitlePayload.Bug == nil {
1731 break
1732 }
1733
1734 return e.complexity.SetTitlePayload.Bug(childComplexity), true
1735
1736 case "SetTitlePayload.clientMutationId":
1737 if e.complexity.SetTitlePayload.ClientMutationID == nil {
1738 break
1739 }
1740
1741 return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
1742
1743 case "SetTitlePayload.operation":
1744 if e.complexity.SetTitlePayload.Operation == nil {
1745 break
1746 }
1747
1748 return e.complexity.SetTitlePayload.Operation(childComplexity), true
1749
1750 case "SetTitleTimelineItem.author":
1751 if e.complexity.SetTitleTimelineItem.Author == nil {
1752 break
1753 }
1754
1755 return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
1756
1757 case "SetTitleTimelineItem.date":
1758 if e.complexity.SetTitleTimelineItem.Date == nil {
1759 break
1760 }
1761
1762 return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
1763
1764 case "SetTitleTimelineItem.id":
1765 if e.complexity.SetTitleTimelineItem.ID == nil {
1766 break
1767 }
1768
1769 return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
1770
1771 case "SetTitleTimelineItem.title":
1772 if e.complexity.SetTitleTimelineItem.Title == nil {
1773 break
1774 }
1775
1776 return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
1777
1778 case "SetTitleTimelineItem.was":
1779 if e.complexity.SetTitleTimelineItem.Was == nil {
1780 break
1781 }
1782
1783 return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
1784
1785 case "TimelineItemConnection.edges":
1786 if e.complexity.TimelineItemConnection.Edges == nil {
1787 break
1788 }
1789
1790 return e.complexity.TimelineItemConnection.Edges(childComplexity), true
1791
1792 case "TimelineItemConnection.nodes":
1793 if e.complexity.TimelineItemConnection.Nodes == nil {
1794 break
1795 }
1796
1797 return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
1798
1799 case "TimelineItemConnection.pageInfo":
1800 if e.complexity.TimelineItemConnection.PageInfo == nil {
1801 break
1802 }
1803
1804 return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
1805
1806 case "TimelineItemConnection.totalCount":
1807 if e.complexity.TimelineItemConnection.TotalCount == nil {
1808 break
1809 }
1810
1811 return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
1812
1813 case "TimelineItemEdge.cursor":
1814 if e.complexity.TimelineItemEdge.Cursor == nil {
1815 break
1816 }
1817
1818 return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
1819
1820 case "TimelineItemEdge.node":
1821 if e.complexity.TimelineItemEdge.Node == nil {
1822 break
1823 }
1824
1825 return e.complexity.TimelineItemEdge.Node(childComplexity), true
1826
1827 }
1828 return 0, false
1829}
1830
1831func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
1832 ec := executionContext{graphql.GetRequestContext(ctx), e}
1833
1834 buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
1835 data := ec._Query(ctx, op.SelectionSet)
1836 var buf bytes.Buffer
1837 data.MarshalGQL(&buf)
1838 return buf.Bytes()
1839 })
1840
1841 return &graphql.Response{
1842 Data: buf,
1843 Errors: ec.Errors,
1844 Extensions: ec.Extensions,
1845 }
1846}
1847
1848func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
1849 ec := executionContext{graphql.GetRequestContext(ctx), e}
1850
1851 buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
1852 data := ec._Mutation(ctx, op.SelectionSet)
1853 var buf bytes.Buffer
1854 data.MarshalGQL(&buf)
1855 return buf.Bytes()
1856 })
1857
1858 return &graphql.Response{
1859 Data: buf,
1860 Errors: ec.Errors,
1861 Extensions: ec.Extensions,
1862 }
1863}
1864
1865func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
1866 return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
1867}
1868
1869type executionContext struct {
1870 *graphql.RequestContext
1871 *executableSchema
1872}
1873
1874func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
1875 if ec.DisableIntrospection {
1876 return nil, errors.New("introspection disabled")
1877 }
1878 return introspection.WrapSchema(parsedSchema), nil
1879}
1880
1881func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
1882 if ec.DisableIntrospection {
1883 return nil, errors.New("introspection disabled")
1884 }
1885 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
1886}
1887
1888var parsedSchema = gqlparser.MustLoadSchema(
1889 &ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
1890type Comment implements Authored {
1891 """The author of this comment."""
1892 author: Identity!
1893
1894 """The message of this comment."""
1895 message: String!
1896
1897 """All media's hash referenced in this comment"""
1898 files: [Hash!]!
1899}
1900
1901type CommentConnection {
1902 edges: [CommentEdge!]!
1903 nodes: [Comment!]!
1904 pageInfo: PageInfo!
1905 totalCount: Int!
1906}
1907
1908type CommentEdge {
1909 cursor: String!
1910 node: Comment!
1911}
1912
1913enum Status {
1914 OPEN
1915 CLOSED
1916}
1917
1918type Bug implements Authored {
1919 """The identifier for this bug"""
1920 id: String!
1921 """The human version (truncated) identifier for this bug"""
1922 humanId: String!
1923 status: Status!
1924 title: String!
1925 labels: [Label!]!
1926 author: Identity!
1927 createdAt: Time!
1928 lastEdit: Time!
1929
1930 """The actors of the bug. Actors are Identity that have interacted with the bug."""
1931 actors(
1932 """Returns the elements in the list that come after the specified cursor."""
1933 after: String
1934 """Returns the elements in the list that come before the specified cursor."""
1935 before: String
1936 """Returns the first _n_ elements from the list."""
1937 first: Int
1938 """Returns the last _n_ elements from the list."""
1939 last: Int
1940 ): IdentityConnection!
1941
1942 """The participants of the bug. Participants are Identity that have created or
1943 added a comment on the bug."""
1944 participants(
1945 """Returns the elements in the list that come after the specified cursor."""
1946 after: String
1947 """Returns the elements in the list that come before the specified cursor."""
1948 before: String
1949 """Returns the first _n_ elements from the list."""
1950 first: Int
1951 """Returns the last _n_ elements from the list."""
1952 last: Int
1953 ): IdentityConnection!
1954
1955 comments(
1956 """Returns the elements in the list that come after the specified cursor."""
1957 after: String
1958 """Returns the elements in the list that come before the specified cursor."""
1959 before: String
1960 """Returns the first _n_ elements from the list."""
1961 first: Int
1962 """Returns the last _n_ elements from the list."""
1963 last: Int
1964 ): CommentConnection!
1965
1966 timeline(
1967 """Returns the elements in the list that come after the specified cursor."""
1968 after: String
1969 """Returns the elements in the list that come before the specified cursor."""
1970 before: String
1971 """Returns the first _n_ elements from the list."""
1972 first: Int
1973 """Returns the last _n_ elements from the list."""
1974 last: Int
1975 ): TimelineItemConnection!
1976
1977 operations(
1978 """Returns the elements in the list that come after the specified cursor."""
1979 after: String
1980 """Returns the elements in the list that come before the specified cursor."""
1981 before: String
1982 """Returns the first _n_ elements from the list."""
1983 first: Int
1984 """Returns the last _n_ elements from the list."""
1985 last: Int
1986 ): OperationConnection!
1987}
1988
1989"""The connection type for Bug."""
1990type BugConnection {
1991 """A list of edges."""
1992 edges: [BugEdge!]!
1993 nodes: [Bug!]!
1994 """Information to aid in pagination."""
1995 pageInfo: PageInfo!
1996 """Identifies the total count of items in the connection."""
1997 totalCount: Int!
1998}
1999
2000"""An edge in a connection."""
2001type BugEdge {
2002 """A cursor for use in pagination."""
2003 cursor: String!
2004 """The item at the end of the edge."""
2005 node: Bug!
2006}
2007`},
2008 &ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
2009type Identity {
2010 """The identifier for this identity"""
2011 id: String!
2012 """The human version (truncated) identifier for this identity"""
2013 humanId: String!
2014 """The name of the person, if known."""
2015 name: String
2016 """The email of the person, if known."""
2017 email: String
2018 """The login of the person, if known."""
2019 login: String
2020 """A string containing the either the name of the person, its login or both"""
2021 displayName: String!
2022 """An url to an avatar"""
2023 avatarUrl: String
2024 """isProtected is true if the chain of git commits started to be signed.
2025 If that's the case, only signed commit with a valid key for this identity can be added."""
2026 isProtected: Boolean!
2027}
2028
2029type IdentityConnection {
2030 edges: [IdentityEdge!]!
2031 nodes: [Identity!]!
2032 pageInfo: PageInfo!
2033 totalCount: Int!
2034}
2035
2036type IdentityEdge {
2037 cursor: String!
2038 node: Identity!
2039}`},
2040 &ast.Source{Name: "schema/label.graphql", Input: `"""Label for a bug."""
2041type Label {
2042 """The name of the label."""
2043 name: String!
2044 """Color of the label."""
2045 color: Color!
2046}
2047
2048type LabelConnection {
2049 edges: [LabelEdge!]!
2050 nodes: [Label!]!
2051 pageInfo: PageInfo!
2052 totalCount: Int!
2053}
2054
2055type LabelEdge {
2056 cursor: String!
2057 node: Label!
2058}`},
2059 &ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
2060 """A unique identifier for the client performing the mutation."""
2061 clientMutationId: String
2062 """"The name of the repository. If not set, the default repository is used."""
2063 repoRef: String
2064 """The title of the new bug."""
2065 title: String!
2066 """The first message of the new bug."""
2067 message: String!
2068 """The collection of file's hash required for the first message."""
2069 files: [Hash!]
2070}
2071
2072type NewBugPayload {
2073 """A unique identifier for the client performing the mutation."""
2074 clientMutationId: String
2075 """The created bug."""
2076 bug: Bug!
2077 """The resulting operation."""
2078 operation: CreateOperation!
2079}
2080
2081input AddCommentInput {
2082 """A unique identifier for the client performing the mutation."""
2083 clientMutationId: String
2084 """"The name of the repository. If not set, the default repository is used."""
2085 repoRef: String
2086 """The bug ID's prefix."""
2087 prefix: String!
2088 """The first message of the new bug."""
2089 message: String!
2090 """The collection of file's hash required for the first message."""
2091 files: [Hash!]
2092}
2093
2094type AddCommentPayload {
2095 """A unique identifier for the client performing the mutation."""
2096 clientMutationId: String
2097 """The affected bug."""
2098 bug: Bug!
2099 """The resulting operation."""
2100 operation: AddCommentOperation!
2101}
2102
2103input ChangeLabelInput {
2104 """A unique identifier for the client performing the mutation."""
2105 clientMutationId: String
2106 """"The name of the repository. If not set, the default repository is used."""
2107 repoRef: String
2108 """The bug ID's prefix."""
2109 prefix: String!
2110 """The list of label to add."""
2111 added: [String!]
2112 """The list of label to remove."""
2113 Removed: [String!]
2114}
2115
2116enum LabelChangeStatus {
2117 ADDED
2118 REMOVED
2119 DUPLICATE_IN_OP
2120 ALREADY_EXIST
2121 DOESNT_EXIST
2122}
2123
2124type LabelChangeResult {
2125 """The source label."""
2126 label: Label!
2127 """The effect this label had."""
2128 status: LabelChangeStatus!
2129}
2130
2131type ChangeLabelPayload {
2132 """A unique identifier for the client performing the mutation."""
2133 clientMutationId: String
2134 """The affected bug."""
2135 bug: Bug!
2136 """The resulting operation."""
2137 operation: LabelChangeOperation!
2138 """The effect each source label had."""
2139 results: [LabelChangeResult]!
2140}
2141
2142input OpenBugInput {
2143 """A unique identifier for the client performing the mutation."""
2144 clientMutationId: String
2145 """"The name of the repository. If not set, the default repository is used."""
2146 repoRef: String
2147 """The bug ID's prefix."""
2148 prefix: String!
2149}
2150
2151type OpenBugPayload {
2152 """A unique identifier for the client performing the mutation."""
2153 clientMutationId: String
2154 """The affected bug."""
2155 bug: Bug!
2156 """The resulting operation."""
2157 operation: SetStatusOperation!
2158}
2159
2160input CloseBugInput {
2161 """A unique identifier for the client performing the mutation."""
2162 clientMutationId: String
2163 """"The name of the repository. If not set, the default repository is used."""
2164 repoRef: String
2165 """The bug ID's prefix."""
2166 prefix: String!
2167}
2168
2169type CloseBugPayload {
2170 """A unique identifier for the client performing the mutation."""
2171 clientMutationId: String
2172 """The affected bug."""
2173 bug: Bug!
2174 """The resulting operation."""
2175 operation: SetStatusOperation!
2176}
2177
2178input SetTitleInput {
2179 """A unique identifier for the client performing the mutation."""
2180 clientMutationId: String
2181 """"The name of the repository. If not set, the default repository is used."""
2182 repoRef: String
2183 """The bug ID's prefix."""
2184 prefix: String!
2185 """The new title."""
2186 title: String!
2187}
2188
2189type SetTitlePayload {
2190 """A unique identifier for the client performing the mutation."""
2191 clientMutationId: String
2192 """The affected bug."""
2193 bug: Bug!
2194 """The resulting operation"""
2195 operation: SetTitleOperation!
2196}
2197
2198input CommitInput {
2199 """A unique identifier for the client performing the mutation."""
2200 clientMutationId: String
2201 """"The name of the repository. If not set, the default repository is used."""
2202 repoRef: String
2203 """The bug ID's prefix."""
2204 prefix: String!
2205}
2206
2207type CommitPayload {
2208 """A unique identifier for the client performing the mutation."""
2209 clientMutationId: String
2210 """The affected bug."""
2211 bug: Bug!
2212}
2213
2214input CommitAsNeededInput {
2215 """A unique identifier for the client performing the mutation."""
2216 clientMutationId: String
2217 """"The name of the repository. If not set, the default repository is used."""
2218 repoRef: String
2219 """The bug ID's prefix."""
2220 prefix: String!
2221}
2222
2223type CommitAsNeededPayload {
2224 """A unique identifier for the client performing the mutation."""
2225 clientMutationId: String
2226 """The affected bug."""
2227 bug: Bug!
2228}
2229`},
2230 &ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
2231interface Operation {
2232 """The identifier of the operation"""
2233 id: String!
2234 """The operations author."""
2235 author: Identity!
2236 """The datetime when this operation was issued."""
2237 date: Time!
2238}
2239
2240# Connection
2241
2242"""The connection type for an Operation"""
2243type OperationConnection {
2244 edges: [OperationEdge!]!
2245 nodes: [Operation!]!
2246 pageInfo: PageInfo!
2247 totalCount: Int!
2248}
2249
2250"""Represent an Operation"""
2251type OperationEdge {
2252 cursor: String!
2253 node: Operation!
2254}
2255
2256# Operations
2257
2258type CreateOperation implements Operation & Authored {
2259 """The identifier of the operation"""
2260 id: String!
2261 """The author of this object."""
2262 author: Identity!
2263 """The datetime when this operation was issued."""
2264 date: Time!
2265
2266 title: String!
2267 message: String!
2268 files: [Hash!]!
2269}
2270
2271type SetTitleOperation implements Operation & Authored {
2272 """The identifier of the operation"""
2273 id: String!
2274 """The author of this object."""
2275 author: Identity!
2276 """The datetime when this operation was issued."""
2277 date: Time!
2278
2279 title: String!
2280 was: String!
2281}
2282
2283type AddCommentOperation implements Operation & Authored {
2284 """The identifier of the operation"""
2285 id: String!
2286 """The author of this object."""
2287 author: Identity!
2288 """The datetime when this operation was issued."""
2289 date: Time!
2290
2291 message: String!
2292 files: [Hash!]!
2293}
2294
2295type EditCommentOperation implements Operation & Authored {
2296 """The identifier of the operation"""
2297 id: String!
2298 """The author of this object."""
2299 author: Identity!
2300 """The datetime when this operation was issued."""
2301 date: Time!
2302
2303 target: String!
2304 message: String!
2305 files: [Hash!]!
2306}
2307
2308type SetStatusOperation implements Operation & Authored {
2309 """The identifier of the operation"""
2310 id: String!
2311 """The author of this object."""
2312 author: Identity!
2313 """The datetime when this operation was issued."""
2314 date: Time!
2315
2316 status: Status!
2317}
2318
2319type LabelChangeOperation implements Operation & Authored {
2320 """The identifier of the operation"""
2321 id: String!
2322 """The author of this object."""
2323 author: Identity!
2324 """The datetime when this operation was issued."""
2325 date: Time!
2326
2327 added: [Label!]!
2328 removed: [Label!]!
2329}
2330`},
2331 &ast.Source{Name: "schema/repository.graphql", Input: `
2332type Repository {
2333 """All the bugs"""
2334 allBugs(
2335 """Returns the elements in the list that come after the specified cursor."""
2336 after: String
2337 """Returns the elements in the list that come before the specified cursor."""
2338 before: String
2339 """Returns the first _n_ elements from the list."""
2340 first: Int
2341 """Returns the last _n_ elements from the list."""
2342 last: Int
2343 """A query to select and order bugs"""
2344 query: String
2345 ): BugConnection!
2346
2347 bug(prefix: String!): Bug
2348
2349 """All the identities"""
2350 allIdentities(
2351 """Returns the elements in the list that come after the specified cursor."""
2352 after: String
2353 """Returns the elements in the list that come before the specified cursor."""
2354 before: String
2355 """Returns the first _n_ elements from the list."""
2356 first: Int
2357 """Returns the last _n_ elements from the list."""
2358 last: Int
2359 ): IdentityConnection!
2360
2361 identity(prefix: String!): Identity
2362
2363 """The identity created or selected by the user as its own"""
2364 userIdentity: Identity
2365
2366 """List of valid labels."""
2367 validLabels(
2368 """Returns the elements in the list that come after the specified cursor."""
2369 after: String
2370 """Returns the elements in the list that come before the specified cursor."""
2371 before: String
2372 """Returns the first _n_ elements from the list."""
2373 first: Int
2374 """Returns the last _n_ elements from the list."""
2375 last: Int
2376 ): LabelConnection!
2377}`},
2378 &ast.Source{Name: "schema/root.graphql", Input: `type Query {
2379 """The default unnamend repository."""
2380 defaultRepository: Repository
2381 """Access a repository by reference/name."""
2382 repository(ref: String!): Repository
2383}
2384
2385type Mutation {
2386 """Create a new bug"""
2387 newBug(input: NewBugInput!): NewBugPayload!
2388 """Add a new comment to a bug"""
2389 addComment(input: AddCommentInput!): AddCommentPayload!
2390 """Add or remove a set of label on a bug"""
2391 changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
2392 """Change a bug's status to open"""
2393 openBug(input: OpenBugInput!): OpenBugPayload!
2394 """Change a bug's status to closed"""
2395 closeBug(input: CloseBugInput!): CloseBugPayload!
2396 """Change a bug's title"""
2397 setTitle(input: SetTitleInput!): SetTitlePayload!
2398 """Commit write the pending operations into storage. This mutation fail if nothing is pending"""
2399 commit(input: CommitInput!): CommitPayload!
2400 """Commit write the pending operations into storage. This mutation succed if nothing is pending"""
2401 commitAsNeeded(input: CommitAsNeededInput!): CommitAsNeededPayload!
2402}
2403`},
2404 &ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
2405interface TimelineItem {
2406 """The identifier of the source operation"""
2407 id: String!
2408}
2409
2410"""CommentHistoryStep hold one version of a message in the history"""
2411type CommentHistoryStep {
2412 message: String!
2413 date: Time!
2414}
2415
2416# Connection
2417
2418"""The connection type for TimelineItem"""
2419type TimelineItemConnection {
2420 edges: [TimelineItemEdge!]!
2421 nodes: [TimelineItem!]!
2422 pageInfo: PageInfo!
2423 totalCount: Int!
2424}
2425
2426"""Represent a TimelineItem"""
2427type TimelineItemEdge {
2428 cursor: String!
2429 node: TimelineItem!
2430}
2431
2432# Items
2433
2434"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
2435type CreateTimelineItem implements TimelineItem & Authored {
2436 """The identifier of the source operation"""
2437 id: String!
2438 author: Identity!
2439 message: String!
2440 messageIsEmpty: Boolean!
2441 files: [Hash!]!
2442 createdAt: Time!
2443 lastEdit: Time!
2444 edited: Boolean!
2445 history: [CommentHistoryStep!]!
2446}
2447
2448"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
2449type AddCommentTimelineItem implements TimelineItem & Authored {
2450 """The identifier of the source operation"""
2451 id: String!
2452 author: Identity!
2453 message: String!
2454 messageIsEmpty: Boolean!
2455 files: [Hash!]!
2456 createdAt: Time!
2457 lastEdit: Time!
2458 edited: Boolean!
2459 history: [CommentHistoryStep!]!
2460}
2461
2462"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
2463type LabelChangeTimelineItem implements TimelineItem & Authored {
2464 """The identifier of the source operation"""
2465 id: String!
2466 author: Identity!
2467 date: Time!
2468 added: [Label!]!
2469 removed: [Label!]!
2470}
2471
2472"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
2473type SetStatusTimelineItem implements TimelineItem & Authored {
2474 """The identifier of the source operation"""
2475 id: String!
2476 author: Identity!
2477 date: Time!
2478 status: Status!
2479}
2480
2481"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
2482type SetTitleTimelineItem implements TimelineItem & Authored {
2483 """The identifier of the source operation"""
2484 id: String!
2485 author: Identity!
2486 date: Time!
2487 title: String!
2488 was: String!
2489}
2490`},
2491 &ast.Source{Name: "schema/types.graphql", Input: `scalar Time
2492scalar Hash
2493
2494"""Defines a color by red, green and blue components."""
2495type Color {
2496 """Red component of the color."""
2497 R: Int!
2498 """Green component of the color."""
2499 G: Int!
2500 """Blue component of the color."""
2501 B: Int!
2502}
2503
2504"""Information about pagination in a connection."""
2505type PageInfo {
2506 """When paginating forwards, are there more items?"""
2507 hasNextPage: Boolean!
2508 """When paginating backwards, are there more items?"""
2509 hasPreviousPage: Boolean!
2510 """When paginating backwards, the cursor to continue."""
2511 startCursor: String!
2512 """When paginating forwards, the cursor to continue."""
2513 endCursor: String!
2514}
2515
2516"""An object that has an author."""
2517interface Authored {
2518 """The author of this object."""
2519 author: Identity!
2520}
2521`},
2522)
2523
2524// endregion ************************** generated!.gotpl **************************
2525
2526// region ***************************** args.gotpl *****************************
2527
2528func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2529 var err error
2530 args := map[string]interface{}{}
2531 var arg0 *string
2532 if tmp, ok := rawArgs["after"]; ok {
2533 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2534 if err != nil {
2535 return nil, err
2536 }
2537 }
2538 args["after"] = arg0
2539 var arg1 *string
2540 if tmp, ok := rawArgs["before"]; ok {
2541 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2542 if err != nil {
2543 return nil, err
2544 }
2545 }
2546 args["before"] = arg1
2547 var arg2 *int
2548 if tmp, ok := rawArgs["first"]; ok {
2549 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2550 if err != nil {
2551 return nil, err
2552 }
2553 }
2554 args["first"] = arg2
2555 var arg3 *int
2556 if tmp, ok := rawArgs["last"]; ok {
2557 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2558 if err != nil {
2559 return nil, err
2560 }
2561 }
2562 args["last"] = arg3
2563 return args, nil
2564}
2565
2566func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2567 var err error
2568 args := map[string]interface{}{}
2569 var arg0 *string
2570 if tmp, ok := rawArgs["after"]; ok {
2571 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2572 if err != nil {
2573 return nil, err
2574 }
2575 }
2576 args["after"] = arg0
2577 var arg1 *string
2578 if tmp, ok := rawArgs["before"]; ok {
2579 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2580 if err != nil {
2581 return nil, err
2582 }
2583 }
2584 args["before"] = arg1
2585 var arg2 *int
2586 if tmp, ok := rawArgs["first"]; ok {
2587 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2588 if err != nil {
2589 return nil, err
2590 }
2591 }
2592 args["first"] = arg2
2593 var arg3 *int
2594 if tmp, ok := rawArgs["last"]; ok {
2595 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2596 if err != nil {
2597 return nil, err
2598 }
2599 }
2600 args["last"] = arg3
2601 return args, nil
2602}
2603
2604func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2605 var err error
2606 args := map[string]interface{}{}
2607 var arg0 *string
2608 if tmp, ok := rawArgs["after"]; ok {
2609 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2610 if err != nil {
2611 return nil, err
2612 }
2613 }
2614 args["after"] = arg0
2615 var arg1 *string
2616 if tmp, ok := rawArgs["before"]; ok {
2617 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2618 if err != nil {
2619 return nil, err
2620 }
2621 }
2622 args["before"] = arg1
2623 var arg2 *int
2624 if tmp, ok := rawArgs["first"]; ok {
2625 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2626 if err != nil {
2627 return nil, err
2628 }
2629 }
2630 args["first"] = arg2
2631 var arg3 *int
2632 if tmp, ok := rawArgs["last"]; ok {
2633 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2634 if err != nil {
2635 return nil, err
2636 }
2637 }
2638 args["last"] = arg3
2639 return args, nil
2640}
2641
2642func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2643 var err error
2644 args := map[string]interface{}{}
2645 var arg0 *string
2646 if tmp, ok := rawArgs["after"]; ok {
2647 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2648 if err != nil {
2649 return nil, err
2650 }
2651 }
2652 args["after"] = arg0
2653 var arg1 *string
2654 if tmp, ok := rawArgs["before"]; ok {
2655 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2656 if err != nil {
2657 return nil, err
2658 }
2659 }
2660 args["before"] = arg1
2661 var arg2 *int
2662 if tmp, ok := rawArgs["first"]; ok {
2663 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2664 if err != nil {
2665 return nil, err
2666 }
2667 }
2668 args["first"] = arg2
2669 var arg3 *int
2670 if tmp, ok := rawArgs["last"]; ok {
2671 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2672 if err != nil {
2673 return nil, err
2674 }
2675 }
2676 args["last"] = arg3
2677 return args, nil
2678}
2679
2680func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2681 var err error
2682 args := map[string]interface{}{}
2683 var arg0 *string
2684 if tmp, ok := rawArgs["after"]; ok {
2685 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2686 if err != nil {
2687 return nil, err
2688 }
2689 }
2690 args["after"] = arg0
2691 var arg1 *string
2692 if tmp, ok := rawArgs["before"]; ok {
2693 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2694 if err != nil {
2695 return nil, err
2696 }
2697 }
2698 args["before"] = arg1
2699 var arg2 *int
2700 if tmp, ok := rawArgs["first"]; ok {
2701 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2702 if err != nil {
2703 return nil, err
2704 }
2705 }
2706 args["first"] = arg2
2707 var arg3 *int
2708 if tmp, ok := rawArgs["last"]; ok {
2709 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2710 if err != nil {
2711 return nil, err
2712 }
2713 }
2714 args["last"] = arg3
2715 return args, nil
2716}
2717
2718func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2719 var err error
2720 args := map[string]interface{}{}
2721 var arg0 models.AddCommentInput
2722 if tmp, ok := rawArgs["input"]; ok {
2723 arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
2724 if err != nil {
2725 return nil, err
2726 }
2727 }
2728 args["input"] = arg0
2729 return args, nil
2730}
2731
2732func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2733 var err error
2734 args := map[string]interface{}{}
2735 var arg0 *models.ChangeLabelInput
2736 if tmp, ok := rawArgs["input"]; ok {
2737 arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
2738 if err != nil {
2739 return nil, err
2740 }
2741 }
2742 args["input"] = arg0
2743 return args, nil
2744}
2745
2746func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2747 var err error
2748 args := map[string]interface{}{}
2749 var arg0 models.CloseBugInput
2750 if tmp, ok := rawArgs["input"]; ok {
2751 arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
2752 if err != nil {
2753 return nil, err
2754 }
2755 }
2756 args["input"] = arg0
2757 return args, nil
2758}
2759
2760func (ec *executionContext) field_Mutation_commitAsNeeded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2761 var err error
2762 args := map[string]interface{}{}
2763 var arg0 models.CommitAsNeededInput
2764 if tmp, ok := rawArgs["input"]; ok {
2765 arg0, err = ec.unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx, tmp)
2766 if err != nil {
2767 return nil, err
2768 }
2769 }
2770 args["input"] = arg0
2771 return args, nil
2772}
2773
2774func (ec *executionContext) field_Mutation_commit_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2775 var err error
2776 args := map[string]interface{}{}
2777 var arg0 models.CommitInput
2778 if tmp, ok := rawArgs["input"]; ok {
2779 arg0, err = ec.unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx, tmp)
2780 if err != nil {
2781 return nil, err
2782 }
2783 }
2784 args["input"] = arg0
2785 return args, nil
2786}
2787
2788func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2789 var err error
2790 args := map[string]interface{}{}
2791 var arg0 models.NewBugInput
2792 if tmp, ok := rawArgs["input"]; ok {
2793 arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
2794 if err != nil {
2795 return nil, err
2796 }
2797 }
2798 args["input"] = arg0
2799 return args, nil
2800}
2801
2802func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2803 var err error
2804 args := map[string]interface{}{}
2805 var arg0 models.OpenBugInput
2806 if tmp, ok := rawArgs["input"]; ok {
2807 arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
2808 if err != nil {
2809 return nil, err
2810 }
2811 }
2812 args["input"] = arg0
2813 return args, nil
2814}
2815
2816func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2817 var err error
2818 args := map[string]interface{}{}
2819 var arg0 models.SetTitleInput
2820 if tmp, ok := rawArgs["input"]; ok {
2821 arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
2822 if err != nil {
2823 return nil, err
2824 }
2825 }
2826 args["input"] = arg0
2827 return args, nil
2828}
2829
2830func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2831 var err error
2832 args := map[string]interface{}{}
2833 var arg0 string
2834 if tmp, ok := rawArgs["name"]; ok {
2835 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2836 if err != nil {
2837 return nil, err
2838 }
2839 }
2840 args["name"] = arg0
2841 return args, nil
2842}
2843
2844func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2845 var err error
2846 args := map[string]interface{}{}
2847 var arg0 string
2848 if tmp, ok := rawArgs["ref"]; ok {
2849 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2850 if err != nil {
2851 return nil, err
2852 }
2853 }
2854 args["ref"] = arg0
2855 return args, nil
2856}
2857
2858func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2859 var err error
2860 args := map[string]interface{}{}
2861 var arg0 *string
2862 if tmp, ok := rawArgs["after"]; ok {
2863 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2864 if err != nil {
2865 return nil, err
2866 }
2867 }
2868 args["after"] = arg0
2869 var arg1 *string
2870 if tmp, ok := rawArgs["before"]; ok {
2871 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2872 if err != nil {
2873 return nil, err
2874 }
2875 }
2876 args["before"] = arg1
2877 var arg2 *int
2878 if tmp, ok := rawArgs["first"]; ok {
2879 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2880 if err != nil {
2881 return nil, err
2882 }
2883 }
2884 args["first"] = arg2
2885 var arg3 *int
2886 if tmp, ok := rawArgs["last"]; ok {
2887 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2888 if err != nil {
2889 return nil, err
2890 }
2891 }
2892 args["last"] = arg3
2893 var arg4 *string
2894 if tmp, ok := rawArgs["query"]; ok {
2895 arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2896 if err != nil {
2897 return nil, err
2898 }
2899 }
2900 args["query"] = arg4
2901 return args, nil
2902}
2903
2904func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2905 var err error
2906 args := map[string]interface{}{}
2907 var arg0 *string
2908 if tmp, ok := rawArgs["after"]; ok {
2909 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2910 if err != nil {
2911 return nil, err
2912 }
2913 }
2914 args["after"] = arg0
2915 var arg1 *string
2916 if tmp, ok := rawArgs["before"]; ok {
2917 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2918 if err != nil {
2919 return nil, err
2920 }
2921 }
2922 args["before"] = arg1
2923 var arg2 *int
2924 if tmp, ok := rawArgs["first"]; ok {
2925 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2926 if err != nil {
2927 return nil, err
2928 }
2929 }
2930 args["first"] = arg2
2931 var arg3 *int
2932 if tmp, ok := rawArgs["last"]; ok {
2933 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2934 if err != nil {
2935 return nil, err
2936 }
2937 }
2938 args["last"] = arg3
2939 return args, nil
2940}
2941
2942func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2943 var err error
2944 args := map[string]interface{}{}
2945 var arg0 string
2946 if tmp, ok := rawArgs["prefix"]; ok {
2947 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2948 if err != nil {
2949 return nil, err
2950 }
2951 }
2952 args["prefix"] = arg0
2953 return args, nil
2954}
2955
2956func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2957 var err error
2958 args := map[string]interface{}{}
2959 var arg0 string
2960 if tmp, ok := rawArgs["prefix"]; ok {
2961 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2962 if err != nil {
2963 return nil, err
2964 }
2965 }
2966 args["prefix"] = arg0
2967 return args, nil
2968}
2969
2970func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2971 var err error
2972 args := map[string]interface{}{}
2973 var arg0 *string
2974 if tmp, ok := rawArgs["after"]; ok {
2975 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2976 if err != nil {
2977 return nil, err
2978 }
2979 }
2980 args["after"] = arg0
2981 var arg1 *string
2982 if tmp, ok := rawArgs["before"]; ok {
2983 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2984 if err != nil {
2985 return nil, err
2986 }
2987 }
2988 args["before"] = arg1
2989 var arg2 *int
2990 if tmp, ok := rawArgs["first"]; ok {
2991 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2992 if err != nil {
2993 return nil, err
2994 }
2995 }
2996 args["first"] = arg2
2997 var arg3 *int
2998 if tmp, ok := rawArgs["last"]; ok {
2999 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3000 if err != nil {
3001 return nil, err
3002 }
3003 }
3004 args["last"] = arg3
3005 return args, nil
3006}
3007
3008func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3009 var err error
3010 args := map[string]interface{}{}
3011 var arg0 bool
3012 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3013 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3014 if err != nil {
3015 return nil, err
3016 }
3017 }
3018 args["includeDeprecated"] = arg0
3019 return args, nil
3020}
3021
3022func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3023 var err error
3024 args := map[string]interface{}{}
3025 var arg0 bool
3026 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3027 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3028 if err != nil {
3029 return nil, err
3030 }
3031 }
3032 args["includeDeprecated"] = arg0
3033 return args, nil
3034}
3035
3036// endregion ***************************** args.gotpl *****************************
3037
3038// region ************************** directives.gotpl **************************
3039
3040// endregion ************************** directives.gotpl **************************
3041
3042// region **************************** field.gotpl *****************************
3043
3044func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3045 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3046 defer func() {
3047 if r := recover(); r != nil {
3048 ec.Error(ctx, ec.Recover(ctx, r))
3049 ret = graphql.Null
3050 }
3051 ec.Tracer.EndFieldExecution(ctx)
3052 }()
3053 rctx := &graphql.ResolverContext{
3054 Object: "AddCommentOperation",
3055 Field: field,
3056 Args: nil,
3057 IsMethod: true,
3058 }
3059 ctx = graphql.WithResolverContext(ctx, rctx)
3060 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3061 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3062 ctx = rctx // use context from middleware stack in children
3063 return ec.resolvers.AddCommentOperation().ID(rctx, obj)
3064 })
3065 if err != nil {
3066 ec.Error(ctx, err)
3067 return graphql.Null
3068 }
3069 if resTmp == nil {
3070 if !ec.HasError(rctx) {
3071 ec.Errorf(ctx, "must not be null")
3072 }
3073 return graphql.Null
3074 }
3075 res := resTmp.(string)
3076 rctx.Result = res
3077 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3078 return ec.marshalNString2string(ctx, field.Selections, res)
3079}
3080
3081func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3082 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3083 defer func() {
3084 if r := recover(); r != nil {
3085 ec.Error(ctx, ec.Recover(ctx, r))
3086 ret = graphql.Null
3087 }
3088 ec.Tracer.EndFieldExecution(ctx)
3089 }()
3090 rctx := &graphql.ResolverContext{
3091 Object: "AddCommentOperation",
3092 Field: field,
3093 Args: nil,
3094 IsMethod: false,
3095 }
3096 ctx = graphql.WithResolverContext(ctx, rctx)
3097 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3098 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3099 ctx = rctx // use context from middleware stack in children
3100 return obj.Author, nil
3101 })
3102 if err != nil {
3103 ec.Error(ctx, err)
3104 return graphql.Null
3105 }
3106 if resTmp == nil {
3107 if !ec.HasError(rctx) {
3108 ec.Errorf(ctx, "must not be null")
3109 }
3110 return graphql.Null
3111 }
3112 res := resTmp.(identity.Interface)
3113 rctx.Result = res
3114 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3115 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
3116}
3117
3118func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3119 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3120 defer func() {
3121 if r := recover(); r != nil {
3122 ec.Error(ctx, ec.Recover(ctx, r))
3123 ret = graphql.Null
3124 }
3125 ec.Tracer.EndFieldExecution(ctx)
3126 }()
3127 rctx := &graphql.ResolverContext{
3128 Object: "AddCommentOperation",
3129 Field: field,
3130 Args: nil,
3131 IsMethod: true,
3132 }
3133 ctx = graphql.WithResolverContext(ctx, rctx)
3134 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3135 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3136 ctx = rctx // use context from middleware stack in children
3137 return ec.resolvers.AddCommentOperation().Date(rctx, obj)
3138 })
3139 if err != nil {
3140 ec.Error(ctx, err)
3141 return graphql.Null
3142 }
3143 if resTmp == nil {
3144 if !ec.HasError(rctx) {
3145 ec.Errorf(ctx, "must not be null")
3146 }
3147 return graphql.Null
3148 }
3149 res := resTmp.(*time.Time)
3150 rctx.Result = res
3151 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3152 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3153}
3154
3155func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3156 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3157 defer func() {
3158 if r := recover(); r != nil {
3159 ec.Error(ctx, ec.Recover(ctx, r))
3160 ret = graphql.Null
3161 }
3162 ec.Tracer.EndFieldExecution(ctx)
3163 }()
3164 rctx := &graphql.ResolverContext{
3165 Object: "AddCommentOperation",
3166 Field: field,
3167 Args: nil,
3168 IsMethod: false,
3169 }
3170 ctx = graphql.WithResolverContext(ctx, rctx)
3171 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3172 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3173 ctx = rctx // use context from middleware stack in children
3174 return obj.Message, nil
3175 })
3176 if err != nil {
3177 ec.Error(ctx, err)
3178 return graphql.Null
3179 }
3180 if resTmp == nil {
3181 if !ec.HasError(rctx) {
3182 ec.Errorf(ctx, "must not be null")
3183 }
3184 return graphql.Null
3185 }
3186 res := resTmp.(string)
3187 rctx.Result = res
3188 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3189 return ec.marshalNString2string(ctx, field.Selections, res)
3190}
3191
3192func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3193 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3194 defer func() {
3195 if r := recover(); r != nil {
3196 ec.Error(ctx, ec.Recover(ctx, r))
3197 ret = graphql.Null
3198 }
3199 ec.Tracer.EndFieldExecution(ctx)
3200 }()
3201 rctx := &graphql.ResolverContext{
3202 Object: "AddCommentOperation",
3203 Field: field,
3204 Args: nil,
3205 IsMethod: false,
3206 }
3207 ctx = graphql.WithResolverContext(ctx, rctx)
3208 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3209 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3210 ctx = rctx // use context from middleware stack in children
3211 return obj.Files, nil
3212 })
3213 if err != nil {
3214 ec.Error(ctx, err)
3215 return graphql.Null
3216 }
3217 if resTmp == nil {
3218 if !ec.HasError(rctx) {
3219 ec.Errorf(ctx, "must not be null")
3220 }
3221 return graphql.Null
3222 }
3223 res := resTmp.([]git.Hash)
3224 rctx.Result = res
3225 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3226 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
3227}
3228
3229func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3230 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3231 defer func() {
3232 if r := recover(); r != nil {
3233 ec.Error(ctx, ec.Recover(ctx, r))
3234 ret = graphql.Null
3235 }
3236 ec.Tracer.EndFieldExecution(ctx)
3237 }()
3238 rctx := &graphql.ResolverContext{
3239 Object: "AddCommentPayload",
3240 Field: field,
3241 Args: nil,
3242 IsMethod: false,
3243 }
3244 ctx = graphql.WithResolverContext(ctx, rctx)
3245 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3246 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3247 ctx = rctx // use context from middleware stack in children
3248 return obj.ClientMutationID, nil
3249 })
3250 if err != nil {
3251 ec.Error(ctx, err)
3252 return graphql.Null
3253 }
3254 if resTmp == nil {
3255 return graphql.Null
3256 }
3257 res := resTmp.(*string)
3258 rctx.Result = res
3259 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3260 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3261}
3262
3263func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3264 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3265 defer func() {
3266 if r := recover(); r != nil {
3267 ec.Error(ctx, ec.Recover(ctx, r))
3268 ret = graphql.Null
3269 }
3270 ec.Tracer.EndFieldExecution(ctx)
3271 }()
3272 rctx := &graphql.ResolverContext{
3273 Object: "AddCommentPayload",
3274 Field: field,
3275 Args: nil,
3276 IsMethod: false,
3277 }
3278 ctx = graphql.WithResolverContext(ctx, rctx)
3279 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3280 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3281 ctx = rctx // use context from middleware stack in children
3282 return obj.Bug, nil
3283 })
3284 if err != nil {
3285 ec.Error(ctx, err)
3286 return graphql.Null
3287 }
3288 if resTmp == nil {
3289 if !ec.HasError(rctx) {
3290 ec.Errorf(ctx, "must not be null")
3291 }
3292 return graphql.Null
3293 }
3294 res := resTmp.(*bug.Snapshot)
3295 rctx.Result = res
3296 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3297 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
3298}
3299
3300func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3301 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3302 defer func() {
3303 if r := recover(); r != nil {
3304 ec.Error(ctx, ec.Recover(ctx, r))
3305 ret = graphql.Null
3306 }
3307 ec.Tracer.EndFieldExecution(ctx)
3308 }()
3309 rctx := &graphql.ResolverContext{
3310 Object: "AddCommentPayload",
3311 Field: field,
3312 Args: nil,
3313 IsMethod: false,
3314 }
3315 ctx = graphql.WithResolverContext(ctx, rctx)
3316 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3317 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3318 ctx = rctx // use context from middleware stack in children
3319 return obj.Operation, nil
3320 })
3321 if err != nil {
3322 ec.Error(ctx, err)
3323 return graphql.Null
3324 }
3325 if resTmp == nil {
3326 if !ec.HasError(rctx) {
3327 ec.Errorf(ctx, "must not be null")
3328 }
3329 return graphql.Null
3330 }
3331 res := resTmp.(*bug.AddCommentOperation)
3332 rctx.Result = res
3333 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3334 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3335}
3336
3337func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3338 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3339 defer func() {
3340 if r := recover(); r != nil {
3341 ec.Error(ctx, ec.Recover(ctx, r))
3342 ret = graphql.Null
3343 }
3344 ec.Tracer.EndFieldExecution(ctx)
3345 }()
3346 rctx := &graphql.ResolverContext{
3347 Object: "AddCommentTimelineItem",
3348 Field: field,
3349 Args: nil,
3350 IsMethod: true,
3351 }
3352 ctx = graphql.WithResolverContext(ctx, rctx)
3353 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3354 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3355 ctx = rctx // use context from middleware stack in children
3356 return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
3357 })
3358 if err != nil {
3359 ec.Error(ctx, err)
3360 return graphql.Null
3361 }
3362 if resTmp == nil {
3363 if !ec.HasError(rctx) {
3364 ec.Errorf(ctx, "must not be null")
3365 }
3366 return graphql.Null
3367 }
3368 res := resTmp.(string)
3369 rctx.Result = res
3370 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3371 return ec.marshalNString2string(ctx, field.Selections, res)
3372}
3373
3374func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3375 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3376 defer func() {
3377 if r := recover(); r != nil {
3378 ec.Error(ctx, ec.Recover(ctx, r))
3379 ret = graphql.Null
3380 }
3381 ec.Tracer.EndFieldExecution(ctx)
3382 }()
3383 rctx := &graphql.ResolverContext{
3384 Object: "AddCommentTimelineItem",
3385 Field: field,
3386 Args: nil,
3387 IsMethod: false,
3388 }
3389 ctx = graphql.WithResolverContext(ctx, rctx)
3390 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3391 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3392 ctx = rctx // use context from middleware stack in children
3393 return obj.Author, nil
3394 })
3395 if err != nil {
3396 ec.Error(ctx, err)
3397 return graphql.Null
3398 }
3399 if resTmp == nil {
3400 if !ec.HasError(rctx) {
3401 ec.Errorf(ctx, "must not be null")
3402 }
3403 return graphql.Null
3404 }
3405 res := resTmp.(identity.Interface)
3406 rctx.Result = res
3407 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3408 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
3409}
3410
3411func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3412 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3413 defer func() {
3414 if r := recover(); r != nil {
3415 ec.Error(ctx, ec.Recover(ctx, r))
3416 ret = graphql.Null
3417 }
3418 ec.Tracer.EndFieldExecution(ctx)
3419 }()
3420 rctx := &graphql.ResolverContext{
3421 Object: "AddCommentTimelineItem",
3422 Field: field,
3423 Args: nil,
3424 IsMethod: false,
3425 }
3426 ctx = graphql.WithResolverContext(ctx, rctx)
3427 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3428 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3429 ctx = rctx // use context from middleware stack in children
3430 return obj.Message, nil
3431 })
3432 if err != nil {
3433 ec.Error(ctx, err)
3434 return graphql.Null
3435 }
3436 if resTmp == nil {
3437 if !ec.HasError(rctx) {
3438 ec.Errorf(ctx, "must not be null")
3439 }
3440 return graphql.Null
3441 }
3442 res := resTmp.(string)
3443 rctx.Result = res
3444 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3445 return ec.marshalNString2string(ctx, field.Selections, res)
3446}
3447
3448func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3449 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3450 defer func() {
3451 if r := recover(); r != nil {
3452 ec.Error(ctx, ec.Recover(ctx, r))
3453 ret = graphql.Null
3454 }
3455 ec.Tracer.EndFieldExecution(ctx)
3456 }()
3457 rctx := &graphql.ResolverContext{
3458 Object: "AddCommentTimelineItem",
3459 Field: field,
3460 Args: nil,
3461 IsMethod: true,
3462 }
3463 ctx = graphql.WithResolverContext(ctx, rctx)
3464 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3465 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3466 ctx = rctx // use context from middleware stack in children
3467 return obj.MessageIsEmpty(), nil
3468 })
3469 if err != nil {
3470 ec.Error(ctx, err)
3471 return graphql.Null
3472 }
3473 if resTmp == nil {
3474 if !ec.HasError(rctx) {
3475 ec.Errorf(ctx, "must not be null")
3476 }
3477 return graphql.Null
3478 }
3479 res := resTmp.(bool)
3480 rctx.Result = res
3481 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3482 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3483}
3484
3485func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3486 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3487 defer func() {
3488 if r := recover(); r != nil {
3489 ec.Error(ctx, ec.Recover(ctx, r))
3490 ret = graphql.Null
3491 }
3492 ec.Tracer.EndFieldExecution(ctx)
3493 }()
3494 rctx := &graphql.ResolverContext{
3495 Object: "AddCommentTimelineItem",
3496 Field: field,
3497 Args: nil,
3498 IsMethod: false,
3499 }
3500 ctx = graphql.WithResolverContext(ctx, rctx)
3501 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3502 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3503 ctx = rctx // use context from middleware stack in children
3504 return obj.Files, nil
3505 })
3506 if err != nil {
3507 ec.Error(ctx, err)
3508 return graphql.Null
3509 }
3510 if resTmp == nil {
3511 if !ec.HasError(rctx) {
3512 ec.Errorf(ctx, "must not be null")
3513 }
3514 return graphql.Null
3515 }
3516 res := resTmp.([]git.Hash)
3517 rctx.Result = res
3518 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3519 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
3520}
3521
3522func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3523 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3524 defer func() {
3525 if r := recover(); r != nil {
3526 ec.Error(ctx, ec.Recover(ctx, r))
3527 ret = graphql.Null
3528 }
3529 ec.Tracer.EndFieldExecution(ctx)
3530 }()
3531 rctx := &graphql.ResolverContext{
3532 Object: "AddCommentTimelineItem",
3533 Field: field,
3534 Args: nil,
3535 IsMethod: true,
3536 }
3537 ctx = graphql.WithResolverContext(ctx, rctx)
3538 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3539 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3540 ctx = rctx // use context from middleware stack in children
3541 return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
3542 })
3543 if err != nil {
3544 ec.Error(ctx, err)
3545 return graphql.Null
3546 }
3547 if resTmp == nil {
3548 if !ec.HasError(rctx) {
3549 ec.Errorf(ctx, "must not be null")
3550 }
3551 return graphql.Null
3552 }
3553 res := resTmp.(*time.Time)
3554 rctx.Result = res
3555 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3556 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3557}
3558
3559func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3560 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3561 defer func() {
3562 if r := recover(); r != nil {
3563 ec.Error(ctx, ec.Recover(ctx, r))
3564 ret = graphql.Null
3565 }
3566 ec.Tracer.EndFieldExecution(ctx)
3567 }()
3568 rctx := &graphql.ResolverContext{
3569 Object: "AddCommentTimelineItem",
3570 Field: field,
3571 Args: nil,
3572 IsMethod: true,
3573 }
3574 ctx = graphql.WithResolverContext(ctx, rctx)
3575 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3576 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3577 ctx = rctx // use context from middleware stack in children
3578 return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
3579 })
3580 if err != nil {
3581 ec.Error(ctx, err)
3582 return graphql.Null
3583 }
3584 if resTmp == nil {
3585 if !ec.HasError(rctx) {
3586 ec.Errorf(ctx, "must not be null")
3587 }
3588 return graphql.Null
3589 }
3590 res := resTmp.(*time.Time)
3591 rctx.Result = res
3592 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3593 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3594}
3595
3596func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3597 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3598 defer func() {
3599 if r := recover(); r != nil {
3600 ec.Error(ctx, ec.Recover(ctx, r))
3601 ret = graphql.Null
3602 }
3603 ec.Tracer.EndFieldExecution(ctx)
3604 }()
3605 rctx := &graphql.ResolverContext{
3606 Object: "AddCommentTimelineItem",
3607 Field: field,
3608 Args: nil,
3609 IsMethod: true,
3610 }
3611 ctx = graphql.WithResolverContext(ctx, rctx)
3612 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3613 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3614 ctx = rctx // use context from middleware stack in children
3615 return obj.Edited(), nil
3616 })
3617 if err != nil {
3618 ec.Error(ctx, err)
3619 return graphql.Null
3620 }
3621 if resTmp == nil {
3622 if !ec.HasError(rctx) {
3623 ec.Errorf(ctx, "must not be null")
3624 }
3625 return graphql.Null
3626 }
3627 res := resTmp.(bool)
3628 rctx.Result = res
3629 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3630 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3631}
3632
3633func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3634 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3635 defer func() {
3636 if r := recover(); r != nil {
3637 ec.Error(ctx, ec.Recover(ctx, r))
3638 ret = graphql.Null
3639 }
3640 ec.Tracer.EndFieldExecution(ctx)
3641 }()
3642 rctx := &graphql.ResolverContext{
3643 Object: "AddCommentTimelineItem",
3644 Field: field,
3645 Args: nil,
3646 IsMethod: false,
3647 }
3648 ctx = graphql.WithResolverContext(ctx, rctx)
3649 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3650 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3651 ctx = rctx // use context from middleware stack in children
3652 return obj.History, nil
3653 })
3654 if err != nil {
3655 ec.Error(ctx, err)
3656 return graphql.Null
3657 }
3658 if resTmp == nil {
3659 if !ec.HasError(rctx) {
3660 ec.Errorf(ctx, "must not be null")
3661 }
3662 return graphql.Null
3663 }
3664 res := resTmp.([]bug.CommentHistoryStep)
3665 rctx.Result = res
3666 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3667 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, field.Selections, res)
3668}
3669
3670func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3671 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3672 defer func() {
3673 if r := recover(); r != nil {
3674 ec.Error(ctx, ec.Recover(ctx, r))
3675 ret = graphql.Null
3676 }
3677 ec.Tracer.EndFieldExecution(ctx)
3678 }()
3679 rctx := &graphql.ResolverContext{
3680 Object: "Bug",
3681 Field: field,
3682 Args: nil,
3683 IsMethod: true,
3684 }
3685 ctx = graphql.WithResolverContext(ctx, rctx)
3686 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3687 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3688 ctx = rctx // use context from middleware stack in children
3689 return ec.resolvers.Bug().ID(rctx, obj)
3690 })
3691 if err != nil {
3692 ec.Error(ctx, err)
3693 return graphql.Null
3694 }
3695 if resTmp == nil {
3696 if !ec.HasError(rctx) {
3697 ec.Errorf(ctx, "must not be null")
3698 }
3699 return graphql.Null
3700 }
3701 res := resTmp.(string)
3702 rctx.Result = res
3703 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3704 return ec.marshalNString2string(ctx, field.Selections, res)
3705}
3706
3707func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3708 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3709 defer func() {
3710 if r := recover(); r != nil {
3711 ec.Error(ctx, ec.Recover(ctx, r))
3712 ret = graphql.Null
3713 }
3714 ec.Tracer.EndFieldExecution(ctx)
3715 }()
3716 rctx := &graphql.ResolverContext{
3717 Object: "Bug",
3718 Field: field,
3719 Args: nil,
3720 IsMethod: true,
3721 }
3722 ctx = graphql.WithResolverContext(ctx, rctx)
3723 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3724 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3725 ctx = rctx // use context from middleware stack in children
3726 return ec.resolvers.Bug().HumanID(rctx, obj)
3727 })
3728 if err != nil {
3729 ec.Error(ctx, err)
3730 return graphql.Null
3731 }
3732 if resTmp == nil {
3733 if !ec.HasError(rctx) {
3734 ec.Errorf(ctx, "must not be null")
3735 }
3736 return graphql.Null
3737 }
3738 res := resTmp.(string)
3739 rctx.Result = res
3740 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3741 return ec.marshalNString2string(ctx, field.Selections, res)
3742}
3743
3744func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3745 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3746 defer func() {
3747 if r := recover(); r != nil {
3748 ec.Error(ctx, ec.Recover(ctx, r))
3749 ret = graphql.Null
3750 }
3751 ec.Tracer.EndFieldExecution(ctx)
3752 }()
3753 rctx := &graphql.ResolverContext{
3754 Object: "Bug",
3755 Field: field,
3756 Args: nil,
3757 IsMethod: true,
3758 }
3759 ctx = graphql.WithResolverContext(ctx, rctx)
3760 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3761 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3762 ctx = rctx // use context from middleware stack in children
3763 return ec.resolvers.Bug().Status(rctx, obj)
3764 })
3765 if err != nil {
3766 ec.Error(ctx, err)
3767 return graphql.Null
3768 }
3769 if resTmp == nil {
3770 if !ec.HasError(rctx) {
3771 ec.Errorf(ctx, "must not be null")
3772 }
3773 return graphql.Null
3774 }
3775 res := resTmp.(models.Status)
3776 rctx.Result = res
3777 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3778 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
3779}
3780
3781func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3782 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3783 defer func() {
3784 if r := recover(); r != nil {
3785 ec.Error(ctx, ec.Recover(ctx, r))
3786 ret = graphql.Null
3787 }
3788 ec.Tracer.EndFieldExecution(ctx)
3789 }()
3790 rctx := &graphql.ResolverContext{
3791 Object: "Bug",
3792 Field: field,
3793 Args: nil,
3794 IsMethod: false,
3795 }
3796 ctx = graphql.WithResolverContext(ctx, rctx)
3797 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3798 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3799 ctx = rctx // use context from middleware stack in children
3800 return obj.Title, nil
3801 })
3802 if err != nil {
3803 ec.Error(ctx, err)
3804 return graphql.Null
3805 }
3806 if resTmp == nil {
3807 if !ec.HasError(rctx) {
3808 ec.Errorf(ctx, "must not be null")
3809 }
3810 return graphql.Null
3811 }
3812 res := resTmp.(string)
3813 rctx.Result = res
3814 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3815 return ec.marshalNString2string(ctx, field.Selections, res)
3816}
3817
3818func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3819 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3820 defer func() {
3821 if r := recover(); r != nil {
3822 ec.Error(ctx, ec.Recover(ctx, r))
3823 ret = graphql.Null
3824 }
3825 ec.Tracer.EndFieldExecution(ctx)
3826 }()
3827 rctx := &graphql.ResolverContext{
3828 Object: "Bug",
3829 Field: field,
3830 Args: nil,
3831 IsMethod: false,
3832 }
3833 ctx = graphql.WithResolverContext(ctx, rctx)
3834 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3835 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3836 ctx = rctx // use context from middleware stack in children
3837 return obj.Labels, nil
3838 })
3839 if err != nil {
3840 ec.Error(ctx, err)
3841 return graphql.Null
3842 }
3843 if resTmp == nil {
3844 if !ec.HasError(rctx) {
3845 ec.Errorf(ctx, "must not be null")
3846 }
3847 return graphql.Null
3848 }
3849 res := resTmp.([]bug.Label)
3850 rctx.Result = res
3851 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3852 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
3853}
3854
3855func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3856 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3857 defer func() {
3858 if r := recover(); r != nil {
3859 ec.Error(ctx, ec.Recover(ctx, r))
3860 ret = graphql.Null
3861 }
3862 ec.Tracer.EndFieldExecution(ctx)
3863 }()
3864 rctx := &graphql.ResolverContext{
3865 Object: "Bug",
3866 Field: field,
3867 Args: nil,
3868 IsMethod: false,
3869 }
3870 ctx = graphql.WithResolverContext(ctx, rctx)
3871 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3872 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3873 ctx = rctx // use context from middleware stack in children
3874 return obj.Author, nil
3875 })
3876 if err != nil {
3877 ec.Error(ctx, err)
3878 return graphql.Null
3879 }
3880 if resTmp == nil {
3881 if !ec.HasError(rctx) {
3882 ec.Errorf(ctx, "must not be null")
3883 }
3884 return graphql.Null
3885 }
3886 res := resTmp.(identity.Interface)
3887 rctx.Result = res
3888 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3889 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
3890}
3891
3892func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3893 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3894 defer func() {
3895 if r := recover(); r != nil {
3896 ec.Error(ctx, ec.Recover(ctx, r))
3897 ret = graphql.Null
3898 }
3899 ec.Tracer.EndFieldExecution(ctx)
3900 }()
3901 rctx := &graphql.ResolverContext{
3902 Object: "Bug",
3903 Field: field,
3904 Args: nil,
3905 IsMethod: false,
3906 }
3907 ctx = graphql.WithResolverContext(ctx, rctx)
3908 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3909 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3910 ctx = rctx // use context from middleware stack in children
3911 return obj.CreatedAt, nil
3912 })
3913 if err != nil {
3914 ec.Error(ctx, err)
3915 return graphql.Null
3916 }
3917 if resTmp == nil {
3918 if !ec.HasError(rctx) {
3919 ec.Errorf(ctx, "must not be null")
3920 }
3921 return graphql.Null
3922 }
3923 res := resTmp.(time.Time)
3924 rctx.Result = res
3925 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3926 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
3927}
3928
3929func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3930 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3931 defer func() {
3932 if r := recover(); r != nil {
3933 ec.Error(ctx, ec.Recover(ctx, r))
3934 ret = graphql.Null
3935 }
3936 ec.Tracer.EndFieldExecution(ctx)
3937 }()
3938 rctx := &graphql.ResolverContext{
3939 Object: "Bug",
3940 Field: field,
3941 Args: nil,
3942 IsMethod: true,
3943 }
3944 ctx = graphql.WithResolverContext(ctx, rctx)
3945 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3946 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3947 ctx = rctx // use context from middleware stack in children
3948 return ec.resolvers.Bug().LastEdit(rctx, obj)
3949 })
3950 if err != nil {
3951 ec.Error(ctx, err)
3952 return graphql.Null
3953 }
3954 if resTmp == nil {
3955 if !ec.HasError(rctx) {
3956 ec.Errorf(ctx, "must not be null")
3957 }
3958 return graphql.Null
3959 }
3960 res := resTmp.(*time.Time)
3961 rctx.Result = res
3962 ctx = ec.Tracer.StartFieldChildExecution(ctx)
3963 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3964}
3965
3966func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3967 ctx = ec.Tracer.StartFieldExecution(ctx, field)
3968 defer func() {
3969 if r := recover(); r != nil {
3970 ec.Error(ctx, ec.Recover(ctx, r))
3971 ret = graphql.Null
3972 }
3973 ec.Tracer.EndFieldExecution(ctx)
3974 }()
3975 rctx := &graphql.ResolverContext{
3976 Object: "Bug",
3977 Field: field,
3978 Args: nil,
3979 IsMethod: true,
3980 }
3981 ctx = graphql.WithResolverContext(ctx, rctx)
3982 rawArgs := field.ArgumentMap(ec.Variables)
3983 args, err := ec.field_Bug_actors_args(ctx, rawArgs)
3984 if err != nil {
3985 ec.Error(ctx, err)
3986 return graphql.Null
3987 }
3988 rctx.Args = args
3989 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3990 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3991 ctx = rctx // use context from middleware stack in children
3992 return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
3993 })
3994 if err != nil {
3995 ec.Error(ctx, err)
3996 return graphql.Null
3997 }
3998 if resTmp == nil {
3999 if !ec.HasError(rctx) {
4000 ec.Errorf(ctx, "must not be null")
4001 }
4002 return graphql.Null
4003 }
4004 res := resTmp.(*models.IdentityConnection)
4005 rctx.Result = res
4006 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4007 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4008}
4009
4010func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4011 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4012 defer func() {
4013 if r := recover(); r != nil {
4014 ec.Error(ctx, ec.Recover(ctx, r))
4015 ret = graphql.Null
4016 }
4017 ec.Tracer.EndFieldExecution(ctx)
4018 }()
4019 rctx := &graphql.ResolverContext{
4020 Object: "Bug",
4021 Field: field,
4022 Args: nil,
4023 IsMethod: true,
4024 }
4025 ctx = graphql.WithResolverContext(ctx, rctx)
4026 rawArgs := field.ArgumentMap(ec.Variables)
4027 args, err := ec.field_Bug_participants_args(ctx, rawArgs)
4028 if err != nil {
4029 ec.Error(ctx, err)
4030 return graphql.Null
4031 }
4032 rctx.Args = args
4033 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4034 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4035 ctx = rctx // use context from middleware stack in children
4036 return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4037 })
4038 if err != nil {
4039 ec.Error(ctx, err)
4040 return graphql.Null
4041 }
4042 if resTmp == nil {
4043 if !ec.HasError(rctx) {
4044 ec.Errorf(ctx, "must not be null")
4045 }
4046 return graphql.Null
4047 }
4048 res := resTmp.(*models.IdentityConnection)
4049 rctx.Result = res
4050 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4051 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4052}
4053
4054func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4055 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4056 defer func() {
4057 if r := recover(); r != nil {
4058 ec.Error(ctx, ec.Recover(ctx, r))
4059 ret = graphql.Null
4060 }
4061 ec.Tracer.EndFieldExecution(ctx)
4062 }()
4063 rctx := &graphql.ResolverContext{
4064 Object: "Bug",
4065 Field: field,
4066 Args: nil,
4067 IsMethod: true,
4068 }
4069 ctx = graphql.WithResolverContext(ctx, rctx)
4070 rawArgs := field.ArgumentMap(ec.Variables)
4071 args, err := ec.field_Bug_comments_args(ctx, rawArgs)
4072 if err != nil {
4073 ec.Error(ctx, err)
4074 return graphql.Null
4075 }
4076 rctx.Args = args
4077 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4078 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4079 ctx = rctx // use context from middleware stack in children
4080 return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4081 })
4082 if err != nil {
4083 ec.Error(ctx, err)
4084 return graphql.Null
4085 }
4086 if resTmp == nil {
4087 if !ec.HasError(rctx) {
4088 ec.Errorf(ctx, "must not be null")
4089 }
4090 return graphql.Null
4091 }
4092 res := resTmp.(*models.CommentConnection)
4093 rctx.Result = res
4094 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4095 return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
4096}
4097
4098func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4099 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4100 defer func() {
4101 if r := recover(); r != nil {
4102 ec.Error(ctx, ec.Recover(ctx, r))
4103 ret = graphql.Null
4104 }
4105 ec.Tracer.EndFieldExecution(ctx)
4106 }()
4107 rctx := &graphql.ResolverContext{
4108 Object: "Bug",
4109 Field: field,
4110 Args: nil,
4111 IsMethod: true,
4112 }
4113 ctx = graphql.WithResolverContext(ctx, rctx)
4114 rawArgs := field.ArgumentMap(ec.Variables)
4115 args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
4116 if err != nil {
4117 ec.Error(ctx, err)
4118 return graphql.Null
4119 }
4120 rctx.Args = args
4121 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4122 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4123 ctx = rctx // use context from middleware stack in children
4124 return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4125 })
4126 if err != nil {
4127 ec.Error(ctx, err)
4128 return graphql.Null
4129 }
4130 if resTmp == nil {
4131 if !ec.HasError(rctx) {
4132 ec.Errorf(ctx, "must not be null")
4133 }
4134 return graphql.Null
4135 }
4136 res := resTmp.(*models.TimelineItemConnection)
4137 rctx.Result = res
4138 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4139 return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
4140}
4141
4142func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4143 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4144 defer func() {
4145 if r := recover(); r != nil {
4146 ec.Error(ctx, ec.Recover(ctx, r))
4147 ret = graphql.Null
4148 }
4149 ec.Tracer.EndFieldExecution(ctx)
4150 }()
4151 rctx := &graphql.ResolverContext{
4152 Object: "Bug",
4153 Field: field,
4154 Args: nil,
4155 IsMethod: true,
4156 }
4157 ctx = graphql.WithResolverContext(ctx, rctx)
4158 rawArgs := field.ArgumentMap(ec.Variables)
4159 args, err := ec.field_Bug_operations_args(ctx, rawArgs)
4160 if err != nil {
4161 ec.Error(ctx, err)
4162 return graphql.Null
4163 }
4164 rctx.Args = args
4165 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4166 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4167 ctx = rctx // use context from middleware stack in children
4168 return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4169 })
4170 if err != nil {
4171 ec.Error(ctx, err)
4172 return graphql.Null
4173 }
4174 if resTmp == nil {
4175 if !ec.HasError(rctx) {
4176 ec.Errorf(ctx, "must not be null")
4177 }
4178 return graphql.Null
4179 }
4180 res := resTmp.(*models.OperationConnection)
4181 rctx.Result = res
4182 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4183 return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
4184}
4185
4186func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4187 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4188 defer func() {
4189 if r := recover(); r != nil {
4190 ec.Error(ctx, ec.Recover(ctx, r))
4191 ret = graphql.Null
4192 }
4193 ec.Tracer.EndFieldExecution(ctx)
4194 }()
4195 rctx := &graphql.ResolverContext{
4196 Object: "BugConnection",
4197 Field: field,
4198 Args: nil,
4199 IsMethod: false,
4200 }
4201 ctx = graphql.WithResolverContext(ctx, rctx)
4202 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4203 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4204 ctx = rctx // use context from middleware stack in children
4205 return obj.Edges, nil
4206 })
4207 if err != nil {
4208 ec.Error(ctx, err)
4209 return graphql.Null
4210 }
4211 if resTmp == nil {
4212 if !ec.HasError(rctx) {
4213 ec.Errorf(ctx, "must not be null")
4214 }
4215 return graphql.Null
4216 }
4217 res := resTmp.([]*models.BugEdge)
4218 rctx.Result = res
4219 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4220 return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, field.Selections, res)
4221}
4222
4223func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4224 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4225 defer func() {
4226 if r := recover(); r != nil {
4227 ec.Error(ctx, ec.Recover(ctx, r))
4228 ret = graphql.Null
4229 }
4230 ec.Tracer.EndFieldExecution(ctx)
4231 }()
4232 rctx := &graphql.ResolverContext{
4233 Object: "BugConnection",
4234 Field: field,
4235 Args: nil,
4236 IsMethod: false,
4237 }
4238 ctx = graphql.WithResolverContext(ctx, rctx)
4239 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4240 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4241 ctx = rctx // use context from middleware stack in children
4242 return obj.Nodes, nil
4243 })
4244 if err != nil {
4245 ec.Error(ctx, err)
4246 return graphql.Null
4247 }
4248 if resTmp == nil {
4249 if !ec.HasError(rctx) {
4250 ec.Errorf(ctx, "must not be null")
4251 }
4252 return graphql.Null
4253 }
4254 res := resTmp.([]*bug.Snapshot)
4255 rctx.Result = res
4256 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4257 return ec.marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
4258}
4259
4260func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4261 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4262 defer func() {
4263 if r := recover(); r != nil {
4264 ec.Error(ctx, ec.Recover(ctx, r))
4265 ret = graphql.Null
4266 }
4267 ec.Tracer.EndFieldExecution(ctx)
4268 }()
4269 rctx := &graphql.ResolverContext{
4270 Object: "BugConnection",
4271 Field: field,
4272 Args: nil,
4273 IsMethod: false,
4274 }
4275 ctx = graphql.WithResolverContext(ctx, rctx)
4276 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4277 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4278 ctx = rctx // use context from middleware stack in children
4279 return obj.PageInfo, nil
4280 })
4281 if err != nil {
4282 ec.Error(ctx, err)
4283 return graphql.Null
4284 }
4285 if resTmp == nil {
4286 if !ec.HasError(rctx) {
4287 ec.Errorf(ctx, "must not be null")
4288 }
4289 return graphql.Null
4290 }
4291 res := resTmp.(*models.PageInfo)
4292 rctx.Result = res
4293 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4294 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4295}
4296
4297func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4298 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4299 defer func() {
4300 if r := recover(); r != nil {
4301 ec.Error(ctx, ec.Recover(ctx, r))
4302 ret = graphql.Null
4303 }
4304 ec.Tracer.EndFieldExecution(ctx)
4305 }()
4306 rctx := &graphql.ResolverContext{
4307 Object: "BugConnection",
4308 Field: field,
4309 Args: nil,
4310 IsMethod: false,
4311 }
4312 ctx = graphql.WithResolverContext(ctx, rctx)
4313 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4314 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4315 ctx = rctx // use context from middleware stack in children
4316 return obj.TotalCount, nil
4317 })
4318 if err != nil {
4319 ec.Error(ctx, err)
4320 return graphql.Null
4321 }
4322 if resTmp == nil {
4323 if !ec.HasError(rctx) {
4324 ec.Errorf(ctx, "must not be null")
4325 }
4326 return graphql.Null
4327 }
4328 res := resTmp.(int)
4329 rctx.Result = res
4330 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4331 return ec.marshalNInt2int(ctx, field.Selections, res)
4332}
4333
4334func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4335 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4336 defer func() {
4337 if r := recover(); r != nil {
4338 ec.Error(ctx, ec.Recover(ctx, r))
4339 ret = graphql.Null
4340 }
4341 ec.Tracer.EndFieldExecution(ctx)
4342 }()
4343 rctx := &graphql.ResolverContext{
4344 Object: "BugEdge",
4345 Field: field,
4346 Args: nil,
4347 IsMethod: false,
4348 }
4349 ctx = graphql.WithResolverContext(ctx, rctx)
4350 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4351 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4352 ctx = rctx // use context from middleware stack in children
4353 return obj.Cursor, nil
4354 })
4355 if err != nil {
4356 ec.Error(ctx, err)
4357 return graphql.Null
4358 }
4359 if resTmp == nil {
4360 if !ec.HasError(rctx) {
4361 ec.Errorf(ctx, "must not be null")
4362 }
4363 return graphql.Null
4364 }
4365 res := resTmp.(string)
4366 rctx.Result = res
4367 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4368 return ec.marshalNString2string(ctx, field.Selections, res)
4369}
4370
4371func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4372 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4373 defer func() {
4374 if r := recover(); r != nil {
4375 ec.Error(ctx, ec.Recover(ctx, r))
4376 ret = graphql.Null
4377 }
4378 ec.Tracer.EndFieldExecution(ctx)
4379 }()
4380 rctx := &graphql.ResolverContext{
4381 Object: "BugEdge",
4382 Field: field,
4383 Args: nil,
4384 IsMethod: false,
4385 }
4386 ctx = graphql.WithResolverContext(ctx, rctx)
4387 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4388 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4389 ctx = rctx // use context from middleware stack in children
4390 return obj.Node, nil
4391 })
4392 if err != nil {
4393 ec.Error(ctx, err)
4394 return graphql.Null
4395 }
4396 if resTmp == nil {
4397 if !ec.HasError(rctx) {
4398 ec.Errorf(ctx, "must not be null")
4399 }
4400 return graphql.Null
4401 }
4402 res := resTmp.(*bug.Snapshot)
4403 rctx.Result = res
4404 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4405 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
4406}
4407
4408func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4409 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4410 defer func() {
4411 if r := recover(); r != nil {
4412 ec.Error(ctx, ec.Recover(ctx, r))
4413 ret = graphql.Null
4414 }
4415 ec.Tracer.EndFieldExecution(ctx)
4416 }()
4417 rctx := &graphql.ResolverContext{
4418 Object: "ChangeLabelPayload",
4419 Field: field,
4420 Args: nil,
4421 IsMethod: false,
4422 }
4423 ctx = graphql.WithResolverContext(ctx, rctx)
4424 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4425 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4426 ctx = rctx // use context from middleware stack in children
4427 return obj.ClientMutationID, nil
4428 })
4429 if err != nil {
4430 ec.Error(ctx, err)
4431 return graphql.Null
4432 }
4433 if resTmp == nil {
4434 return graphql.Null
4435 }
4436 res := resTmp.(*string)
4437 rctx.Result = res
4438 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4439 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4440}
4441
4442func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4443 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4444 defer func() {
4445 if r := recover(); r != nil {
4446 ec.Error(ctx, ec.Recover(ctx, r))
4447 ret = graphql.Null
4448 }
4449 ec.Tracer.EndFieldExecution(ctx)
4450 }()
4451 rctx := &graphql.ResolverContext{
4452 Object: "ChangeLabelPayload",
4453 Field: field,
4454 Args: nil,
4455 IsMethod: false,
4456 }
4457 ctx = graphql.WithResolverContext(ctx, rctx)
4458 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4459 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4460 ctx = rctx // use context from middleware stack in children
4461 return obj.Bug, nil
4462 })
4463 if err != nil {
4464 ec.Error(ctx, err)
4465 return graphql.Null
4466 }
4467 if resTmp == nil {
4468 if !ec.HasError(rctx) {
4469 ec.Errorf(ctx, "must not be null")
4470 }
4471 return graphql.Null
4472 }
4473 res := resTmp.(*bug.Snapshot)
4474 rctx.Result = res
4475 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4476 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
4477}
4478
4479func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4480 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4481 defer func() {
4482 if r := recover(); r != nil {
4483 ec.Error(ctx, ec.Recover(ctx, r))
4484 ret = graphql.Null
4485 }
4486 ec.Tracer.EndFieldExecution(ctx)
4487 }()
4488 rctx := &graphql.ResolverContext{
4489 Object: "ChangeLabelPayload",
4490 Field: field,
4491 Args: nil,
4492 IsMethod: false,
4493 }
4494 ctx = graphql.WithResolverContext(ctx, rctx)
4495 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4496 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4497 ctx = rctx // use context from middleware stack in children
4498 return obj.Operation, nil
4499 })
4500 if err != nil {
4501 ec.Error(ctx, err)
4502 return graphql.Null
4503 }
4504 if resTmp == nil {
4505 if !ec.HasError(rctx) {
4506 ec.Errorf(ctx, "must not be null")
4507 }
4508 return graphql.Null
4509 }
4510 res := resTmp.(*bug.LabelChangeOperation)
4511 rctx.Result = res
4512 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4513 return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
4514}
4515
4516func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4517 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4518 defer func() {
4519 if r := recover(); r != nil {
4520 ec.Error(ctx, ec.Recover(ctx, r))
4521 ret = graphql.Null
4522 }
4523 ec.Tracer.EndFieldExecution(ctx)
4524 }()
4525 rctx := &graphql.ResolverContext{
4526 Object: "ChangeLabelPayload",
4527 Field: field,
4528 Args: nil,
4529 IsMethod: false,
4530 }
4531 ctx = graphql.WithResolverContext(ctx, rctx)
4532 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4533 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4534 ctx = rctx // use context from middleware stack in children
4535 return obj.Results, nil
4536 })
4537 if err != nil {
4538 ec.Error(ctx, err)
4539 return graphql.Null
4540 }
4541 if resTmp == nil {
4542 if !ec.HasError(rctx) {
4543 ec.Errorf(ctx, "must not be null")
4544 }
4545 return graphql.Null
4546 }
4547 res := resTmp.([]*bug.LabelChangeResult)
4548 rctx.Result = res
4549 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4550 return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
4551}
4552
4553func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4554 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4555 defer func() {
4556 if r := recover(); r != nil {
4557 ec.Error(ctx, ec.Recover(ctx, r))
4558 ret = graphql.Null
4559 }
4560 ec.Tracer.EndFieldExecution(ctx)
4561 }()
4562 rctx := &graphql.ResolverContext{
4563 Object: "CloseBugPayload",
4564 Field: field,
4565 Args: nil,
4566 IsMethod: false,
4567 }
4568 ctx = graphql.WithResolverContext(ctx, rctx)
4569 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4570 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4571 ctx = rctx // use context from middleware stack in children
4572 return obj.ClientMutationID, nil
4573 })
4574 if err != nil {
4575 ec.Error(ctx, err)
4576 return graphql.Null
4577 }
4578 if resTmp == nil {
4579 return graphql.Null
4580 }
4581 res := resTmp.(*string)
4582 rctx.Result = res
4583 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4584 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4585}
4586
4587func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4588 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4589 defer func() {
4590 if r := recover(); r != nil {
4591 ec.Error(ctx, ec.Recover(ctx, r))
4592 ret = graphql.Null
4593 }
4594 ec.Tracer.EndFieldExecution(ctx)
4595 }()
4596 rctx := &graphql.ResolverContext{
4597 Object: "CloseBugPayload",
4598 Field: field,
4599 Args: nil,
4600 IsMethod: false,
4601 }
4602 ctx = graphql.WithResolverContext(ctx, rctx)
4603 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4604 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4605 ctx = rctx // use context from middleware stack in children
4606 return obj.Bug, nil
4607 })
4608 if err != nil {
4609 ec.Error(ctx, err)
4610 return graphql.Null
4611 }
4612 if resTmp == nil {
4613 if !ec.HasError(rctx) {
4614 ec.Errorf(ctx, "must not be null")
4615 }
4616 return graphql.Null
4617 }
4618 res := resTmp.(*bug.Snapshot)
4619 rctx.Result = res
4620 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4621 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
4622}
4623
4624func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4625 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4626 defer func() {
4627 if r := recover(); r != nil {
4628 ec.Error(ctx, ec.Recover(ctx, r))
4629 ret = graphql.Null
4630 }
4631 ec.Tracer.EndFieldExecution(ctx)
4632 }()
4633 rctx := &graphql.ResolverContext{
4634 Object: "CloseBugPayload",
4635 Field: field,
4636 Args: nil,
4637 IsMethod: false,
4638 }
4639 ctx = graphql.WithResolverContext(ctx, rctx)
4640 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4641 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4642 ctx = rctx // use context from middleware stack in children
4643 return obj.Operation, nil
4644 })
4645 if err != nil {
4646 ec.Error(ctx, err)
4647 return graphql.Null
4648 }
4649 if resTmp == nil {
4650 if !ec.HasError(rctx) {
4651 ec.Errorf(ctx, "must not be null")
4652 }
4653 return graphql.Null
4654 }
4655 res := resTmp.(*bug.SetStatusOperation)
4656 rctx.Result = res
4657 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4658 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
4659}
4660
4661func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4662 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4663 defer func() {
4664 if r := recover(); r != nil {
4665 ec.Error(ctx, ec.Recover(ctx, r))
4666 ret = graphql.Null
4667 }
4668 ec.Tracer.EndFieldExecution(ctx)
4669 }()
4670 rctx := &graphql.ResolverContext{
4671 Object: "Color",
4672 Field: field,
4673 Args: nil,
4674 IsMethod: true,
4675 }
4676 ctx = graphql.WithResolverContext(ctx, rctx)
4677 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4678 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4679 ctx = rctx // use context from middleware stack in children
4680 return ec.resolvers.Color().R(rctx, obj)
4681 })
4682 if err != nil {
4683 ec.Error(ctx, err)
4684 return graphql.Null
4685 }
4686 if resTmp == nil {
4687 if !ec.HasError(rctx) {
4688 ec.Errorf(ctx, "must not be null")
4689 }
4690 return graphql.Null
4691 }
4692 res := resTmp.(int)
4693 rctx.Result = res
4694 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4695 return ec.marshalNInt2int(ctx, field.Selections, res)
4696}
4697
4698func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4699 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4700 defer func() {
4701 if r := recover(); r != nil {
4702 ec.Error(ctx, ec.Recover(ctx, r))
4703 ret = graphql.Null
4704 }
4705 ec.Tracer.EndFieldExecution(ctx)
4706 }()
4707 rctx := &graphql.ResolverContext{
4708 Object: "Color",
4709 Field: field,
4710 Args: nil,
4711 IsMethod: true,
4712 }
4713 ctx = graphql.WithResolverContext(ctx, rctx)
4714 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4715 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4716 ctx = rctx // use context from middleware stack in children
4717 return ec.resolvers.Color().G(rctx, obj)
4718 })
4719 if err != nil {
4720 ec.Error(ctx, err)
4721 return graphql.Null
4722 }
4723 if resTmp == nil {
4724 if !ec.HasError(rctx) {
4725 ec.Errorf(ctx, "must not be null")
4726 }
4727 return graphql.Null
4728 }
4729 res := resTmp.(int)
4730 rctx.Result = res
4731 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4732 return ec.marshalNInt2int(ctx, field.Selections, res)
4733}
4734
4735func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4736 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4737 defer func() {
4738 if r := recover(); r != nil {
4739 ec.Error(ctx, ec.Recover(ctx, r))
4740 ret = graphql.Null
4741 }
4742 ec.Tracer.EndFieldExecution(ctx)
4743 }()
4744 rctx := &graphql.ResolverContext{
4745 Object: "Color",
4746 Field: field,
4747 Args: nil,
4748 IsMethod: true,
4749 }
4750 ctx = graphql.WithResolverContext(ctx, rctx)
4751 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4752 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4753 ctx = rctx // use context from middleware stack in children
4754 return ec.resolvers.Color().B(rctx, obj)
4755 })
4756 if err != nil {
4757 ec.Error(ctx, err)
4758 return graphql.Null
4759 }
4760 if resTmp == nil {
4761 if !ec.HasError(rctx) {
4762 ec.Errorf(ctx, "must not be null")
4763 }
4764 return graphql.Null
4765 }
4766 res := resTmp.(int)
4767 rctx.Result = res
4768 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4769 return ec.marshalNInt2int(ctx, field.Selections, res)
4770}
4771
4772func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4773 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4774 defer func() {
4775 if r := recover(); r != nil {
4776 ec.Error(ctx, ec.Recover(ctx, r))
4777 ret = graphql.Null
4778 }
4779 ec.Tracer.EndFieldExecution(ctx)
4780 }()
4781 rctx := &graphql.ResolverContext{
4782 Object: "Comment",
4783 Field: field,
4784 Args: nil,
4785 IsMethod: false,
4786 }
4787 ctx = graphql.WithResolverContext(ctx, rctx)
4788 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4789 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4790 ctx = rctx // use context from middleware stack in children
4791 return obj.Author, nil
4792 })
4793 if err != nil {
4794 ec.Error(ctx, err)
4795 return graphql.Null
4796 }
4797 if resTmp == nil {
4798 if !ec.HasError(rctx) {
4799 ec.Errorf(ctx, "must not be null")
4800 }
4801 return graphql.Null
4802 }
4803 res := resTmp.(identity.Interface)
4804 rctx.Result = res
4805 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4806 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
4807}
4808
4809func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4810 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4811 defer func() {
4812 if r := recover(); r != nil {
4813 ec.Error(ctx, ec.Recover(ctx, r))
4814 ret = graphql.Null
4815 }
4816 ec.Tracer.EndFieldExecution(ctx)
4817 }()
4818 rctx := &graphql.ResolverContext{
4819 Object: "Comment",
4820 Field: field,
4821 Args: nil,
4822 IsMethod: false,
4823 }
4824 ctx = graphql.WithResolverContext(ctx, rctx)
4825 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4826 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4827 ctx = rctx // use context from middleware stack in children
4828 return obj.Message, nil
4829 })
4830 if err != nil {
4831 ec.Error(ctx, err)
4832 return graphql.Null
4833 }
4834 if resTmp == nil {
4835 if !ec.HasError(rctx) {
4836 ec.Errorf(ctx, "must not be null")
4837 }
4838 return graphql.Null
4839 }
4840 res := resTmp.(string)
4841 rctx.Result = res
4842 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4843 return ec.marshalNString2string(ctx, field.Selections, res)
4844}
4845
4846func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4847 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4848 defer func() {
4849 if r := recover(); r != nil {
4850 ec.Error(ctx, ec.Recover(ctx, r))
4851 ret = graphql.Null
4852 }
4853 ec.Tracer.EndFieldExecution(ctx)
4854 }()
4855 rctx := &graphql.ResolverContext{
4856 Object: "Comment",
4857 Field: field,
4858 Args: nil,
4859 IsMethod: false,
4860 }
4861 ctx = graphql.WithResolverContext(ctx, rctx)
4862 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4863 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4864 ctx = rctx // use context from middleware stack in children
4865 return obj.Files, nil
4866 })
4867 if err != nil {
4868 ec.Error(ctx, err)
4869 return graphql.Null
4870 }
4871 if resTmp == nil {
4872 if !ec.HasError(rctx) {
4873 ec.Errorf(ctx, "must not be null")
4874 }
4875 return graphql.Null
4876 }
4877 res := resTmp.([]git.Hash)
4878 rctx.Result = res
4879 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4880 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
4881}
4882
4883func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4884 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4885 defer func() {
4886 if r := recover(); r != nil {
4887 ec.Error(ctx, ec.Recover(ctx, r))
4888 ret = graphql.Null
4889 }
4890 ec.Tracer.EndFieldExecution(ctx)
4891 }()
4892 rctx := &graphql.ResolverContext{
4893 Object: "CommentConnection",
4894 Field: field,
4895 Args: nil,
4896 IsMethod: false,
4897 }
4898 ctx = graphql.WithResolverContext(ctx, rctx)
4899 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4900 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4901 ctx = rctx // use context from middleware stack in children
4902 return obj.Edges, nil
4903 })
4904 if err != nil {
4905 ec.Error(ctx, err)
4906 return graphql.Null
4907 }
4908 if resTmp == nil {
4909 if !ec.HasError(rctx) {
4910 ec.Errorf(ctx, "must not be null")
4911 }
4912 return graphql.Null
4913 }
4914 res := resTmp.([]*models.CommentEdge)
4915 rctx.Result = res
4916 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4917 return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, field.Selections, res)
4918}
4919
4920func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4921 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4922 defer func() {
4923 if r := recover(); r != nil {
4924 ec.Error(ctx, ec.Recover(ctx, r))
4925 ret = graphql.Null
4926 }
4927 ec.Tracer.EndFieldExecution(ctx)
4928 }()
4929 rctx := &graphql.ResolverContext{
4930 Object: "CommentConnection",
4931 Field: field,
4932 Args: nil,
4933 IsMethod: false,
4934 }
4935 ctx = graphql.WithResolverContext(ctx, rctx)
4936 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4937 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4938 ctx = rctx // use context from middleware stack in children
4939 return obj.Nodes, nil
4940 })
4941 if err != nil {
4942 ec.Error(ctx, err)
4943 return graphql.Null
4944 }
4945 if resTmp == nil {
4946 if !ec.HasError(rctx) {
4947 ec.Errorf(ctx, "must not be null")
4948 }
4949 return graphql.Null
4950 }
4951 res := resTmp.([]*bug.Comment)
4952 rctx.Result = res
4953 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4954 return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
4955}
4956
4957func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4958 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4959 defer func() {
4960 if r := recover(); r != nil {
4961 ec.Error(ctx, ec.Recover(ctx, r))
4962 ret = graphql.Null
4963 }
4964 ec.Tracer.EndFieldExecution(ctx)
4965 }()
4966 rctx := &graphql.ResolverContext{
4967 Object: "CommentConnection",
4968 Field: field,
4969 Args: nil,
4970 IsMethod: false,
4971 }
4972 ctx = graphql.WithResolverContext(ctx, rctx)
4973 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4974 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4975 ctx = rctx // use context from middleware stack in children
4976 return obj.PageInfo, nil
4977 })
4978 if err != nil {
4979 ec.Error(ctx, err)
4980 return graphql.Null
4981 }
4982 if resTmp == nil {
4983 if !ec.HasError(rctx) {
4984 ec.Errorf(ctx, "must not be null")
4985 }
4986 return graphql.Null
4987 }
4988 res := resTmp.(*models.PageInfo)
4989 rctx.Result = res
4990 ctx = ec.Tracer.StartFieldChildExecution(ctx)
4991 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4992}
4993
4994func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4995 ctx = ec.Tracer.StartFieldExecution(ctx, field)
4996 defer func() {
4997 if r := recover(); r != nil {
4998 ec.Error(ctx, ec.Recover(ctx, r))
4999 ret = graphql.Null
5000 }
5001 ec.Tracer.EndFieldExecution(ctx)
5002 }()
5003 rctx := &graphql.ResolverContext{
5004 Object: "CommentConnection",
5005 Field: field,
5006 Args: nil,
5007 IsMethod: false,
5008 }
5009 ctx = graphql.WithResolverContext(ctx, rctx)
5010 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5011 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5012 ctx = rctx // use context from middleware stack in children
5013 return obj.TotalCount, nil
5014 })
5015 if err != nil {
5016 ec.Error(ctx, err)
5017 return graphql.Null
5018 }
5019 if resTmp == nil {
5020 if !ec.HasError(rctx) {
5021 ec.Errorf(ctx, "must not be null")
5022 }
5023 return graphql.Null
5024 }
5025 res := resTmp.(int)
5026 rctx.Result = res
5027 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5028 return ec.marshalNInt2int(ctx, field.Selections, res)
5029}
5030
5031func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
5032 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5033 defer func() {
5034 if r := recover(); r != nil {
5035 ec.Error(ctx, ec.Recover(ctx, r))
5036 ret = graphql.Null
5037 }
5038 ec.Tracer.EndFieldExecution(ctx)
5039 }()
5040 rctx := &graphql.ResolverContext{
5041 Object: "CommentEdge",
5042 Field: field,
5043 Args: nil,
5044 IsMethod: false,
5045 }
5046 ctx = graphql.WithResolverContext(ctx, rctx)
5047 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5048 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5049 ctx = rctx // use context from middleware stack in children
5050 return obj.Cursor, nil
5051 })
5052 if err != nil {
5053 ec.Error(ctx, err)
5054 return graphql.Null
5055 }
5056 if resTmp == nil {
5057 if !ec.HasError(rctx) {
5058 ec.Errorf(ctx, "must not be null")
5059 }
5060 return graphql.Null
5061 }
5062 res := resTmp.(string)
5063 rctx.Result = res
5064 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5065 return ec.marshalNString2string(ctx, field.Selections, res)
5066}
5067
5068func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
5069 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5070 defer func() {
5071 if r := recover(); r != nil {
5072 ec.Error(ctx, ec.Recover(ctx, r))
5073 ret = graphql.Null
5074 }
5075 ec.Tracer.EndFieldExecution(ctx)
5076 }()
5077 rctx := &graphql.ResolverContext{
5078 Object: "CommentEdge",
5079 Field: field,
5080 Args: nil,
5081 IsMethod: false,
5082 }
5083 ctx = graphql.WithResolverContext(ctx, rctx)
5084 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5085 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5086 ctx = rctx // use context from middleware stack in children
5087 return obj.Node, nil
5088 })
5089 if err != nil {
5090 ec.Error(ctx, err)
5091 return graphql.Null
5092 }
5093 if resTmp == nil {
5094 if !ec.HasError(rctx) {
5095 ec.Errorf(ctx, "must not be null")
5096 }
5097 return graphql.Null
5098 }
5099 res := resTmp.(*bug.Comment)
5100 rctx.Result = res
5101 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5102 return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
5103}
5104
5105func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
5106 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5107 defer func() {
5108 if r := recover(); r != nil {
5109 ec.Error(ctx, ec.Recover(ctx, r))
5110 ret = graphql.Null
5111 }
5112 ec.Tracer.EndFieldExecution(ctx)
5113 }()
5114 rctx := &graphql.ResolverContext{
5115 Object: "CommentHistoryStep",
5116 Field: field,
5117 Args: nil,
5118 IsMethod: false,
5119 }
5120 ctx = graphql.WithResolverContext(ctx, rctx)
5121 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5122 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5123 ctx = rctx // use context from middleware stack in children
5124 return obj.Message, nil
5125 })
5126 if err != nil {
5127 ec.Error(ctx, err)
5128 return graphql.Null
5129 }
5130 if resTmp == nil {
5131 if !ec.HasError(rctx) {
5132 ec.Errorf(ctx, "must not be null")
5133 }
5134 return graphql.Null
5135 }
5136 res := resTmp.(string)
5137 rctx.Result = res
5138 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5139 return ec.marshalNString2string(ctx, field.Selections, res)
5140}
5141
5142func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
5143 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5144 defer func() {
5145 if r := recover(); r != nil {
5146 ec.Error(ctx, ec.Recover(ctx, r))
5147 ret = graphql.Null
5148 }
5149 ec.Tracer.EndFieldExecution(ctx)
5150 }()
5151 rctx := &graphql.ResolverContext{
5152 Object: "CommentHistoryStep",
5153 Field: field,
5154 Args: nil,
5155 IsMethod: true,
5156 }
5157 ctx = graphql.WithResolverContext(ctx, rctx)
5158 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5159 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5160 ctx = rctx // use context from middleware stack in children
5161 return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
5162 })
5163 if err != nil {
5164 ec.Error(ctx, err)
5165 return graphql.Null
5166 }
5167 if resTmp == nil {
5168 if !ec.HasError(rctx) {
5169 ec.Errorf(ctx, "must not be null")
5170 }
5171 return graphql.Null
5172 }
5173 res := resTmp.(*time.Time)
5174 rctx.Result = res
5175 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5176 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5177}
5178
5179func (ec *executionContext) _CommitAsNeededPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
5180 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5181 defer func() {
5182 if r := recover(); r != nil {
5183 ec.Error(ctx, ec.Recover(ctx, r))
5184 ret = graphql.Null
5185 }
5186 ec.Tracer.EndFieldExecution(ctx)
5187 }()
5188 rctx := &graphql.ResolverContext{
5189 Object: "CommitAsNeededPayload",
5190 Field: field,
5191 Args: nil,
5192 IsMethod: false,
5193 }
5194 ctx = graphql.WithResolverContext(ctx, rctx)
5195 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5196 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5197 ctx = rctx // use context from middleware stack in children
5198 return obj.ClientMutationID, nil
5199 })
5200 if err != nil {
5201 ec.Error(ctx, err)
5202 return graphql.Null
5203 }
5204 if resTmp == nil {
5205 return graphql.Null
5206 }
5207 res := resTmp.(*string)
5208 rctx.Result = res
5209 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5210 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5211}
5212
5213func (ec *executionContext) _CommitAsNeededPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
5214 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5215 defer func() {
5216 if r := recover(); r != nil {
5217 ec.Error(ctx, ec.Recover(ctx, r))
5218 ret = graphql.Null
5219 }
5220 ec.Tracer.EndFieldExecution(ctx)
5221 }()
5222 rctx := &graphql.ResolverContext{
5223 Object: "CommitAsNeededPayload",
5224 Field: field,
5225 Args: nil,
5226 IsMethod: false,
5227 }
5228 ctx = graphql.WithResolverContext(ctx, rctx)
5229 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5230 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5231 ctx = rctx // use context from middleware stack in children
5232 return obj.Bug, nil
5233 })
5234 if err != nil {
5235 ec.Error(ctx, err)
5236 return graphql.Null
5237 }
5238 if resTmp == nil {
5239 if !ec.HasError(rctx) {
5240 ec.Errorf(ctx, "must not be null")
5241 }
5242 return graphql.Null
5243 }
5244 res := resTmp.(*bug.Snapshot)
5245 rctx.Result = res
5246 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5247 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
5248}
5249
5250func (ec *executionContext) _CommitPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
5251 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5252 defer func() {
5253 if r := recover(); r != nil {
5254 ec.Error(ctx, ec.Recover(ctx, r))
5255 ret = graphql.Null
5256 }
5257 ec.Tracer.EndFieldExecution(ctx)
5258 }()
5259 rctx := &graphql.ResolverContext{
5260 Object: "CommitPayload",
5261 Field: field,
5262 Args: nil,
5263 IsMethod: false,
5264 }
5265 ctx = graphql.WithResolverContext(ctx, rctx)
5266 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5267 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5268 ctx = rctx // use context from middleware stack in children
5269 return obj.ClientMutationID, nil
5270 })
5271 if err != nil {
5272 ec.Error(ctx, err)
5273 return graphql.Null
5274 }
5275 if resTmp == nil {
5276 return graphql.Null
5277 }
5278 res := resTmp.(*string)
5279 rctx.Result = res
5280 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5281 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5282}
5283
5284func (ec *executionContext) _CommitPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
5285 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5286 defer func() {
5287 if r := recover(); r != nil {
5288 ec.Error(ctx, ec.Recover(ctx, r))
5289 ret = graphql.Null
5290 }
5291 ec.Tracer.EndFieldExecution(ctx)
5292 }()
5293 rctx := &graphql.ResolverContext{
5294 Object: "CommitPayload",
5295 Field: field,
5296 Args: nil,
5297 IsMethod: false,
5298 }
5299 ctx = graphql.WithResolverContext(ctx, rctx)
5300 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5301 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5302 ctx = rctx // use context from middleware stack in children
5303 return obj.Bug, nil
5304 })
5305 if err != nil {
5306 ec.Error(ctx, err)
5307 return graphql.Null
5308 }
5309 if resTmp == nil {
5310 if !ec.HasError(rctx) {
5311 ec.Errorf(ctx, "must not be null")
5312 }
5313 return graphql.Null
5314 }
5315 res := resTmp.(*bug.Snapshot)
5316 rctx.Result = res
5317 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5318 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
5319}
5320
5321func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5322 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5323 defer func() {
5324 if r := recover(); r != nil {
5325 ec.Error(ctx, ec.Recover(ctx, r))
5326 ret = graphql.Null
5327 }
5328 ec.Tracer.EndFieldExecution(ctx)
5329 }()
5330 rctx := &graphql.ResolverContext{
5331 Object: "CreateOperation",
5332 Field: field,
5333 Args: nil,
5334 IsMethod: true,
5335 }
5336 ctx = graphql.WithResolverContext(ctx, rctx)
5337 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5338 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5339 ctx = rctx // use context from middleware stack in children
5340 return ec.resolvers.CreateOperation().ID(rctx, obj)
5341 })
5342 if err != nil {
5343 ec.Error(ctx, err)
5344 return graphql.Null
5345 }
5346 if resTmp == nil {
5347 if !ec.HasError(rctx) {
5348 ec.Errorf(ctx, "must not be null")
5349 }
5350 return graphql.Null
5351 }
5352 res := resTmp.(string)
5353 rctx.Result = res
5354 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5355 return ec.marshalNString2string(ctx, field.Selections, res)
5356}
5357
5358func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5359 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5360 defer func() {
5361 if r := recover(); r != nil {
5362 ec.Error(ctx, ec.Recover(ctx, r))
5363 ret = graphql.Null
5364 }
5365 ec.Tracer.EndFieldExecution(ctx)
5366 }()
5367 rctx := &graphql.ResolverContext{
5368 Object: "CreateOperation",
5369 Field: field,
5370 Args: nil,
5371 IsMethod: false,
5372 }
5373 ctx = graphql.WithResolverContext(ctx, rctx)
5374 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5375 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5376 ctx = rctx // use context from middleware stack in children
5377 return obj.Author, nil
5378 })
5379 if err != nil {
5380 ec.Error(ctx, err)
5381 return graphql.Null
5382 }
5383 if resTmp == nil {
5384 if !ec.HasError(rctx) {
5385 ec.Errorf(ctx, "must not be null")
5386 }
5387 return graphql.Null
5388 }
5389 res := resTmp.(identity.Interface)
5390 rctx.Result = res
5391 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5392 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
5393}
5394
5395func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5396 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5397 defer func() {
5398 if r := recover(); r != nil {
5399 ec.Error(ctx, ec.Recover(ctx, r))
5400 ret = graphql.Null
5401 }
5402 ec.Tracer.EndFieldExecution(ctx)
5403 }()
5404 rctx := &graphql.ResolverContext{
5405 Object: "CreateOperation",
5406 Field: field,
5407 Args: nil,
5408 IsMethod: true,
5409 }
5410 ctx = graphql.WithResolverContext(ctx, rctx)
5411 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5412 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5413 ctx = rctx // use context from middleware stack in children
5414 return ec.resolvers.CreateOperation().Date(rctx, obj)
5415 })
5416 if err != nil {
5417 ec.Error(ctx, err)
5418 return graphql.Null
5419 }
5420 if resTmp == nil {
5421 if !ec.HasError(rctx) {
5422 ec.Errorf(ctx, "must not be null")
5423 }
5424 return graphql.Null
5425 }
5426 res := resTmp.(*time.Time)
5427 rctx.Result = res
5428 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5429 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5430}
5431
5432func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5433 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5434 defer func() {
5435 if r := recover(); r != nil {
5436 ec.Error(ctx, ec.Recover(ctx, r))
5437 ret = graphql.Null
5438 }
5439 ec.Tracer.EndFieldExecution(ctx)
5440 }()
5441 rctx := &graphql.ResolverContext{
5442 Object: "CreateOperation",
5443 Field: field,
5444 Args: nil,
5445 IsMethod: false,
5446 }
5447 ctx = graphql.WithResolverContext(ctx, rctx)
5448 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5449 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5450 ctx = rctx // use context from middleware stack in children
5451 return obj.Title, nil
5452 })
5453 if err != nil {
5454 ec.Error(ctx, err)
5455 return graphql.Null
5456 }
5457 if resTmp == nil {
5458 if !ec.HasError(rctx) {
5459 ec.Errorf(ctx, "must not be null")
5460 }
5461 return graphql.Null
5462 }
5463 res := resTmp.(string)
5464 rctx.Result = res
5465 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5466 return ec.marshalNString2string(ctx, field.Selections, res)
5467}
5468
5469func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5470 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5471 defer func() {
5472 if r := recover(); r != nil {
5473 ec.Error(ctx, ec.Recover(ctx, r))
5474 ret = graphql.Null
5475 }
5476 ec.Tracer.EndFieldExecution(ctx)
5477 }()
5478 rctx := &graphql.ResolverContext{
5479 Object: "CreateOperation",
5480 Field: field,
5481 Args: nil,
5482 IsMethod: false,
5483 }
5484 ctx = graphql.WithResolverContext(ctx, rctx)
5485 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5486 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5487 ctx = rctx // use context from middleware stack in children
5488 return obj.Message, nil
5489 })
5490 if err != nil {
5491 ec.Error(ctx, err)
5492 return graphql.Null
5493 }
5494 if resTmp == nil {
5495 if !ec.HasError(rctx) {
5496 ec.Errorf(ctx, "must not be null")
5497 }
5498 return graphql.Null
5499 }
5500 res := resTmp.(string)
5501 rctx.Result = res
5502 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5503 return ec.marshalNString2string(ctx, field.Selections, res)
5504}
5505
5506func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5507 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5508 defer func() {
5509 if r := recover(); r != nil {
5510 ec.Error(ctx, ec.Recover(ctx, r))
5511 ret = graphql.Null
5512 }
5513 ec.Tracer.EndFieldExecution(ctx)
5514 }()
5515 rctx := &graphql.ResolverContext{
5516 Object: "CreateOperation",
5517 Field: field,
5518 Args: nil,
5519 IsMethod: false,
5520 }
5521 ctx = graphql.WithResolverContext(ctx, rctx)
5522 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5523 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5524 ctx = rctx // use context from middleware stack in children
5525 return obj.Files, nil
5526 })
5527 if err != nil {
5528 ec.Error(ctx, err)
5529 return graphql.Null
5530 }
5531 if resTmp == nil {
5532 if !ec.HasError(rctx) {
5533 ec.Errorf(ctx, "must not be null")
5534 }
5535 return graphql.Null
5536 }
5537 res := resTmp.([]git.Hash)
5538 rctx.Result = res
5539 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5540 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
5541}
5542
5543func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5544 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5545 defer func() {
5546 if r := recover(); r != nil {
5547 ec.Error(ctx, ec.Recover(ctx, r))
5548 ret = graphql.Null
5549 }
5550 ec.Tracer.EndFieldExecution(ctx)
5551 }()
5552 rctx := &graphql.ResolverContext{
5553 Object: "CreateTimelineItem",
5554 Field: field,
5555 Args: nil,
5556 IsMethod: true,
5557 }
5558 ctx = graphql.WithResolverContext(ctx, rctx)
5559 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5560 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5561 ctx = rctx // use context from middleware stack in children
5562 return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
5563 })
5564 if err != nil {
5565 ec.Error(ctx, err)
5566 return graphql.Null
5567 }
5568 if resTmp == nil {
5569 if !ec.HasError(rctx) {
5570 ec.Errorf(ctx, "must not be null")
5571 }
5572 return graphql.Null
5573 }
5574 res := resTmp.(string)
5575 rctx.Result = res
5576 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5577 return ec.marshalNString2string(ctx, field.Selections, res)
5578}
5579
5580func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5581 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5582 defer func() {
5583 if r := recover(); r != nil {
5584 ec.Error(ctx, ec.Recover(ctx, r))
5585 ret = graphql.Null
5586 }
5587 ec.Tracer.EndFieldExecution(ctx)
5588 }()
5589 rctx := &graphql.ResolverContext{
5590 Object: "CreateTimelineItem",
5591 Field: field,
5592 Args: nil,
5593 IsMethod: false,
5594 }
5595 ctx = graphql.WithResolverContext(ctx, rctx)
5596 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5597 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5598 ctx = rctx // use context from middleware stack in children
5599 return obj.Author, nil
5600 })
5601 if err != nil {
5602 ec.Error(ctx, err)
5603 return graphql.Null
5604 }
5605 if resTmp == nil {
5606 if !ec.HasError(rctx) {
5607 ec.Errorf(ctx, "must not be null")
5608 }
5609 return graphql.Null
5610 }
5611 res := resTmp.(identity.Interface)
5612 rctx.Result = res
5613 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5614 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
5615}
5616
5617func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5618 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5619 defer func() {
5620 if r := recover(); r != nil {
5621 ec.Error(ctx, ec.Recover(ctx, r))
5622 ret = graphql.Null
5623 }
5624 ec.Tracer.EndFieldExecution(ctx)
5625 }()
5626 rctx := &graphql.ResolverContext{
5627 Object: "CreateTimelineItem",
5628 Field: field,
5629 Args: nil,
5630 IsMethod: false,
5631 }
5632 ctx = graphql.WithResolverContext(ctx, rctx)
5633 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5634 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5635 ctx = rctx // use context from middleware stack in children
5636 return obj.Message, nil
5637 })
5638 if err != nil {
5639 ec.Error(ctx, err)
5640 return graphql.Null
5641 }
5642 if resTmp == nil {
5643 if !ec.HasError(rctx) {
5644 ec.Errorf(ctx, "must not be null")
5645 }
5646 return graphql.Null
5647 }
5648 res := resTmp.(string)
5649 rctx.Result = res
5650 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5651 return ec.marshalNString2string(ctx, field.Selections, res)
5652}
5653
5654func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5655 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5656 defer func() {
5657 if r := recover(); r != nil {
5658 ec.Error(ctx, ec.Recover(ctx, r))
5659 ret = graphql.Null
5660 }
5661 ec.Tracer.EndFieldExecution(ctx)
5662 }()
5663 rctx := &graphql.ResolverContext{
5664 Object: "CreateTimelineItem",
5665 Field: field,
5666 Args: nil,
5667 IsMethod: true,
5668 }
5669 ctx = graphql.WithResolverContext(ctx, rctx)
5670 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5671 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5672 ctx = rctx // use context from middleware stack in children
5673 return obj.MessageIsEmpty(), nil
5674 })
5675 if err != nil {
5676 ec.Error(ctx, err)
5677 return graphql.Null
5678 }
5679 if resTmp == nil {
5680 if !ec.HasError(rctx) {
5681 ec.Errorf(ctx, "must not be null")
5682 }
5683 return graphql.Null
5684 }
5685 res := resTmp.(bool)
5686 rctx.Result = res
5687 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5688 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5689}
5690
5691func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5692 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5693 defer func() {
5694 if r := recover(); r != nil {
5695 ec.Error(ctx, ec.Recover(ctx, r))
5696 ret = graphql.Null
5697 }
5698 ec.Tracer.EndFieldExecution(ctx)
5699 }()
5700 rctx := &graphql.ResolverContext{
5701 Object: "CreateTimelineItem",
5702 Field: field,
5703 Args: nil,
5704 IsMethod: false,
5705 }
5706 ctx = graphql.WithResolverContext(ctx, rctx)
5707 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5708 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5709 ctx = rctx // use context from middleware stack in children
5710 return obj.Files, nil
5711 })
5712 if err != nil {
5713 ec.Error(ctx, err)
5714 return graphql.Null
5715 }
5716 if resTmp == nil {
5717 if !ec.HasError(rctx) {
5718 ec.Errorf(ctx, "must not be null")
5719 }
5720 return graphql.Null
5721 }
5722 res := resTmp.([]git.Hash)
5723 rctx.Result = res
5724 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5725 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
5726}
5727
5728func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5729 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5730 defer func() {
5731 if r := recover(); r != nil {
5732 ec.Error(ctx, ec.Recover(ctx, r))
5733 ret = graphql.Null
5734 }
5735 ec.Tracer.EndFieldExecution(ctx)
5736 }()
5737 rctx := &graphql.ResolverContext{
5738 Object: "CreateTimelineItem",
5739 Field: field,
5740 Args: nil,
5741 IsMethod: true,
5742 }
5743 ctx = graphql.WithResolverContext(ctx, rctx)
5744 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5745 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5746 ctx = rctx // use context from middleware stack in children
5747 return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
5748 })
5749 if err != nil {
5750 ec.Error(ctx, err)
5751 return graphql.Null
5752 }
5753 if resTmp == nil {
5754 if !ec.HasError(rctx) {
5755 ec.Errorf(ctx, "must not be null")
5756 }
5757 return graphql.Null
5758 }
5759 res := resTmp.(*time.Time)
5760 rctx.Result = res
5761 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5762 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5763}
5764
5765func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5766 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5767 defer func() {
5768 if r := recover(); r != nil {
5769 ec.Error(ctx, ec.Recover(ctx, r))
5770 ret = graphql.Null
5771 }
5772 ec.Tracer.EndFieldExecution(ctx)
5773 }()
5774 rctx := &graphql.ResolverContext{
5775 Object: "CreateTimelineItem",
5776 Field: field,
5777 Args: nil,
5778 IsMethod: true,
5779 }
5780 ctx = graphql.WithResolverContext(ctx, rctx)
5781 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5782 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5783 ctx = rctx // use context from middleware stack in children
5784 return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
5785 })
5786 if err != nil {
5787 ec.Error(ctx, err)
5788 return graphql.Null
5789 }
5790 if resTmp == nil {
5791 if !ec.HasError(rctx) {
5792 ec.Errorf(ctx, "must not be null")
5793 }
5794 return graphql.Null
5795 }
5796 res := resTmp.(*time.Time)
5797 rctx.Result = res
5798 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5799 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5800}
5801
5802func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5803 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5804 defer func() {
5805 if r := recover(); r != nil {
5806 ec.Error(ctx, ec.Recover(ctx, r))
5807 ret = graphql.Null
5808 }
5809 ec.Tracer.EndFieldExecution(ctx)
5810 }()
5811 rctx := &graphql.ResolverContext{
5812 Object: "CreateTimelineItem",
5813 Field: field,
5814 Args: nil,
5815 IsMethod: true,
5816 }
5817 ctx = graphql.WithResolverContext(ctx, rctx)
5818 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5819 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5820 ctx = rctx // use context from middleware stack in children
5821 return obj.Edited(), nil
5822 })
5823 if err != nil {
5824 ec.Error(ctx, err)
5825 return graphql.Null
5826 }
5827 if resTmp == nil {
5828 if !ec.HasError(rctx) {
5829 ec.Errorf(ctx, "must not be null")
5830 }
5831 return graphql.Null
5832 }
5833 res := resTmp.(bool)
5834 rctx.Result = res
5835 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5836 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5837}
5838
5839func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5840 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5841 defer func() {
5842 if r := recover(); r != nil {
5843 ec.Error(ctx, ec.Recover(ctx, r))
5844 ret = graphql.Null
5845 }
5846 ec.Tracer.EndFieldExecution(ctx)
5847 }()
5848 rctx := &graphql.ResolverContext{
5849 Object: "CreateTimelineItem",
5850 Field: field,
5851 Args: nil,
5852 IsMethod: false,
5853 }
5854 ctx = graphql.WithResolverContext(ctx, rctx)
5855 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5856 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5857 ctx = rctx // use context from middleware stack in children
5858 return obj.History, nil
5859 })
5860 if err != nil {
5861 ec.Error(ctx, err)
5862 return graphql.Null
5863 }
5864 if resTmp == nil {
5865 if !ec.HasError(rctx) {
5866 ec.Errorf(ctx, "must not be null")
5867 }
5868 return graphql.Null
5869 }
5870 res := resTmp.([]bug.CommentHistoryStep)
5871 rctx.Result = res
5872 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5873 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, field.Selections, res)
5874}
5875
5876func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5877 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5878 defer func() {
5879 if r := recover(); r != nil {
5880 ec.Error(ctx, ec.Recover(ctx, r))
5881 ret = graphql.Null
5882 }
5883 ec.Tracer.EndFieldExecution(ctx)
5884 }()
5885 rctx := &graphql.ResolverContext{
5886 Object: "EditCommentOperation",
5887 Field: field,
5888 Args: nil,
5889 IsMethod: true,
5890 }
5891 ctx = graphql.WithResolverContext(ctx, rctx)
5892 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5893 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5894 ctx = rctx // use context from middleware stack in children
5895 return ec.resolvers.EditCommentOperation().ID(rctx, obj)
5896 })
5897 if err != nil {
5898 ec.Error(ctx, err)
5899 return graphql.Null
5900 }
5901 if resTmp == nil {
5902 if !ec.HasError(rctx) {
5903 ec.Errorf(ctx, "must not be null")
5904 }
5905 return graphql.Null
5906 }
5907 res := resTmp.(string)
5908 rctx.Result = res
5909 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5910 return ec.marshalNString2string(ctx, field.Selections, res)
5911}
5912
5913func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5914 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5915 defer func() {
5916 if r := recover(); r != nil {
5917 ec.Error(ctx, ec.Recover(ctx, r))
5918 ret = graphql.Null
5919 }
5920 ec.Tracer.EndFieldExecution(ctx)
5921 }()
5922 rctx := &graphql.ResolverContext{
5923 Object: "EditCommentOperation",
5924 Field: field,
5925 Args: nil,
5926 IsMethod: false,
5927 }
5928 ctx = graphql.WithResolverContext(ctx, rctx)
5929 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5930 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5931 ctx = rctx // use context from middleware stack in children
5932 return obj.Author, nil
5933 })
5934 if err != nil {
5935 ec.Error(ctx, err)
5936 return graphql.Null
5937 }
5938 if resTmp == nil {
5939 if !ec.HasError(rctx) {
5940 ec.Errorf(ctx, "must not be null")
5941 }
5942 return graphql.Null
5943 }
5944 res := resTmp.(identity.Interface)
5945 rctx.Result = res
5946 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5947 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
5948}
5949
5950func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5951 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5952 defer func() {
5953 if r := recover(); r != nil {
5954 ec.Error(ctx, ec.Recover(ctx, r))
5955 ret = graphql.Null
5956 }
5957 ec.Tracer.EndFieldExecution(ctx)
5958 }()
5959 rctx := &graphql.ResolverContext{
5960 Object: "EditCommentOperation",
5961 Field: field,
5962 Args: nil,
5963 IsMethod: true,
5964 }
5965 ctx = graphql.WithResolverContext(ctx, rctx)
5966 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5967 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5968 ctx = rctx // use context from middleware stack in children
5969 return ec.resolvers.EditCommentOperation().Date(rctx, obj)
5970 })
5971 if err != nil {
5972 ec.Error(ctx, err)
5973 return graphql.Null
5974 }
5975 if resTmp == nil {
5976 if !ec.HasError(rctx) {
5977 ec.Errorf(ctx, "must not be null")
5978 }
5979 return graphql.Null
5980 }
5981 res := resTmp.(*time.Time)
5982 rctx.Result = res
5983 ctx = ec.Tracer.StartFieldChildExecution(ctx)
5984 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5985}
5986
5987func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5988 ctx = ec.Tracer.StartFieldExecution(ctx, field)
5989 defer func() {
5990 if r := recover(); r != nil {
5991 ec.Error(ctx, ec.Recover(ctx, r))
5992 ret = graphql.Null
5993 }
5994 ec.Tracer.EndFieldExecution(ctx)
5995 }()
5996 rctx := &graphql.ResolverContext{
5997 Object: "EditCommentOperation",
5998 Field: field,
5999 Args: nil,
6000 IsMethod: true,
6001 }
6002 ctx = graphql.WithResolverContext(ctx, rctx)
6003 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6004 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6005 ctx = rctx // use context from middleware stack in children
6006 return ec.resolvers.EditCommentOperation().Target(rctx, obj)
6007 })
6008 if err != nil {
6009 ec.Error(ctx, err)
6010 return graphql.Null
6011 }
6012 if resTmp == nil {
6013 if !ec.HasError(rctx) {
6014 ec.Errorf(ctx, "must not be null")
6015 }
6016 return graphql.Null
6017 }
6018 res := resTmp.(string)
6019 rctx.Result = res
6020 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6021 return ec.marshalNString2string(ctx, field.Selections, res)
6022}
6023
6024func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6025 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6026 defer func() {
6027 if r := recover(); r != nil {
6028 ec.Error(ctx, ec.Recover(ctx, r))
6029 ret = graphql.Null
6030 }
6031 ec.Tracer.EndFieldExecution(ctx)
6032 }()
6033 rctx := &graphql.ResolverContext{
6034 Object: "EditCommentOperation",
6035 Field: field,
6036 Args: nil,
6037 IsMethod: false,
6038 }
6039 ctx = graphql.WithResolverContext(ctx, rctx)
6040 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6041 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6042 ctx = rctx // use context from middleware stack in children
6043 return obj.Message, nil
6044 })
6045 if err != nil {
6046 ec.Error(ctx, err)
6047 return graphql.Null
6048 }
6049 if resTmp == nil {
6050 if !ec.HasError(rctx) {
6051 ec.Errorf(ctx, "must not be null")
6052 }
6053 return graphql.Null
6054 }
6055 res := resTmp.(string)
6056 rctx.Result = res
6057 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6058 return ec.marshalNString2string(ctx, field.Selections, res)
6059}
6060
6061func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6062 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6063 defer func() {
6064 if r := recover(); r != nil {
6065 ec.Error(ctx, ec.Recover(ctx, r))
6066 ret = graphql.Null
6067 }
6068 ec.Tracer.EndFieldExecution(ctx)
6069 }()
6070 rctx := &graphql.ResolverContext{
6071 Object: "EditCommentOperation",
6072 Field: field,
6073 Args: nil,
6074 IsMethod: false,
6075 }
6076 ctx = graphql.WithResolverContext(ctx, rctx)
6077 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6078 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6079 ctx = rctx // use context from middleware stack in children
6080 return obj.Files, nil
6081 })
6082 if err != nil {
6083 ec.Error(ctx, err)
6084 return graphql.Null
6085 }
6086 if resTmp == nil {
6087 if !ec.HasError(rctx) {
6088 ec.Errorf(ctx, "must not be null")
6089 }
6090 return graphql.Null
6091 }
6092 res := resTmp.([]git.Hash)
6093 rctx.Result = res
6094 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6095 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
6096}
6097
6098func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6099 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6100 defer func() {
6101 if r := recover(); r != nil {
6102 ec.Error(ctx, ec.Recover(ctx, r))
6103 ret = graphql.Null
6104 }
6105 ec.Tracer.EndFieldExecution(ctx)
6106 }()
6107 rctx := &graphql.ResolverContext{
6108 Object: "Identity",
6109 Field: field,
6110 Args: nil,
6111 IsMethod: true,
6112 }
6113 ctx = graphql.WithResolverContext(ctx, rctx)
6114 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6115 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6116 ctx = rctx // use context from middleware stack in children
6117 return ec.resolvers.Identity().ID(rctx, obj)
6118 })
6119 if err != nil {
6120 ec.Error(ctx, err)
6121 return graphql.Null
6122 }
6123 if resTmp == nil {
6124 if !ec.HasError(rctx) {
6125 ec.Errorf(ctx, "must not be null")
6126 }
6127 return graphql.Null
6128 }
6129 res := resTmp.(string)
6130 rctx.Result = res
6131 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6132 return ec.marshalNString2string(ctx, field.Selections, res)
6133}
6134
6135func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6136 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6137 defer func() {
6138 if r := recover(); r != nil {
6139 ec.Error(ctx, ec.Recover(ctx, r))
6140 ret = graphql.Null
6141 }
6142 ec.Tracer.EndFieldExecution(ctx)
6143 }()
6144 rctx := &graphql.ResolverContext{
6145 Object: "Identity",
6146 Field: field,
6147 Args: nil,
6148 IsMethod: true,
6149 }
6150 ctx = graphql.WithResolverContext(ctx, rctx)
6151 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6152 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6153 ctx = rctx // use context from middleware stack in children
6154 return ec.resolvers.Identity().HumanID(rctx, obj)
6155 })
6156 if err != nil {
6157 ec.Error(ctx, err)
6158 return graphql.Null
6159 }
6160 if resTmp == nil {
6161 if !ec.HasError(rctx) {
6162 ec.Errorf(ctx, "must not be null")
6163 }
6164 return graphql.Null
6165 }
6166 res := resTmp.(string)
6167 rctx.Result = res
6168 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6169 return ec.marshalNString2string(ctx, field.Selections, res)
6170}
6171
6172func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6173 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6174 defer func() {
6175 if r := recover(); r != nil {
6176 ec.Error(ctx, ec.Recover(ctx, r))
6177 ret = graphql.Null
6178 }
6179 ec.Tracer.EndFieldExecution(ctx)
6180 }()
6181 rctx := &graphql.ResolverContext{
6182 Object: "Identity",
6183 Field: field,
6184 Args: nil,
6185 IsMethod: true,
6186 }
6187 ctx = graphql.WithResolverContext(ctx, rctx)
6188 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6189 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6190 ctx = rctx // use context from middleware stack in children
6191 return ec.resolvers.Identity().Name(rctx, obj)
6192 })
6193 if err != nil {
6194 ec.Error(ctx, err)
6195 return graphql.Null
6196 }
6197 if resTmp == nil {
6198 return graphql.Null
6199 }
6200 res := resTmp.(*string)
6201 rctx.Result = res
6202 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6203 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6204}
6205
6206func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6207 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6208 defer func() {
6209 if r := recover(); r != nil {
6210 ec.Error(ctx, ec.Recover(ctx, r))
6211 ret = graphql.Null
6212 }
6213 ec.Tracer.EndFieldExecution(ctx)
6214 }()
6215 rctx := &graphql.ResolverContext{
6216 Object: "Identity",
6217 Field: field,
6218 Args: nil,
6219 IsMethod: true,
6220 }
6221 ctx = graphql.WithResolverContext(ctx, rctx)
6222 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6223 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6224 ctx = rctx // use context from middleware stack in children
6225 return ec.resolvers.Identity().Email(rctx, obj)
6226 })
6227 if err != nil {
6228 ec.Error(ctx, err)
6229 return graphql.Null
6230 }
6231 if resTmp == nil {
6232 return graphql.Null
6233 }
6234 res := resTmp.(*string)
6235 rctx.Result = res
6236 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6237 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6238}
6239
6240func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6241 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6242 defer func() {
6243 if r := recover(); r != nil {
6244 ec.Error(ctx, ec.Recover(ctx, r))
6245 ret = graphql.Null
6246 }
6247 ec.Tracer.EndFieldExecution(ctx)
6248 }()
6249 rctx := &graphql.ResolverContext{
6250 Object: "Identity",
6251 Field: field,
6252 Args: nil,
6253 IsMethod: true,
6254 }
6255 ctx = graphql.WithResolverContext(ctx, rctx)
6256 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6257 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6258 ctx = rctx // use context from middleware stack in children
6259 return ec.resolvers.Identity().Login(rctx, obj)
6260 })
6261 if err != nil {
6262 ec.Error(ctx, err)
6263 return graphql.Null
6264 }
6265 if resTmp == nil {
6266 return graphql.Null
6267 }
6268 res := resTmp.(*string)
6269 rctx.Result = res
6270 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6271 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6272}
6273
6274func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6275 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6276 defer func() {
6277 if r := recover(); r != nil {
6278 ec.Error(ctx, ec.Recover(ctx, r))
6279 ret = graphql.Null
6280 }
6281 ec.Tracer.EndFieldExecution(ctx)
6282 }()
6283 rctx := &graphql.ResolverContext{
6284 Object: "Identity",
6285 Field: field,
6286 Args: nil,
6287 IsMethod: true,
6288 }
6289 ctx = graphql.WithResolverContext(ctx, rctx)
6290 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6291 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6292 ctx = rctx // use context from middleware stack in children
6293 return ec.resolvers.Identity().DisplayName(rctx, obj)
6294 })
6295 if err != nil {
6296 ec.Error(ctx, err)
6297 return graphql.Null
6298 }
6299 if resTmp == nil {
6300 if !ec.HasError(rctx) {
6301 ec.Errorf(ctx, "must not be null")
6302 }
6303 return graphql.Null
6304 }
6305 res := resTmp.(string)
6306 rctx.Result = res
6307 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6308 return ec.marshalNString2string(ctx, field.Selections, res)
6309}
6310
6311func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6312 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6313 defer func() {
6314 if r := recover(); r != nil {
6315 ec.Error(ctx, ec.Recover(ctx, r))
6316 ret = graphql.Null
6317 }
6318 ec.Tracer.EndFieldExecution(ctx)
6319 }()
6320 rctx := &graphql.ResolverContext{
6321 Object: "Identity",
6322 Field: field,
6323 Args: nil,
6324 IsMethod: true,
6325 }
6326 ctx = graphql.WithResolverContext(ctx, rctx)
6327 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6328 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6329 ctx = rctx // use context from middleware stack in children
6330 return ec.resolvers.Identity().AvatarURL(rctx, obj)
6331 })
6332 if err != nil {
6333 ec.Error(ctx, err)
6334 return graphql.Null
6335 }
6336 if resTmp == nil {
6337 return graphql.Null
6338 }
6339 res := resTmp.(*string)
6340 rctx.Result = res
6341 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6342 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6343}
6344
6345func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
6346 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6347 defer func() {
6348 if r := recover(); r != nil {
6349 ec.Error(ctx, ec.Recover(ctx, r))
6350 ret = graphql.Null
6351 }
6352 ec.Tracer.EndFieldExecution(ctx)
6353 }()
6354 rctx := &graphql.ResolverContext{
6355 Object: "Identity",
6356 Field: field,
6357 Args: nil,
6358 IsMethod: true,
6359 }
6360 ctx = graphql.WithResolverContext(ctx, rctx)
6361 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6362 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6363 ctx = rctx // use context from middleware stack in children
6364 return ec.resolvers.Identity().IsProtected(rctx, obj)
6365 })
6366 if err != nil {
6367 ec.Error(ctx, err)
6368 return graphql.Null
6369 }
6370 if resTmp == nil {
6371 if !ec.HasError(rctx) {
6372 ec.Errorf(ctx, "must not be null")
6373 }
6374 return graphql.Null
6375 }
6376 res := resTmp.(bool)
6377 rctx.Result = res
6378 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6379 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6380}
6381
6382func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6383 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6384 defer func() {
6385 if r := recover(); r != nil {
6386 ec.Error(ctx, ec.Recover(ctx, r))
6387 ret = graphql.Null
6388 }
6389 ec.Tracer.EndFieldExecution(ctx)
6390 }()
6391 rctx := &graphql.ResolverContext{
6392 Object: "IdentityConnection",
6393 Field: field,
6394 Args: nil,
6395 IsMethod: false,
6396 }
6397 ctx = graphql.WithResolverContext(ctx, rctx)
6398 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6399 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6400 ctx = rctx // use context from middleware stack in children
6401 return obj.Edges, nil
6402 })
6403 if err != nil {
6404 ec.Error(ctx, err)
6405 return graphql.Null
6406 }
6407 if resTmp == nil {
6408 if !ec.HasError(rctx) {
6409 ec.Errorf(ctx, "must not be null")
6410 }
6411 return graphql.Null
6412 }
6413 res := resTmp.([]*models.IdentityEdge)
6414 rctx.Result = res
6415 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6416 return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, field.Selections, res)
6417}
6418
6419func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6420 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6421 defer func() {
6422 if r := recover(); r != nil {
6423 ec.Error(ctx, ec.Recover(ctx, r))
6424 ret = graphql.Null
6425 }
6426 ec.Tracer.EndFieldExecution(ctx)
6427 }()
6428 rctx := &graphql.ResolverContext{
6429 Object: "IdentityConnection",
6430 Field: field,
6431 Args: nil,
6432 IsMethod: false,
6433 }
6434 ctx = graphql.WithResolverContext(ctx, rctx)
6435 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6436 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6437 ctx = rctx // use context from middleware stack in children
6438 return obj.Nodes, nil
6439 })
6440 if err != nil {
6441 ec.Error(ctx, err)
6442 return graphql.Null
6443 }
6444 if resTmp == nil {
6445 if !ec.HasError(rctx) {
6446 ec.Errorf(ctx, "must not be null")
6447 }
6448 return graphql.Null
6449 }
6450 res := resTmp.([]identity.Interface)
6451 rctx.Result = res
6452 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6453 return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
6454}
6455
6456func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6457 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6458 defer func() {
6459 if r := recover(); r != nil {
6460 ec.Error(ctx, ec.Recover(ctx, r))
6461 ret = graphql.Null
6462 }
6463 ec.Tracer.EndFieldExecution(ctx)
6464 }()
6465 rctx := &graphql.ResolverContext{
6466 Object: "IdentityConnection",
6467 Field: field,
6468 Args: nil,
6469 IsMethod: false,
6470 }
6471 ctx = graphql.WithResolverContext(ctx, rctx)
6472 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6473 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6474 ctx = rctx // use context from middleware stack in children
6475 return obj.PageInfo, nil
6476 })
6477 if err != nil {
6478 ec.Error(ctx, err)
6479 return graphql.Null
6480 }
6481 if resTmp == nil {
6482 if !ec.HasError(rctx) {
6483 ec.Errorf(ctx, "must not be null")
6484 }
6485 return graphql.Null
6486 }
6487 res := resTmp.(*models.PageInfo)
6488 rctx.Result = res
6489 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6490 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
6491}
6492
6493func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6494 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6495 defer func() {
6496 if r := recover(); r != nil {
6497 ec.Error(ctx, ec.Recover(ctx, r))
6498 ret = graphql.Null
6499 }
6500 ec.Tracer.EndFieldExecution(ctx)
6501 }()
6502 rctx := &graphql.ResolverContext{
6503 Object: "IdentityConnection",
6504 Field: field,
6505 Args: nil,
6506 IsMethod: false,
6507 }
6508 ctx = graphql.WithResolverContext(ctx, rctx)
6509 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6510 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6511 ctx = rctx // use context from middleware stack in children
6512 return obj.TotalCount, nil
6513 })
6514 if err != nil {
6515 ec.Error(ctx, err)
6516 return graphql.Null
6517 }
6518 if resTmp == nil {
6519 if !ec.HasError(rctx) {
6520 ec.Errorf(ctx, "must not be null")
6521 }
6522 return graphql.Null
6523 }
6524 res := resTmp.(int)
6525 rctx.Result = res
6526 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6527 return ec.marshalNInt2int(ctx, field.Selections, res)
6528}
6529
6530func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6531 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6532 defer func() {
6533 if r := recover(); r != nil {
6534 ec.Error(ctx, ec.Recover(ctx, r))
6535 ret = graphql.Null
6536 }
6537 ec.Tracer.EndFieldExecution(ctx)
6538 }()
6539 rctx := &graphql.ResolverContext{
6540 Object: "IdentityEdge",
6541 Field: field,
6542 Args: nil,
6543 IsMethod: false,
6544 }
6545 ctx = graphql.WithResolverContext(ctx, rctx)
6546 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6547 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6548 ctx = rctx // use context from middleware stack in children
6549 return obj.Cursor, nil
6550 })
6551 if err != nil {
6552 ec.Error(ctx, err)
6553 return graphql.Null
6554 }
6555 if resTmp == nil {
6556 if !ec.HasError(rctx) {
6557 ec.Errorf(ctx, "must not be null")
6558 }
6559 return graphql.Null
6560 }
6561 res := resTmp.(string)
6562 rctx.Result = res
6563 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6564 return ec.marshalNString2string(ctx, field.Selections, res)
6565}
6566
6567func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6568 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6569 defer func() {
6570 if r := recover(); r != nil {
6571 ec.Error(ctx, ec.Recover(ctx, r))
6572 ret = graphql.Null
6573 }
6574 ec.Tracer.EndFieldExecution(ctx)
6575 }()
6576 rctx := &graphql.ResolverContext{
6577 Object: "IdentityEdge",
6578 Field: field,
6579 Args: nil,
6580 IsMethod: false,
6581 }
6582 ctx = graphql.WithResolverContext(ctx, rctx)
6583 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6584 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6585 ctx = rctx // use context from middleware stack in children
6586 return obj.Node, nil
6587 })
6588 if err != nil {
6589 ec.Error(ctx, err)
6590 return graphql.Null
6591 }
6592 if resTmp == nil {
6593 if !ec.HasError(rctx) {
6594 ec.Errorf(ctx, "must not be null")
6595 }
6596 return graphql.Null
6597 }
6598 res := resTmp.(identity.Interface)
6599 rctx.Result = res
6600 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6601 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
6602}
6603
6604func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6605 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6606 defer func() {
6607 if r := recover(); r != nil {
6608 ec.Error(ctx, ec.Recover(ctx, r))
6609 ret = graphql.Null
6610 }
6611 ec.Tracer.EndFieldExecution(ctx)
6612 }()
6613 rctx := &graphql.ResolverContext{
6614 Object: "Label",
6615 Field: field,
6616 Args: nil,
6617 IsMethod: true,
6618 }
6619 ctx = graphql.WithResolverContext(ctx, rctx)
6620 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6621 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6622 ctx = rctx // use context from middleware stack in children
6623 return ec.resolvers.Label().Name(rctx, obj)
6624 })
6625 if err != nil {
6626 ec.Error(ctx, err)
6627 return graphql.Null
6628 }
6629 if resTmp == nil {
6630 if !ec.HasError(rctx) {
6631 ec.Errorf(ctx, "must not be null")
6632 }
6633 return graphql.Null
6634 }
6635 res := resTmp.(string)
6636 rctx.Result = res
6637 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6638 return ec.marshalNString2string(ctx, field.Selections, res)
6639}
6640
6641func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6642 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6643 defer func() {
6644 if r := recover(); r != nil {
6645 ec.Error(ctx, ec.Recover(ctx, r))
6646 ret = graphql.Null
6647 }
6648 ec.Tracer.EndFieldExecution(ctx)
6649 }()
6650 rctx := &graphql.ResolverContext{
6651 Object: "Label",
6652 Field: field,
6653 Args: nil,
6654 IsMethod: true,
6655 }
6656 ctx = graphql.WithResolverContext(ctx, rctx)
6657 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6658 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6659 ctx = rctx // use context from middleware stack in children
6660 return ec.resolvers.Label().Color(rctx, obj)
6661 })
6662 if err != nil {
6663 ec.Error(ctx, err)
6664 return graphql.Null
6665 }
6666 if resTmp == nil {
6667 if !ec.HasError(rctx) {
6668 ec.Errorf(ctx, "must not be null")
6669 }
6670 return graphql.Null
6671 }
6672 res := resTmp.(*color.RGBA)
6673 rctx.Result = res
6674 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6675 return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
6676}
6677
6678func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6679 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6680 defer func() {
6681 if r := recover(); r != nil {
6682 ec.Error(ctx, ec.Recover(ctx, r))
6683 ret = graphql.Null
6684 }
6685 ec.Tracer.EndFieldExecution(ctx)
6686 }()
6687 rctx := &graphql.ResolverContext{
6688 Object: "LabelChangeOperation",
6689 Field: field,
6690 Args: nil,
6691 IsMethod: true,
6692 }
6693 ctx = graphql.WithResolverContext(ctx, rctx)
6694 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6695 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6696 ctx = rctx // use context from middleware stack in children
6697 return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
6698 })
6699 if err != nil {
6700 ec.Error(ctx, err)
6701 return graphql.Null
6702 }
6703 if resTmp == nil {
6704 if !ec.HasError(rctx) {
6705 ec.Errorf(ctx, "must not be null")
6706 }
6707 return graphql.Null
6708 }
6709 res := resTmp.(string)
6710 rctx.Result = res
6711 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6712 return ec.marshalNString2string(ctx, field.Selections, res)
6713}
6714
6715func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6716 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6717 defer func() {
6718 if r := recover(); r != nil {
6719 ec.Error(ctx, ec.Recover(ctx, r))
6720 ret = graphql.Null
6721 }
6722 ec.Tracer.EndFieldExecution(ctx)
6723 }()
6724 rctx := &graphql.ResolverContext{
6725 Object: "LabelChangeOperation",
6726 Field: field,
6727 Args: nil,
6728 IsMethod: false,
6729 }
6730 ctx = graphql.WithResolverContext(ctx, rctx)
6731 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6732 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6733 ctx = rctx // use context from middleware stack in children
6734 return obj.Author, nil
6735 })
6736 if err != nil {
6737 ec.Error(ctx, err)
6738 return graphql.Null
6739 }
6740 if resTmp == nil {
6741 if !ec.HasError(rctx) {
6742 ec.Errorf(ctx, "must not be null")
6743 }
6744 return graphql.Null
6745 }
6746 res := resTmp.(identity.Interface)
6747 rctx.Result = res
6748 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6749 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
6750}
6751
6752func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6753 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6754 defer func() {
6755 if r := recover(); r != nil {
6756 ec.Error(ctx, ec.Recover(ctx, r))
6757 ret = graphql.Null
6758 }
6759 ec.Tracer.EndFieldExecution(ctx)
6760 }()
6761 rctx := &graphql.ResolverContext{
6762 Object: "LabelChangeOperation",
6763 Field: field,
6764 Args: nil,
6765 IsMethod: true,
6766 }
6767 ctx = graphql.WithResolverContext(ctx, rctx)
6768 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6769 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6770 ctx = rctx // use context from middleware stack in children
6771 return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
6772 })
6773 if err != nil {
6774 ec.Error(ctx, err)
6775 return graphql.Null
6776 }
6777 if resTmp == nil {
6778 if !ec.HasError(rctx) {
6779 ec.Errorf(ctx, "must not be null")
6780 }
6781 return graphql.Null
6782 }
6783 res := resTmp.(*time.Time)
6784 rctx.Result = res
6785 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6786 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6787}
6788
6789func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6790 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6791 defer func() {
6792 if r := recover(); r != nil {
6793 ec.Error(ctx, ec.Recover(ctx, r))
6794 ret = graphql.Null
6795 }
6796 ec.Tracer.EndFieldExecution(ctx)
6797 }()
6798 rctx := &graphql.ResolverContext{
6799 Object: "LabelChangeOperation",
6800 Field: field,
6801 Args: nil,
6802 IsMethod: false,
6803 }
6804 ctx = graphql.WithResolverContext(ctx, rctx)
6805 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6806 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6807 ctx = rctx // use context from middleware stack in children
6808 return obj.Added, nil
6809 })
6810 if err != nil {
6811 ec.Error(ctx, err)
6812 return graphql.Null
6813 }
6814 if resTmp == nil {
6815 if !ec.HasError(rctx) {
6816 ec.Errorf(ctx, "must not be null")
6817 }
6818 return graphql.Null
6819 }
6820 res := resTmp.([]bug.Label)
6821 rctx.Result = res
6822 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6823 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6824}
6825
6826func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6827 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6828 defer func() {
6829 if r := recover(); r != nil {
6830 ec.Error(ctx, ec.Recover(ctx, r))
6831 ret = graphql.Null
6832 }
6833 ec.Tracer.EndFieldExecution(ctx)
6834 }()
6835 rctx := &graphql.ResolverContext{
6836 Object: "LabelChangeOperation",
6837 Field: field,
6838 Args: nil,
6839 IsMethod: false,
6840 }
6841 ctx = graphql.WithResolverContext(ctx, rctx)
6842 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6843 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6844 ctx = rctx // use context from middleware stack in children
6845 return obj.Removed, nil
6846 })
6847 if err != nil {
6848 ec.Error(ctx, err)
6849 return graphql.Null
6850 }
6851 if resTmp == nil {
6852 if !ec.HasError(rctx) {
6853 ec.Errorf(ctx, "must not be null")
6854 }
6855 return graphql.Null
6856 }
6857 res := resTmp.([]bug.Label)
6858 rctx.Result = res
6859 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6860 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6861}
6862
6863func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6864 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6865 defer func() {
6866 if r := recover(); r != nil {
6867 ec.Error(ctx, ec.Recover(ctx, r))
6868 ret = graphql.Null
6869 }
6870 ec.Tracer.EndFieldExecution(ctx)
6871 }()
6872 rctx := &graphql.ResolverContext{
6873 Object: "LabelChangeResult",
6874 Field: field,
6875 Args: nil,
6876 IsMethod: false,
6877 }
6878 ctx = graphql.WithResolverContext(ctx, rctx)
6879 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6880 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6881 ctx = rctx // use context from middleware stack in children
6882 return obj.Label, nil
6883 })
6884 if err != nil {
6885 ec.Error(ctx, err)
6886 return graphql.Null
6887 }
6888 if resTmp == nil {
6889 if !ec.HasError(rctx) {
6890 ec.Errorf(ctx, "must not be null")
6891 }
6892 return graphql.Null
6893 }
6894 res := resTmp.(bug.Label)
6895 rctx.Result = res
6896 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6897 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6898}
6899
6900func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6901 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6902 defer func() {
6903 if r := recover(); r != nil {
6904 ec.Error(ctx, ec.Recover(ctx, r))
6905 ret = graphql.Null
6906 }
6907 ec.Tracer.EndFieldExecution(ctx)
6908 }()
6909 rctx := &graphql.ResolverContext{
6910 Object: "LabelChangeResult",
6911 Field: field,
6912 Args: nil,
6913 IsMethod: true,
6914 }
6915 ctx = graphql.WithResolverContext(ctx, rctx)
6916 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6917 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6918 ctx = rctx // use context from middleware stack in children
6919 return ec.resolvers.LabelChangeResult().Status(rctx, obj)
6920 })
6921 if err != nil {
6922 ec.Error(ctx, err)
6923 return graphql.Null
6924 }
6925 if resTmp == nil {
6926 if !ec.HasError(rctx) {
6927 ec.Errorf(ctx, "must not be null")
6928 }
6929 return graphql.Null
6930 }
6931 res := resTmp.(models.LabelChangeStatus)
6932 rctx.Result = res
6933 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6934 return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
6935}
6936
6937func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6938 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6939 defer func() {
6940 if r := recover(); r != nil {
6941 ec.Error(ctx, ec.Recover(ctx, r))
6942 ret = graphql.Null
6943 }
6944 ec.Tracer.EndFieldExecution(ctx)
6945 }()
6946 rctx := &graphql.ResolverContext{
6947 Object: "LabelChangeTimelineItem",
6948 Field: field,
6949 Args: nil,
6950 IsMethod: true,
6951 }
6952 ctx = graphql.WithResolverContext(ctx, rctx)
6953 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6954 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6955 ctx = rctx // use context from middleware stack in children
6956 return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
6957 })
6958 if err != nil {
6959 ec.Error(ctx, err)
6960 return graphql.Null
6961 }
6962 if resTmp == nil {
6963 if !ec.HasError(rctx) {
6964 ec.Errorf(ctx, "must not be null")
6965 }
6966 return graphql.Null
6967 }
6968 res := resTmp.(string)
6969 rctx.Result = res
6970 ctx = ec.Tracer.StartFieldChildExecution(ctx)
6971 return ec.marshalNString2string(ctx, field.Selections, res)
6972}
6973
6974func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6975 ctx = ec.Tracer.StartFieldExecution(ctx, field)
6976 defer func() {
6977 if r := recover(); r != nil {
6978 ec.Error(ctx, ec.Recover(ctx, r))
6979 ret = graphql.Null
6980 }
6981 ec.Tracer.EndFieldExecution(ctx)
6982 }()
6983 rctx := &graphql.ResolverContext{
6984 Object: "LabelChangeTimelineItem",
6985 Field: field,
6986 Args: nil,
6987 IsMethod: false,
6988 }
6989 ctx = graphql.WithResolverContext(ctx, rctx)
6990 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6991 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6992 ctx = rctx // use context from middleware stack in children
6993 return obj.Author, nil
6994 })
6995 if err != nil {
6996 ec.Error(ctx, err)
6997 return graphql.Null
6998 }
6999 if resTmp == nil {
7000 if !ec.HasError(rctx) {
7001 ec.Errorf(ctx, "must not be null")
7002 }
7003 return graphql.Null
7004 }
7005 res := resTmp.(identity.Interface)
7006 rctx.Result = res
7007 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7008 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
7009}
7010
7011func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7012 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7013 defer func() {
7014 if r := recover(); r != nil {
7015 ec.Error(ctx, ec.Recover(ctx, r))
7016 ret = graphql.Null
7017 }
7018 ec.Tracer.EndFieldExecution(ctx)
7019 }()
7020 rctx := &graphql.ResolverContext{
7021 Object: "LabelChangeTimelineItem",
7022 Field: field,
7023 Args: nil,
7024 IsMethod: true,
7025 }
7026 ctx = graphql.WithResolverContext(ctx, rctx)
7027 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7028 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7029 ctx = rctx // use context from middleware stack in children
7030 return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
7031 })
7032 if err != nil {
7033 ec.Error(ctx, err)
7034 return graphql.Null
7035 }
7036 if resTmp == nil {
7037 if !ec.HasError(rctx) {
7038 ec.Errorf(ctx, "must not be null")
7039 }
7040 return graphql.Null
7041 }
7042 res := resTmp.(*time.Time)
7043 rctx.Result = res
7044 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7045 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
7046}
7047
7048func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7049 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7050 defer func() {
7051 if r := recover(); r != nil {
7052 ec.Error(ctx, ec.Recover(ctx, r))
7053 ret = graphql.Null
7054 }
7055 ec.Tracer.EndFieldExecution(ctx)
7056 }()
7057 rctx := &graphql.ResolverContext{
7058 Object: "LabelChangeTimelineItem",
7059 Field: field,
7060 Args: nil,
7061 IsMethod: false,
7062 }
7063 ctx = graphql.WithResolverContext(ctx, rctx)
7064 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7065 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7066 ctx = rctx // use context from middleware stack in children
7067 return obj.Added, nil
7068 })
7069 if err != nil {
7070 ec.Error(ctx, err)
7071 return graphql.Null
7072 }
7073 if resTmp == nil {
7074 if !ec.HasError(rctx) {
7075 ec.Errorf(ctx, "must not be null")
7076 }
7077 return graphql.Null
7078 }
7079 res := resTmp.([]bug.Label)
7080 rctx.Result = res
7081 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7082 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
7083}
7084
7085func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7086 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7087 defer func() {
7088 if r := recover(); r != nil {
7089 ec.Error(ctx, ec.Recover(ctx, r))
7090 ret = graphql.Null
7091 }
7092 ec.Tracer.EndFieldExecution(ctx)
7093 }()
7094 rctx := &graphql.ResolverContext{
7095 Object: "LabelChangeTimelineItem",
7096 Field: field,
7097 Args: nil,
7098 IsMethod: false,
7099 }
7100 ctx = graphql.WithResolverContext(ctx, rctx)
7101 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7102 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7103 ctx = rctx // use context from middleware stack in children
7104 return obj.Removed, nil
7105 })
7106 if err != nil {
7107 ec.Error(ctx, err)
7108 return graphql.Null
7109 }
7110 if resTmp == nil {
7111 if !ec.HasError(rctx) {
7112 ec.Errorf(ctx, "must not be null")
7113 }
7114 return graphql.Null
7115 }
7116 res := resTmp.([]bug.Label)
7117 rctx.Result = res
7118 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7119 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
7120}
7121
7122func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7123 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7124 defer func() {
7125 if r := recover(); r != nil {
7126 ec.Error(ctx, ec.Recover(ctx, r))
7127 ret = graphql.Null
7128 }
7129 ec.Tracer.EndFieldExecution(ctx)
7130 }()
7131 rctx := &graphql.ResolverContext{
7132 Object: "LabelConnection",
7133 Field: field,
7134 Args: nil,
7135 IsMethod: false,
7136 }
7137 ctx = graphql.WithResolverContext(ctx, rctx)
7138 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7139 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7140 ctx = rctx // use context from middleware stack in children
7141 return obj.Edges, nil
7142 })
7143 if err != nil {
7144 ec.Error(ctx, err)
7145 return graphql.Null
7146 }
7147 if resTmp == nil {
7148 if !ec.HasError(rctx) {
7149 ec.Errorf(ctx, "must not be null")
7150 }
7151 return graphql.Null
7152 }
7153 res := resTmp.([]*models.LabelEdge)
7154 rctx.Result = res
7155 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7156 return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx, field.Selections, res)
7157}
7158
7159func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7160 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7161 defer func() {
7162 if r := recover(); r != nil {
7163 ec.Error(ctx, ec.Recover(ctx, r))
7164 ret = graphql.Null
7165 }
7166 ec.Tracer.EndFieldExecution(ctx)
7167 }()
7168 rctx := &graphql.ResolverContext{
7169 Object: "LabelConnection",
7170 Field: field,
7171 Args: nil,
7172 IsMethod: false,
7173 }
7174 ctx = graphql.WithResolverContext(ctx, rctx)
7175 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7176 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7177 ctx = rctx // use context from middleware stack in children
7178 return obj.Nodes, nil
7179 })
7180 if err != nil {
7181 ec.Error(ctx, err)
7182 return graphql.Null
7183 }
7184 if resTmp == nil {
7185 if !ec.HasError(rctx) {
7186 ec.Errorf(ctx, "must not be null")
7187 }
7188 return graphql.Null
7189 }
7190 res := resTmp.([]bug.Label)
7191 rctx.Result = res
7192 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7193 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
7194}
7195
7196func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7197 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7198 defer func() {
7199 if r := recover(); r != nil {
7200 ec.Error(ctx, ec.Recover(ctx, r))
7201 ret = graphql.Null
7202 }
7203 ec.Tracer.EndFieldExecution(ctx)
7204 }()
7205 rctx := &graphql.ResolverContext{
7206 Object: "LabelConnection",
7207 Field: field,
7208 Args: nil,
7209 IsMethod: false,
7210 }
7211 ctx = graphql.WithResolverContext(ctx, rctx)
7212 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7213 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7214 ctx = rctx // use context from middleware stack in children
7215 return obj.PageInfo, nil
7216 })
7217 if err != nil {
7218 ec.Error(ctx, err)
7219 return graphql.Null
7220 }
7221 if resTmp == nil {
7222 if !ec.HasError(rctx) {
7223 ec.Errorf(ctx, "must not be null")
7224 }
7225 return graphql.Null
7226 }
7227 res := resTmp.(*models.PageInfo)
7228 rctx.Result = res
7229 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7230 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
7231}
7232
7233func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7234 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7235 defer func() {
7236 if r := recover(); r != nil {
7237 ec.Error(ctx, ec.Recover(ctx, r))
7238 ret = graphql.Null
7239 }
7240 ec.Tracer.EndFieldExecution(ctx)
7241 }()
7242 rctx := &graphql.ResolverContext{
7243 Object: "LabelConnection",
7244 Field: field,
7245 Args: nil,
7246 IsMethod: false,
7247 }
7248 ctx = graphql.WithResolverContext(ctx, rctx)
7249 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7250 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7251 ctx = rctx // use context from middleware stack in children
7252 return obj.TotalCount, nil
7253 })
7254 if err != nil {
7255 ec.Error(ctx, err)
7256 return graphql.Null
7257 }
7258 if resTmp == nil {
7259 if !ec.HasError(rctx) {
7260 ec.Errorf(ctx, "must not be null")
7261 }
7262 return graphql.Null
7263 }
7264 res := resTmp.(int)
7265 rctx.Result = res
7266 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7267 return ec.marshalNInt2int(ctx, field.Selections, res)
7268}
7269
7270func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
7271 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7272 defer func() {
7273 if r := recover(); r != nil {
7274 ec.Error(ctx, ec.Recover(ctx, r))
7275 ret = graphql.Null
7276 }
7277 ec.Tracer.EndFieldExecution(ctx)
7278 }()
7279 rctx := &graphql.ResolverContext{
7280 Object: "LabelEdge",
7281 Field: field,
7282 Args: nil,
7283 IsMethod: false,
7284 }
7285 ctx = graphql.WithResolverContext(ctx, rctx)
7286 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7287 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7288 ctx = rctx // use context from middleware stack in children
7289 return obj.Cursor, nil
7290 })
7291 if err != nil {
7292 ec.Error(ctx, err)
7293 return graphql.Null
7294 }
7295 if resTmp == nil {
7296 if !ec.HasError(rctx) {
7297 ec.Errorf(ctx, "must not be null")
7298 }
7299 return graphql.Null
7300 }
7301 res := resTmp.(string)
7302 rctx.Result = res
7303 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7304 return ec.marshalNString2string(ctx, field.Selections, res)
7305}
7306
7307func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
7308 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7309 defer func() {
7310 if r := recover(); r != nil {
7311 ec.Error(ctx, ec.Recover(ctx, r))
7312 ret = graphql.Null
7313 }
7314 ec.Tracer.EndFieldExecution(ctx)
7315 }()
7316 rctx := &graphql.ResolverContext{
7317 Object: "LabelEdge",
7318 Field: field,
7319 Args: nil,
7320 IsMethod: false,
7321 }
7322 ctx = graphql.WithResolverContext(ctx, rctx)
7323 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7324 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7325 ctx = rctx // use context from middleware stack in children
7326 return obj.Node, nil
7327 })
7328 if err != nil {
7329 ec.Error(ctx, err)
7330 return graphql.Null
7331 }
7332 if resTmp == nil {
7333 if !ec.HasError(rctx) {
7334 ec.Errorf(ctx, "must not be null")
7335 }
7336 return graphql.Null
7337 }
7338 res := resTmp.(bug.Label)
7339 rctx.Result = res
7340 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7341 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
7342}
7343
7344func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7345 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7346 defer func() {
7347 if r := recover(); r != nil {
7348 ec.Error(ctx, ec.Recover(ctx, r))
7349 ret = graphql.Null
7350 }
7351 ec.Tracer.EndFieldExecution(ctx)
7352 }()
7353 rctx := &graphql.ResolverContext{
7354 Object: "Mutation",
7355 Field: field,
7356 Args: nil,
7357 IsMethod: true,
7358 }
7359 ctx = graphql.WithResolverContext(ctx, rctx)
7360 rawArgs := field.ArgumentMap(ec.Variables)
7361 args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
7362 if err != nil {
7363 ec.Error(ctx, err)
7364 return graphql.Null
7365 }
7366 rctx.Args = args
7367 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7368 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7369 ctx = rctx // use context from middleware stack in children
7370 return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
7371 })
7372 if err != nil {
7373 ec.Error(ctx, err)
7374 return graphql.Null
7375 }
7376 if resTmp == nil {
7377 if !ec.HasError(rctx) {
7378 ec.Errorf(ctx, "must not be null")
7379 }
7380 return graphql.Null
7381 }
7382 res := resTmp.(*models.NewBugPayload)
7383 rctx.Result = res
7384 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7385 return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
7386}
7387
7388func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7389 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7390 defer func() {
7391 if r := recover(); r != nil {
7392 ec.Error(ctx, ec.Recover(ctx, r))
7393 ret = graphql.Null
7394 }
7395 ec.Tracer.EndFieldExecution(ctx)
7396 }()
7397 rctx := &graphql.ResolverContext{
7398 Object: "Mutation",
7399 Field: field,
7400 Args: nil,
7401 IsMethod: true,
7402 }
7403 ctx = graphql.WithResolverContext(ctx, rctx)
7404 rawArgs := field.ArgumentMap(ec.Variables)
7405 args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
7406 if err != nil {
7407 ec.Error(ctx, err)
7408 return graphql.Null
7409 }
7410 rctx.Args = args
7411 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7412 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7413 ctx = rctx // use context from middleware stack in children
7414 return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
7415 })
7416 if err != nil {
7417 ec.Error(ctx, err)
7418 return graphql.Null
7419 }
7420 if resTmp == nil {
7421 if !ec.HasError(rctx) {
7422 ec.Errorf(ctx, "must not be null")
7423 }
7424 return graphql.Null
7425 }
7426 res := resTmp.(*models.AddCommentPayload)
7427 rctx.Result = res
7428 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7429 return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
7430}
7431
7432func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7433 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7434 defer func() {
7435 if r := recover(); r != nil {
7436 ec.Error(ctx, ec.Recover(ctx, r))
7437 ret = graphql.Null
7438 }
7439 ec.Tracer.EndFieldExecution(ctx)
7440 }()
7441 rctx := &graphql.ResolverContext{
7442 Object: "Mutation",
7443 Field: field,
7444 Args: nil,
7445 IsMethod: true,
7446 }
7447 ctx = graphql.WithResolverContext(ctx, rctx)
7448 rawArgs := field.ArgumentMap(ec.Variables)
7449 args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
7450 if err != nil {
7451 ec.Error(ctx, err)
7452 return graphql.Null
7453 }
7454 rctx.Args = args
7455 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7456 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7457 ctx = rctx // use context from middleware stack in children
7458 return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
7459 })
7460 if err != nil {
7461 ec.Error(ctx, err)
7462 return graphql.Null
7463 }
7464 if resTmp == nil {
7465 if !ec.HasError(rctx) {
7466 ec.Errorf(ctx, "must not be null")
7467 }
7468 return graphql.Null
7469 }
7470 res := resTmp.(*models.ChangeLabelPayload)
7471 rctx.Result = res
7472 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7473 return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
7474}
7475
7476func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7477 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7478 defer func() {
7479 if r := recover(); r != nil {
7480 ec.Error(ctx, ec.Recover(ctx, r))
7481 ret = graphql.Null
7482 }
7483 ec.Tracer.EndFieldExecution(ctx)
7484 }()
7485 rctx := &graphql.ResolverContext{
7486 Object: "Mutation",
7487 Field: field,
7488 Args: nil,
7489 IsMethod: true,
7490 }
7491 ctx = graphql.WithResolverContext(ctx, rctx)
7492 rawArgs := field.ArgumentMap(ec.Variables)
7493 args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
7494 if err != nil {
7495 ec.Error(ctx, err)
7496 return graphql.Null
7497 }
7498 rctx.Args = args
7499 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7500 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7501 ctx = rctx // use context from middleware stack in children
7502 return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
7503 })
7504 if err != nil {
7505 ec.Error(ctx, err)
7506 return graphql.Null
7507 }
7508 if resTmp == nil {
7509 if !ec.HasError(rctx) {
7510 ec.Errorf(ctx, "must not be null")
7511 }
7512 return graphql.Null
7513 }
7514 res := resTmp.(*models.OpenBugPayload)
7515 rctx.Result = res
7516 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7517 return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
7518}
7519
7520func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7521 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7522 defer func() {
7523 if r := recover(); r != nil {
7524 ec.Error(ctx, ec.Recover(ctx, r))
7525 ret = graphql.Null
7526 }
7527 ec.Tracer.EndFieldExecution(ctx)
7528 }()
7529 rctx := &graphql.ResolverContext{
7530 Object: "Mutation",
7531 Field: field,
7532 Args: nil,
7533 IsMethod: true,
7534 }
7535 ctx = graphql.WithResolverContext(ctx, rctx)
7536 rawArgs := field.ArgumentMap(ec.Variables)
7537 args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
7538 if err != nil {
7539 ec.Error(ctx, err)
7540 return graphql.Null
7541 }
7542 rctx.Args = args
7543 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7544 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7545 ctx = rctx // use context from middleware stack in children
7546 return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
7547 })
7548 if err != nil {
7549 ec.Error(ctx, err)
7550 return graphql.Null
7551 }
7552 if resTmp == nil {
7553 if !ec.HasError(rctx) {
7554 ec.Errorf(ctx, "must not be null")
7555 }
7556 return graphql.Null
7557 }
7558 res := resTmp.(*models.CloseBugPayload)
7559 rctx.Result = res
7560 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7561 return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
7562}
7563
7564func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7565 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7566 defer func() {
7567 if r := recover(); r != nil {
7568 ec.Error(ctx, ec.Recover(ctx, r))
7569 ret = graphql.Null
7570 }
7571 ec.Tracer.EndFieldExecution(ctx)
7572 }()
7573 rctx := &graphql.ResolverContext{
7574 Object: "Mutation",
7575 Field: field,
7576 Args: nil,
7577 IsMethod: true,
7578 }
7579 ctx = graphql.WithResolverContext(ctx, rctx)
7580 rawArgs := field.ArgumentMap(ec.Variables)
7581 args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
7582 if err != nil {
7583 ec.Error(ctx, err)
7584 return graphql.Null
7585 }
7586 rctx.Args = args
7587 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7588 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7589 ctx = rctx // use context from middleware stack in children
7590 return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
7591 })
7592 if err != nil {
7593 ec.Error(ctx, err)
7594 return graphql.Null
7595 }
7596 if resTmp == nil {
7597 if !ec.HasError(rctx) {
7598 ec.Errorf(ctx, "must not be null")
7599 }
7600 return graphql.Null
7601 }
7602 res := resTmp.(*models.SetTitlePayload)
7603 rctx.Result = res
7604 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7605 return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
7606}
7607
7608func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7609 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7610 defer func() {
7611 if r := recover(); r != nil {
7612 ec.Error(ctx, ec.Recover(ctx, r))
7613 ret = graphql.Null
7614 }
7615 ec.Tracer.EndFieldExecution(ctx)
7616 }()
7617 rctx := &graphql.ResolverContext{
7618 Object: "Mutation",
7619 Field: field,
7620 Args: nil,
7621 IsMethod: true,
7622 }
7623 ctx = graphql.WithResolverContext(ctx, rctx)
7624 rawArgs := field.ArgumentMap(ec.Variables)
7625 args, err := ec.field_Mutation_commit_args(ctx, rawArgs)
7626 if err != nil {
7627 ec.Error(ctx, err)
7628 return graphql.Null
7629 }
7630 rctx.Args = args
7631 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7632 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7633 ctx = rctx // use context from middleware stack in children
7634 return ec.resolvers.Mutation().Commit(rctx, args["input"].(models.CommitInput))
7635 })
7636 if err != nil {
7637 ec.Error(ctx, err)
7638 return graphql.Null
7639 }
7640 if resTmp == nil {
7641 if !ec.HasError(rctx) {
7642 ec.Errorf(ctx, "must not be null")
7643 }
7644 return graphql.Null
7645 }
7646 res := resTmp.(*models.CommitPayload)
7647 rctx.Result = res
7648 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7649 return ec.marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx, field.Selections, res)
7650}
7651
7652func (ec *executionContext) _Mutation_commitAsNeeded(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7653 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7654 defer func() {
7655 if r := recover(); r != nil {
7656 ec.Error(ctx, ec.Recover(ctx, r))
7657 ret = graphql.Null
7658 }
7659 ec.Tracer.EndFieldExecution(ctx)
7660 }()
7661 rctx := &graphql.ResolverContext{
7662 Object: "Mutation",
7663 Field: field,
7664 Args: nil,
7665 IsMethod: true,
7666 }
7667 ctx = graphql.WithResolverContext(ctx, rctx)
7668 rawArgs := field.ArgumentMap(ec.Variables)
7669 args, err := ec.field_Mutation_commitAsNeeded_args(ctx, rawArgs)
7670 if err != nil {
7671 ec.Error(ctx, err)
7672 return graphql.Null
7673 }
7674 rctx.Args = args
7675 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7676 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7677 ctx = rctx // use context from middleware stack in children
7678 return ec.resolvers.Mutation().CommitAsNeeded(rctx, args["input"].(models.CommitAsNeededInput))
7679 })
7680 if err != nil {
7681 ec.Error(ctx, err)
7682 return graphql.Null
7683 }
7684 if resTmp == nil {
7685 if !ec.HasError(rctx) {
7686 ec.Errorf(ctx, "must not be null")
7687 }
7688 return graphql.Null
7689 }
7690 res := resTmp.(*models.CommitAsNeededPayload)
7691 rctx.Result = res
7692 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7693 return ec.marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx, field.Selections, res)
7694}
7695
7696func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7697 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7698 defer func() {
7699 if r := recover(); r != nil {
7700 ec.Error(ctx, ec.Recover(ctx, r))
7701 ret = graphql.Null
7702 }
7703 ec.Tracer.EndFieldExecution(ctx)
7704 }()
7705 rctx := &graphql.ResolverContext{
7706 Object: "NewBugPayload",
7707 Field: field,
7708 Args: nil,
7709 IsMethod: false,
7710 }
7711 ctx = graphql.WithResolverContext(ctx, rctx)
7712 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7713 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7714 ctx = rctx // use context from middleware stack in children
7715 return obj.ClientMutationID, nil
7716 })
7717 if err != nil {
7718 ec.Error(ctx, err)
7719 return graphql.Null
7720 }
7721 if resTmp == nil {
7722 return graphql.Null
7723 }
7724 res := resTmp.(*string)
7725 rctx.Result = res
7726 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7727 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7728}
7729
7730func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7731 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7732 defer func() {
7733 if r := recover(); r != nil {
7734 ec.Error(ctx, ec.Recover(ctx, r))
7735 ret = graphql.Null
7736 }
7737 ec.Tracer.EndFieldExecution(ctx)
7738 }()
7739 rctx := &graphql.ResolverContext{
7740 Object: "NewBugPayload",
7741 Field: field,
7742 Args: nil,
7743 IsMethod: false,
7744 }
7745 ctx = graphql.WithResolverContext(ctx, rctx)
7746 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7747 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7748 ctx = rctx // use context from middleware stack in children
7749 return obj.Bug, nil
7750 })
7751 if err != nil {
7752 ec.Error(ctx, err)
7753 return graphql.Null
7754 }
7755 if resTmp == nil {
7756 if !ec.HasError(rctx) {
7757 ec.Errorf(ctx, "must not be null")
7758 }
7759 return graphql.Null
7760 }
7761 res := resTmp.(*bug.Snapshot)
7762 rctx.Result = res
7763 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7764 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
7765}
7766
7767func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7768 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7769 defer func() {
7770 if r := recover(); r != nil {
7771 ec.Error(ctx, ec.Recover(ctx, r))
7772 ret = graphql.Null
7773 }
7774 ec.Tracer.EndFieldExecution(ctx)
7775 }()
7776 rctx := &graphql.ResolverContext{
7777 Object: "NewBugPayload",
7778 Field: field,
7779 Args: nil,
7780 IsMethod: false,
7781 }
7782 ctx = graphql.WithResolverContext(ctx, rctx)
7783 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7784 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7785 ctx = rctx // use context from middleware stack in children
7786 return obj.Operation, nil
7787 })
7788 if err != nil {
7789 ec.Error(ctx, err)
7790 return graphql.Null
7791 }
7792 if resTmp == nil {
7793 if !ec.HasError(rctx) {
7794 ec.Errorf(ctx, "must not be null")
7795 }
7796 return graphql.Null
7797 }
7798 res := resTmp.(*bug.CreateOperation)
7799 rctx.Result = res
7800 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7801 return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
7802}
7803
7804func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7805 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7806 defer func() {
7807 if r := recover(); r != nil {
7808 ec.Error(ctx, ec.Recover(ctx, r))
7809 ret = graphql.Null
7810 }
7811 ec.Tracer.EndFieldExecution(ctx)
7812 }()
7813 rctx := &graphql.ResolverContext{
7814 Object: "OpenBugPayload",
7815 Field: field,
7816 Args: nil,
7817 IsMethod: false,
7818 }
7819 ctx = graphql.WithResolverContext(ctx, rctx)
7820 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7821 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7822 ctx = rctx // use context from middleware stack in children
7823 return obj.ClientMutationID, nil
7824 })
7825 if err != nil {
7826 ec.Error(ctx, err)
7827 return graphql.Null
7828 }
7829 if resTmp == nil {
7830 return graphql.Null
7831 }
7832 res := resTmp.(*string)
7833 rctx.Result = res
7834 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7835 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7836}
7837
7838func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7839 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7840 defer func() {
7841 if r := recover(); r != nil {
7842 ec.Error(ctx, ec.Recover(ctx, r))
7843 ret = graphql.Null
7844 }
7845 ec.Tracer.EndFieldExecution(ctx)
7846 }()
7847 rctx := &graphql.ResolverContext{
7848 Object: "OpenBugPayload",
7849 Field: field,
7850 Args: nil,
7851 IsMethod: false,
7852 }
7853 ctx = graphql.WithResolverContext(ctx, rctx)
7854 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7855 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7856 ctx = rctx // use context from middleware stack in children
7857 return obj.Bug, nil
7858 })
7859 if err != nil {
7860 ec.Error(ctx, err)
7861 return graphql.Null
7862 }
7863 if resTmp == nil {
7864 if !ec.HasError(rctx) {
7865 ec.Errorf(ctx, "must not be null")
7866 }
7867 return graphql.Null
7868 }
7869 res := resTmp.(*bug.Snapshot)
7870 rctx.Result = res
7871 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7872 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
7873}
7874
7875func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7876 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7877 defer func() {
7878 if r := recover(); r != nil {
7879 ec.Error(ctx, ec.Recover(ctx, r))
7880 ret = graphql.Null
7881 }
7882 ec.Tracer.EndFieldExecution(ctx)
7883 }()
7884 rctx := &graphql.ResolverContext{
7885 Object: "OpenBugPayload",
7886 Field: field,
7887 Args: nil,
7888 IsMethod: false,
7889 }
7890 ctx = graphql.WithResolverContext(ctx, rctx)
7891 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7892 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7893 ctx = rctx // use context from middleware stack in children
7894 return obj.Operation, nil
7895 })
7896 if err != nil {
7897 ec.Error(ctx, err)
7898 return graphql.Null
7899 }
7900 if resTmp == nil {
7901 if !ec.HasError(rctx) {
7902 ec.Errorf(ctx, "must not be null")
7903 }
7904 return graphql.Null
7905 }
7906 res := resTmp.(*bug.SetStatusOperation)
7907 rctx.Result = res
7908 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7909 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
7910}
7911
7912func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7913 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7914 defer func() {
7915 if r := recover(); r != nil {
7916 ec.Error(ctx, ec.Recover(ctx, r))
7917 ret = graphql.Null
7918 }
7919 ec.Tracer.EndFieldExecution(ctx)
7920 }()
7921 rctx := &graphql.ResolverContext{
7922 Object: "OperationConnection",
7923 Field: field,
7924 Args: nil,
7925 IsMethod: false,
7926 }
7927 ctx = graphql.WithResolverContext(ctx, rctx)
7928 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7929 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7930 ctx = rctx // use context from middleware stack in children
7931 return obj.Edges, nil
7932 })
7933 if err != nil {
7934 ec.Error(ctx, err)
7935 return graphql.Null
7936 }
7937 if resTmp == nil {
7938 if !ec.HasError(rctx) {
7939 ec.Errorf(ctx, "must not be null")
7940 }
7941 return graphql.Null
7942 }
7943 res := resTmp.([]*models.OperationEdge)
7944 rctx.Result = res
7945 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7946 return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, field.Selections, res)
7947}
7948
7949func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7950 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7951 defer func() {
7952 if r := recover(); r != nil {
7953 ec.Error(ctx, ec.Recover(ctx, r))
7954 ret = graphql.Null
7955 }
7956 ec.Tracer.EndFieldExecution(ctx)
7957 }()
7958 rctx := &graphql.ResolverContext{
7959 Object: "OperationConnection",
7960 Field: field,
7961 Args: nil,
7962 IsMethod: false,
7963 }
7964 ctx = graphql.WithResolverContext(ctx, rctx)
7965 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7966 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7967 ctx = rctx // use context from middleware stack in children
7968 return obj.Nodes, nil
7969 })
7970 if err != nil {
7971 ec.Error(ctx, err)
7972 return graphql.Null
7973 }
7974 if resTmp == nil {
7975 if !ec.HasError(rctx) {
7976 ec.Errorf(ctx, "must not be null")
7977 }
7978 return graphql.Null
7979 }
7980 res := resTmp.([]bug.Operation)
7981 rctx.Result = res
7982 ctx = ec.Tracer.StartFieldChildExecution(ctx)
7983 return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
7984}
7985
7986func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7987 ctx = ec.Tracer.StartFieldExecution(ctx, field)
7988 defer func() {
7989 if r := recover(); r != nil {
7990 ec.Error(ctx, ec.Recover(ctx, r))
7991 ret = graphql.Null
7992 }
7993 ec.Tracer.EndFieldExecution(ctx)
7994 }()
7995 rctx := &graphql.ResolverContext{
7996 Object: "OperationConnection",
7997 Field: field,
7998 Args: nil,
7999 IsMethod: false,
8000 }
8001 ctx = graphql.WithResolverContext(ctx, rctx)
8002 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8003 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8004 ctx = rctx // use context from middleware stack in children
8005 return obj.PageInfo, nil
8006 })
8007 if err != nil {
8008 ec.Error(ctx, err)
8009 return graphql.Null
8010 }
8011 if resTmp == nil {
8012 if !ec.HasError(rctx) {
8013 ec.Errorf(ctx, "must not be null")
8014 }
8015 return graphql.Null
8016 }
8017 res := resTmp.(*models.PageInfo)
8018 rctx.Result = res
8019 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8020 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
8021}
8022
8023func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
8024 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8025 defer func() {
8026 if r := recover(); r != nil {
8027 ec.Error(ctx, ec.Recover(ctx, r))
8028 ret = graphql.Null
8029 }
8030 ec.Tracer.EndFieldExecution(ctx)
8031 }()
8032 rctx := &graphql.ResolverContext{
8033 Object: "OperationConnection",
8034 Field: field,
8035 Args: nil,
8036 IsMethod: false,
8037 }
8038 ctx = graphql.WithResolverContext(ctx, rctx)
8039 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8040 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8041 ctx = rctx // use context from middleware stack in children
8042 return obj.TotalCount, nil
8043 })
8044 if err != nil {
8045 ec.Error(ctx, err)
8046 return graphql.Null
8047 }
8048 if resTmp == nil {
8049 if !ec.HasError(rctx) {
8050 ec.Errorf(ctx, "must not be null")
8051 }
8052 return graphql.Null
8053 }
8054 res := resTmp.(int)
8055 rctx.Result = res
8056 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8057 return ec.marshalNInt2int(ctx, field.Selections, res)
8058}
8059
8060func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
8061 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8062 defer func() {
8063 if r := recover(); r != nil {
8064 ec.Error(ctx, ec.Recover(ctx, r))
8065 ret = graphql.Null
8066 }
8067 ec.Tracer.EndFieldExecution(ctx)
8068 }()
8069 rctx := &graphql.ResolverContext{
8070 Object: "OperationEdge",
8071 Field: field,
8072 Args: nil,
8073 IsMethod: false,
8074 }
8075 ctx = graphql.WithResolverContext(ctx, rctx)
8076 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8077 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8078 ctx = rctx // use context from middleware stack in children
8079 return obj.Cursor, nil
8080 })
8081 if err != nil {
8082 ec.Error(ctx, err)
8083 return graphql.Null
8084 }
8085 if resTmp == nil {
8086 if !ec.HasError(rctx) {
8087 ec.Errorf(ctx, "must not be null")
8088 }
8089 return graphql.Null
8090 }
8091 res := resTmp.(string)
8092 rctx.Result = res
8093 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8094 return ec.marshalNString2string(ctx, field.Selections, res)
8095}
8096
8097func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
8098 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8099 defer func() {
8100 if r := recover(); r != nil {
8101 ec.Error(ctx, ec.Recover(ctx, r))
8102 ret = graphql.Null
8103 }
8104 ec.Tracer.EndFieldExecution(ctx)
8105 }()
8106 rctx := &graphql.ResolverContext{
8107 Object: "OperationEdge",
8108 Field: field,
8109 Args: nil,
8110 IsMethod: false,
8111 }
8112 ctx = graphql.WithResolverContext(ctx, rctx)
8113 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8114 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8115 ctx = rctx // use context from middleware stack in children
8116 return obj.Node, nil
8117 })
8118 if err != nil {
8119 ec.Error(ctx, err)
8120 return graphql.Null
8121 }
8122 if resTmp == nil {
8123 if !ec.HasError(rctx) {
8124 ec.Errorf(ctx, "must not be null")
8125 }
8126 return graphql.Null
8127 }
8128 res := resTmp.(bug.Operation)
8129 rctx.Result = res
8130 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8131 return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
8132}
8133
8134func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8135 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8136 defer func() {
8137 if r := recover(); r != nil {
8138 ec.Error(ctx, ec.Recover(ctx, r))
8139 ret = graphql.Null
8140 }
8141 ec.Tracer.EndFieldExecution(ctx)
8142 }()
8143 rctx := &graphql.ResolverContext{
8144 Object: "PageInfo",
8145 Field: field,
8146 Args: nil,
8147 IsMethod: false,
8148 }
8149 ctx = graphql.WithResolverContext(ctx, rctx)
8150 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8151 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8152 ctx = rctx // use context from middleware stack in children
8153 return obj.HasNextPage, nil
8154 })
8155 if err != nil {
8156 ec.Error(ctx, err)
8157 return graphql.Null
8158 }
8159 if resTmp == nil {
8160 if !ec.HasError(rctx) {
8161 ec.Errorf(ctx, "must not be null")
8162 }
8163 return graphql.Null
8164 }
8165 res := resTmp.(bool)
8166 rctx.Result = res
8167 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8168 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
8169}
8170
8171func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8172 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8173 defer func() {
8174 if r := recover(); r != nil {
8175 ec.Error(ctx, ec.Recover(ctx, r))
8176 ret = graphql.Null
8177 }
8178 ec.Tracer.EndFieldExecution(ctx)
8179 }()
8180 rctx := &graphql.ResolverContext{
8181 Object: "PageInfo",
8182 Field: field,
8183 Args: nil,
8184 IsMethod: false,
8185 }
8186 ctx = graphql.WithResolverContext(ctx, rctx)
8187 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8188 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8189 ctx = rctx // use context from middleware stack in children
8190 return obj.HasPreviousPage, nil
8191 })
8192 if err != nil {
8193 ec.Error(ctx, err)
8194 return graphql.Null
8195 }
8196 if resTmp == nil {
8197 if !ec.HasError(rctx) {
8198 ec.Errorf(ctx, "must not be null")
8199 }
8200 return graphql.Null
8201 }
8202 res := resTmp.(bool)
8203 rctx.Result = res
8204 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8205 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
8206}
8207
8208func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8209 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8210 defer func() {
8211 if r := recover(); r != nil {
8212 ec.Error(ctx, ec.Recover(ctx, r))
8213 ret = graphql.Null
8214 }
8215 ec.Tracer.EndFieldExecution(ctx)
8216 }()
8217 rctx := &graphql.ResolverContext{
8218 Object: "PageInfo",
8219 Field: field,
8220 Args: nil,
8221 IsMethod: false,
8222 }
8223 ctx = graphql.WithResolverContext(ctx, rctx)
8224 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8225 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8226 ctx = rctx // use context from middleware stack in children
8227 return obj.StartCursor, nil
8228 })
8229 if err != nil {
8230 ec.Error(ctx, err)
8231 return graphql.Null
8232 }
8233 if resTmp == nil {
8234 if !ec.HasError(rctx) {
8235 ec.Errorf(ctx, "must not be null")
8236 }
8237 return graphql.Null
8238 }
8239 res := resTmp.(string)
8240 rctx.Result = res
8241 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8242 return ec.marshalNString2string(ctx, field.Selections, res)
8243}
8244
8245func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8246 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8247 defer func() {
8248 if r := recover(); r != nil {
8249 ec.Error(ctx, ec.Recover(ctx, r))
8250 ret = graphql.Null
8251 }
8252 ec.Tracer.EndFieldExecution(ctx)
8253 }()
8254 rctx := &graphql.ResolverContext{
8255 Object: "PageInfo",
8256 Field: field,
8257 Args: nil,
8258 IsMethod: false,
8259 }
8260 ctx = graphql.WithResolverContext(ctx, rctx)
8261 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8262 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8263 ctx = rctx // use context from middleware stack in children
8264 return obj.EndCursor, nil
8265 })
8266 if err != nil {
8267 ec.Error(ctx, err)
8268 return graphql.Null
8269 }
8270 if resTmp == nil {
8271 if !ec.HasError(rctx) {
8272 ec.Errorf(ctx, "must not be null")
8273 }
8274 return graphql.Null
8275 }
8276 res := resTmp.(string)
8277 rctx.Result = res
8278 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8279 return ec.marshalNString2string(ctx, field.Selections, res)
8280}
8281
8282func (ec *executionContext) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8283 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8284 defer func() {
8285 if r := recover(); r != nil {
8286 ec.Error(ctx, ec.Recover(ctx, r))
8287 ret = graphql.Null
8288 }
8289 ec.Tracer.EndFieldExecution(ctx)
8290 }()
8291 rctx := &graphql.ResolverContext{
8292 Object: "Query",
8293 Field: field,
8294 Args: nil,
8295 IsMethod: true,
8296 }
8297 ctx = graphql.WithResolverContext(ctx, rctx)
8298 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8299 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8300 ctx = rctx // use context from middleware stack in children
8301 return ec.resolvers.Query().DefaultRepository(rctx)
8302 })
8303 if err != nil {
8304 ec.Error(ctx, err)
8305 return graphql.Null
8306 }
8307 if resTmp == nil {
8308 return graphql.Null
8309 }
8310 res := resTmp.(*models.Repository)
8311 rctx.Result = res
8312 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8313 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
8314}
8315
8316func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8317 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8318 defer func() {
8319 if r := recover(); r != nil {
8320 ec.Error(ctx, ec.Recover(ctx, r))
8321 ret = graphql.Null
8322 }
8323 ec.Tracer.EndFieldExecution(ctx)
8324 }()
8325 rctx := &graphql.ResolverContext{
8326 Object: "Query",
8327 Field: field,
8328 Args: nil,
8329 IsMethod: true,
8330 }
8331 ctx = graphql.WithResolverContext(ctx, rctx)
8332 rawArgs := field.ArgumentMap(ec.Variables)
8333 args, err := ec.field_Query_repository_args(ctx, rawArgs)
8334 if err != nil {
8335 ec.Error(ctx, err)
8336 return graphql.Null
8337 }
8338 rctx.Args = args
8339 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8340 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8341 ctx = rctx // use context from middleware stack in children
8342 return ec.resolvers.Query().Repository(rctx, args["ref"].(string))
8343 })
8344 if err != nil {
8345 ec.Error(ctx, err)
8346 return graphql.Null
8347 }
8348 if resTmp == nil {
8349 return graphql.Null
8350 }
8351 res := resTmp.(*models.Repository)
8352 rctx.Result = res
8353 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8354 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
8355}
8356
8357func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8358 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8359 defer func() {
8360 if r := recover(); r != nil {
8361 ec.Error(ctx, ec.Recover(ctx, r))
8362 ret = graphql.Null
8363 }
8364 ec.Tracer.EndFieldExecution(ctx)
8365 }()
8366 rctx := &graphql.ResolverContext{
8367 Object: "Query",
8368 Field: field,
8369 Args: nil,
8370 IsMethod: true,
8371 }
8372 ctx = graphql.WithResolverContext(ctx, rctx)
8373 rawArgs := field.ArgumentMap(ec.Variables)
8374 args, err := ec.field_Query___type_args(ctx, rawArgs)
8375 if err != nil {
8376 ec.Error(ctx, err)
8377 return graphql.Null
8378 }
8379 rctx.Args = args
8380 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8381 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8382 ctx = rctx // use context from middleware stack in children
8383 return ec.introspectType(args["name"].(string))
8384 })
8385 if err != nil {
8386 ec.Error(ctx, err)
8387 return graphql.Null
8388 }
8389 if resTmp == nil {
8390 return graphql.Null
8391 }
8392 res := resTmp.(*introspection.Type)
8393 rctx.Result = res
8394 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8395 return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
8396}
8397
8398func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8399 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8400 defer func() {
8401 if r := recover(); r != nil {
8402 ec.Error(ctx, ec.Recover(ctx, r))
8403 ret = graphql.Null
8404 }
8405 ec.Tracer.EndFieldExecution(ctx)
8406 }()
8407 rctx := &graphql.ResolverContext{
8408 Object: "Query",
8409 Field: field,
8410 Args: nil,
8411 IsMethod: true,
8412 }
8413 ctx = graphql.WithResolverContext(ctx, rctx)
8414 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8415 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8416 ctx = rctx // use context from middleware stack in children
8417 return ec.introspectSchema()
8418 })
8419 if err != nil {
8420 ec.Error(ctx, err)
8421 return graphql.Null
8422 }
8423 if resTmp == nil {
8424 return graphql.Null
8425 }
8426 res := resTmp.(*introspection.Schema)
8427 rctx.Result = res
8428 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8429 return ec.marshalO__Schema2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
8430}
8431
8432func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8433 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8434 defer func() {
8435 if r := recover(); r != nil {
8436 ec.Error(ctx, ec.Recover(ctx, r))
8437 ret = graphql.Null
8438 }
8439 ec.Tracer.EndFieldExecution(ctx)
8440 }()
8441 rctx := &graphql.ResolverContext{
8442 Object: "Repository",
8443 Field: field,
8444 Args: nil,
8445 IsMethod: true,
8446 }
8447 ctx = graphql.WithResolverContext(ctx, rctx)
8448 rawArgs := field.ArgumentMap(ec.Variables)
8449 args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
8450 if err != nil {
8451 ec.Error(ctx, err)
8452 return graphql.Null
8453 }
8454 rctx.Args = args
8455 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8456 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8457 ctx = rctx // use context from middleware stack in children
8458 return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
8459 })
8460 if err != nil {
8461 ec.Error(ctx, err)
8462 return graphql.Null
8463 }
8464 if resTmp == nil {
8465 if !ec.HasError(rctx) {
8466 ec.Errorf(ctx, "must not be null")
8467 }
8468 return graphql.Null
8469 }
8470 res := resTmp.(*models.BugConnection)
8471 rctx.Result = res
8472 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8473 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
8474}
8475
8476func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8477 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8478 defer func() {
8479 if r := recover(); r != nil {
8480 ec.Error(ctx, ec.Recover(ctx, r))
8481 ret = graphql.Null
8482 }
8483 ec.Tracer.EndFieldExecution(ctx)
8484 }()
8485 rctx := &graphql.ResolverContext{
8486 Object: "Repository",
8487 Field: field,
8488 Args: nil,
8489 IsMethod: true,
8490 }
8491 ctx = graphql.WithResolverContext(ctx, rctx)
8492 rawArgs := field.ArgumentMap(ec.Variables)
8493 args, err := ec.field_Repository_bug_args(ctx, rawArgs)
8494 if err != nil {
8495 ec.Error(ctx, err)
8496 return graphql.Null
8497 }
8498 rctx.Args = args
8499 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8500 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8501 ctx = rctx // use context from middleware stack in children
8502 return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
8503 })
8504 if err != nil {
8505 ec.Error(ctx, err)
8506 return graphql.Null
8507 }
8508 if resTmp == nil {
8509 return graphql.Null
8510 }
8511 res := resTmp.(*bug.Snapshot)
8512 rctx.Result = res
8513 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8514 return ec.marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
8515}
8516
8517func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8518 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8519 defer func() {
8520 if r := recover(); r != nil {
8521 ec.Error(ctx, ec.Recover(ctx, r))
8522 ret = graphql.Null
8523 }
8524 ec.Tracer.EndFieldExecution(ctx)
8525 }()
8526 rctx := &graphql.ResolverContext{
8527 Object: "Repository",
8528 Field: field,
8529 Args: nil,
8530 IsMethod: true,
8531 }
8532 ctx = graphql.WithResolverContext(ctx, rctx)
8533 rawArgs := field.ArgumentMap(ec.Variables)
8534 args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
8535 if err != nil {
8536 ec.Error(ctx, err)
8537 return graphql.Null
8538 }
8539 rctx.Args = args
8540 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8541 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8542 ctx = rctx // use context from middleware stack in children
8543 return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8544 })
8545 if err != nil {
8546 ec.Error(ctx, err)
8547 return graphql.Null
8548 }
8549 if resTmp == nil {
8550 if !ec.HasError(rctx) {
8551 ec.Errorf(ctx, "must not be null")
8552 }
8553 return graphql.Null
8554 }
8555 res := resTmp.(*models.IdentityConnection)
8556 rctx.Result = res
8557 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8558 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
8559}
8560
8561func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8562 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8563 defer func() {
8564 if r := recover(); r != nil {
8565 ec.Error(ctx, ec.Recover(ctx, r))
8566 ret = graphql.Null
8567 }
8568 ec.Tracer.EndFieldExecution(ctx)
8569 }()
8570 rctx := &graphql.ResolverContext{
8571 Object: "Repository",
8572 Field: field,
8573 Args: nil,
8574 IsMethod: true,
8575 }
8576 ctx = graphql.WithResolverContext(ctx, rctx)
8577 rawArgs := field.ArgumentMap(ec.Variables)
8578 args, err := ec.field_Repository_identity_args(ctx, rawArgs)
8579 if err != nil {
8580 ec.Error(ctx, err)
8581 return graphql.Null
8582 }
8583 rctx.Args = args
8584 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8585 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8586 ctx = rctx // use context from middleware stack in children
8587 return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
8588 })
8589 if err != nil {
8590 ec.Error(ctx, err)
8591 return graphql.Null
8592 }
8593 if resTmp == nil {
8594 return graphql.Null
8595 }
8596 res := resTmp.(identity.Interface)
8597 rctx.Result = res
8598 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8599 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8600}
8601
8602func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8603 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8604 defer func() {
8605 if r := recover(); r != nil {
8606 ec.Error(ctx, ec.Recover(ctx, r))
8607 ret = graphql.Null
8608 }
8609 ec.Tracer.EndFieldExecution(ctx)
8610 }()
8611 rctx := &graphql.ResolverContext{
8612 Object: "Repository",
8613 Field: field,
8614 Args: nil,
8615 IsMethod: true,
8616 }
8617 ctx = graphql.WithResolverContext(ctx, rctx)
8618 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8619 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8620 ctx = rctx // use context from middleware stack in children
8621 return ec.resolvers.Repository().UserIdentity(rctx, obj)
8622 })
8623 if err != nil {
8624 ec.Error(ctx, err)
8625 return graphql.Null
8626 }
8627 if resTmp == nil {
8628 return graphql.Null
8629 }
8630 res := resTmp.(identity.Interface)
8631 rctx.Result = res
8632 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8633 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8634}
8635
8636func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8637 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8638 defer func() {
8639 if r := recover(); r != nil {
8640 ec.Error(ctx, ec.Recover(ctx, r))
8641 ret = graphql.Null
8642 }
8643 ec.Tracer.EndFieldExecution(ctx)
8644 }()
8645 rctx := &graphql.ResolverContext{
8646 Object: "Repository",
8647 Field: field,
8648 Args: nil,
8649 IsMethod: true,
8650 }
8651 ctx = graphql.WithResolverContext(ctx, rctx)
8652 rawArgs := field.ArgumentMap(ec.Variables)
8653 args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
8654 if err != nil {
8655 ec.Error(ctx, err)
8656 return graphql.Null
8657 }
8658 rctx.Args = args
8659 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8660 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8661 ctx = rctx // use context from middleware stack in children
8662 return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8663 })
8664 if err != nil {
8665 ec.Error(ctx, err)
8666 return graphql.Null
8667 }
8668 if resTmp == nil {
8669 if !ec.HasError(rctx) {
8670 ec.Errorf(ctx, "must not be null")
8671 }
8672 return graphql.Null
8673 }
8674 res := resTmp.(*models.LabelConnection)
8675 rctx.Result = res
8676 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8677 return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
8678}
8679
8680func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8681 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8682 defer func() {
8683 if r := recover(); r != nil {
8684 ec.Error(ctx, ec.Recover(ctx, r))
8685 ret = graphql.Null
8686 }
8687 ec.Tracer.EndFieldExecution(ctx)
8688 }()
8689 rctx := &graphql.ResolverContext{
8690 Object: "SetStatusOperation",
8691 Field: field,
8692 Args: nil,
8693 IsMethod: true,
8694 }
8695 ctx = graphql.WithResolverContext(ctx, rctx)
8696 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8697 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8698 ctx = rctx // use context from middleware stack in children
8699 return ec.resolvers.SetStatusOperation().ID(rctx, obj)
8700 })
8701 if err != nil {
8702 ec.Error(ctx, err)
8703 return graphql.Null
8704 }
8705 if resTmp == nil {
8706 if !ec.HasError(rctx) {
8707 ec.Errorf(ctx, "must not be null")
8708 }
8709 return graphql.Null
8710 }
8711 res := resTmp.(string)
8712 rctx.Result = res
8713 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8714 return ec.marshalNString2string(ctx, field.Selections, res)
8715}
8716
8717func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8718 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8719 defer func() {
8720 if r := recover(); r != nil {
8721 ec.Error(ctx, ec.Recover(ctx, r))
8722 ret = graphql.Null
8723 }
8724 ec.Tracer.EndFieldExecution(ctx)
8725 }()
8726 rctx := &graphql.ResolverContext{
8727 Object: "SetStatusOperation",
8728 Field: field,
8729 Args: nil,
8730 IsMethod: false,
8731 }
8732 ctx = graphql.WithResolverContext(ctx, rctx)
8733 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8734 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8735 ctx = rctx // use context from middleware stack in children
8736 return obj.Author, nil
8737 })
8738 if err != nil {
8739 ec.Error(ctx, err)
8740 return graphql.Null
8741 }
8742 if resTmp == nil {
8743 if !ec.HasError(rctx) {
8744 ec.Errorf(ctx, "must not be null")
8745 }
8746 return graphql.Null
8747 }
8748 res := resTmp.(identity.Interface)
8749 rctx.Result = res
8750 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8751 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8752}
8753
8754func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8755 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8756 defer func() {
8757 if r := recover(); r != nil {
8758 ec.Error(ctx, ec.Recover(ctx, r))
8759 ret = graphql.Null
8760 }
8761 ec.Tracer.EndFieldExecution(ctx)
8762 }()
8763 rctx := &graphql.ResolverContext{
8764 Object: "SetStatusOperation",
8765 Field: field,
8766 Args: nil,
8767 IsMethod: true,
8768 }
8769 ctx = graphql.WithResolverContext(ctx, rctx)
8770 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8771 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8772 ctx = rctx // use context from middleware stack in children
8773 return ec.resolvers.SetStatusOperation().Date(rctx, obj)
8774 })
8775 if err != nil {
8776 ec.Error(ctx, err)
8777 return graphql.Null
8778 }
8779 if resTmp == nil {
8780 if !ec.HasError(rctx) {
8781 ec.Errorf(ctx, "must not be null")
8782 }
8783 return graphql.Null
8784 }
8785 res := resTmp.(*time.Time)
8786 rctx.Result = res
8787 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8788 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8789}
8790
8791func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8792 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8793 defer func() {
8794 if r := recover(); r != nil {
8795 ec.Error(ctx, ec.Recover(ctx, r))
8796 ret = graphql.Null
8797 }
8798 ec.Tracer.EndFieldExecution(ctx)
8799 }()
8800 rctx := &graphql.ResolverContext{
8801 Object: "SetStatusOperation",
8802 Field: field,
8803 Args: nil,
8804 IsMethod: true,
8805 }
8806 ctx = graphql.WithResolverContext(ctx, rctx)
8807 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8808 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8809 ctx = rctx // use context from middleware stack in children
8810 return ec.resolvers.SetStatusOperation().Status(rctx, obj)
8811 })
8812 if err != nil {
8813 ec.Error(ctx, err)
8814 return graphql.Null
8815 }
8816 if resTmp == nil {
8817 if !ec.HasError(rctx) {
8818 ec.Errorf(ctx, "must not be null")
8819 }
8820 return graphql.Null
8821 }
8822 res := resTmp.(models.Status)
8823 rctx.Result = res
8824 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8825 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8826}
8827
8828func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8829 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8830 defer func() {
8831 if r := recover(); r != nil {
8832 ec.Error(ctx, ec.Recover(ctx, r))
8833 ret = graphql.Null
8834 }
8835 ec.Tracer.EndFieldExecution(ctx)
8836 }()
8837 rctx := &graphql.ResolverContext{
8838 Object: "SetStatusTimelineItem",
8839 Field: field,
8840 Args: nil,
8841 IsMethod: true,
8842 }
8843 ctx = graphql.WithResolverContext(ctx, rctx)
8844 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8845 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8846 ctx = rctx // use context from middleware stack in children
8847 return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
8848 })
8849 if err != nil {
8850 ec.Error(ctx, err)
8851 return graphql.Null
8852 }
8853 if resTmp == nil {
8854 if !ec.HasError(rctx) {
8855 ec.Errorf(ctx, "must not be null")
8856 }
8857 return graphql.Null
8858 }
8859 res := resTmp.(string)
8860 rctx.Result = res
8861 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8862 return ec.marshalNString2string(ctx, field.Selections, res)
8863}
8864
8865func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8866 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8867 defer func() {
8868 if r := recover(); r != nil {
8869 ec.Error(ctx, ec.Recover(ctx, r))
8870 ret = graphql.Null
8871 }
8872 ec.Tracer.EndFieldExecution(ctx)
8873 }()
8874 rctx := &graphql.ResolverContext{
8875 Object: "SetStatusTimelineItem",
8876 Field: field,
8877 Args: nil,
8878 IsMethod: false,
8879 }
8880 ctx = graphql.WithResolverContext(ctx, rctx)
8881 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8882 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8883 ctx = rctx // use context from middleware stack in children
8884 return obj.Author, nil
8885 })
8886 if err != nil {
8887 ec.Error(ctx, err)
8888 return graphql.Null
8889 }
8890 if resTmp == nil {
8891 if !ec.HasError(rctx) {
8892 ec.Errorf(ctx, "must not be null")
8893 }
8894 return graphql.Null
8895 }
8896 res := resTmp.(identity.Interface)
8897 rctx.Result = res
8898 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8899 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8900}
8901
8902func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8903 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8904 defer func() {
8905 if r := recover(); r != nil {
8906 ec.Error(ctx, ec.Recover(ctx, r))
8907 ret = graphql.Null
8908 }
8909 ec.Tracer.EndFieldExecution(ctx)
8910 }()
8911 rctx := &graphql.ResolverContext{
8912 Object: "SetStatusTimelineItem",
8913 Field: field,
8914 Args: nil,
8915 IsMethod: true,
8916 }
8917 ctx = graphql.WithResolverContext(ctx, rctx)
8918 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8919 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8920 ctx = rctx // use context from middleware stack in children
8921 return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
8922 })
8923 if err != nil {
8924 ec.Error(ctx, err)
8925 return graphql.Null
8926 }
8927 if resTmp == nil {
8928 if !ec.HasError(rctx) {
8929 ec.Errorf(ctx, "must not be null")
8930 }
8931 return graphql.Null
8932 }
8933 res := resTmp.(*time.Time)
8934 rctx.Result = res
8935 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8936 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8937}
8938
8939func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8940 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8941 defer func() {
8942 if r := recover(); r != nil {
8943 ec.Error(ctx, ec.Recover(ctx, r))
8944 ret = graphql.Null
8945 }
8946 ec.Tracer.EndFieldExecution(ctx)
8947 }()
8948 rctx := &graphql.ResolverContext{
8949 Object: "SetStatusTimelineItem",
8950 Field: field,
8951 Args: nil,
8952 IsMethod: true,
8953 }
8954 ctx = graphql.WithResolverContext(ctx, rctx)
8955 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8956 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8957 ctx = rctx // use context from middleware stack in children
8958 return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
8959 })
8960 if err != nil {
8961 ec.Error(ctx, err)
8962 return graphql.Null
8963 }
8964 if resTmp == nil {
8965 if !ec.HasError(rctx) {
8966 ec.Errorf(ctx, "must not be null")
8967 }
8968 return graphql.Null
8969 }
8970 res := resTmp.(models.Status)
8971 rctx.Result = res
8972 ctx = ec.Tracer.StartFieldChildExecution(ctx)
8973 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8974}
8975
8976func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8977 ctx = ec.Tracer.StartFieldExecution(ctx, field)
8978 defer func() {
8979 if r := recover(); r != nil {
8980 ec.Error(ctx, ec.Recover(ctx, r))
8981 ret = graphql.Null
8982 }
8983 ec.Tracer.EndFieldExecution(ctx)
8984 }()
8985 rctx := &graphql.ResolverContext{
8986 Object: "SetTitleOperation",
8987 Field: field,
8988 Args: nil,
8989 IsMethod: true,
8990 }
8991 ctx = graphql.WithResolverContext(ctx, rctx)
8992 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8993 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8994 ctx = rctx // use context from middleware stack in children
8995 return ec.resolvers.SetTitleOperation().ID(rctx, obj)
8996 })
8997 if err != nil {
8998 ec.Error(ctx, err)
8999 return graphql.Null
9000 }
9001 if resTmp == nil {
9002 if !ec.HasError(rctx) {
9003 ec.Errorf(ctx, "must not be null")
9004 }
9005 return graphql.Null
9006 }
9007 res := resTmp.(string)
9008 rctx.Result = res
9009 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9010 return ec.marshalNString2string(ctx, field.Selections, res)
9011}
9012
9013func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
9014 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9015 defer func() {
9016 if r := recover(); r != nil {
9017 ec.Error(ctx, ec.Recover(ctx, r))
9018 ret = graphql.Null
9019 }
9020 ec.Tracer.EndFieldExecution(ctx)
9021 }()
9022 rctx := &graphql.ResolverContext{
9023 Object: "SetTitleOperation",
9024 Field: field,
9025 Args: nil,
9026 IsMethod: false,
9027 }
9028 ctx = graphql.WithResolverContext(ctx, rctx)
9029 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9030 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9031 ctx = rctx // use context from middleware stack in children
9032 return obj.Author, nil
9033 })
9034 if err != nil {
9035 ec.Error(ctx, err)
9036 return graphql.Null
9037 }
9038 if resTmp == nil {
9039 if !ec.HasError(rctx) {
9040 ec.Errorf(ctx, "must not be null")
9041 }
9042 return graphql.Null
9043 }
9044 res := resTmp.(identity.Interface)
9045 rctx.Result = res
9046 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9047 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
9048}
9049
9050func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
9051 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9052 defer func() {
9053 if r := recover(); r != nil {
9054 ec.Error(ctx, ec.Recover(ctx, r))
9055 ret = graphql.Null
9056 }
9057 ec.Tracer.EndFieldExecution(ctx)
9058 }()
9059 rctx := &graphql.ResolverContext{
9060 Object: "SetTitleOperation",
9061 Field: field,
9062 Args: nil,
9063 IsMethod: true,
9064 }
9065 ctx = graphql.WithResolverContext(ctx, rctx)
9066 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9067 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9068 ctx = rctx // use context from middleware stack in children
9069 return ec.resolvers.SetTitleOperation().Date(rctx, obj)
9070 })
9071 if err != nil {
9072 ec.Error(ctx, err)
9073 return graphql.Null
9074 }
9075 if resTmp == nil {
9076 if !ec.HasError(rctx) {
9077 ec.Errorf(ctx, "must not be null")
9078 }
9079 return graphql.Null
9080 }
9081 res := resTmp.(*time.Time)
9082 rctx.Result = res
9083 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9084 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
9085}
9086
9087func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
9088 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9089 defer func() {
9090 if r := recover(); r != nil {
9091 ec.Error(ctx, ec.Recover(ctx, r))
9092 ret = graphql.Null
9093 }
9094 ec.Tracer.EndFieldExecution(ctx)
9095 }()
9096 rctx := &graphql.ResolverContext{
9097 Object: "SetTitleOperation",
9098 Field: field,
9099 Args: nil,
9100 IsMethod: false,
9101 }
9102 ctx = graphql.WithResolverContext(ctx, rctx)
9103 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9104 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9105 ctx = rctx // use context from middleware stack in children
9106 return obj.Title, nil
9107 })
9108 if err != nil {
9109 ec.Error(ctx, err)
9110 return graphql.Null
9111 }
9112 if resTmp == nil {
9113 if !ec.HasError(rctx) {
9114 ec.Errorf(ctx, "must not be null")
9115 }
9116 return graphql.Null
9117 }
9118 res := resTmp.(string)
9119 rctx.Result = res
9120 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9121 return ec.marshalNString2string(ctx, field.Selections, res)
9122}
9123
9124func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
9125 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9126 defer func() {
9127 if r := recover(); r != nil {
9128 ec.Error(ctx, ec.Recover(ctx, r))
9129 ret = graphql.Null
9130 }
9131 ec.Tracer.EndFieldExecution(ctx)
9132 }()
9133 rctx := &graphql.ResolverContext{
9134 Object: "SetTitleOperation",
9135 Field: field,
9136 Args: nil,
9137 IsMethod: false,
9138 }
9139 ctx = graphql.WithResolverContext(ctx, rctx)
9140 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9141 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9142 ctx = rctx // use context from middleware stack in children
9143 return obj.Was, nil
9144 })
9145 if err != nil {
9146 ec.Error(ctx, err)
9147 return graphql.Null
9148 }
9149 if resTmp == nil {
9150 if !ec.HasError(rctx) {
9151 ec.Errorf(ctx, "must not be null")
9152 }
9153 return graphql.Null
9154 }
9155 res := resTmp.(string)
9156 rctx.Result = res
9157 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9158 return ec.marshalNString2string(ctx, field.Selections, res)
9159}
9160
9161func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
9162 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9163 defer func() {
9164 if r := recover(); r != nil {
9165 ec.Error(ctx, ec.Recover(ctx, r))
9166 ret = graphql.Null
9167 }
9168 ec.Tracer.EndFieldExecution(ctx)
9169 }()
9170 rctx := &graphql.ResolverContext{
9171 Object: "SetTitlePayload",
9172 Field: field,
9173 Args: nil,
9174 IsMethod: false,
9175 }
9176 ctx = graphql.WithResolverContext(ctx, rctx)
9177 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9178 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9179 ctx = rctx // use context from middleware stack in children
9180 return obj.ClientMutationID, nil
9181 })
9182 if err != nil {
9183 ec.Error(ctx, err)
9184 return graphql.Null
9185 }
9186 if resTmp == nil {
9187 return graphql.Null
9188 }
9189 res := resTmp.(*string)
9190 rctx.Result = res
9191 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9192 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9193}
9194
9195func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
9196 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9197 defer func() {
9198 if r := recover(); r != nil {
9199 ec.Error(ctx, ec.Recover(ctx, r))
9200 ret = graphql.Null
9201 }
9202 ec.Tracer.EndFieldExecution(ctx)
9203 }()
9204 rctx := &graphql.ResolverContext{
9205 Object: "SetTitlePayload",
9206 Field: field,
9207 Args: nil,
9208 IsMethod: false,
9209 }
9210 ctx = graphql.WithResolverContext(ctx, rctx)
9211 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9212 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9213 ctx = rctx // use context from middleware stack in children
9214 return obj.Bug, nil
9215 })
9216 if err != nil {
9217 ec.Error(ctx, err)
9218 return graphql.Null
9219 }
9220 if resTmp == nil {
9221 if !ec.HasError(rctx) {
9222 ec.Errorf(ctx, "must not be null")
9223 }
9224 return graphql.Null
9225 }
9226 res := resTmp.(*bug.Snapshot)
9227 rctx.Result = res
9228 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9229 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
9230}
9231
9232func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
9233 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9234 defer func() {
9235 if r := recover(); r != nil {
9236 ec.Error(ctx, ec.Recover(ctx, r))
9237 ret = graphql.Null
9238 }
9239 ec.Tracer.EndFieldExecution(ctx)
9240 }()
9241 rctx := &graphql.ResolverContext{
9242 Object: "SetTitlePayload",
9243 Field: field,
9244 Args: nil,
9245 IsMethod: false,
9246 }
9247 ctx = graphql.WithResolverContext(ctx, rctx)
9248 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9249 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9250 ctx = rctx // use context from middleware stack in children
9251 return obj.Operation, nil
9252 })
9253 if err != nil {
9254 ec.Error(ctx, err)
9255 return graphql.Null
9256 }
9257 if resTmp == nil {
9258 if !ec.HasError(rctx) {
9259 ec.Errorf(ctx, "must not be null")
9260 }
9261 return graphql.Null
9262 }
9263 res := resTmp.(*bug.SetTitleOperation)
9264 rctx.Result = res
9265 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9266 return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
9267}
9268
9269func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9270 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9271 defer func() {
9272 if r := recover(); r != nil {
9273 ec.Error(ctx, ec.Recover(ctx, r))
9274 ret = graphql.Null
9275 }
9276 ec.Tracer.EndFieldExecution(ctx)
9277 }()
9278 rctx := &graphql.ResolverContext{
9279 Object: "SetTitleTimelineItem",
9280 Field: field,
9281 Args: nil,
9282 IsMethod: true,
9283 }
9284 ctx = graphql.WithResolverContext(ctx, rctx)
9285 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9286 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9287 ctx = rctx // use context from middleware stack in children
9288 return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
9289 })
9290 if err != nil {
9291 ec.Error(ctx, err)
9292 return graphql.Null
9293 }
9294 if resTmp == nil {
9295 if !ec.HasError(rctx) {
9296 ec.Errorf(ctx, "must not be null")
9297 }
9298 return graphql.Null
9299 }
9300 res := resTmp.(string)
9301 rctx.Result = res
9302 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9303 return ec.marshalNString2string(ctx, field.Selections, res)
9304}
9305
9306func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9307 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9308 defer func() {
9309 if r := recover(); r != nil {
9310 ec.Error(ctx, ec.Recover(ctx, r))
9311 ret = graphql.Null
9312 }
9313 ec.Tracer.EndFieldExecution(ctx)
9314 }()
9315 rctx := &graphql.ResolverContext{
9316 Object: "SetTitleTimelineItem",
9317 Field: field,
9318 Args: nil,
9319 IsMethod: false,
9320 }
9321 ctx = graphql.WithResolverContext(ctx, rctx)
9322 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9323 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9324 ctx = rctx // use context from middleware stack in children
9325 return obj.Author, nil
9326 })
9327 if err != nil {
9328 ec.Error(ctx, err)
9329 return graphql.Null
9330 }
9331 if resTmp == nil {
9332 if !ec.HasError(rctx) {
9333 ec.Errorf(ctx, "must not be null")
9334 }
9335 return graphql.Null
9336 }
9337 res := resTmp.(identity.Interface)
9338 rctx.Result = res
9339 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9340 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
9341}
9342
9343func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9344 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9345 defer func() {
9346 if r := recover(); r != nil {
9347 ec.Error(ctx, ec.Recover(ctx, r))
9348 ret = graphql.Null
9349 }
9350 ec.Tracer.EndFieldExecution(ctx)
9351 }()
9352 rctx := &graphql.ResolverContext{
9353 Object: "SetTitleTimelineItem",
9354 Field: field,
9355 Args: nil,
9356 IsMethod: true,
9357 }
9358 ctx = graphql.WithResolverContext(ctx, rctx)
9359 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9360 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9361 ctx = rctx // use context from middleware stack in children
9362 return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
9363 })
9364 if err != nil {
9365 ec.Error(ctx, err)
9366 return graphql.Null
9367 }
9368 if resTmp == nil {
9369 if !ec.HasError(rctx) {
9370 ec.Errorf(ctx, "must not be null")
9371 }
9372 return graphql.Null
9373 }
9374 res := resTmp.(*time.Time)
9375 rctx.Result = res
9376 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9377 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
9378}
9379
9380func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9381 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9382 defer func() {
9383 if r := recover(); r != nil {
9384 ec.Error(ctx, ec.Recover(ctx, r))
9385 ret = graphql.Null
9386 }
9387 ec.Tracer.EndFieldExecution(ctx)
9388 }()
9389 rctx := &graphql.ResolverContext{
9390 Object: "SetTitleTimelineItem",
9391 Field: field,
9392 Args: nil,
9393 IsMethod: false,
9394 }
9395 ctx = graphql.WithResolverContext(ctx, rctx)
9396 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9397 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9398 ctx = rctx // use context from middleware stack in children
9399 return obj.Title, nil
9400 })
9401 if err != nil {
9402 ec.Error(ctx, err)
9403 return graphql.Null
9404 }
9405 if resTmp == nil {
9406 if !ec.HasError(rctx) {
9407 ec.Errorf(ctx, "must not be null")
9408 }
9409 return graphql.Null
9410 }
9411 res := resTmp.(string)
9412 rctx.Result = res
9413 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9414 return ec.marshalNString2string(ctx, field.Selections, res)
9415}
9416
9417func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9418 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9419 defer func() {
9420 if r := recover(); r != nil {
9421 ec.Error(ctx, ec.Recover(ctx, r))
9422 ret = graphql.Null
9423 }
9424 ec.Tracer.EndFieldExecution(ctx)
9425 }()
9426 rctx := &graphql.ResolverContext{
9427 Object: "SetTitleTimelineItem",
9428 Field: field,
9429 Args: nil,
9430 IsMethod: false,
9431 }
9432 ctx = graphql.WithResolverContext(ctx, rctx)
9433 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9434 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9435 ctx = rctx // use context from middleware stack in children
9436 return obj.Was, nil
9437 })
9438 if err != nil {
9439 ec.Error(ctx, err)
9440 return graphql.Null
9441 }
9442 if resTmp == nil {
9443 if !ec.HasError(rctx) {
9444 ec.Errorf(ctx, "must not be null")
9445 }
9446 return graphql.Null
9447 }
9448 res := resTmp.(string)
9449 rctx.Result = res
9450 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9451 return ec.marshalNString2string(ctx, field.Selections, res)
9452}
9453
9454func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9455 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9456 defer func() {
9457 if r := recover(); r != nil {
9458 ec.Error(ctx, ec.Recover(ctx, r))
9459 ret = graphql.Null
9460 }
9461 ec.Tracer.EndFieldExecution(ctx)
9462 }()
9463 rctx := &graphql.ResolverContext{
9464 Object: "TimelineItemConnection",
9465 Field: field,
9466 Args: nil,
9467 IsMethod: false,
9468 }
9469 ctx = graphql.WithResolverContext(ctx, rctx)
9470 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9471 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9472 ctx = rctx // use context from middleware stack in children
9473 return obj.Edges, nil
9474 })
9475 if err != nil {
9476 ec.Error(ctx, err)
9477 return graphql.Null
9478 }
9479 if resTmp == nil {
9480 if !ec.HasError(rctx) {
9481 ec.Errorf(ctx, "must not be null")
9482 }
9483 return graphql.Null
9484 }
9485 res := resTmp.([]*models.TimelineItemEdge)
9486 rctx.Result = res
9487 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9488 return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, field.Selections, res)
9489}
9490
9491func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9492 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9493 defer func() {
9494 if r := recover(); r != nil {
9495 ec.Error(ctx, ec.Recover(ctx, r))
9496 ret = graphql.Null
9497 }
9498 ec.Tracer.EndFieldExecution(ctx)
9499 }()
9500 rctx := &graphql.ResolverContext{
9501 Object: "TimelineItemConnection",
9502 Field: field,
9503 Args: nil,
9504 IsMethod: false,
9505 }
9506 ctx = graphql.WithResolverContext(ctx, rctx)
9507 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9508 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9509 ctx = rctx // use context from middleware stack in children
9510 return obj.Nodes, nil
9511 })
9512 if err != nil {
9513 ec.Error(ctx, err)
9514 return graphql.Null
9515 }
9516 if resTmp == nil {
9517 if !ec.HasError(rctx) {
9518 ec.Errorf(ctx, "must not be null")
9519 }
9520 return graphql.Null
9521 }
9522 res := resTmp.([]bug.TimelineItem)
9523 rctx.Result = res
9524 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9525 return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
9526}
9527
9528func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9529 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9530 defer func() {
9531 if r := recover(); r != nil {
9532 ec.Error(ctx, ec.Recover(ctx, r))
9533 ret = graphql.Null
9534 }
9535 ec.Tracer.EndFieldExecution(ctx)
9536 }()
9537 rctx := &graphql.ResolverContext{
9538 Object: "TimelineItemConnection",
9539 Field: field,
9540 Args: nil,
9541 IsMethod: false,
9542 }
9543 ctx = graphql.WithResolverContext(ctx, rctx)
9544 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9545 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9546 ctx = rctx // use context from middleware stack in children
9547 return obj.PageInfo, nil
9548 })
9549 if err != nil {
9550 ec.Error(ctx, err)
9551 return graphql.Null
9552 }
9553 if resTmp == nil {
9554 if !ec.HasError(rctx) {
9555 ec.Errorf(ctx, "must not be null")
9556 }
9557 return graphql.Null
9558 }
9559 res := resTmp.(*models.PageInfo)
9560 rctx.Result = res
9561 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9562 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
9563}
9564
9565func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9566 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9567 defer func() {
9568 if r := recover(); r != nil {
9569 ec.Error(ctx, ec.Recover(ctx, r))
9570 ret = graphql.Null
9571 }
9572 ec.Tracer.EndFieldExecution(ctx)
9573 }()
9574 rctx := &graphql.ResolverContext{
9575 Object: "TimelineItemConnection",
9576 Field: field,
9577 Args: nil,
9578 IsMethod: false,
9579 }
9580 ctx = graphql.WithResolverContext(ctx, rctx)
9581 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9582 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9583 ctx = rctx // use context from middleware stack in children
9584 return obj.TotalCount, nil
9585 })
9586 if err != nil {
9587 ec.Error(ctx, err)
9588 return graphql.Null
9589 }
9590 if resTmp == nil {
9591 if !ec.HasError(rctx) {
9592 ec.Errorf(ctx, "must not be null")
9593 }
9594 return graphql.Null
9595 }
9596 res := resTmp.(int)
9597 rctx.Result = res
9598 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9599 return ec.marshalNInt2int(ctx, field.Selections, res)
9600}
9601
9602func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9603 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9604 defer func() {
9605 if r := recover(); r != nil {
9606 ec.Error(ctx, ec.Recover(ctx, r))
9607 ret = graphql.Null
9608 }
9609 ec.Tracer.EndFieldExecution(ctx)
9610 }()
9611 rctx := &graphql.ResolverContext{
9612 Object: "TimelineItemEdge",
9613 Field: field,
9614 Args: nil,
9615 IsMethod: false,
9616 }
9617 ctx = graphql.WithResolverContext(ctx, rctx)
9618 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9619 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9620 ctx = rctx // use context from middleware stack in children
9621 return obj.Cursor, nil
9622 })
9623 if err != nil {
9624 ec.Error(ctx, err)
9625 return graphql.Null
9626 }
9627 if resTmp == nil {
9628 if !ec.HasError(rctx) {
9629 ec.Errorf(ctx, "must not be null")
9630 }
9631 return graphql.Null
9632 }
9633 res := resTmp.(string)
9634 rctx.Result = res
9635 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9636 return ec.marshalNString2string(ctx, field.Selections, res)
9637}
9638
9639func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9640 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9641 defer func() {
9642 if r := recover(); r != nil {
9643 ec.Error(ctx, ec.Recover(ctx, r))
9644 ret = graphql.Null
9645 }
9646 ec.Tracer.EndFieldExecution(ctx)
9647 }()
9648 rctx := &graphql.ResolverContext{
9649 Object: "TimelineItemEdge",
9650 Field: field,
9651 Args: nil,
9652 IsMethod: false,
9653 }
9654 ctx = graphql.WithResolverContext(ctx, rctx)
9655 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9656 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9657 ctx = rctx // use context from middleware stack in children
9658 return obj.Node, nil
9659 })
9660 if err != nil {
9661 ec.Error(ctx, err)
9662 return graphql.Null
9663 }
9664 if resTmp == nil {
9665 if !ec.HasError(rctx) {
9666 ec.Errorf(ctx, "must not be null")
9667 }
9668 return graphql.Null
9669 }
9670 res := resTmp.(bug.TimelineItem)
9671 rctx.Result = res
9672 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9673 return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
9674}
9675
9676func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9677 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9678 defer func() {
9679 if r := recover(); r != nil {
9680 ec.Error(ctx, ec.Recover(ctx, r))
9681 ret = graphql.Null
9682 }
9683 ec.Tracer.EndFieldExecution(ctx)
9684 }()
9685 rctx := &graphql.ResolverContext{
9686 Object: "__Directive",
9687 Field: field,
9688 Args: nil,
9689 IsMethod: false,
9690 }
9691 ctx = graphql.WithResolverContext(ctx, rctx)
9692 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9693 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9694 ctx = rctx // use context from middleware stack in children
9695 return obj.Name, nil
9696 })
9697 if err != nil {
9698 ec.Error(ctx, err)
9699 return graphql.Null
9700 }
9701 if resTmp == nil {
9702 if !ec.HasError(rctx) {
9703 ec.Errorf(ctx, "must not be null")
9704 }
9705 return graphql.Null
9706 }
9707 res := resTmp.(string)
9708 rctx.Result = res
9709 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9710 return ec.marshalNString2string(ctx, field.Selections, res)
9711}
9712
9713func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9714 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9715 defer func() {
9716 if r := recover(); r != nil {
9717 ec.Error(ctx, ec.Recover(ctx, r))
9718 ret = graphql.Null
9719 }
9720 ec.Tracer.EndFieldExecution(ctx)
9721 }()
9722 rctx := &graphql.ResolverContext{
9723 Object: "__Directive",
9724 Field: field,
9725 Args: nil,
9726 IsMethod: false,
9727 }
9728 ctx = graphql.WithResolverContext(ctx, rctx)
9729 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9730 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9731 ctx = rctx // use context from middleware stack in children
9732 return obj.Description, nil
9733 })
9734 if err != nil {
9735 ec.Error(ctx, err)
9736 return graphql.Null
9737 }
9738 if resTmp == nil {
9739 return graphql.Null
9740 }
9741 res := resTmp.(string)
9742 rctx.Result = res
9743 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9744 return ec.marshalOString2string(ctx, field.Selections, res)
9745}
9746
9747func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9748 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9749 defer func() {
9750 if r := recover(); r != nil {
9751 ec.Error(ctx, ec.Recover(ctx, r))
9752 ret = graphql.Null
9753 }
9754 ec.Tracer.EndFieldExecution(ctx)
9755 }()
9756 rctx := &graphql.ResolverContext{
9757 Object: "__Directive",
9758 Field: field,
9759 Args: nil,
9760 IsMethod: false,
9761 }
9762 ctx = graphql.WithResolverContext(ctx, rctx)
9763 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9764 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9765 ctx = rctx // use context from middleware stack in children
9766 return obj.Locations, nil
9767 })
9768 if err != nil {
9769 ec.Error(ctx, err)
9770 return graphql.Null
9771 }
9772 if resTmp == nil {
9773 if !ec.HasError(rctx) {
9774 ec.Errorf(ctx, "must not be null")
9775 }
9776 return graphql.Null
9777 }
9778 res := resTmp.([]string)
9779 rctx.Result = res
9780 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9781 return ec.marshalN__DirectiveLocation2ᚕstring(ctx, field.Selections, res)
9782}
9783
9784func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9785 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9786 defer func() {
9787 if r := recover(); r != nil {
9788 ec.Error(ctx, ec.Recover(ctx, r))
9789 ret = graphql.Null
9790 }
9791 ec.Tracer.EndFieldExecution(ctx)
9792 }()
9793 rctx := &graphql.ResolverContext{
9794 Object: "__Directive",
9795 Field: field,
9796 Args: nil,
9797 IsMethod: false,
9798 }
9799 ctx = graphql.WithResolverContext(ctx, rctx)
9800 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9801 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9802 ctx = rctx // use context from middleware stack in children
9803 return obj.Args, nil
9804 })
9805 if err != nil {
9806 ec.Error(ctx, err)
9807 return graphql.Null
9808 }
9809 if resTmp == nil {
9810 if !ec.HasError(rctx) {
9811 ec.Errorf(ctx, "must not be null")
9812 }
9813 return graphql.Null
9814 }
9815 res := resTmp.([]introspection.InputValue)
9816 rctx.Result = res
9817 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9818 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
9819}
9820
9821func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9822 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9823 defer func() {
9824 if r := recover(); r != nil {
9825 ec.Error(ctx, ec.Recover(ctx, r))
9826 ret = graphql.Null
9827 }
9828 ec.Tracer.EndFieldExecution(ctx)
9829 }()
9830 rctx := &graphql.ResolverContext{
9831 Object: "__EnumValue",
9832 Field: field,
9833 Args: nil,
9834 IsMethod: false,
9835 }
9836 ctx = graphql.WithResolverContext(ctx, rctx)
9837 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9838 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9839 ctx = rctx // use context from middleware stack in children
9840 return obj.Name, nil
9841 })
9842 if err != nil {
9843 ec.Error(ctx, err)
9844 return graphql.Null
9845 }
9846 if resTmp == nil {
9847 if !ec.HasError(rctx) {
9848 ec.Errorf(ctx, "must not be null")
9849 }
9850 return graphql.Null
9851 }
9852 res := resTmp.(string)
9853 rctx.Result = res
9854 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9855 return ec.marshalNString2string(ctx, field.Selections, res)
9856}
9857
9858func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9859 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9860 defer func() {
9861 if r := recover(); r != nil {
9862 ec.Error(ctx, ec.Recover(ctx, r))
9863 ret = graphql.Null
9864 }
9865 ec.Tracer.EndFieldExecution(ctx)
9866 }()
9867 rctx := &graphql.ResolverContext{
9868 Object: "__EnumValue",
9869 Field: field,
9870 Args: nil,
9871 IsMethod: false,
9872 }
9873 ctx = graphql.WithResolverContext(ctx, rctx)
9874 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9875 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9876 ctx = rctx // use context from middleware stack in children
9877 return obj.Description, nil
9878 })
9879 if err != nil {
9880 ec.Error(ctx, err)
9881 return graphql.Null
9882 }
9883 if resTmp == nil {
9884 return graphql.Null
9885 }
9886 res := resTmp.(string)
9887 rctx.Result = res
9888 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9889 return ec.marshalOString2string(ctx, field.Selections, res)
9890}
9891
9892func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9893 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9894 defer func() {
9895 if r := recover(); r != nil {
9896 ec.Error(ctx, ec.Recover(ctx, r))
9897 ret = graphql.Null
9898 }
9899 ec.Tracer.EndFieldExecution(ctx)
9900 }()
9901 rctx := &graphql.ResolverContext{
9902 Object: "__EnumValue",
9903 Field: field,
9904 Args: nil,
9905 IsMethod: true,
9906 }
9907 ctx = graphql.WithResolverContext(ctx, rctx)
9908 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9909 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9910 ctx = rctx // use context from middleware stack in children
9911 return obj.IsDeprecated(), nil
9912 })
9913 if err != nil {
9914 ec.Error(ctx, err)
9915 return graphql.Null
9916 }
9917 if resTmp == nil {
9918 if !ec.HasError(rctx) {
9919 ec.Errorf(ctx, "must not be null")
9920 }
9921 return graphql.Null
9922 }
9923 res := resTmp.(bool)
9924 rctx.Result = res
9925 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9926 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9927}
9928
9929func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9930 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9931 defer func() {
9932 if r := recover(); r != nil {
9933 ec.Error(ctx, ec.Recover(ctx, r))
9934 ret = graphql.Null
9935 }
9936 ec.Tracer.EndFieldExecution(ctx)
9937 }()
9938 rctx := &graphql.ResolverContext{
9939 Object: "__EnumValue",
9940 Field: field,
9941 Args: nil,
9942 IsMethod: true,
9943 }
9944 ctx = graphql.WithResolverContext(ctx, rctx)
9945 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9946 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9947 ctx = rctx // use context from middleware stack in children
9948 return obj.DeprecationReason(), nil
9949 })
9950 if err != nil {
9951 ec.Error(ctx, err)
9952 return graphql.Null
9953 }
9954 if resTmp == nil {
9955 return graphql.Null
9956 }
9957 res := resTmp.(*string)
9958 rctx.Result = res
9959 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9960 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9961}
9962
9963func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9964 ctx = ec.Tracer.StartFieldExecution(ctx, field)
9965 defer func() {
9966 if r := recover(); r != nil {
9967 ec.Error(ctx, ec.Recover(ctx, r))
9968 ret = graphql.Null
9969 }
9970 ec.Tracer.EndFieldExecution(ctx)
9971 }()
9972 rctx := &graphql.ResolverContext{
9973 Object: "__Field",
9974 Field: field,
9975 Args: nil,
9976 IsMethod: false,
9977 }
9978 ctx = graphql.WithResolverContext(ctx, rctx)
9979 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9980 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9981 ctx = rctx // use context from middleware stack in children
9982 return obj.Name, nil
9983 })
9984 if err != nil {
9985 ec.Error(ctx, err)
9986 return graphql.Null
9987 }
9988 if resTmp == nil {
9989 if !ec.HasError(rctx) {
9990 ec.Errorf(ctx, "must not be null")
9991 }
9992 return graphql.Null
9993 }
9994 res := resTmp.(string)
9995 rctx.Result = res
9996 ctx = ec.Tracer.StartFieldChildExecution(ctx)
9997 return ec.marshalNString2string(ctx, field.Selections, res)
9998}
9999
10000func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
10001 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10002 defer func() {
10003 if r := recover(); r != nil {
10004 ec.Error(ctx, ec.Recover(ctx, r))
10005 ret = graphql.Null
10006 }
10007 ec.Tracer.EndFieldExecution(ctx)
10008 }()
10009 rctx := &graphql.ResolverContext{
10010 Object: "__Field",
10011 Field: field,
10012 Args: nil,
10013 IsMethod: false,
10014 }
10015 ctx = graphql.WithResolverContext(ctx, rctx)
10016 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10017 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10018 ctx = rctx // use context from middleware stack in children
10019 return obj.Description, nil
10020 })
10021 if err != nil {
10022 ec.Error(ctx, err)
10023 return graphql.Null
10024 }
10025 if resTmp == nil {
10026 return graphql.Null
10027 }
10028 res := resTmp.(string)
10029 rctx.Result = res
10030 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10031 return ec.marshalOString2string(ctx, field.Selections, res)
10032}
10033
10034func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
10035 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10036 defer func() {
10037 if r := recover(); r != nil {
10038 ec.Error(ctx, ec.Recover(ctx, r))
10039 ret = graphql.Null
10040 }
10041 ec.Tracer.EndFieldExecution(ctx)
10042 }()
10043 rctx := &graphql.ResolverContext{
10044 Object: "__Field",
10045 Field: field,
10046 Args: nil,
10047 IsMethod: false,
10048 }
10049 ctx = graphql.WithResolverContext(ctx, rctx)
10050 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10051 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10052 ctx = rctx // use context from middleware stack in children
10053 return obj.Args, nil
10054 })
10055 if err != nil {
10056 ec.Error(ctx, err)
10057 return graphql.Null
10058 }
10059 if resTmp == nil {
10060 if !ec.HasError(rctx) {
10061 ec.Errorf(ctx, "must not be null")
10062 }
10063 return graphql.Null
10064 }
10065 res := resTmp.([]introspection.InputValue)
10066 rctx.Result = res
10067 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10068 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
10069}
10070
10071func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
10072 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10073 defer func() {
10074 if r := recover(); r != nil {
10075 ec.Error(ctx, ec.Recover(ctx, r))
10076 ret = graphql.Null
10077 }
10078 ec.Tracer.EndFieldExecution(ctx)
10079 }()
10080 rctx := &graphql.ResolverContext{
10081 Object: "__Field",
10082 Field: field,
10083 Args: nil,
10084 IsMethod: false,
10085 }
10086 ctx = graphql.WithResolverContext(ctx, rctx)
10087 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10088 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10089 ctx = rctx // use context from middleware stack in children
10090 return obj.Type, nil
10091 })
10092 if err != nil {
10093 ec.Error(ctx, err)
10094 return graphql.Null
10095 }
10096 if resTmp == nil {
10097 if !ec.HasError(rctx) {
10098 ec.Errorf(ctx, "must not be null")
10099 }
10100 return graphql.Null
10101 }
10102 res := resTmp.(*introspection.Type)
10103 rctx.Result = res
10104 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10105 return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10106}
10107
10108func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
10109 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10110 defer func() {
10111 if r := recover(); r != nil {
10112 ec.Error(ctx, ec.Recover(ctx, r))
10113 ret = graphql.Null
10114 }
10115 ec.Tracer.EndFieldExecution(ctx)
10116 }()
10117 rctx := &graphql.ResolverContext{
10118 Object: "__Field",
10119 Field: field,
10120 Args: nil,
10121 IsMethod: true,
10122 }
10123 ctx = graphql.WithResolverContext(ctx, rctx)
10124 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10125 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10126 ctx = rctx // use context from middleware stack in children
10127 return obj.IsDeprecated(), nil
10128 })
10129 if err != nil {
10130 ec.Error(ctx, err)
10131 return graphql.Null
10132 }
10133 if resTmp == nil {
10134 if !ec.HasError(rctx) {
10135 ec.Errorf(ctx, "must not be null")
10136 }
10137 return graphql.Null
10138 }
10139 res := resTmp.(bool)
10140 rctx.Result = res
10141 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10142 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
10143}
10144
10145func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
10146 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10147 defer func() {
10148 if r := recover(); r != nil {
10149 ec.Error(ctx, ec.Recover(ctx, r))
10150 ret = graphql.Null
10151 }
10152 ec.Tracer.EndFieldExecution(ctx)
10153 }()
10154 rctx := &graphql.ResolverContext{
10155 Object: "__Field",
10156 Field: field,
10157 Args: nil,
10158 IsMethod: true,
10159 }
10160 ctx = graphql.WithResolverContext(ctx, rctx)
10161 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10162 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10163 ctx = rctx // use context from middleware stack in children
10164 return obj.DeprecationReason(), nil
10165 })
10166 if err != nil {
10167 ec.Error(ctx, err)
10168 return graphql.Null
10169 }
10170 if resTmp == nil {
10171 return graphql.Null
10172 }
10173 res := resTmp.(*string)
10174 rctx.Result = res
10175 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10176 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10177}
10178
10179func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10180 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10181 defer func() {
10182 if r := recover(); r != nil {
10183 ec.Error(ctx, ec.Recover(ctx, r))
10184 ret = graphql.Null
10185 }
10186 ec.Tracer.EndFieldExecution(ctx)
10187 }()
10188 rctx := &graphql.ResolverContext{
10189 Object: "__InputValue",
10190 Field: field,
10191 Args: nil,
10192 IsMethod: false,
10193 }
10194 ctx = graphql.WithResolverContext(ctx, rctx)
10195 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10196 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10197 ctx = rctx // use context from middleware stack in children
10198 return obj.Name, nil
10199 })
10200 if err != nil {
10201 ec.Error(ctx, err)
10202 return graphql.Null
10203 }
10204 if resTmp == nil {
10205 if !ec.HasError(rctx) {
10206 ec.Errorf(ctx, "must not be null")
10207 }
10208 return graphql.Null
10209 }
10210 res := resTmp.(string)
10211 rctx.Result = res
10212 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10213 return ec.marshalNString2string(ctx, field.Selections, res)
10214}
10215
10216func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10217 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10218 defer func() {
10219 if r := recover(); r != nil {
10220 ec.Error(ctx, ec.Recover(ctx, r))
10221 ret = graphql.Null
10222 }
10223 ec.Tracer.EndFieldExecution(ctx)
10224 }()
10225 rctx := &graphql.ResolverContext{
10226 Object: "__InputValue",
10227 Field: field,
10228 Args: nil,
10229 IsMethod: false,
10230 }
10231 ctx = graphql.WithResolverContext(ctx, rctx)
10232 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10233 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10234 ctx = rctx // use context from middleware stack in children
10235 return obj.Description, nil
10236 })
10237 if err != nil {
10238 ec.Error(ctx, err)
10239 return graphql.Null
10240 }
10241 if resTmp == nil {
10242 return graphql.Null
10243 }
10244 res := resTmp.(string)
10245 rctx.Result = res
10246 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10247 return ec.marshalOString2string(ctx, field.Selections, res)
10248}
10249
10250func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10251 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10252 defer func() {
10253 if r := recover(); r != nil {
10254 ec.Error(ctx, ec.Recover(ctx, r))
10255 ret = graphql.Null
10256 }
10257 ec.Tracer.EndFieldExecution(ctx)
10258 }()
10259 rctx := &graphql.ResolverContext{
10260 Object: "__InputValue",
10261 Field: field,
10262 Args: nil,
10263 IsMethod: false,
10264 }
10265 ctx = graphql.WithResolverContext(ctx, rctx)
10266 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10267 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10268 ctx = rctx // use context from middleware stack in children
10269 return obj.Type, nil
10270 })
10271 if err != nil {
10272 ec.Error(ctx, err)
10273 return graphql.Null
10274 }
10275 if resTmp == nil {
10276 if !ec.HasError(rctx) {
10277 ec.Errorf(ctx, "must not be null")
10278 }
10279 return graphql.Null
10280 }
10281 res := resTmp.(*introspection.Type)
10282 rctx.Result = res
10283 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10284 return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10285}
10286
10287func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10288 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10289 defer func() {
10290 if r := recover(); r != nil {
10291 ec.Error(ctx, ec.Recover(ctx, r))
10292 ret = graphql.Null
10293 }
10294 ec.Tracer.EndFieldExecution(ctx)
10295 }()
10296 rctx := &graphql.ResolverContext{
10297 Object: "__InputValue",
10298 Field: field,
10299 Args: nil,
10300 IsMethod: false,
10301 }
10302 ctx = graphql.WithResolverContext(ctx, rctx)
10303 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10304 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10305 ctx = rctx // use context from middleware stack in children
10306 return obj.DefaultValue, nil
10307 })
10308 if err != nil {
10309 ec.Error(ctx, err)
10310 return graphql.Null
10311 }
10312 if resTmp == nil {
10313 return graphql.Null
10314 }
10315 res := resTmp.(*string)
10316 rctx.Result = res
10317 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10318 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10319}
10320
10321func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10322 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10323 defer func() {
10324 if r := recover(); r != nil {
10325 ec.Error(ctx, ec.Recover(ctx, r))
10326 ret = graphql.Null
10327 }
10328 ec.Tracer.EndFieldExecution(ctx)
10329 }()
10330 rctx := &graphql.ResolverContext{
10331 Object: "__Schema",
10332 Field: field,
10333 Args: nil,
10334 IsMethod: true,
10335 }
10336 ctx = graphql.WithResolverContext(ctx, rctx)
10337 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10338 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10339 ctx = rctx // use context from middleware stack in children
10340 return obj.Types(), nil
10341 })
10342 if err != nil {
10343 ec.Error(ctx, err)
10344 return graphql.Null
10345 }
10346 if resTmp == nil {
10347 if !ec.HasError(rctx) {
10348 ec.Errorf(ctx, "must not be null")
10349 }
10350 return graphql.Null
10351 }
10352 res := resTmp.([]introspection.Type)
10353 rctx.Result = res
10354 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10355 return ec.marshalN__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10356}
10357
10358func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10359 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10360 defer func() {
10361 if r := recover(); r != nil {
10362 ec.Error(ctx, ec.Recover(ctx, r))
10363 ret = graphql.Null
10364 }
10365 ec.Tracer.EndFieldExecution(ctx)
10366 }()
10367 rctx := &graphql.ResolverContext{
10368 Object: "__Schema",
10369 Field: field,
10370 Args: nil,
10371 IsMethod: true,
10372 }
10373 ctx = graphql.WithResolverContext(ctx, rctx)
10374 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10375 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10376 ctx = rctx // use context from middleware stack in children
10377 return obj.QueryType(), nil
10378 })
10379 if err != nil {
10380 ec.Error(ctx, err)
10381 return graphql.Null
10382 }
10383 if resTmp == nil {
10384 if !ec.HasError(rctx) {
10385 ec.Errorf(ctx, "must not be null")
10386 }
10387 return graphql.Null
10388 }
10389 res := resTmp.(*introspection.Type)
10390 rctx.Result = res
10391 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10392 return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10393}
10394
10395func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10396 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10397 defer func() {
10398 if r := recover(); r != nil {
10399 ec.Error(ctx, ec.Recover(ctx, r))
10400 ret = graphql.Null
10401 }
10402 ec.Tracer.EndFieldExecution(ctx)
10403 }()
10404 rctx := &graphql.ResolverContext{
10405 Object: "__Schema",
10406 Field: field,
10407 Args: nil,
10408 IsMethod: true,
10409 }
10410 ctx = graphql.WithResolverContext(ctx, rctx)
10411 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10412 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10413 ctx = rctx // use context from middleware stack in children
10414 return obj.MutationType(), nil
10415 })
10416 if err != nil {
10417 ec.Error(ctx, err)
10418 return graphql.Null
10419 }
10420 if resTmp == nil {
10421 return graphql.Null
10422 }
10423 res := resTmp.(*introspection.Type)
10424 rctx.Result = res
10425 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10426 return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10427}
10428
10429func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10430 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10431 defer func() {
10432 if r := recover(); r != nil {
10433 ec.Error(ctx, ec.Recover(ctx, r))
10434 ret = graphql.Null
10435 }
10436 ec.Tracer.EndFieldExecution(ctx)
10437 }()
10438 rctx := &graphql.ResolverContext{
10439 Object: "__Schema",
10440 Field: field,
10441 Args: nil,
10442 IsMethod: true,
10443 }
10444 ctx = graphql.WithResolverContext(ctx, rctx)
10445 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10446 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10447 ctx = rctx // use context from middleware stack in children
10448 return obj.SubscriptionType(), nil
10449 })
10450 if err != nil {
10451 ec.Error(ctx, err)
10452 return graphql.Null
10453 }
10454 if resTmp == nil {
10455 return graphql.Null
10456 }
10457 res := resTmp.(*introspection.Type)
10458 rctx.Result = res
10459 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10460 return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10461}
10462
10463func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10464 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10465 defer func() {
10466 if r := recover(); r != nil {
10467 ec.Error(ctx, ec.Recover(ctx, r))
10468 ret = graphql.Null
10469 }
10470 ec.Tracer.EndFieldExecution(ctx)
10471 }()
10472 rctx := &graphql.ResolverContext{
10473 Object: "__Schema",
10474 Field: field,
10475 Args: nil,
10476 IsMethod: true,
10477 }
10478 ctx = graphql.WithResolverContext(ctx, rctx)
10479 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10480 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10481 ctx = rctx // use context from middleware stack in children
10482 return obj.Directives(), nil
10483 })
10484 if err != nil {
10485 ec.Error(ctx, err)
10486 return graphql.Null
10487 }
10488 if resTmp == nil {
10489 if !ec.HasError(rctx) {
10490 ec.Errorf(ctx, "must not be null")
10491 }
10492 return graphql.Null
10493 }
10494 res := resTmp.([]introspection.Directive)
10495 rctx.Result = res
10496 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10497 return ec.marshalN__Directive2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, field.Selections, res)
10498}
10499
10500func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10501 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10502 defer func() {
10503 if r := recover(); r != nil {
10504 ec.Error(ctx, ec.Recover(ctx, r))
10505 ret = graphql.Null
10506 }
10507 ec.Tracer.EndFieldExecution(ctx)
10508 }()
10509 rctx := &graphql.ResolverContext{
10510 Object: "__Type",
10511 Field: field,
10512 Args: nil,
10513 IsMethod: true,
10514 }
10515 ctx = graphql.WithResolverContext(ctx, rctx)
10516 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10517 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10518 ctx = rctx // use context from middleware stack in children
10519 return obj.Kind(), nil
10520 })
10521 if err != nil {
10522 ec.Error(ctx, err)
10523 return graphql.Null
10524 }
10525 if resTmp == nil {
10526 if !ec.HasError(rctx) {
10527 ec.Errorf(ctx, "must not be null")
10528 }
10529 return graphql.Null
10530 }
10531 res := resTmp.(string)
10532 rctx.Result = res
10533 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10534 return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
10535}
10536
10537func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10538 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10539 defer func() {
10540 if r := recover(); r != nil {
10541 ec.Error(ctx, ec.Recover(ctx, r))
10542 ret = graphql.Null
10543 }
10544 ec.Tracer.EndFieldExecution(ctx)
10545 }()
10546 rctx := &graphql.ResolverContext{
10547 Object: "__Type",
10548 Field: field,
10549 Args: nil,
10550 IsMethod: true,
10551 }
10552 ctx = graphql.WithResolverContext(ctx, rctx)
10553 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10554 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10555 ctx = rctx // use context from middleware stack in children
10556 return obj.Name(), nil
10557 })
10558 if err != nil {
10559 ec.Error(ctx, err)
10560 return graphql.Null
10561 }
10562 if resTmp == nil {
10563 return graphql.Null
10564 }
10565 res := resTmp.(*string)
10566 rctx.Result = res
10567 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10568 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10569}
10570
10571func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10572 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10573 defer func() {
10574 if r := recover(); r != nil {
10575 ec.Error(ctx, ec.Recover(ctx, r))
10576 ret = graphql.Null
10577 }
10578 ec.Tracer.EndFieldExecution(ctx)
10579 }()
10580 rctx := &graphql.ResolverContext{
10581 Object: "__Type",
10582 Field: field,
10583 Args: nil,
10584 IsMethod: true,
10585 }
10586 ctx = graphql.WithResolverContext(ctx, rctx)
10587 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10588 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10589 ctx = rctx // use context from middleware stack in children
10590 return obj.Description(), nil
10591 })
10592 if err != nil {
10593 ec.Error(ctx, err)
10594 return graphql.Null
10595 }
10596 if resTmp == nil {
10597 return graphql.Null
10598 }
10599 res := resTmp.(string)
10600 rctx.Result = res
10601 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10602 return ec.marshalOString2string(ctx, field.Selections, res)
10603}
10604
10605func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10606 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10607 defer func() {
10608 if r := recover(); r != nil {
10609 ec.Error(ctx, ec.Recover(ctx, r))
10610 ret = graphql.Null
10611 }
10612 ec.Tracer.EndFieldExecution(ctx)
10613 }()
10614 rctx := &graphql.ResolverContext{
10615 Object: "__Type",
10616 Field: field,
10617 Args: nil,
10618 IsMethod: true,
10619 }
10620 ctx = graphql.WithResolverContext(ctx, rctx)
10621 rawArgs := field.ArgumentMap(ec.Variables)
10622 args, err := ec.field___Type_fields_args(ctx, rawArgs)
10623 if err != nil {
10624 ec.Error(ctx, err)
10625 return graphql.Null
10626 }
10627 rctx.Args = args
10628 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10629 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10630 ctx = rctx // use context from middleware stack in children
10631 return obj.Fields(args["includeDeprecated"].(bool)), nil
10632 })
10633 if err != nil {
10634 ec.Error(ctx, err)
10635 return graphql.Null
10636 }
10637 if resTmp == nil {
10638 return graphql.Null
10639 }
10640 res := resTmp.([]introspection.Field)
10641 rctx.Result = res
10642 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10643 return ec.marshalO__Field2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, field.Selections, res)
10644}
10645
10646func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10647 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10648 defer func() {
10649 if r := recover(); r != nil {
10650 ec.Error(ctx, ec.Recover(ctx, r))
10651 ret = graphql.Null
10652 }
10653 ec.Tracer.EndFieldExecution(ctx)
10654 }()
10655 rctx := &graphql.ResolverContext{
10656 Object: "__Type",
10657 Field: field,
10658 Args: nil,
10659 IsMethod: true,
10660 }
10661 ctx = graphql.WithResolverContext(ctx, rctx)
10662 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10663 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10664 ctx = rctx // use context from middleware stack in children
10665 return obj.Interfaces(), nil
10666 })
10667 if err != nil {
10668 ec.Error(ctx, err)
10669 return graphql.Null
10670 }
10671 if resTmp == nil {
10672 return graphql.Null
10673 }
10674 res := resTmp.([]introspection.Type)
10675 rctx.Result = res
10676 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10677 return ec.marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10678}
10679
10680func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10681 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10682 defer func() {
10683 if r := recover(); r != nil {
10684 ec.Error(ctx, ec.Recover(ctx, r))
10685 ret = graphql.Null
10686 }
10687 ec.Tracer.EndFieldExecution(ctx)
10688 }()
10689 rctx := &graphql.ResolverContext{
10690 Object: "__Type",
10691 Field: field,
10692 Args: nil,
10693 IsMethod: true,
10694 }
10695 ctx = graphql.WithResolverContext(ctx, rctx)
10696 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10697 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10698 ctx = rctx // use context from middleware stack in children
10699 return obj.PossibleTypes(), nil
10700 })
10701 if err != nil {
10702 ec.Error(ctx, err)
10703 return graphql.Null
10704 }
10705 if resTmp == nil {
10706 return graphql.Null
10707 }
10708 res := resTmp.([]introspection.Type)
10709 rctx.Result = res
10710 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10711 return ec.marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10712}
10713
10714func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10715 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10716 defer func() {
10717 if r := recover(); r != nil {
10718 ec.Error(ctx, ec.Recover(ctx, r))
10719 ret = graphql.Null
10720 }
10721 ec.Tracer.EndFieldExecution(ctx)
10722 }()
10723 rctx := &graphql.ResolverContext{
10724 Object: "__Type",
10725 Field: field,
10726 Args: nil,
10727 IsMethod: true,
10728 }
10729 ctx = graphql.WithResolverContext(ctx, rctx)
10730 rawArgs := field.ArgumentMap(ec.Variables)
10731 args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
10732 if err != nil {
10733 ec.Error(ctx, err)
10734 return graphql.Null
10735 }
10736 rctx.Args = args
10737 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10738 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10739 ctx = rctx // use context from middleware stack in children
10740 return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10741 })
10742 if err != nil {
10743 ec.Error(ctx, err)
10744 return graphql.Null
10745 }
10746 if resTmp == nil {
10747 return graphql.Null
10748 }
10749 res := resTmp.([]introspection.EnumValue)
10750 rctx.Result = res
10751 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10752 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, field.Selections, res)
10753}
10754
10755func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10756 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10757 defer func() {
10758 if r := recover(); r != nil {
10759 ec.Error(ctx, ec.Recover(ctx, r))
10760 ret = graphql.Null
10761 }
10762 ec.Tracer.EndFieldExecution(ctx)
10763 }()
10764 rctx := &graphql.ResolverContext{
10765 Object: "__Type",
10766 Field: field,
10767 Args: nil,
10768 IsMethod: true,
10769 }
10770 ctx = graphql.WithResolverContext(ctx, rctx)
10771 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10772 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10773 ctx = rctx // use context from middleware stack in children
10774 return obj.InputFields(), nil
10775 })
10776 if err != nil {
10777 ec.Error(ctx, err)
10778 return graphql.Null
10779 }
10780 if resTmp == nil {
10781 return graphql.Null
10782 }
10783 res := resTmp.([]introspection.InputValue)
10784 rctx.Result = res
10785 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10786 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
10787}
10788
10789func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10790 ctx = ec.Tracer.StartFieldExecution(ctx, field)
10791 defer func() {
10792 if r := recover(); r != nil {
10793 ec.Error(ctx, ec.Recover(ctx, r))
10794 ret = graphql.Null
10795 }
10796 ec.Tracer.EndFieldExecution(ctx)
10797 }()
10798 rctx := &graphql.ResolverContext{
10799 Object: "__Type",
10800 Field: field,
10801 Args: nil,
10802 IsMethod: true,
10803 }
10804 ctx = graphql.WithResolverContext(ctx, rctx)
10805 ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10806 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10807 ctx = rctx // use context from middleware stack in children
10808 return obj.OfType(), nil
10809 })
10810 if err != nil {
10811 ec.Error(ctx, err)
10812 return graphql.Null
10813 }
10814 if resTmp == nil {
10815 return graphql.Null
10816 }
10817 res := resTmp.(*introspection.Type)
10818 rctx.Result = res
10819 ctx = ec.Tracer.StartFieldChildExecution(ctx)
10820 return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10821}
10822
10823// endregion **************************** field.gotpl *****************************
10824
10825// region **************************** input.gotpl *****************************
10826
10827func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
10828 var it models.AddCommentInput
10829 var asMap = obj.(map[string]interface{})
10830
10831 for k, v := range asMap {
10832 switch k {
10833 case "clientMutationId":
10834 var err error
10835 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10836 if err != nil {
10837 return it, err
10838 }
10839 case "repoRef":
10840 var err error
10841 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10842 if err != nil {
10843 return it, err
10844 }
10845 case "prefix":
10846 var err error
10847 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10848 if err != nil {
10849 return it, err
10850 }
10851 case "message":
10852 var err error
10853 it.Message, err = ec.unmarshalNString2string(ctx, v)
10854 if err != nil {
10855 return it, err
10856 }
10857 case "files":
10858 var err error
10859 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, v)
10860 if err != nil {
10861 return it, err
10862 }
10863 }
10864 }
10865
10866 return it, nil
10867}
10868
10869func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
10870 var it models.ChangeLabelInput
10871 var asMap = obj.(map[string]interface{})
10872
10873 for k, v := range asMap {
10874 switch k {
10875 case "clientMutationId":
10876 var err error
10877 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10878 if err != nil {
10879 return it, err
10880 }
10881 case "repoRef":
10882 var err error
10883 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10884 if err != nil {
10885 return it, err
10886 }
10887 case "prefix":
10888 var err error
10889 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10890 if err != nil {
10891 return it, err
10892 }
10893 case "added":
10894 var err error
10895 it.Added, err = ec.unmarshalOString2ᚕstring(ctx, v)
10896 if err != nil {
10897 return it, err
10898 }
10899 case "Removed":
10900 var err error
10901 it.Removed, err = ec.unmarshalOString2ᚕstring(ctx, v)
10902 if err != nil {
10903 return it, err
10904 }
10905 }
10906 }
10907
10908 return it, nil
10909}
10910
10911func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
10912 var it models.CloseBugInput
10913 var asMap = obj.(map[string]interface{})
10914
10915 for k, v := range asMap {
10916 switch k {
10917 case "clientMutationId":
10918 var err error
10919 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10920 if err != nil {
10921 return it, err
10922 }
10923 case "repoRef":
10924 var err error
10925 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10926 if err != nil {
10927 return it, err
10928 }
10929 case "prefix":
10930 var err error
10931 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10932 if err != nil {
10933 return it, err
10934 }
10935 }
10936 }
10937
10938 return it, nil
10939}
10940
10941func (ec *executionContext) unmarshalInputCommitAsNeededInput(ctx context.Context, obj interface{}) (models.CommitAsNeededInput, error) {
10942 var it models.CommitAsNeededInput
10943 var asMap = obj.(map[string]interface{})
10944
10945 for k, v := range asMap {
10946 switch k {
10947 case "clientMutationId":
10948 var err error
10949 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10950 if err != nil {
10951 return it, err
10952 }
10953 case "repoRef":
10954 var err error
10955 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10956 if err != nil {
10957 return it, err
10958 }
10959 case "prefix":
10960 var err error
10961 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10962 if err != nil {
10963 return it, err
10964 }
10965 }
10966 }
10967
10968 return it, nil
10969}
10970
10971func (ec *executionContext) unmarshalInputCommitInput(ctx context.Context, obj interface{}) (models.CommitInput, error) {
10972 var it models.CommitInput
10973 var asMap = obj.(map[string]interface{})
10974
10975 for k, v := range asMap {
10976 switch k {
10977 case "clientMutationId":
10978 var err error
10979 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10980 if err != nil {
10981 return it, err
10982 }
10983 case "repoRef":
10984 var err error
10985 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10986 if err != nil {
10987 return it, err
10988 }
10989 case "prefix":
10990 var err error
10991 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10992 if err != nil {
10993 return it, err
10994 }
10995 }
10996 }
10997
10998 return it, nil
10999}
11000
11001func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
11002 var it models.NewBugInput
11003 var asMap = obj.(map[string]interface{})
11004
11005 for k, v := range asMap {
11006 switch k {
11007 case "clientMutationId":
11008 var err error
11009 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
11010 if err != nil {
11011 return it, err
11012 }
11013 case "repoRef":
11014 var err error
11015 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
11016 if err != nil {
11017 return it, err
11018 }
11019 case "title":
11020 var err error
11021 it.Title, err = ec.unmarshalNString2string(ctx, v)
11022 if err != nil {
11023 return it, err
11024 }
11025 case "message":
11026 var err error
11027 it.Message, err = ec.unmarshalNString2string(ctx, v)
11028 if err != nil {
11029 return it, err
11030 }
11031 case "files":
11032 var err error
11033 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, v)
11034 if err != nil {
11035 return it, err
11036 }
11037 }
11038 }
11039
11040 return it, nil
11041}
11042
11043func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
11044 var it models.OpenBugInput
11045 var asMap = obj.(map[string]interface{})
11046
11047 for k, v := range asMap {
11048 switch k {
11049 case "clientMutationId":
11050 var err error
11051 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
11052 if err != nil {
11053 return it, err
11054 }
11055 case "repoRef":
11056 var err error
11057 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
11058 if err != nil {
11059 return it, err
11060 }
11061 case "prefix":
11062 var err error
11063 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
11064 if err != nil {
11065 return it, err
11066 }
11067 }
11068 }
11069
11070 return it, nil
11071}
11072
11073func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
11074 var it models.SetTitleInput
11075 var asMap = obj.(map[string]interface{})
11076
11077 for k, v := range asMap {
11078 switch k {
11079 case "clientMutationId":
11080 var err error
11081 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
11082 if err != nil {
11083 return it, err
11084 }
11085 case "repoRef":
11086 var err error
11087 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
11088 if err != nil {
11089 return it, err
11090 }
11091 case "prefix":
11092 var err error
11093 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
11094 if err != nil {
11095 return it, err
11096 }
11097 case "title":
11098 var err error
11099 it.Title, err = ec.unmarshalNString2string(ctx, v)
11100 if err != nil {
11101 return it, err
11102 }
11103 }
11104 }
11105
11106 return it, nil
11107}
11108
11109// endregion **************************** input.gotpl *****************************
11110
11111// region ************************** interface.gotpl ***************************
11112
11113func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj *models.Authored) graphql.Marshaler {
11114 switch obj := (*obj).(type) {
11115 case nil:
11116 return graphql.Null
11117 case bug.Comment:
11118 return ec._Comment(ctx, sel, &obj)
11119 case *bug.Comment:
11120 return ec._Comment(ctx, sel, obj)
11121 case *bug.Snapshot:
11122 return ec._Bug(ctx, sel, obj)
11123 case *bug.CreateOperation:
11124 return ec._CreateOperation(ctx, sel, obj)
11125 case *bug.SetTitleOperation:
11126 return ec._SetTitleOperation(ctx, sel, obj)
11127 case *bug.AddCommentOperation:
11128 return ec._AddCommentOperation(ctx, sel, obj)
11129 case *bug.EditCommentOperation:
11130 return ec._EditCommentOperation(ctx, sel, obj)
11131 case *bug.SetStatusOperation:
11132 return ec._SetStatusOperation(ctx, sel, obj)
11133 case *bug.LabelChangeOperation:
11134 return ec._LabelChangeOperation(ctx, sel, obj)
11135 case *bug.CreateTimelineItem:
11136 return ec._CreateTimelineItem(ctx, sel, obj)
11137 case *bug.AddCommentTimelineItem:
11138 return ec._AddCommentTimelineItem(ctx, sel, obj)
11139 case *bug.LabelChangeTimelineItem:
11140 return ec._LabelChangeTimelineItem(ctx, sel, obj)
11141 case *bug.SetStatusTimelineItem:
11142 return ec._SetStatusTimelineItem(ctx, sel, obj)
11143 case *bug.SetTitleTimelineItem:
11144 return ec._SetTitleTimelineItem(ctx, sel, obj)
11145 default:
11146 panic(fmt.Errorf("unexpected type %T", obj))
11147 }
11148}
11149
11150func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj *bug.Operation) graphql.Marshaler {
11151 switch obj := (*obj).(type) {
11152 case nil:
11153 return graphql.Null
11154 case *bug.CreateOperation:
11155 return ec._CreateOperation(ctx, sel, obj)
11156 case *bug.SetTitleOperation:
11157 return ec._SetTitleOperation(ctx, sel, obj)
11158 case *bug.AddCommentOperation:
11159 return ec._AddCommentOperation(ctx, sel, obj)
11160 case *bug.EditCommentOperation:
11161 return ec._EditCommentOperation(ctx, sel, obj)
11162 case *bug.SetStatusOperation:
11163 return ec._SetStatusOperation(ctx, sel, obj)
11164 case *bug.LabelChangeOperation:
11165 return ec._LabelChangeOperation(ctx, sel, obj)
11166 default:
11167 panic(fmt.Errorf("unexpected type %T", obj))
11168 }
11169}
11170
11171func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.TimelineItem) graphql.Marshaler {
11172 switch obj := (*obj).(type) {
11173 case nil:
11174 return graphql.Null
11175 case *bug.CreateTimelineItem:
11176 return ec._CreateTimelineItem(ctx, sel, obj)
11177 case *bug.AddCommentTimelineItem:
11178 return ec._AddCommentTimelineItem(ctx, sel, obj)
11179 case bug.LabelChangeTimelineItem:
11180 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
11181 case *bug.LabelChangeTimelineItem:
11182 return ec._LabelChangeTimelineItem(ctx, sel, obj)
11183 case bug.SetStatusTimelineItem:
11184 return ec._SetStatusTimelineItem(ctx, sel, &obj)
11185 case *bug.SetStatusTimelineItem:
11186 return ec._SetStatusTimelineItem(ctx, sel, obj)
11187 case bug.SetTitleTimelineItem:
11188 return ec._SetTitleTimelineItem(ctx, sel, &obj)
11189 case *bug.SetTitleTimelineItem:
11190 return ec._SetTitleTimelineItem(ctx, sel, obj)
11191 default:
11192 panic(fmt.Errorf("unexpected type %T", obj))
11193 }
11194}
11195
11196// endregion ************************** interface.gotpl ***************************
11197
11198// region **************************** object.gotpl ****************************
11199
11200var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
11201
11202func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
11203 fields := graphql.CollectFields(ec.RequestContext, sel, addCommentOperationImplementors)
11204
11205 out := graphql.NewFieldSet(fields)
11206 var invalids uint32
11207 for i, field := range fields {
11208 switch field.Name {
11209 case "__typename":
11210 out.Values[i] = graphql.MarshalString("AddCommentOperation")
11211 case "id":
11212 field := field
11213 out.Concurrently(i, func() (res graphql.Marshaler) {
11214 defer func() {
11215 if r := recover(); r != nil {
11216 ec.Error(ctx, ec.Recover(ctx, r))
11217 }
11218 }()
11219 res = ec._AddCommentOperation_id(ctx, field, obj)
11220 if res == graphql.Null {
11221 atomic.AddUint32(&invalids, 1)
11222 }
11223 return res
11224 })
11225 case "author":
11226 out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
11227 if out.Values[i] == graphql.Null {
11228 atomic.AddUint32(&invalids, 1)
11229 }
11230 case "date":
11231 field := field
11232 out.Concurrently(i, func() (res graphql.Marshaler) {
11233 defer func() {
11234 if r := recover(); r != nil {
11235 ec.Error(ctx, ec.Recover(ctx, r))
11236 }
11237 }()
11238 res = ec._AddCommentOperation_date(ctx, field, obj)
11239 if res == graphql.Null {
11240 atomic.AddUint32(&invalids, 1)
11241 }
11242 return res
11243 })
11244 case "message":
11245 out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
11246 if out.Values[i] == graphql.Null {
11247 atomic.AddUint32(&invalids, 1)
11248 }
11249 case "files":
11250 out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
11251 if out.Values[i] == graphql.Null {
11252 atomic.AddUint32(&invalids, 1)
11253 }
11254 default:
11255 panic("unknown field " + strconv.Quote(field.Name))
11256 }
11257 }
11258 out.Dispatch()
11259 if invalids > 0 {
11260 return graphql.Null
11261 }
11262 return out
11263}
11264
11265var addCommentPayloadImplementors = []string{"AddCommentPayload"}
11266
11267func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
11268 fields := graphql.CollectFields(ec.RequestContext, sel, addCommentPayloadImplementors)
11269
11270 out := graphql.NewFieldSet(fields)
11271 var invalids uint32
11272 for i, field := range fields {
11273 switch field.Name {
11274 case "__typename":
11275 out.Values[i] = graphql.MarshalString("AddCommentPayload")
11276 case "clientMutationId":
11277 out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
11278 case "bug":
11279 out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
11280 if out.Values[i] == graphql.Null {
11281 invalids++
11282 }
11283 case "operation":
11284 out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
11285 if out.Values[i] == graphql.Null {
11286 invalids++
11287 }
11288 default:
11289 panic("unknown field " + strconv.Quote(field.Name))
11290 }
11291 }
11292 out.Dispatch()
11293 if invalids > 0 {
11294 return graphql.Null
11295 }
11296 return out
11297}
11298
11299var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
11300
11301func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
11302 fields := graphql.CollectFields(ec.RequestContext, sel, addCommentTimelineItemImplementors)
11303
11304 out := graphql.NewFieldSet(fields)
11305 var invalids uint32
11306 for i, field := range fields {
11307 switch field.Name {
11308 case "__typename":
11309 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
11310 case "id":
11311 field := field
11312 out.Concurrently(i, func() (res graphql.Marshaler) {
11313 defer func() {
11314 if r := recover(); r != nil {
11315 ec.Error(ctx, ec.Recover(ctx, r))
11316 }
11317 }()
11318 res = ec._AddCommentTimelineItem_id(ctx, field, obj)
11319 if res == graphql.Null {
11320 atomic.AddUint32(&invalids, 1)
11321 }
11322 return res
11323 })
11324 case "author":
11325 out.Values[i] = ec._AddCommentTimelineItem_author(ctx, field, obj)
11326 if out.Values[i] == graphql.Null {
11327 atomic.AddUint32(&invalids, 1)
11328 }
11329 case "message":
11330 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
11331 if out.Values[i] == graphql.Null {
11332 atomic.AddUint32(&invalids, 1)
11333 }
11334 case "messageIsEmpty":
11335 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
11336 if out.Values[i] == graphql.Null {
11337 atomic.AddUint32(&invalids, 1)
11338 }
11339 case "files":
11340 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
11341 if out.Values[i] == graphql.Null {
11342 atomic.AddUint32(&invalids, 1)
11343 }
11344 case "createdAt":
11345 field := field
11346 out.Concurrently(i, func() (res graphql.Marshaler) {
11347 defer func() {
11348 if r := recover(); r != nil {
11349 ec.Error(ctx, ec.Recover(ctx, r))
11350 }
11351 }()
11352 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
11353 if res == graphql.Null {
11354 atomic.AddUint32(&invalids, 1)
11355 }
11356 return res
11357 })
11358 case "lastEdit":
11359 field := field
11360 out.Concurrently(i, func() (res graphql.Marshaler) {
11361 defer func() {
11362 if r := recover(); r != nil {
11363 ec.Error(ctx, ec.Recover(ctx, r))
11364 }
11365 }()
11366 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
11367 if res == graphql.Null {
11368 atomic.AddUint32(&invalids, 1)
11369 }
11370 return res
11371 })
11372 case "edited":
11373 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
11374 if out.Values[i] == graphql.Null {
11375 atomic.AddUint32(&invalids, 1)
11376 }
11377 case "history":
11378 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
11379 if out.Values[i] == graphql.Null {
11380 atomic.AddUint32(&invalids, 1)
11381 }
11382 default:
11383 panic("unknown field " + strconv.Quote(field.Name))
11384 }
11385 }
11386 out.Dispatch()
11387 if invalids > 0 {
11388 return graphql.Null
11389 }
11390 return out
11391}
11392
11393var bugImplementors = []string{"Bug", "Authored"}
11394
11395func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
11396 fields := graphql.CollectFields(ec.RequestContext, sel, bugImplementors)
11397
11398 out := graphql.NewFieldSet(fields)
11399 var invalids uint32
11400 for i, field := range fields {
11401 switch field.Name {
11402 case "__typename":
11403 out.Values[i] = graphql.MarshalString("Bug")
11404 case "id":
11405 field := field
11406 out.Concurrently(i, func() (res graphql.Marshaler) {
11407 defer func() {
11408 if r := recover(); r != nil {
11409 ec.Error(ctx, ec.Recover(ctx, r))
11410 }
11411 }()
11412 res = ec._Bug_id(ctx, field, obj)
11413 if res == graphql.Null {
11414 atomic.AddUint32(&invalids, 1)
11415 }
11416 return res
11417 })
11418 case "humanId":
11419 field := field
11420 out.Concurrently(i, func() (res graphql.Marshaler) {
11421 defer func() {
11422 if r := recover(); r != nil {
11423 ec.Error(ctx, ec.Recover(ctx, r))
11424 }
11425 }()
11426 res = ec._Bug_humanId(ctx, field, obj)
11427 if res == graphql.Null {
11428 atomic.AddUint32(&invalids, 1)
11429 }
11430 return res
11431 })
11432 case "status":
11433 field := field
11434 out.Concurrently(i, func() (res graphql.Marshaler) {
11435 defer func() {
11436 if r := recover(); r != nil {
11437 ec.Error(ctx, ec.Recover(ctx, r))
11438 }
11439 }()
11440 res = ec._Bug_status(ctx, field, obj)
11441 if res == graphql.Null {
11442 atomic.AddUint32(&invalids, 1)
11443 }
11444 return res
11445 })
11446 case "title":
11447 out.Values[i] = ec._Bug_title(ctx, field, obj)
11448 if out.Values[i] == graphql.Null {
11449 atomic.AddUint32(&invalids, 1)
11450 }
11451 case "labels":
11452 out.Values[i] = ec._Bug_labels(ctx, field, obj)
11453 if out.Values[i] == graphql.Null {
11454 atomic.AddUint32(&invalids, 1)
11455 }
11456 case "author":
11457 out.Values[i] = ec._Bug_author(ctx, field, obj)
11458 if out.Values[i] == graphql.Null {
11459 atomic.AddUint32(&invalids, 1)
11460 }
11461 case "createdAt":
11462 out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
11463 if out.Values[i] == graphql.Null {
11464 atomic.AddUint32(&invalids, 1)
11465 }
11466 case "lastEdit":
11467 field := field
11468 out.Concurrently(i, func() (res graphql.Marshaler) {
11469 defer func() {
11470 if r := recover(); r != nil {
11471 ec.Error(ctx, ec.Recover(ctx, r))
11472 }
11473 }()
11474 res = ec._Bug_lastEdit(ctx, field, obj)
11475 if res == graphql.Null {
11476 atomic.AddUint32(&invalids, 1)
11477 }
11478 return res
11479 })
11480 case "actors":
11481 field := field
11482 out.Concurrently(i, func() (res graphql.Marshaler) {
11483 defer func() {
11484 if r := recover(); r != nil {
11485 ec.Error(ctx, ec.Recover(ctx, r))
11486 }
11487 }()
11488 res = ec._Bug_actors(ctx, field, obj)
11489 if res == graphql.Null {
11490 atomic.AddUint32(&invalids, 1)
11491 }
11492 return res
11493 })
11494 case "participants":
11495 field := field
11496 out.Concurrently(i, func() (res graphql.Marshaler) {
11497 defer func() {
11498 if r := recover(); r != nil {
11499 ec.Error(ctx, ec.Recover(ctx, r))
11500 }
11501 }()
11502 res = ec._Bug_participants(ctx, field, obj)
11503 if res == graphql.Null {
11504 atomic.AddUint32(&invalids, 1)
11505 }
11506 return res
11507 })
11508 case "comments":
11509 field := field
11510 out.Concurrently(i, func() (res graphql.Marshaler) {
11511 defer func() {
11512 if r := recover(); r != nil {
11513 ec.Error(ctx, ec.Recover(ctx, r))
11514 }
11515 }()
11516 res = ec._Bug_comments(ctx, field, obj)
11517 if res == graphql.Null {
11518 atomic.AddUint32(&invalids, 1)
11519 }
11520 return res
11521 })
11522 case "timeline":
11523 field := field
11524 out.Concurrently(i, func() (res graphql.Marshaler) {
11525 defer func() {
11526 if r := recover(); r != nil {
11527 ec.Error(ctx, ec.Recover(ctx, r))
11528 }
11529 }()
11530 res = ec._Bug_timeline(ctx, field, obj)
11531 if res == graphql.Null {
11532 atomic.AddUint32(&invalids, 1)
11533 }
11534 return res
11535 })
11536 case "operations":
11537 field := field
11538 out.Concurrently(i, func() (res graphql.Marshaler) {
11539 defer func() {
11540 if r := recover(); r != nil {
11541 ec.Error(ctx, ec.Recover(ctx, r))
11542 }
11543 }()
11544 res = ec._Bug_operations(ctx, field, obj)
11545 if res == graphql.Null {
11546 atomic.AddUint32(&invalids, 1)
11547 }
11548 return res
11549 })
11550 default:
11551 panic("unknown field " + strconv.Quote(field.Name))
11552 }
11553 }
11554 out.Dispatch()
11555 if invalids > 0 {
11556 return graphql.Null
11557 }
11558 return out
11559}
11560
11561var bugConnectionImplementors = []string{"BugConnection"}
11562
11563func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
11564 fields := graphql.CollectFields(ec.RequestContext, sel, bugConnectionImplementors)
11565
11566 out := graphql.NewFieldSet(fields)
11567 var invalids uint32
11568 for i, field := range fields {
11569 switch field.Name {
11570 case "__typename":
11571 out.Values[i] = graphql.MarshalString("BugConnection")
11572 case "edges":
11573 out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
11574 if out.Values[i] == graphql.Null {
11575 invalids++
11576 }
11577 case "nodes":
11578 out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
11579 if out.Values[i] == graphql.Null {
11580 invalids++
11581 }
11582 case "pageInfo":
11583 out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
11584 if out.Values[i] == graphql.Null {
11585 invalids++
11586 }
11587 case "totalCount":
11588 out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
11589 if out.Values[i] == graphql.Null {
11590 invalids++
11591 }
11592 default:
11593 panic("unknown field " + strconv.Quote(field.Name))
11594 }
11595 }
11596 out.Dispatch()
11597 if invalids > 0 {
11598 return graphql.Null
11599 }
11600 return out
11601}
11602
11603var bugEdgeImplementors = []string{"BugEdge"}
11604
11605func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
11606 fields := graphql.CollectFields(ec.RequestContext, sel, bugEdgeImplementors)
11607
11608 out := graphql.NewFieldSet(fields)
11609 var invalids uint32
11610 for i, field := range fields {
11611 switch field.Name {
11612 case "__typename":
11613 out.Values[i] = graphql.MarshalString("BugEdge")
11614 case "cursor":
11615 out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
11616 if out.Values[i] == graphql.Null {
11617 invalids++
11618 }
11619 case "node":
11620 out.Values[i] = ec._BugEdge_node(ctx, field, obj)
11621 if out.Values[i] == graphql.Null {
11622 invalids++
11623 }
11624 default:
11625 panic("unknown field " + strconv.Quote(field.Name))
11626 }
11627 }
11628 out.Dispatch()
11629 if invalids > 0 {
11630 return graphql.Null
11631 }
11632 return out
11633}
11634
11635var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
11636
11637func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
11638 fields := graphql.CollectFields(ec.RequestContext, sel, changeLabelPayloadImplementors)
11639
11640 out := graphql.NewFieldSet(fields)
11641 var invalids uint32
11642 for i, field := range fields {
11643 switch field.Name {
11644 case "__typename":
11645 out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
11646 case "clientMutationId":
11647 out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
11648 case "bug":
11649 out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
11650 if out.Values[i] == graphql.Null {
11651 invalids++
11652 }
11653 case "operation":
11654 out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
11655 if out.Values[i] == graphql.Null {
11656 invalids++
11657 }
11658 case "results":
11659 out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
11660 if out.Values[i] == graphql.Null {
11661 invalids++
11662 }
11663 default:
11664 panic("unknown field " + strconv.Quote(field.Name))
11665 }
11666 }
11667 out.Dispatch()
11668 if invalids > 0 {
11669 return graphql.Null
11670 }
11671 return out
11672}
11673
11674var closeBugPayloadImplementors = []string{"CloseBugPayload"}
11675
11676func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11677 fields := graphql.CollectFields(ec.RequestContext, sel, closeBugPayloadImplementors)
11678
11679 out := graphql.NewFieldSet(fields)
11680 var invalids uint32
11681 for i, field := range fields {
11682 switch field.Name {
11683 case "__typename":
11684 out.Values[i] = graphql.MarshalString("CloseBugPayload")
11685 case "clientMutationId":
11686 out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11687 case "bug":
11688 out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11689 if out.Values[i] == graphql.Null {
11690 invalids++
11691 }
11692 case "operation":
11693 out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11694 if out.Values[i] == graphql.Null {
11695 invalids++
11696 }
11697 default:
11698 panic("unknown field " + strconv.Quote(field.Name))
11699 }
11700 }
11701 out.Dispatch()
11702 if invalids > 0 {
11703 return graphql.Null
11704 }
11705 return out
11706}
11707
11708var colorImplementors = []string{"Color"}
11709
11710func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11711 fields := graphql.CollectFields(ec.RequestContext, sel, colorImplementors)
11712
11713 out := graphql.NewFieldSet(fields)
11714 var invalids uint32
11715 for i, field := range fields {
11716 switch field.Name {
11717 case "__typename":
11718 out.Values[i] = graphql.MarshalString("Color")
11719 case "R":
11720 field := field
11721 out.Concurrently(i, func() (res graphql.Marshaler) {
11722 defer func() {
11723 if r := recover(); r != nil {
11724 ec.Error(ctx, ec.Recover(ctx, r))
11725 }
11726 }()
11727 res = ec._Color_R(ctx, field, obj)
11728 if res == graphql.Null {
11729 atomic.AddUint32(&invalids, 1)
11730 }
11731 return res
11732 })
11733 case "G":
11734 field := field
11735 out.Concurrently(i, func() (res graphql.Marshaler) {
11736 defer func() {
11737 if r := recover(); r != nil {
11738 ec.Error(ctx, ec.Recover(ctx, r))
11739 }
11740 }()
11741 res = ec._Color_G(ctx, field, obj)
11742 if res == graphql.Null {
11743 atomic.AddUint32(&invalids, 1)
11744 }
11745 return res
11746 })
11747 case "B":
11748 field := field
11749 out.Concurrently(i, func() (res graphql.Marshaler) {
11750 defer func() {
11751 if r := recover(); r != nil {
11752 ec.Error(ctx, ec.Recover(ctx, r))
11753 }
11754 }()
11755 res = ec._Color_B(ctx, field, obj)
11756 if res == graphql.Null {
11757 atomic.AddUint32(&invalids, 1)
11758 }
11759 return res
11760 })
11761 default:
11762 panic("unknown field " + strconv.Quote(field.Name))
11763 }
11764 }
11765 out.Dispatch()
11766 if invalids > 0 {
11767 return graphql.Null
11768 }
11769 return out
11770}
11771
11772var commentImplementors = []string{"Comment", "Authored"}
11773
11774func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11775 fields := graphql.CollectFields(ec.RequestContext, sel, commentImplementors)
11776
11777 out := graphql.NewFieldSet(fields)
11778 var invalids uint32
11779 for i, field := range fields {
11780 switch field.Name {
11781 case "__typename":
11782 out.Values[i] = graphql.MarshalString("Comment")
11783 case "author":
11784 out.Values[i] = ec._Comment_author(ctx, field, obj)
11785 if out.Values[i] == graphql.Null {
11786 invalids++
11787 }
11788 case "message":
11789 out.Values[i] = ec._Comment_message(ctx, field, obj)
11790 if out.Values[i] == graphql.Null {
11791 invalids++
11792 }
11793 case "files":
11794 out.Values[i] = ec._Comment_files(ctx, field, obj)
11795 if out.Values[i] == graphql.Null {
11796 invalids++
11797 }
11798 default:
11799 panic("unknown field " + strconv.Quote(field.Name))
11800 }
11801 }
11802 out.Dispatch()
11803 if invalids > 0 {
11804 return graphql.Null
11805 }
11806 return out
11807}
11808
11809var commentConnectionImplementors = []string{"CommentConnection"}
11810
11811func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11812 fields := graphql.CollectFields(ec.RequestContext, sel, commentConnectionImplementors)
11813
11814 out := graphql.NewFieldSet(fields)
11815 var invalids uint32
11816 for i, field := range fields {
11817 switch field.Name {
11818 case "__typename":
11819 out.Values[i] = graphql.MarshalString("CommentConnection")
11820 case "edges":
11821 out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11822 if out.Values[i] == graphql.Null {
11823 invalids++
11824 }
11825 case "nodes":
11826 out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11827 if out.Values[i] == graphql.Null {
11828 invalids++
11829 }
11830 case "pageInfo":
11831 out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11832 if out.Values[i] == graphql.Null {
11833 invalids++
11834 }
11835 case "totalCount":
11836 out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11837 if out.Values[i] == graphql.Null {
11838 invalids++
11839 }
11840 default:
11841 panic("unknown field " + strconv.Quote(field.Name))
11842 }
11843 }
11844 out.Dispatch()
11845 if invalids > 0 {
11846 return graphql.Null
11847 }
11848 return out
11849}
11850
11851var commentEdgeImplementors = []string{"CommentEdge"}
11852
11853func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11854 fields := graphql.CollectFields(ec.RequestContext, sel, commentEdgeImplementors)
11855
11856 out := graphql.NewFieldSet(fields)
11857 var invalids uint32
11858 for i, field := range fields {
11859 switch field.Name {
11860 case "__typename":
11861 out.Values[i] = graphql.MarshalString("CommentEdge")
11862 case "cursor":
11863 out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11864 if out.Values[i] == graphql.Null {
11865 invalids++
11866 }
11867 case "node":
11868 out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11869 if out.Values[i] == graphql.Null {
11870 invalids++
11871 }
11872 default:
11873 panic("unknown field " + strconv.Quote(field.Name))
11874 }
11875 }
11876 out.Dispatch()
11877 if invalids > 0 {
11878 return graphql.Null
11879 }
11880 return out
11881}
11882
11883var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11884
11885func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11886 fields := graphql.CollectFields(ec.RequestContext, sel, commentHistoryStepImplementors)
11887
11888 out := graphql.NewFieldSet(fields)
11889 var invalids uint32
11890 for i, field := range fields {
11891 switch field.Name {
11892 case "__typename":
11893 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11894 case "message":
11895 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11896 if out.Values[i] == graphql.Null {
11897 atomic.AddUint32(&invalids, 1)
11898 }
11899 case "date":
11900 field := field
11901 out.Concurrently(i, func() (res graphql.Marshaler) {
11902 defer func() {
11903 if r := recover(); r != nil {
11904 ec.Error(ctx, ec.Recover(ctx, r))
11905 }
11906 }()
11907 res = ec._CommentHistoryStep_date(ctx, field, obj)
11908 if res == graphql.Null {
11909 atomic.AddUint32(&invalids, 1)
11910 }
11911 return res
11912 })
11913 default:
11914 panic("unknown field " + strconv.Quote(field.Name))
11915 }
11916 }
11917 out.Dispatch()
11918 if invalids > 0 {
11919 return graphql.Null
11920 }
11921 return out
11922}
11923
11924var commitAsNeededPayloadImplementors = []string{"CommitAsNeededPayload"}
11925
11926func (ec *executionContext) _CommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitAsNeededPayload) graphql.Marshaler {
11927 fields := graphql.CollectFields(ec.RequestContext, sel, commitAsNeededPayloadImplementors)
11928
11929 out := graphql.NewFieldSet(fields)
11930 var invalids uint32
11931 for i, field := range fields {
11932 switch field.Name {
11933 case "__typename":
11934 out.Values[i] = graphql.MarshalString("CommitAsNeededPayload")
11935 case "clientMutationId":
11936 out.Values[i] = ec._CommitAsNeededPayload_clientMutationId(ctx, field, obj)
11937 case "bug":
11938 out.Values[i] = ec._CommitAsNeededPayload_bug(ctx, field, obj)
11939 if out.Values[i] == graphql.Null {
11940 invalids++
11941 }
11942 default:
11943 panic("unknown field " + strconv.Quote(field.Name))
11944 }
11945 }
11946 out.Dispatch()
11947 if invalids > 0 {
11948 return graphql.Null
11949 }
11950 return out
11951}
11952
11953var commitPayloadImplementors = []string{"CommitPayload"}
11954
11955func (ec *executionContext) _CommitPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitPayload) graphql.Marshaler {
11956 fields := graphql.CollectFields(ec.RequestContext, sel, commitPayloadImplementors)
11957
11958 out := graphql.NewFieldSet(fields)
11959 var invalids uint32
11960 for i, field := range fields {
11961 switch field.Name {
11962 case "__typename":
11963 out.Values[i] = graphql.MarshalString("CommitPayload")
11964 case "clientMutationId":
11965 out.Values[i] = ec._CommitPayload_clientMutationId(ctx, field, obj)
11966 case "bug":
11967 out.Values[i] = ec._CommitPayload_bug(ctx, field, obj)
11968 if out.Values[i] == graphql.Null {
11969 invalids++
11970 }
11971 default:
11972 panic("unknown field " + strconv.Quote(field.Name))
11973 }
11974 }
11975 out.Dispatch()
11976 if invalids > 0 {
11977 return graphql.Null
11978 }
11979 return out
11980}
11981
11982var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11983
11984func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11985 fields := graphql.CollectFields(ec.RequestContext, sel, createOperationImplementors)
11986
11987 out := graphql.NewFieldSet(fields)
11988 var invalids uint32
11989 for i, field := range fields {
11990 switch field.Name {
11991 case "__typename":
11992 out.Values[i] = graphql.MarshalString("CreateOperation")
11993 case "id":
11994 field := field
11995 out.Concurrently(i, func() (res graphql.Marshaler) {
11996 defer func() {
11997 if r := recover(); r != nil {
11998 ec.Error(ctx, ec.Recover(ctx, r))
11999 }
12000 }()
12001 res = ec._CreateOperation_id(ctx, field, obj)
12002 if res == graphql.Null {
12003 atomic.AddUint32(&invalids, 1)
12004 }
12005 return res
12006 })
12007 case "author":
12008 out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
12009 if out.Values[i] == graphql.Null {
12010 atomic.AddUint32(&invalids, 1)
12011 }
12012 case "date":
12013 field := field
12014 out.Concurrently(i, func() (res graphql.Marshaler) {
12015 defer func() {
12016 if r := recover(); r != nil {
12017 ec.Error(ctx, ec.Recover(ctx, r))
12018 }
12019 }()
12020 res = ec._CreateOperation_date(ctx, field, obj)
12021 if res == graphql.Null {
12022 atomic.AddUint32(&invalids, 1)
12023 }
12024 return res
12025 })
12026 case "title":
12027 out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
12028 if out.Values[i] == graphql.Null {
12029 atomic.AddUint32(&invalids, 1)
12030 }
12031 case "message":
12032 out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
12033 if out.Values[i] == graphql.Null {
12034 atomic.AddUint32(&invalids, 1)
12035 }
12036 case "files":
12037 out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
12038 if out.Values[i] == graphql.Null {
12039 atomic.AddUint32(&invalids, 1)
12040 }
12041 default:
12042 panic("unknown field " + strconv.Quote(field.Name))
12043 }
12044 }
12045 out.Dispatch()
12046 if invalids > 0 {
12047 return graphql.Null
12048 }
12049 return out
12050}
12051
12052var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
12053
12054func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
12055 fields := graphql.CollectFields(ec.RequestContext, sel, createTimelineItemImplementors)
12056
12057 out := graphql.NewFieldSet(fields)
12058 var invalids uint32
12059 for i, field := range fields {
12060 switch field.Name {
12061 case "__typename":
12062 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
12063 case "id":
12064 field := field
12065 out.Concurrently(i, func() (res graphql.Marshaler) {
12066 defer func() {
12067 if r := recover(); r != nil {
12068 ec.Error(ctx, ec.Recover(ctx, r))
12069 }
12070 }()
12071 res = ec._CreateTimelineItem_id(ctx, field, obj)
12072 if res == graphql.Null {
12073 atomic.AddUint32(&invalids, 1)
12074 }
12075 return res
12076 })
12077 case "author":
12078 out.Values[i] = ec._CreateTimelineItem_author(ctx, field, obj)
12079 if out.Values[i] == graphql.Null {
12080 atomic.AddUint32(&invalids, 1)
12081 }
12082 case "message":
12083 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
12084 if out.Values[i] == graphql.Null {
12085 atomic.AddUint32(&invalids, 1)
12086 }
12087 case "messageIsEmpty":
12088 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
12089 if out.Values[i] == graphql.Null {
12090 atomic.AddUint32(&invalids, 1)
12091 }
12092 case "files":
12093 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
12094 if out.Values[i] == graphql.Null {
12095 atomic.AddUint32(&invalids, 1)
12096 }
12097 case "createdAt":
12098 field := field
12099 out.Concurrently(i, func() (res graphql.Marshaler) {
12100 defer func() {
12101 if r := recover(); r != nil {
12102 ec.Error(ctx, ec.Recover(ctx, r))
12103 }
12104 }()
12105 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
12106 if res == graphql.Null {
12107 atomic.AddUint32(&invalids, 1)
12108 }
12109 return res
12110 })
12111 case "lastEdit":
12112 field := field
12113 out.Concurrently(i, func() (res graphql.Marshaler) {
12114 defer func() {
12115 if r := recover(); r != nil {
12116 ec.Error(ctx, ec.Recover(ctx, r))
12117 }
12118 }()
12119 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
12120 if res == graphql.Null {
12121 atomic.AddUint32(&invalids, 1)
12122 }
12123 return res
12124 })
12125 case "edited":
12126 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
12127 if out.Values[i] == graphql.Null {
12128 atomic.AddUint32(&invalids, 1)
12129 }
12130 case "history":
12131 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
12132 if out.Values[i] == graphql.Null {
12133 atomic.AddUint32(&invalids, 1)
12134 }
12135 default:
12136 panic("unknown field " + strconv.Quote(field.Name))
12137 }
12138 }
12139 out.Dispatch()
12140 if invalids > 0 {
12141 return graphql.Null
12142 }
12143 return out
12144}
12145
12146var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
12147
12148func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
12149 fields := graphql.CollectFields(ec.RequestContext, sel, editCommentOperationImplementors)
12150
12151 out := graphql.NewFieldSet(fields)
12152 var invalids uint32
12153 for i, field := range fields {
12154 switch field.Name {
12155 case "__typename":
12156 out.Values[i] = graphql.MarshalString("EditCommentOperation")
12157 case "id":
12158 field := field
12159 out.Concurrently(i, func() (res graphql.Marshaler) {
12160 defer func() {
12161 if r := recover(); r != nil {
12162 ec.Error(ctx, ec.Recover(ctx, r))
12163 }
12164 }()
12165 res = ec._EditCommentOperation_id(ctx, field, obj)
12166 if res == graphql.Null {
12167 atomic.AddUint32(&invalids, 1)
12168 }
12169 return res
12170 })
12171 case "author":
12172 out.Values[i] = ec._EditCommentOperation_author(ctx, field, obj)
12173 if out.Values[i] == graphql.Null {
12174 atomic.AddUint32(&invalids, 1)
12175 }
12176 case "date":
12177 field := field
12178 out.Concurrently(i, func() (res graphql.Marshaler) {
12179 defer func() {
12180 if r := recover(); r != nil {
12181 ec.Error(ctx, ec.Recover(ctx, r))
12182 }
12183 }()
12184 res = ec._EditCommentOperation_date(ctx, field, obj)
12185 if res == graphql.Null {
12186 atomic.AddUint32(&invalids, 1)
12187 }
12188 return res
12189 })
12190 case "target":
12191 field := field
12192 out.Concurrently(i, func() (res graphql.Marshaler) {
12193 defer func() {
12194 if r := recover(); r != nil {
12195 ec.Error(ctx, ec.Recover(ctx, r))
12196 }
12197 }()
12198 res = ec._EditCommentOperation_target(ctx, field, obj)
12199 if res == graphql.Null {
12200 atomic.AddUint32(&invalids, 1)
12201 }
12202 return res
12203 })
12204 case "message":
12205 out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
12206 if out.Values[i] == graphql.Null {
12207 atomic.AddUint32(&invalids, 1)
12208 }
12209 case "files":
12210 out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
12211 if out.Values[i] == graphql.Null {
12212 atomic.AddUint32(&invalids, 1)
12213 }
12214 default:
12215 panic("unknown field " + strconv.Quote(field.Name))
12216 }
12217 }
12218 out.Dispatch()
12219 if invalids > 0 {
12220 return graphql.Null
12221 }
12222 return out
12223}
12224
12225var identityImplementors = []string{"Identity"}
12226
12227func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj *identity.Interface) graphql.Marshaler {
12228 fields := graphql.CollectFields(ec.RequestContext, sel, identityImplementors)
12229
12230 out := graphql.NewFieldSet(fields)
12231 var invalids uint32
12232 for i, field := range fields {
12233 switch field.Name {
12234 case "__typename":
12235 out.Values[i] = graphql.MarshalString("Identity")
12236 case "id":
12237 field := field
12238 out.Concurrently(i, func() (res graphql.Marshaler) {
12239 defer func() {
12240 if r := recover(); r != nil {
12241 ec.Error(ctx, ec.Recover(ctx, r))
12242 }
12243 }()
12244 res = ec._Identity_id(ctx, field, obj)
12245 if res == graphql.Null {
12246 atomic.AddUint32(&invalids, 1)
12247 }
12248 return res
12249 })
12250 case "humanId":
12251 field := field
12252 out.Concurrently(i, func() (res graphql.Marshaler) {
12253 defer func() {
12254 if r := recover(); r != nil {
12255 ec.Error(ctx, ec.Recover(ctx, r))
12256 }
12257 }()
12258 res = ec._Identity_humanId(ctx, field, obj)
12259 if res == graphql.Null {
12260 atomic.AddUint32(&invalids, 1)
12261 }
12262 return res
12263 })
12264 case "name":
12265 field := field
12266 out.Concurrently(i, func() (res graphql.Marshaler) {
12267 defer func() {
12268 if r := recover(); r != nil {
12269 ec.Error(ctx, ec.Recover(ctx, r))
12270 }
12271 }()
12272 res = ec._Identity_name(ctx, field, obj)
12273 return res
12274 })
12275 case "email":
12276 field := field
12277 out.Concurrently(i, func() (res graphql.Marshaler) {
12278 defer func() {
12279 if r := recover(); r != nil {
12280 ec.Error(ctx, ec.Recover(ctx, r))
12281 }
12282 }()
12283 res = ec._Identity_email(ctx, field, obj)
12284 return res
12285 })
12286 case "login":
12287 field := field
12288 out.Concurrently(i, func() (res graphql.Marshaler) {
12289 defer func() {
12290 if r := recover(); r != nil {
12291 ec.Error(ctx, ec.Recover(ctx, r))
12292 }
12293 }()
12294 res = ec._Identity_login(ctx, field, obj)
12295 return res
12296 })
12297 case "displayName":
12298 field := field
12299 out.Concurrently(i, func() (res graphql.Marshaler) {
12300 defer func() {
12301 if r := recover(); r != nil {
12302 ec.Error(ctx, ec.Recover(ctx, r))
12303 }
12304 }()
12305 res = ec._Identity_displayName(ctx, field, obj)
12306 if res == graphql.Null {
12307 atomic.AddUint32(&invalids, 1)
12308 }
12309 return res
12310 })
12311 case "avatarUrl":
12312 field := field
12313 out.Concurrently(i, func() (res graphql.Marshaler) {
12314 defer func() {
12315 if r := recover(); r != nil {
12316 ec.Error(ctx, ec.Recover(ctx, r))
12317 }
12318 }()
12319 res = ec._Identity_avatarUrl(ctx, field, obj)
12320 return res
12321 })
12322 case "isProtected":
12323 field := field
12324 out.Concurrently(i, func() (res graphql.Marshaler) {
12325 defer func() {
12326 if r := recover(); r != nil {
12327 ec.Error(ctx, ec.Recover(ctx, r))
12328 }
12329 }()
12330 res = ec._Identity_isProtected(ctx, field, obj)
12331 if res == graphql.Null {
12332 atomic.AddUint32(&invalids, 1)
12333 }
12334 return res
12335 })
12336 default:
12337 panic("unknown field " + strconv.Quote(field.Name))
12338 }
12339 }
12340 out.Dispatch()
12341 if invalids > 0 {
12342 return graphql.Null
12343 }
12344 return out
12345}
12346
12347var identityConnectionImplementors = []string{"IdentityConnection"}
12348
12349func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
12350 fields := graphql.CollectFields(ec.RequestContext, sel, identityConnectionImplementors)
12351
12352 out := graphql.NewFieldSet(fields)
12353 var invalids uint32
12354 for i, field := range fields {
12355 switch field.Name {
12356 case "__typename":
12357 out.Values[i] = graphql.MarshalString("IdentityConnection")
12358 case "edges":
12359 out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
12360 if out.Values[i] == graphql.Null {
12361 invalids++
12362 }
12363 case "nodes":
12364 out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
12365 if out.Values[i] == graphql.Null {
12366 invalids++
12367 }
12368 case "pageInfo":
12369 out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
12370 if out.Values[i] == graphql.Null {
12371 invalids++
12372 }
12373 case "totalCount":
12374 out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
12375 if out.Values[i] == graphql.Null {
12376 invalids++
12377 }
12378 default:
12379 panic("unknown field " + strconv.Quote(field.Name))
12380 }
12381 }
12382 out.Dispatch()
12383 if invalids > 0 {
12384 return graphql.Null
12385 }
12386 return out
12387}
12388
12389var identityEdgeImplementors = []string{"IdentityEdge"}
12390
12391func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
12392 fields := graphql.CollectFields(ec.RequestContext, sel, identityEdgeImplementors)
12393
12394 out := graphql.NewFieldSet(fields)
12395 var invalids uint32
12396 for i, field := range fields {
12397 switch field.Name {
12398 case "__typename":
12399 out.Values[i] = graphql.MarshalString("IdentityEdge")
12400 case "cursor":
12401 out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
12402 if out.Values[i] == graphql.Null {
12403 invalids++
12404 }
12405 case "node":
12406 out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
12407 if out.Values[i] == graphql.Null {
12408 invalids++
12409 }
12410 default:
12411 panic("unknown field " + strconv.Quote(field.Name))
12412 }
12413 }
12414 out.Dispatch()
12415 if invalids > 0 {
12416 return graphql.Null
12417 }
12418 return out
12419}
12420
12421var labelImplementors = []string{"Label"}
12422
12423func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
12424 fields := graphql.CollectFields(ec.RequestContext, sel, labelImplementors)
12425
12426 out := graphql.NewFieldSet(fields)
12427 var invalids uint32
12428 for i, field := range fields {
12429 switch field.Name {
12430 case "__typename":
12431 out.Values[i] = graphql.MarshalString("Label")
12432 case "name":
12433 field := field
12434 out.Concurrently(i, func() (res graphql.Marshaler) {
12435 defer func() {
12436 if r := recover(); r != nil {
12437 ec.Error(ctx, ec.Recover(ctx, r))
12438 }
12439 }()
12440 res = ec._Label_name(ctx, field, obj)
12441 if res == graphql.Null {
12442 atomic.AddUint32(&invalids, 1)
12443 }
12444 return res
12445 })
12446 case "color":
12447 field := field
12448 out.Concurrently(i, func() (res graphql.Marshaler) {
12449 defer func() {
12450 if r := recover(); r != nil {
12451 ec.Error(ctx, ec.Recover(ctx, r))
12452 }
12453 }()
12454 res = ec._Label_color(ctx, field, obj)
12455 if res == graphql.Null {
12456 atomic.AddUint32(&invalids, 1)
12457 }
12458 return res
12459 })
12460 default:
12461 panic("unknown field " + strconv.Quote(field.Name))
12462 }
12463 }
12464 out.Dispatch()
12465 if invalids > 0 {
12466 return graphql.Null
12467 }
12468 return out
12469}
12470
12471var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
12472
12473func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
12474 fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeOperationImplementors)
12475
12476 out := graphql.NewFieldSet(fields)
12477 var invalids uint32
12478 for i, field := range fields {
12479 switch field.Name {
12480 case "__typename":
12481 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
12482 case "id":
12483 field := field
12484 out.Concurrently(i, func() (res graphql.Marshaler) {
12485 defer func() {
12486 if r := recover(); r != nil {
12487 ec.Error(ctx, ec.Recover(ctx, r))
12488 }
12489 }()
12490 res = ec._LabelChangeOperation_id(ctx, field, obj)
12491 if res == graphql.Null {
12492 atomic.AddUint32(&invalids, 1)
12493 }
12494 return res
12495 })
12496 case "author":
12497 out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
12498 if out.Values[i] == graphql.Null {
12499 atomic.AddUint32(&invalids, 1)
12500 }
12501 case "date":
12502 field := field
12503 out.Concurrently(i, func() (res graphql.Marshaler) {
12504 defer func() {
12505 if r := recover(); r != nil {
12506 ec.Error(ctx, ec.Recover(ctx, r))
12507 }
12508 }()
12509 res = ec._LabelChangeOperation_date(ctx, field, obj)
12510 if res == graphql.Null {
12511 atomic.AddUint32(&invalids, 1)
12512 }
12513 return res
12514 })
12515 case "added":
12516 out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
12517 if out.Values[i] == graphql.Null {
12518 atomic.AddUint32(&invalids, 1)
12519 }
12520 case "removed":
12521 out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
12522 if out.Values[i] == graphql.Null {
12523 atomic.AddUint32(&invalids, 1)
12524 }
12525 default:
12526 panic("unknown field " + strconv.Quote(field.Name))
12527 }
12528 }
12529 out.Dispatch()
12530 if invalids > 0 {
12531 return graphql.Null
12532 }
12533 return out
12534}
12535
12536var labelChangeResultImplementors = []string{"LabelChangeResult"}
12537
12538func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
12539 fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeResultImplementors)
12540
12541 out := graphql.NewFieldSet(fields)
12542 var invalids uint32
12543 for i, field := range fields {
12544 switch field.Name {
12545 case "__typename":
12546 out.Values[i] = graphql.MarshalString("LabelChangeResult")
12547 case "label":
12548 out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
12549 if out.Values[i] == graphql.Null {
12550 atomic.AddUint32(&invalids, 1)
12551 }
12552 case "status":
12553 field := field
12554 out.Concurrently(i, func() (res graphql.Marshaler) {
12555 defer func() {
12556 if r := recover(); r != nil {
12557 ec.Error(ctx, ec.Recover(ctx, r))
12558 }
12559 }()
12560 res = ec._LabelChangeResult_status(ctx, field, obj)
12561 if res == graphql.Null {
12562 atomic.AddUint32(&invalids, 1)
12563 }
12564 return res
12565 })
12566 default:
12567 panic("unknown field " + strconv.Quote(field.Name))
12568 }
12569 }
12570 out.Dispatch()
12571 if invalids > 0 {
12572 return graphql.Null
12573 }
12574 return out
12575}
12576
12577var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
12578
12579func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
12580 fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeTimelineItemImplementors)
12581
12582 out := graphql.NewFieldSet(fields)
12583 var invalids uint32
12584 for i, field := range fields {
12585 switch field.Name {
12586 case "__typename":
12587 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
12588 case "id":
12589 field := field
12590 out.Concurrently(i, func() (res graphql.Marshaler) {
12591 defer func() {
12592 if r := recover(); r != nil {
12593 ec.Error(ctx, ec.Recover(ctx, r))
12594 }
12595 }()
12596 res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
12597 if res == graphql.Null {
12598 atomic.AddUint32(&invalids, 1)
12599 }
12600 return res
12601 })
12602 case "author":
12603 out.Values[i] = ec._LabelChangeTimelineItem_author(ctx, field, obj)
12604 if out.Values[i] == graphql.Null {
12605 atomic.AddUint32(&invalids, 1)
12606 }
12607 case "date":
12608 field := field
12609 out.Concurrently(i, func() (res graphql.Marshaler) {
12610 defer func() {
12611 if r := recover(); r != nil {
12612 ec.Error(ctx, ec.Recover(ctx, r))
12613 }
12614 }()
12615 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
12616 if res == graphql.Null {
12617 atomic.AddUint32(&invalids, 1)
12618 }
12619 return res
12620 })
12621 case "added":
12622 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
12623 if out.Values[i] == graphql.Null {
12624 atomic.AddUint32(&invalids, 1)
12625 }
12626 case "removed":
12627 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
12628 if out.Values[i] == graphql.Null {
12629 atomic.AddUint32(&invalids, 1)
12630 }
12631 default:
12632 panic("unknown field " + strconv.Quote(field.Name))
12633 }
12634 }
12635 out.Dispatch()
12636 if invalids > 0 {
12637 return graphql.Null
12638 }
12639 return out
12640}
12641
12642var labelConnectionImplementors = []string{"LabelConnection"}
12643
12644func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
12645 fields := graphql.CollectFields(ec.RequestContext, sel, labelConnectionImplementors)
12646
12647 out := graphql.NewFieldSet(fields)
12648 var invalids uint32
12649 for i, field := range fields {
12650 switch field.Name {
12651 case "__typename":
12652 out.Values[i] = graphql.MarshalString("LabelConnection")
12653 case "edges":
12654 out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
12655 if out.Values[i] == graphql.Null {
12656 invalids++
12657 }
12658 case "nodes":
12659 out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
12660 if out.Values[i] == graphql.Null {
12661 invalids++
12662 }
12663 case "pageInfo":
12664 out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
12665 if out.Values[i] == graphql.Null {
12666 invalids++
12667 }
12668 case "totalCount":
12669 out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
12670 if out.Values[i] == graphql.Null {
12671 invalids++
12672 }
12673 default:
12674 panic("unknown field " + strconv.Quote(field.Name))
12675 }
12676 }
12677 out.Dispatch()
12678 if invalids > 0 {
12679 return graphql.Null
12680 }
12681 return out
12682}
12683
12684var labelEdgeImplementors = []string{"LabelEdge"}
12685
12686func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
12687 fields := graphql.CollectFields(ec.RequestContext, sel, labelEdgeImplementors)
12688
12689 out := graphql.NewFieldSet(fields)
12690 var invalids uint32
12691 for i, field := range fields {
12692 switch field.Name {
12693 case "__typename":
12694 out.Values[i] = graphql.MarshalString("LabelEdge")
12695 case "cursor":
12696 out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
12697 if out.Values[i] == graphql.Null {
12698 invalids++
12699 }
12700 case "node":
12701 out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
12702 if out.Values[i] == graphql.Null {
12703 invalids++
12704 }
12705 default:
12706 panic("unknown field " + strconv.Quote(field.Name))
12707 }
12708 }
12709 out.Dispatch()
12710 if invalids > 0 {
12711 return graphql.Null
12712 }
12713 return out
12714}
12715
12716var mutationImplementors = []string{"Mutation"}
12717
12718func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12719 fields := graphql.CollectFields(ec.RequestContext, sel, mutationImplementors)
12720
12721 ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
12722 Object: "Mutation",
12723 })
12724
12725 out := graphql.NewFieldSet(fields)
12726 var invalids uint32
12727 for i, field := range fields {
12728 switch field.Name {
12729 case "__typename":
12730 out.Values[i] = graphql.MarshalString("Mutation")
12731 case "newBug":
12732 out.Values[i] = ec._Mutation_newBug(ctx, field)
12733 if out.Values[i] == graphql.Null {
12734 invalids++
12735 }
12736 case "addComment":
12737 out.Values[i] = ec._Mutation_addComment(ctx, field)
12738 if out.Values[i] == graphql.Null {
12739 invalids++
12740 }
12741 case "changeLabels":
12742 out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12743 if out.Values[i] == graphql.Null {
12744 invalids++
12745 }
12746 case "openBug":
12747 out.Values[i] = ec._Mutation_openBug(ctx, field)
12748 if out.Values[i] == graphql.Null {
12749 invalids++
12750 }
12751 case "closeBug":
12752 out.Values[i] = ec._Mutation_closeBug(ctx, field)
12753 if out.Values[i] == graphql.Null {
12754 invalids++
12755 }
12756 case "setTitle":
12757 out.Values[i] = ec._Mutation_setTitle(ctx, field)
12758 if out.Values[i] == graphql.Null {
12759 invalids++
12760 }
12761 case "commit":
12762 out.Values[i] = ec._Mutation_commit(ctx, field)
12763 if out.Values[i] == graphql.Null {
12764 invalids++
12765 }
12766 case "commitAsNeeded":
12767 out.Values[i] = ec._Mutation_commitAsNeeded(ctx, field)
12768 if out.Values[i] == graphql.Null {
12769 invalids++
12770 }
12771 default:
12772 panic("unknown field " + strconv.Quote(field.Name))
12773 }
12774 }
12775 out.Dispatch()
12776 if invalids > 0 {
12777 return graphql.Null
12778 }
12779 return out
12780}
12781
12782var newBugPayloadImplementors = []string{"NewBugPayload"}
12783
12784func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12785 fields := graphql.CollectFields(ec.RequestContext, sel, newBugPayloadImplementors)
12786
12787 out := graphql.NewFieldSet(fields)
12788 var invalids uint32
12789 for i, field := range fields {
12790 switch field.Name {
12791 case "__typename":
12792 out.Values[i] = graphql.MarshalString("NewBugPayload")
12793 case "clientMutationId":
12794 out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12795 case "bug":
12796 out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12797 if out.Values[i] == graphql.Null {
12798 invalids++
12799 }
12800 case "operation":
12801 out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
12802 if out.Values[i] == graphql.Null {
12803 invalids++
12804 }
12805 default:
12806 panic("unknown field " + strconv.Quote(field.Name))
12807 }
12808 }
12809 out.Dispatch()
12810 if invalids > 0 {
12811 return graphql.Null
12812 }
12813 return out
12814}
12815
12816var openBugPayloadImplementors = []string{"OpenBugPayload"}
12817
12818func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12819 fields := graphql.CollectFields(ec.RequestContext, sel, openBugPayloadImplementors)
12820
12821 out := graphql.NewFieldSet(fields)
12822 var invalids uint32
12823 for i, field := range fields {
12824 switch field.Name {
12825 case "__typename":
12826 out.Values[i] = graphql.MarshalString("OpenBugPayload")
12827 case "clientMutationId":
12828 out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12829 case "bug":
12830 out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12831 if out.Values[i] == graphql.Null {
12832 invalids++
12833 }
12834 case "operation":
12835 out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12836 if out.Values[i] == graphql.Null {
12837 invalids++
12838 }
12839 default:
12840 panic("unknown field " + strconv.Quote(field.Name))
12841 }
12842 }
12843 out.Dispatch()
12844 if invalids > 0 {
12845 return graphql.Null
12846 }
12847 return out
12848}
12849
12850var operationConnectionImplementors = []string{"OperationConnection"}
12851
12852func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12853 fields := graphql.CollectFields(ec.RequestContext, sel, operationConnectionImplementors)
12854
12855 out := graphql.NewFieldSet(fields)
12856 var invalids uint32
12857 for i, field := range fields {
12858 switch field.Name {
12859 case "__typename":
12860 out.Values[i] = graphql.MarshalString("OperationConnection")
12861 case "edges":
12862 out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12863 if out.Values[i] == graphql.Null {
12864 invalids++
12865 }
12866 case "nodes":
12867 out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12868 if out.Values[i] == graphql.Null {
12869 invalids++
12870 }
12871 case "pageInfo":
12872 out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12873 if out.Values[i] == graphql.Null {
12874 invalids++
12875 }
12876 case "totalCount":
12877 out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12878 if out.Values[i] == graphql.Null {
12879 invalids++
12880 }
12881 default:
12882 panic("unknown field " + strconv.Quote(field.Name))
12883 }
12884 }
12885 out.Dispatch()
12886 if invalids > 0 {
12887 return graphql.Null
12888 }
12889 return out
12890}
12891
12892var operationEdgeImplementors = []string{"OperationEdge"}
12893
12894func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12895 fields := graphql.CollectFields(ec.RequestContext, sel, operationEdgeImplementors)
12896
12897 out := graphql.NewFieldSet(fields)
12898 var invalids uint32
12899 for i, field := range fields {
12900 switch field.Name {
12901 case "__typename":
12902 out.Values[i] = graphql.MarshalString("OperationEdge")
12903 case "cursor":
12904 out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12905 if out.Values[i] == graphql.Null {
12906 invalids++
12907 }
12908 case "node":
12909 out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12910 if out.Values[i] == graphql.Null {
12911 invalids++
12912 }
12913 default:
12914 panic("unknown field " + strconv.Quote(field.Name))
12915 }
12916 }
12917 out.Dispatch()
12918 if invalids > 0 {
12919 return graphql.Null
12920 }
12921 return out
12922}
12923
12924var pageInfoImplementors = []string{"PageInfo"}
12925
12926func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12927 fields := graphql.CollectFields(ec.RequestContext, sel, pageInfoImplementors)
12928
12929 out := graphql.NewFieldSet(fields)
12930 var invalids uint32
12931 for i, field := range fields {
12932 switch field.Name {
12933 case "__typename":
12934 out.Values[i] = graphql.MarshalString("PageInfo")
12935 case "hasNextPage":
12936 out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12937 if out.Values[i] == graphql.Null {
12938 invalids++
12939 }
12940 case "hasPreviousPage":
12941 out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12942 if out.Values[i] == graphql.Null {
12943 invalids++
12944 }
12945 case "startCursor":
12946 out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12947 if out.Values[i] == graphql.Null {
12948 invalids++
12949 }
12950 case "endCursor":
12951 out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12952 if out.Values[i] == graphql.Null {
12953 invalids++
12954 }
12955 default:
12956 panic("unknown field " + strconv.Quote(field.Name))
12957 }
12958 }
12959 out.Dispatch()
12960 if invalids > 0 {
12961 return graphql.Null
12962 }
12963 return out
12964}
12965
12966var queryImplementors = []string{"Query"}
12967
12968func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12969 fields := graphql.CollectFields(ec.RequestContext, sel, queryImplementors)
12970
12971 ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
12972 Object: "Query",
12973 })
12974
12975 out := graphql.NewFieldSet(fields)
12976 var invalids uint32
12977 for i, field := range fields {
12978 switch field.Name {
12979 case "__typename":
12980 out.Values[i] = graphql.MarshalString("Query")
12981 case "defaultRepository":
12982 field := field
12983 out.Concurrently(i, func() (res graphql.Marshaler) {
12984 defer func() {
12985 if r := recover(); r != nil {
12986 ec.Error(ctx, ec.Recover(ctx, r))
12987 }
12988 }()
12989 res = ec._Query_defaultRepository(ctx, field)
12990 return res
12991 })
12992 case "repository":
12993 field := field
12994 out.Concurrently(i, func() (res graphql.Marshaler) {
12995 defer func() {
12996 if r := recover(); r != nil {
12997 ec.Error(ctx, ec.Recover(ctx, r))
12998 }
12999 }()
13000 res = ec._Query_repository(ctx, field)
13001 return res
13002 })
13003 case "__type":
13004 out.Values[i] = ec._Query___type(ctx, field)
13005 case "__schema":
13006 out.Values[i] = ec._Query___schema(ctx, field)
13007 default:
13008 panic("unknown field " + strconv.Quote(field.Name))
13009 }
13010 }
13011 out.Dispatch()
13012 if invalids > 0 {
13013 return graphql.Null
13014 }
13015 return out
13016}
13017
13018var repositoryImplementors = []string{"Repository"}
13019
13020func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
13021 fields := graphql.CollectFields(ec.RequestContext, sel, repositoryImplementors)
13022
13023 out := graphql.NewFieldSet(fields)
13024 var invalids uint32
13025 for i, field := range fields {
13026 switch field.Name {
13027 case "__typename":
13028 out.Values[i] = graphql.MarshalString("Repository")
13029 case "allBugs":
13030 field := field
13031 out.Concurrently(i, func() (res graphql.Marshaler) {
13032 defer func() {
13033 if r := recover(); r != nil {
13034 ec.Error(ctx, ec.Recover(ctx, r))
13035 }
13036 }()
13037 res = ec._Repository_allBugs(ctx, field, obj)
13038 if res == graphql.Null {
13039 atomic.AddUint32(&invalids, 1)
13040 }
13041 return res
13042 })
13043 case "bug":
13044 field := field
13045 out.Concurrently(i, func() (res graphql.Marshaler) {
13046 defer func() {
13047 if r := recover(); r != nil {
13048 ec.Error(ctx, ec.Recover(ctx, r))
13049 }
13050 }()
13051 res = ec._Repository_bug(ctx, field, obj)
13052 return res
13053 })
13054 case "allIdentities":
13055 field := field
13056 out.Concurrently(i, func() (res graphql.Marshaler) {
13057 defer func() {
13058 if r := recover(); r != nil {
13059 ec.Error(ctx, ec.Recover(ctx, r))
13060 }
13061 }()
13062 res = ec._Repository_allIdentities(ctx, field, obj)
13063 if res == graphql.Null {
13064 atomic.AddUint32(&invalids, 1)
13065 }
13066 return res
13067 })
13068 case "identity":
13069 field := field
13070 out.Concurrently(i, func() (res graphql.Marshaler) {
13071 defer func() {
13072 if r := recover(); r != nil {
13073 ec.Error(ctx, ec.Recover(ctx, r))
13074 }
13075 }()
13076 res = ec._Repository_identity(ctx, field, obj)
13077 return res
13078 })
13079 case "userIdentity":
13080 field := field
13081 out.Concurrently(i, func() (res graphql.Marshaler) {
13082 defer func() {
13083 if r := recover(); r != nil {
13084 ec.Error(ctx, ec.Recover(ctx, r))
13085 }
13086 }()
13087 res = ec._Repository_userIdentity(ctx, field, obj)
13088 return res
13089 })
13090 case "validLabels":
13091 field := field
13092 out.Concurrently(i, func() (res graphql.Marshaler) {
13093 defer func() {
13094 if r := recover(); r != nil {
13095 ec.Error(ctx, ec.Recover(ctx, r))
13096 }
13097 }()
13098 res = ec._Repository_validLabels(ctx, field, obj)
13099 if res == graphql.Null {
13100 atomic.AddUint32(&invalids, 1)
13101 }
13102 return res
13103 })
13104 default:
13105 panic("unknown field " + strconv.Quote(field.Name))
13106 }
13107 }
13108 out.Dispatch()
13109 if invalids > 0 {
13110 return graphql.Null
13111 }
13112 return out
13113}
13114
13115var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
13116
13117func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
13118 fields := graphql.CollectFields(ec.RequestContext, sel, setStatusOperationImplementors)
13119
13120 out := graphql.NewFieldSet(fields)
13121 var invalids uint32
13122 for i, field := range fields {
13123 switch field.Name {
13124 case "__typename":
13125 out.Values[i] = graphql.MarshalString("SetStatusOperation")
13126 case "id":
13127 field := field
13128 out.Concurrently(i, func() (res graphql.Marshaler) {
13129 defer func() {
13130 if r := recover(); r != nil {
13131 ec.Error(ctx, ec.Recover(ctx, r))
13132 }
13133 }()
13134 res = ec._SetStatusOperation_id(ctx, field, obj)
13135 if res == graphql.Null {
13136 atomic.AddUint32(&invalids, 1)
13137 }
13138 return res
13139 })
13140 case "author":
13141 out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
13142 if out.Values[i] == graphql.Null {
13143 atomic.AddUint32(&invalids, 1)
13144 }
13145 case "date":
13146 field := field
13147 out.Concurrently(i, func() (res graphql.Marshaler) {
13148 defer func() {
13149 if r := recover(); r != nil {
13150 ec.Error(ctx, ec.Recover(ctx, r))
13151 }
13152 }()
13153 res = ec._SetStatusOperation_date(ctx, field, obj)
13154 if res == graphql.Null {
13155 atomic.AddUint32(&invalids, 1)
13156 }
13157 return res
13158 })
13159 case "status":
13160 field := field
13161 out.Concurrently(i, func() (res graphql.Marshaler) {
13162 defer func() {
13163 if r := recover(); r != nil {
13164 ec.Error(ctx, ec.Recover(ctx, r))
13165 }
13166 }()
13167 res = ec._SetStatusOperation_status(ctx, field, obj)
13168 if res == graphql.Null {
13169 atomic.AddUint32(&invalids, 1)
13170 }
13171 return res
13172 })
13173 default:
13174 panic("unknown field " + strconv.Quote(field.Name))
13175 }
13176 }
13177 out.Dispatch()
13178 if invalids > 0 {
13179 return graphql.Null
13180 }
13181 return out
13182}
13183
13184var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
13185
13186func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
13187 fields := graphql.CollectFields(ec.RequestContext, sel, setStatusTimelineItemImplementors)
13188
13189 out := graphql.NewFieldSet(fields)
13190 var invalids uint32
13191 for i, field := range fields {
13192 switch field.Name {
13193 case "__typename":
13194 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
13195 case "id":
13196 field := field
13197 out.Concurrently(i, func() (res graphql.Marshaler) {
13198 defer func() {
13199 if r := recover(); r != nil {
13200 ec.Error(ctx, ec.Recover(ctx, r))
13201 }
13202 }()
13203 res = ec._SetStatusTimelineItem_id(ctx, field, obj)
13204 if res == graphql.Null {
13205 atomic.AddUint32(&invalids, 1)
13206 }
13207 return res
13208 })
13209 case "author":
13210 out.Values[i] = ec._SetStatusTimelineItem_author(ctx, field, obj)
13211 if out.Values[i] == graphql.Null {
13212 atomic.AddUint32(&invalids, 1)
13213 }
13214 case "date":
13215 field := field
13216 out.Concurrently(i, func() (res graphql.Marshaler) {
13217 defer func() {
13218 if r := recover(); r != nil {
13219 ec.Error(ctx, ec.Recover(ctx, r))
13220 }
13221 }()
13222 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
13223 if res == graphql.Null {
13224 atomic.AddUint32(&invalids, 1)
13225 }
13226 return res
13227 })
13228 case "status":
13229 field := field
13230 out.Concurrently(i, func() (res graphql.Marshaler) {
13231 defer func() {
13232 if r := recover(); r != nil {
13233 ec.Error(ctx, ec.Recover(ctx, r))
13234 }
13235 }()
13236 res = ec._SetStatusTimelineItem_status(ctx, field, obj)
13237 if res == graphql.Null {
13238 atomic.AddUint32(&invalids, 1)
13239 }
13240 return res
13241 })
13242 default:
13243 panic("unknown field " + strconv.Quote(field.Name))
13244 }
13245 }
13246 out.Dispatch()
13247 if invalids > 0 {
13248 return graphql.Null
13249 }
13250 return out
13251}
13252
13253var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
13254
13255func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
13256 fields := graphql.CollectFields(ec.RequestContext, sel, setTitleOperationImplementors)
13257
13258 out := graphql.NewFieldSet(fields)
13259 var invalids uint32
13260 for i, field := range fields {
13261 switch field.Name {
13262 case "__typename":
13263 out.Values[i] = graphql.MarshalString("SetTitleOperation")
13264 case "id":
13265 field := field
13266 out.Concurrently(i, func() (res graphql.Marshaler) {
13267 defer func() {
13268 if r := recover(); r != nil {
13269 ec.Error(ctx, ec.Recover(ctx, r))
13270 }
13271 }()
13272 res = ec._SetTitleOperation_id(ctx, field, obj)
13273 if res == graphql.Null {
13274 atomic.AddUint32(&invalids, 1)
13275 }
13276 return res
13277 })
13278 case "author":
13279 out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
13280 if out.Values[i] == graphql.Null {
13281 atomic.AddUint32(&invalids, 1)
13282 }
13283 case "date":
13284 field := field
13285 out.Concurrently(i, func() (res graphql.Marshaler) {
13286 defer func() {
13287 if r := recover(); r != nil {
13288 ec.Error(ctx, ec.Recover(ctx, r))
13289 }
13290 }()
13291 res = ec._SetTitleOperation_date(ctx, field, obj)
13292 if res == graphql.Null {
13293 atomic.AddUint32(&invalids, 1)
13294 }
13295 return res
13296 })
13297 case "title":
13298 out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
13299 if out.Values[i] == graphql.Null {
13300 atomic.AddUint32(&invalids, 1)
13301 }
13302 case "was":
13303 out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
13304 if out.Values[i] == graphql.Null {
13305 atomic.AddUint32(&invalids, 1)
13306 }
13307 default:
13308 panic("unknown field " + strconv.Quote(field.Name))
13309 }
13310 }
13311 out.Dispatch()
13312 if invalids > 0 {
13313 return graphql.Null
13314 }
13315 return out
13316}
13317
13318var setTitlePayloadImplementors = []string{"SetTitlePayload"}
13319
13320func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
13321 fields := graphql.CollectFields(ec.RequestContext, sel, setTitlePayloadImplementors)
13322
13323 out := graphql.NewFieldSet(fields)
13324 var invalids uint32
13325 for i, field := range fields {
13326 switch field.Name {
13327 case "__typename":
13328 out.Values[i] = graphql.MarshalString("SetTitlePayload")
13329 case "clientMutationId":
13330 out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
13331 case "bug":
13332 out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
13333 if out.Values[i] == graphql.Null {
13334 invalids++
13335 }
13336 case "operation":
13337 out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
13338 if out.Values[i] == graphql.Null {
13339 invalids++
13340 }
13341 default:
13342 panic("unknown field " + strconv.Quote(field.Name))
13343 }
13344 }
13345 out.Dispatch()
13346 if invalids > 0 {
13347 return graphql.Null
13348 }
13349 return out
13350}
13351
13352var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
13353
13354func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
13355 fields := graphql.CollectFields(ec.RequestContext, sel, setTitleTimelineItemImplementors)
13356
13357 out := graphql.NewFieldSet(fields)
13358 var invalids uint32
13359 for i, field := range fields {
13360 switch field.Name {
13361 case "__typename":
13362 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
13363 case "id":
13364 field := field
13365 out.Concurrently(i, func() (res graphql.Marshaler) {
13366 defer func() {
13367 if r := recover(); r != nil {
13368 ec.Error(ctx, ec.Recover(ctx, r))
13369 }
13370 }()
13371 res = ec._SetTitleTimelineItem_id(ctx, field, obj)
13372 if res == graphql.Null {
13373 atomic.AddUint32(&invalids, 1)
13374 }
13375 return res
13376 })
13377 case "author":
13378 out.Values[i] = ec._SetTitleTimelineItem_author(ctx, field, obj)
13379 if out.Values[i] == graphql.Null {
13380 atomic.AddUint32(&invalids, 1)
13381 }
13382 case "date":
13383 field := field
13384 out.Concurrently(i, func() (res graphql.Marshaler) {
13385 defer func() {
13386 if r := recover(); r != nil {
13387 ec.Error(ctx, ec.Recover(ctx, r))
13388 }
13389 }()
13390 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
13391 if res == graphql.Null {
13392 atomic.AddUint32(&invalids, 1)
13393 }
13394 return res
13395 })
13396 case "title":
13397 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
13398 if out.Values[i] == graphql.Null {
13399 atomic.AddUint32(&invalids, 1)
13400 }
13401 case "was":
13402 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
13403 if out.Values[i] == graphql.Null {
13404 atomic.AddUint32(&invalids, 1)
13405 }
13406 default:
13407 panic("unknown field " + strconv.Quote(field.Name))
13408 }
13409 }
13410 out.Dispatch()
13411 if invalids > 0 {
13412 return graphql.Null
13413 }
13414 return out
13415}
13416
13417var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
13418
13419func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
13420 fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemConnectionImplementors)
13421
13422 out := graphql.NewFieldSet(fields)
13423 var invalids uint32
13424 for i, field := range fields {
13425 switch field.Name {
13426 case "__typename":
13427 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
13428 case "edges":
13429 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
13430 if out.Values[i] == graphql.Null {
13431 invalids++
13432 }
13433 case "nodes":
13434 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
13435 if out.Values[i] == graphql.Null {
13436 invalids++
13437 }
13438 case "pageInfo":
13439 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
13440 if out.Values[i] == graphql.Null {
13441 invalids++
13442 }
13443 case "totalCount":
13444 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
13445 if out.Values[i] == graphql.Null {
13446 invalids++
13447 }
13448 default:
13449 panic("unknown field " + strconv.Quote(field.Name))
13450 }
13451 }
13452 out.Dispatch()
13453 if invalids > 0 {
13454 return graphql.Null
13455 }
13456 return out
13457}
13458
13459var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
13460
13461func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
13462 fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemEdgeImplementors)
13463
13464 out := graphql.NewFieldSet(fields)
13465 var invalids uint32
13466 for i, field := range fields {
13467 switch field.Name {
13468 case "__typename":
13469 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
13470 case "cursor":
13471 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
13472 if out.Values[i] == graphql.Null {
13473 invalids++
13474 }
13475 case "node":
13476 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
13477 if out.Values[i] == graphql.Null {
13478 invalids++
13479 }
13480 default:
13481 panic("unknown field " + strconv.Quote(field.Name))
13482 }
13483 }
13484 out.Dispatch()
13485 if invalids > 0 {
13486 return graphql.Null
13487 }
13488 return out
13489}
13490
13491var __DirectiveImplementors = []string{"__Directive"}
13492
13493func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
13494 fields := graphql.CollectFields(ec.RequestContext, sel, __DirectiveImplementors)
13495
13496 out := graphql.NewFieldSet(fields)
13497 var invalids uint32
13498 for i, field := range fields {
13499 switch field.Name {
13500 case "__typename":
13501 out.Values[i] = graphql.MarshalString("__Directive")
13502 case "name":
13503 out.Values[i] = ec.___Directive_name(ctx, field, obj)
13504 if out.Values[i] == graphql.Null {
13505 invalids++
13506 }
13507 case "description":
13508 out.Values[i] = ec.___Directive_description(ctx, field, obj)
13509 case "locations":
13510 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
13511 if out.Values[i] == graphql.Null {
13512 invalids++
13513 }
13514 case "args":
13515 out.Values[i] = ec.___Directive_args(ctx, field, obj)
13516 if out.Values[i] == graphql.Null {
13517 invalids++
13518 }
13519 default:
13520 panic("unknown field " + strconv.Quote(field.Name))
13521 }
13522 }
13523 out.Dispatch()
13524 if invalids > 0 {
13525 return graphql.Null
13526 }
13527 return out
13528}
13529
13530var __EnumValueImplementors = []string{"__EnumValue"}
13531
13532func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
13533 fields := graphql.CollectFields(ec.RequestContext, sel, __EnumValueImplementors)
13534
13535 out := graphql.NewFieldSet(fields)
13536 var invalids uint32
13537 for i, field := range fields {
13538 switch field.Name {
13539 case "__typename":
13540 out.Values[i] = graphql.MarshalString("__EnumValue")
13541 case "name":
13542 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
13543 if out.Values[i] == graphql.Null {
13544 invalids++
13545 }
13546 case "description":
13547 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
13548 case "isDeprecated":
13549 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
13550 if out.Values[i] == graphql.Null {
13551 invalids++
13552 }
13553 case "deprecationReason":
13554 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
13555 default:
13556 panic("unknown field " + strconv.Quote(field.Name))
13557 }
13558 }
13559 out.Dispatch()
13560 if invalids > 0 {
13561 return graphql.Null
13562 }
13563 return out
13564}
13565
13566var __FieldImplementors = []string{"__Field"}
13567
13568func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
13569 fields := graphql.CollectFields(ec.RequestContext, sel, __FieldImplementors)
13570
13571 out := graphql.NewFieldSet(fields)
13572 var invalids uint32
13573 for i, field := range fields {
13574 switch field.Name {
13575 case "__typename":
13576 out.Values[i] = graphql.MarshalString("__Field")
13577 case "name":
13578 out.Values[i] = ec.___Field_name(ctx, field, obj)
13579 if out.Values[i] == graphql.Null {
13580 invalids++
13581 }
13582 case "description":
13583 out.Values[i] = ec.___Field_description(ctx, field, obj)
13584 case "args":
13585 out.Values[i] = ec.___Field_args(ctx, field, obj)
13586 if out.Values[i] == graphql.Null {
13587 invalids++
13588 }
13589 case "type":
13590 out.Values[i] = ec.___Field_type(ctx, field, obj)
13591 if out.Values[i] == graphql.Null {
13592 invalids++
13593 }
13594 case "isDeprecated":
13595 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
13596 if out.Values[i] == graphql.Null {
13597 invalids++
13598 }
13599 case "deprecationReason":
13600 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
13601 default:
13602 panic("unknown field " + strconv.Quote(field.Name))
13603 }
13604 }
13605 out.Dispatch()
13606 if invalids > 0 {
13607 return graphql.Null
13608 }
13609 return out
13610}
13611
13612var __InputValueImplementors = []string{"__InputValue"}
13613
13614func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
13615 fields := graphql.CollectFields(ec.RequestContext, sel, __InputValueImplementors)
13616
13617 out := graphql.NewFieldSet(fields)
13618 var invalids uint32
13619 for i, field := range fields {
13620 switch field.Name {
13621 case "__typename":
13622 out.Values[i] = graphql.MarshalString("__InputValue")
13623 case "name":
13624 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
13625 if out.Values[i] == graphql.Null {
13626 invalids++
13627 }
13628 case "description":
13629 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
13630 case "type":
13631 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
13632 if out.Values[i] == graphql.Null {
13633 invalids++
13634 }
13635 case "defaultValue":
13636 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
13637 default:
13638 panic("unknown field " + strconv.Quote(field.Name))
13639 }
13640 }
13641 out.Dispatch()
13642 if invalids > 0 {
13643 return graphql.Null
13644 }
13645 return out
13646}
13647
13648var __SchemaImplementors = []string{"__Schema"}
13649
13650func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
13651 fields := graphql.CollectFields(ec.RequestContext, sel, __SchemaImplementors)
13652
13653 out := graphql.NewFieldSet(fields)
13654 var invalids uint32
13655 for i, field := range fields {
13656 switch field.Name {
13657 case "__typename":
13658 out.Values[i] = graphql.MarshalString("__Schema")
13659 case "types":
13660 out.Values[i] = ec.___Schema_types(ctx, field, obj)
13661 if out.Values[i] == graphql.Null {
13662 invalids++
13663 }
13664 case "queryType":
13665 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
13666 if out.Values[i] == graphql.Null {
13667 invalids++
13668 }
13669 case "mutationType":
13670 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13671 case "subscriptionType":
13672 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13673 case "directives":
13674 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13675 if out.Values[i] == graphql.Null {
13676 invalids++
13677 }
13678 default:
13679 panic("unknown field " + strconv.Quote(field.Name))
13680 }
13681 }
13682 out.Dispatch()
13683 if invalids > 0 {
13684 return graphql.Null
13685 }
13686 return out
13687}
13688
13689var __TypeImplementors = []string{"__Type"}
13690
13691func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13692 fields := graphql.CollectFields(ec.RequestContext, sel, __TypeImplementors)
13693
13694 out := graphql.NewFieldSet(fields)
13695 var invalids uint32
13696 for i, field := range fields {
13697 switch field.Name {
13698 case "__typename":
13699 out.Values[i] = graphql.MarshalString("__Type")
13700 case "kind":
13701 out.Values[i] = ec.___Type_kind(ctx, field, obj)
13702 if out.Values[i] == graphql.Null {
13703 invalids++
13704 }
13705 case "name":
13706 out.Values[i] = ec.___Type_name(ctx, field, obj)
13707 case "description":
13708 out.Values[i] = ec.___Type_description(ctx, field, obj)
13709 case "fields":
13710 out.Values[i] = ec.___Type_fields(ctx, field, obj)
13711 case "interfaces":
13712 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13713 case "possibleTypes":
13714 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13715 case "enumValues":
13716 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13717 case "inputFields":
13718 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13719 case "ofType":
13720 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13721 default:
13722 panic("unknown field " + strconv.Quote(field.Name))
13723 }
13724 }
13725 out.Dispatch()
13726 if invalids > 0 {
13727 return graphql.Null
13728 }
13729 return out
13730}
13731
13732// endregion **************************** object.gotpl ****************************
13733
13734// region ***************************** type.gotpl *****************************
13735
13736func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13737 return ec.unmarshalInputAddCommentInput(ctx, v)
13738}
13739
13740func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13741 return ec._AddCommentOperation(ctx, sel, &v)
13742}
13743
13744func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
13745 if v == nil {
13746 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13747 ec.Errorf(ctx, "must not be null")
13748 }
13749 return graphql.Null
13750 }
13751 return ec._AddCommentOperation(ctx, sel, v)
13752}
13753
13754func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13755 return ec._AddCommentPayload(ctx, sel, &v)
13756}
13757
13758func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13759 if v == nil {
13760 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13761 ec.Errorf(ctx, "must not be null")
13762 }
13763 return graphql.Null
13764 }
13765 return ec._AddCommentPayload(ctx, sel, v)
13766}
13767
13768func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13769 return graphql.UnmarshalBoolean(v)
13770}
13771
13772func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13773 res := graphql.MarshalBoolean(v)
13774 if res == graphql.Null {
13775 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13776 ec.Errorf(ctx, "must not be null")
13777 }
13778 }
13779 return res
13780}
13781
13782func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
13783 return ec._Bug(ctx, sel, &v)
13784}
13785
13786func (ec *executionContext) marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v []*bug.Snapshot) graphql.Marshaler {
13787 ret := make(graphql.Array, len(v))
13788 var wg sync.WaitGroup
13789 isLen1 := len(v) == 1
13790 if !isLen1 {
13791 wg.Add(len(v))
13792 }
13793 for i := range v {
13794 i := i
13795 rctx := &graphql.ResolverContext{
13796 Index: &i,
13797 Result: &v[i],
13798 }
13799 ctx := graphql.WithResolverContext(ctx, rctx)
13800 f := func(i int) {
13801 defer func() {
13802 if r := recover(); r != nil {
13803 ec.Error(ctx, ec.Recover(ctx, r))
13804 ret = nil
13805 }
13806 }()
13807 if !isLen1 {
13808 defer wg.Done()
13809 }
13810 ret[i] = ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, sel, v[i])
13811 }
13812 if isLen1 {
13813 f(i)
13814 } else {
13815 go f(i)
13816 }
13817
13818 }
13819 wg.Wait()
13820 return ret
13821}
13822
13823func (ec *executionContext) marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
13824 if v == nil {
13825 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13826 ec.Errorf(ctx, "must not be null")
13827 }
13828 return graphql.Null
13829 }
13830 return ec._Bug(ctx, sel, v)
13831}
13832
13833func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13834 return ec._BugConnection(ctx, sel, &v)
13835}
13836
13837func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
13838 if v == nil {
13839 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13840 ec.Errorf(ctx, "must not be null")
13841 }
13842 return graphql.Null
13843 }
13844 return ec._BugConnection(ctx, sel, v)
13845}
13846
13847func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13848 return ec._BugEdge(ctx, sel, &v)
13849}
13850
13851func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13852 ret := make(graphql.Array, len(v))
13853 var wg sync.WaitGroup
13854 isLen1 := len(v) == 1
13855 if !isLen1 {
13856 wg.Add(len(v))
13857 }
13858 for i := range v {
13859 i := i
13860 rctx := &graphql.ResolverContext{
13861 Index: &i,
13862 Result: &v[i],
13863 }
13864 ctx := graphql.WithResolverContext(ctx, rctx)
13865 f := func(i int) {
13866 defer func() {
13867 if r := recover(); r != nil {
13868 ec.Error(ctx, ec.Recover(ctx, r))
13869 ret = nil
13870 }
13871 }()
13872 if !isLen1 {
13873 defer wg.Done()
13874 }
13875 ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13876 }
13877 if isLen1 {
13878 f(i)
13879 } else {
13880 go f(i)
13881 }
13882
13883 }
13884 wg.Wait()
13885 return ret
13886}
13887
13888func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13889 if v == nil {
13890 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13891 ec.Errorf(ctx, "must not be null")
13892 }
13893 return graphql.Null
13894 }
13895 return ec._BugEdge(ctx, sel, v)
13896}
13897
13898func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13899 return ec._ChangeLabelPayload(ctx, sel, &v)
13900}
13901
13902func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13903 if v == nil {
13904 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13905 ec.Errorf(ctx, "must not be null")
13906 }
13907 return graphql.Null
13908 }
13909 return ec._ChangeLabelPayload(ctx, sel, v)
13910}
13911
13912func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13913 return ec.unmarshalInputCloseBugInput(ctx, v)
13914}
13915
13916func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13917 return ec._CloseBugPayload(ctx, sel, &v)
13918}
13919
13920func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
13921 if v == nil {
13922 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13923 ec.Errorf(ctx, "must not be null")
13924 }
13925 return graphql.Null
13926 }
13927 return ec._CloseBugPayload(ctx, sel, v)
13928}
13929
13930func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13931 return ec._Color(ctx, sel, &v)
13932}
13933
13934func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) 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._Color(ctx, sel, v)
13942}
13943
13944func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
13945 return ec._Comment(ctx, sel, &v)
13946}
13947
13948func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
13949 ret := make(graphql.Array, len(v))
13950 var wg sync.WaitGroup
13951 isLen1 := len(v) == 1
13952 if !isLen1 {
13953 wg.Add(len(v))
13954 }
13955 for i := range v {
13956 i := i
13957 rctx := &graphql.ResolverContext{
13958 Index: &i,
13959 Result: &v[i],
13960 }
13961 ctx := graphql.WithResolverContext(ctx, rctx)
13962 f := func(i int) {
13963 defer func() {
13964 if r := recover(); r != nil {
13965 ec.Error(ctx, ec.Recover(ctx, r))
13966 ret = nil
13967 }
13968 }()
13969 if !isLen1 {
13970 defer wg.Done()
13971 }
13972 ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
13973 }
13974 if isLen1 {
13975 f(i)
13976 } else {
13977 go f(i)
13978 }
13979
13980 }
13981 wg.Wait()
13982 return ret
13983}
13984
13985func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13986 if v == nil {
13987 if !ec.HasError(graphql.GetResolverContext(ctx)) {
13988 ec.Errorf(ctx, "must not be null")
13989 }
13990 return graphql.Null
13991 }
13992 return ec._Comment(ctx, sel, v)
13993}
13994
13995func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13996 return ec._CommentConnection(ctx, sel, &v)
13997}
13998
13999func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
14000 if v == nil {
14001 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14002 ec.Errorf(ctx, "must not be null")
14003 }
14004 return graphql.Null
14005 }
14006 return ec._CommentConnection(ctx, sel, v)
14007}
14008
14009func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
14010 return ec._CommentEdge(ctx, sel, &v)
14011}
14012
14013func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
14014 ret := make(graphql.Array, len(v))
14015 var wg sync.WaitGroup
14016 isLen1 := len(v) == 1
14017 if !isLen1 {
14018 wg.Add(len(v))
14019 }
14020 for i := range v {
14021 i := i
14022 rctx := &graphql.ResolverContext{
14023 Index: &i,
14024 Result: &v[i],
14025 }
14026 ctx := graphql.WithResolverContext(ctx, rctx)
14027 f := func(i int) {
14028 defer func() {
14029 if r := recover(); r != nil {
14030 ec.Error(ctx, ec.Recover(ctx, r))
14031 ret = nil
14032 }
14033 }()
14034 if !isLen1 {
14035 defer wg.Done()
14036 }
14037 ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
14038 }
14039 if isLen1 {
14040 f(i)
14041 } else {
14042 go f(i)
14043 }
14044
14045 }
14046 wg.Wait()
14047 return ret
14048}
14049
14050func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
14051 if v == nil {
14052 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14053 ec.Errorf(ctx, "must not be null")
14054 }
14055 return graphql.Null
14056 }
14057 return ec._CommentEdge(ctx, sel, v)
14058}
14059
14060func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
14061 return ec._CommentHistoryStep(ctx, sel, &v)
14062}
14063
14064func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
14065 ret := make(graphql.Array, len(v))
14066 var wg sync.WaitGroup
14067 isLen1 := len(v) == 1
14068 if !isLen1 {
14069 wg.Add(len(v))
14070 }
14071 for i := range v {
14072 i := i
14073 rctx := &graphql.ResolverContext{
14074 Index: &i,
14075 Result: &v[i],
14076 }
14077 ctx := graphql.WithResolverContext(ctx, rctx)
14078 f := func(i int) {
14079 defer func() {
14080 if r := recover(); r != nil {
14081 ec.Error(ctx, ec.Recover(ctx, r))
14082 ret = nil
14083 }
14084 }()
14085 if !isLen1 {
14086 defer wg.Done()
14087 }
14088 ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
14089 }
14090 if isLen1 {
14091 f(i)
14092 } else {
14093 go f(i)
14094 }
14095
14096 }
14097 wg.Wait()
14098 return ret
14099}
14100
14101func (ec *executionContext) unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
14102 return ec.unmarshalInputCommitAsNeededInput(ctx, v)
14103}
14104
14105func (ec *executionContext) marshalNCommitAsNeededPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitAsNeededPayload) graphql.Marshaler {
14106 return ec._CommitAsNeededPayload(ctx, sel, &v)
14107}
14108
14109func (ec *executionContext) marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitAsNeededPayload) graphql.Marshaler {
14110 if v == nil {
14111 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14112 ec.Errorf(ctx, "must not be null")
14113 }
14114 return graphql.Null
14115 }
14116 return ec._CommitAsNeededPayload(ctx, sel, v)
14117}
14118
14119func (ec *executionContext) unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
14120 return ec.unmarshalInputCommitInput(ctx, v)
14121}
14122
14123func (ec *executionContext) marshalNCommitPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitPayload) graphql.Marshaler {
14124 return ec._CommitPayload(ctx, sel, &v)
14125}
14126
14127func (ec *executionContext) marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitPayload) graphql.Marshaler {
14128 if v == nil {
14129 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14130 ec.Errorf(ctx, "must not be null")
14131 }
14132 return graphql.Null
14133 }
14134 return ec._CommitPayload(ctx, sel, v)
14135}
14136
14137func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
14138 return ec._CreateOperation(ctx, sel, &v)
14139}
14140
14141func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
14142 if v == nil {
14143 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14144 ec.Errorf(ctx, "must not be null")
14145 }
14146 return graphql.Null
14147 }
14148 return ec._CreateOperation(ctx, sel, v)
14149}
14150
14151func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
14152 var res git.Hash
14153 return res, res.UnmarshalGQL(v)
14154}
14155
14156func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
14157 return v
14158}
14159
14160func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
14161 var vSlice []interface{}
14162 if v != nil {
14163 if tmp1, ok := v.([]interface{}); ok {
14164 vSlice = tmp1
14165 } else {
14166 vSlice = []interface{}{v}
14167 }
14168 }
14169 var err error
14170 res := make([]git.Hash, len(vSlice))
14171 for i := range vSlice {
14172 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14173 if err != nil {
14174 return nil, err
14175 }
14176 }
14177 return res, nil
14178}
14179
14180func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14181 ret := make(graphql.Array, len(v))
14182 for i := range v {
14183 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14184 }
14185
14186 return ret
14187}
14188
14189func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
14190 return ec._Identity(ctx, sel, &v)
14191}
14192
14193func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v []identity.Interface) graphql.Marshaler {
14194 ret := make(graphql.Array, len(v))
14195 var wg sync.WaitGroup
14196 isLen1 := len(v) == 1
14197 if !isLen1 {
14198 wg.Add(len(v))
14199 }
14200 for i := range v {
14201 i := i
14202 rctx := &graphql.ResolverContext{
14203 Index: &i,
14204 Result: &v[i],
14205 }
14206 ctx := graphql.WithResolverContext(ctx, rctx)
14207 f := func(i int) {
14208 defer func() {
14209 if r := recover(); r != nil {
14210 ec.Error(ctx, ec.Recover(ctx, r))
14211 ret = nil
14212 }
14213 }()
14214 if !isLen1 {
14215 defer wg.Done()
14216 }
14217 ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, sel, v[i])
14218 }
14219 if isLen1 {
14220 f(i)
14221 } else {
14222 go f(i)
14223 }
14224
14225 }
14226 wg.Wait()
14227 return ret
14228}
14229
14230func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
14231 return ec._IdentityConnection(ctx, sel, &v)
14232}
14233
14234func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
14235 if v == nil {
14236 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14237 ec.Errorf(ctx, "must not be null")
14238 }
14239 return graphql.Null
14240 }
14241 return ec._IdentityConnection(ctx, sel, v)
14242}
14243
14244func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
14245 return ec._IdentityEdge(ctx, sel, &v)
14246}
14247
14248func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
14249 ret := make(graphql.Array, len(v))
14250 var wg sync.WaitGroup
14251 isLen1 := len(v) == 1
14252 if !isLen1 {
14253 wg.Add(len(v))
14254 }
14255 for i := range v {
14256 i := i
14257 rctx := &graphql.ResolverContext{
14258 Index: &i,
14259 Result: &v[i],
14260 }
14261 ctx := graphql.WithResolverContext(ctx, rctx)
14262 f := func(i int) {
14263 defer func() {
14264 if r := recover(); r != nil {
14265 ec.Error(ctx, ec.Recover(ctx, r))
14266 ret = nil
14267 }
14268 }()
14269 if !isLen1 {
14270 defer wg.Done()
14271 }
14272 ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
14273 }
14274 if isLen1 {
14275 f(i)
14276 } else {
14277 go f(i)
14278 }
14279
14280 }
14281 wg.Wait()
14282 return ret
14283}
14284
14285func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
14286 if v == nil {
14287 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14288 ec.Errorf(ctx, "must not be null")
14289 }
14290 return graphql.Null
14291 }
14292 return ec._IdentityEdge(ctx, sel, v)
14293}
14294
14295func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
14296 return graphql.UnmarshalInt(v)
14297}
14298
14299func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14300 res := graphql.MarshalInt(v)
14301 if res == graphql.Null {
14302 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14303 ec.Errorf(ctx, "must not be null")
14304 }
14305 }
14306 return res
14307}
14308
14309func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
14310 return ec._Label(ctx, sel, &v)
14311}
14312
14313func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
14314 ret := make(graphql.Array, len(v))
14315 var wg sync.WaitGroup
14316 isLen1 := len(v) == 1
14317 if !isLen1 {
14318 wg.Add(len(v))
14319 }
14320 for i := range v {
14321 i := i
14322 rctx := &graphql.ResolverContext{
14323 Index: &i,
14324 Result: &v[i],
14325 }
14326 ctx := graphql.WithResolverContext(ctx, rctx)
14327 f := func(i int) {
14328 defer func() {
14329 if r := recover(); r != nil {
14330 ec.Error(ctx, ec.Recover(ctx, r))
14331 ret = nil
14332 }
14333 }()
14334 if !isLen1 {
14335 defer wg.Done()
14336 }
14337 ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
14338 }
14339 if isLen1 {
14340 f(i)
14341 } else {
14342 go f(i)
14343 }
14344
14345 }
14346 wg.Wait()
14347 return ret
14348}
14349
14350func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
14351 return ec._LabelChangeOperation(ctx, sel, &v)
14352}
14353
14354func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
14355 if v == nil {
14356 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14357 ec.Errorf(ctx, "must not be null")
14358 }
14359 return graphql.Null
14360 }
14361 return ec._LabelChangeOperation(ctx, sel, v)
14362}
14363
14364func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
14365 ret := make(graphql.Array, len(v))
14366 var wg sync.WaitGroup
14367 isLen1 := len(v) == 1
14368 if !isLen1 {
14369 wg.Add(len(v))
14370 }
14371 for i := range v {
14372 i := i
14373 rctx := &graphql.ResolverContext{
14374 Index: &i,
14375 Result: &v[i],
14376 }
14377 ctx := graphql.WithResolverContext(ctx, rctx)
14378 f := func(i int) {
14379 defer func() {
14380 if r := recover(); r != nil {
14381 ec.Error(ctx, ec.Recover(ctx, r))
14382 ret = nil
14383 }
14384 }()
14385 if !isLen1 {
14386 defer wg.Done()
14387 }
14388 ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
14389 }
14390 if isLen1 {
14391 f(i)
14392 } else {
14393 go f(i)
14394 }
14395
14396 }
14397 wg.Wait()
14398 return ret
14399}
14400
14401func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
14402 var res models.LabelChangeStatus
14403 return res, res.UnmarshalGQL(v)
14404}
14405
14406func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
14407 return v
14408}
14409
14410func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
14411 return ec._LabelConnection(ctx, sel, &v)
14412}
14413
14414func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
14415 if v == nil {
14416 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14417 ec.Errorf(ctx, "must not be null")
14418 }
14419 return graphql.Null
14420 }
14421 return ec._LabelConnection(ctx, sel, v)
14422}
14423
14424func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
14425 return ec._LabelEdge(ctx, sel, &v)
14426}
14427
14428func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) 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.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(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) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
14466 if v == nil {
14467 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14468 ec.Errorf(ctx, "must not be null")
14469 }
14470 return graphql.Null
14471 }
14472 return ec._LabelEdge(ctx, sel, v)
14473}
14474
14475func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
14476 return ec.unmarshalInputNewBugInput(ctx, v)
14477}
14478
14479func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
14480 return ec._NewBugPayload(ctx, sel, &v)
14481}
14482
14483func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
14484 if v == nil {
14485 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14486 ec.Errorf(ctx, "must not be null")
14487 }
14488 return graphql.Null
14489 }
14490 return ec._NewBugPayload(ctx, sel, v)
14491}
14492
14493func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
14494 return ec.unmarshalInputOpenBugInput(ctx, v)
14495}
14496
14497func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
14498 return ec._OpenBugPayload(ctx, sel, &v)
14499}
14500
14501func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
14502 if v == nil {
14503 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14504 ec.Errorf(ctx, "must not be null")
14505 }
14506 return graphql.Null
14507 }
14508 return ec._OpenBugPayload(ctx, sel, v)
14509}
14510
14511func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
14512 return ec._Operation(ctx, sel, &v)
14513}
14514
14515func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
14516 ret := make(graphql.Array, len(v))
14517 var wg sync.WaitGroup
14518 isLen1 := len(v) == 1
14519 if !isLen1 {
14520 wg.Add(len(v))
14521 }
14522 for i := range v {
14523 i := i
14524 rctx := &graphql.ResolverContext{
14525 Index: &i,
14526 Result: &v[i],
14527 }
14528 ctx := graphql.WithResolverContext(ctx, rctx)
14529 f := func(i int) {
14530 defer func() {
14531 if r := recover(); r != nil {
14532 ec.Error(ctx, ec.Recover(ctx, r))
14533 ret = nil
14534 }
14535 }()
14536 if !isLen1 {
14537 defer wg.Done()
14538 }
14539 ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
14540 }
14541 if isLen1 {
14542 f(i)
14543 } else {
14544 go f(i)
14545 }
14546
14547 }
14548 wg.Wait()
14549 return ret
14550}
14551
14552func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
14553 return ec._OperationConnection(ctx, sel, &v)
14554}
14555
14556func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
14557 if v == nil {
14558 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14559 ec.Errorf(ctx, "must not be null")
14560 }
14561 return graphql.Null
14562 }
14563 return ec._OperationConnection(ctx, sel, v)
14564}
14565
14566func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
14567 return ec._OperationEdge(ctx, sel, &v)
14568}
14569
14570func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
14571 ret := make(graphql.Array, len(v))
14572 var wg sync.WaitGroup
14573 isLen1 := len(v) == 1
14574 if !isLen1 {
14575 wg.Add(len(v))
14576 }
14577 for i := range v {
14578 i := i
14579 rctx := &graphql.ResolverContext{
14580 Index: &i,
14581 Result: &v[i],
14582 }
14583 ctx := graphql.WithResolverContext(ctx, rctx)
14584 f := func(i int) {
14585 defer func() {
14586 if r := recover(); r != nil {
14587 ec.Error(ctx, ec.Recover(ctx, r))
14588 ret = nil
14589 }
14590 }()
14591 if !isLen1 {
14592 defer wg.Done()
14593 }
14594 ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
14595 }
14596 if isLen1 {
14597 f(i)
14598 } else {
14599 go f(i)
14600 }
14601
14602 }
14603 wg.Wait()
14604 return ret
14605}
14606
14607func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
14608 if v == nil {
14609 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14610 ec.Errorf(ctx, "must not be null")
14611 }
14612 return graphql.Null
14613 }
14614 return ec._OperationEdge(ctx, sel, v)
14615}
14616
14617func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
14618 return ec._PageInfo(ctx, sel, &v)
14619}
14620
14621func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
14622 if v == nil {
14623 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14624 ec.Errorf(ctx, "must not be null")
14625 }
14626 return graphql.Null
14627 }
14628 return ec._PageInfo(ctx, sel, v)
14629}
14630
14631func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
14632 return ec._SetStatusOperation(ctx, sel, &v)
14633}
14634
14635func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
14636 if v == nil {
14637 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14638 ec.Errorf(ctx, "must not be null")
14639 }
14640 return graphql.Null
14641 }
14642 return ec._SetStatusOperation(ctx, sel, v)
14643}
14644
14645func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
14646 return ec.unmarshalInputSetTitleInput(ctx, v)
14647}
14648
14649func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
14650 return ec._SetTitleOperation(ctx, sel, &v)
14651}
14652
14653func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
14654 if v == nil {
14655 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14656 ec.Errorf(ctx, "must not be null")
14657 }
14658 return graphql.Null
14659 }
14660 return ec._SetTitleOperation(ctx, sel, v)
14661}
14662
14663func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
14664 return ec._SetTitlePayload(ctx, sel, &v)
14665}
14666
14667func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14668 if v == nil {
14669 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14670 ec.Errorf(ctx, "must not be null")
14671 }
14672 return graphql.Null
14673 }
14674 return ec._SetTitlePayload(ctx, sel, v)
14675}
14676
14677func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14678 var res models.Status
14679 return res, res.UnmarshalGQL(v)
14680}
14681
14682func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14683 return v
14684}
14685
14686func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14687 return graphql.UnmarshalString(v)
14688}
14689
14690func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14691 res := graphql.MarshalString(v)
14692 if res == graphql.Null {
14693 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14694 ec.Errorf(ctx, "must not be null")
14695 }
14696 }
14697 return res
14698}
14699
14700func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14701 return graphql.UnmarshalTime(v)
14702}
14703
14704func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14705 res := graphql.MarshalTime(v)
14706 if res == graphql.Null {
14707 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14708 ec.Errorf(ctx, "must not be null")
14709 }
14710 }
14711 return res
14712}
14713
14714func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14715 if v == nil {
14716 return nil, nil
14717 }
14718 res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14719 return &res, err
14720}
14721
14722func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14723 if v == nil {
14724 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14725 ec.Errorf(ctx, "must not be null")
14726 }
14727 return graphql.Null
14728 }
14729 return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14730}
14731
14732func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14733 return ec._TimelineItem(ctx, sel, &v)
14734}
14735
14736func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14737 ret := make(graphql.Array, len(v))
14738 var wg sync.WaitGroup
14739 isLen1 := len(v) == 1
14740 if !isLen1 {
14741 wg.Add(len(v))
14742 }
14743 for i := range v {
14744 i := i
14745 rctx := &graphql.ResolverContext{
14746 Index: &i,
14747 Result: &v[i],
14748 }
14749 ctx := graphql.WithResolverContext(ctx, rctx)
14750 f := func(i int) {
14751 defer func() {
14752 if r := recover(); r != nil {
14753 ec.Error(ctx, ec.Recover(ctx, r))
14754 ret = nil
14755 }
14756 }()
14757 if !isLen1 {
14758 defer wg.Done()
14759 }
14760 ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14761 }
14762 if isLen1 {
14763 f(i)
14764 } else {
14765 go f(i)
14766 }
14767
14768 }
14769 wg.Wait()
14770 return ret
14771}
14772
14773func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14774 return ec._TimelineItemConnection(ctx, sel, &v)
14775}
14776
14777func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14778 if v == nil {
14779 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14780 ec.Errorf(ctx, "must not be null")
14781 }
14782 return graphql.Null
14783 }
14784 return ec._TimelineItemConnection(ctx, sel, v)
14785}
14786
14787func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14788 return ec._TimelineItemEdge(ctx, sel, &v)
14789}
14790
14791func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14792 ret := make(graphql.Array, len(v))
14793 var wg sync.WaitGroup
14794 isLen1 := len(v) == 1
14795 if !isLen1 {
14796 wg.Add(len(v))
14797 }
14798 for i := range v {
14799 i := i
14800 rctx := &graphql.ResolverContext{
14801 Index: &i,
14802 Result: &v[i],
14803 }
14804 ctx := graphql.WithResolverContext(ctx, rctx)
14805 f := func(i int) {
14806 defer func() {
14807 if r := recover(); r != nil {
14808 ec.Error(ctx, ec.Recover(ctx, r))
14809 ret = nil
14810 }
14811 }()
14812 if !isLen1 {
14813 defer wg.Done()
14814 }
14815 ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14816 }
14817 if isLen1 {
14818 f(i)
14819 } else {
14820 go f(i)
14821 }
14822
14823 }
14824 wg.Wait()
14825 return ret
14826}
14827
14828func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
14829 if v == nil {
14830 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14831 ec.Errorf(ctx, "must not be null")
14832 }
14833 return graphql.Null
14834 }
14835 return ec._TimelineItemEdge(ctx, sel, v)
14836}
14837
14838func (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 {
14839 return ec.___Directive(ctx, sel, &v)
14840}
14841
14842func (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 {
14843 ret := make(graphql.Array, len(v))
14844 var wg sync.WaitGroup
14845 isLen1 := len(v) == 1
14846 if !isLen1 {
14847 wg.Add(len(v))
14848 }
14849 for i := range v {
14850 i := i
14851 rctx := &graphql.ResolverContext{
14852 Index: &i,
14853 Result: &v[i],
14854 }
14855 ctx := graphql.WithResolverContext(ctx, rctx)
14856 f := func(i int) {
14857 defer func() {
14858 if r := recover(); r != nil {
14859 ec.Error(ctx, ec.Recover(ctx, r))
14860 ret = nil
14861 }
14862 }()
14863 if !isLen1 {
14864 defer wg.Done()
14865 }
14866 ret[i] = ec.marshalN__Directive2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14867 }
14868 if isLen1 {
14869 f(i)
14870 } else {
14871 go f(i)
14872 }
14873
14874 }
14875 wg.Wait()
14876 return ret
14877}
14878
14879func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14880 return graphql.UnmarshalString(v)
14881}
14882
14883func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14884 res := graphql.MarshalString(v)
14885 if res == graphql.Null {
14886 if !ec.HasError(graphql.GetResolverContext(ctx)) {
14887 ec.Errorf(ctx, "must not be null")
14888 }
14889 }
14890 return res
14891}
14892
14893func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
14894 var vSlice []interface{}
14895 if v != nil {
14896 if tmp1, ok := v.([]interface{}); ok {
14897 vSlice = tmp1
14898 } else {
14899 vSlice = []interface{}{v}
14900 }
14901 }
14902 var err error
14903 res := make([]string, len(vSlice))
14904 for i := range vSlice {
14905 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14906 if err != nil {
14907 return nil, err
14908 }
14909 }
14910 return res, nil
14911}
14912
14913func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14914 ret := make(graphql.Array, len(v))
14915 var wg sync.WaitGroup
14916 isLen1 := len(v) == 1
14917 if !isLen1 {
14918 wg.Add(len(v))
14919 }
14920 for i := range v {
14921 i := i
14922 rctx := &graphql.ResolverContext{
14923 Index: &i,
14924 Result: &v[i],
14925 }
14926 ctx := graphql.WithResolverContext(ctx, rctx)
14927 f := func(i int) {
14928 defer func() {
14929 if r := recover(); r != nil {
14930 ec.Error(ctx, ec.Recover(ctx, r))
14931 ret = nil
14932 }
14933 }()
14934 if !isLen1 {
14935 defer wg.Done()
14936 }
14937 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
14938 }
14939 if isLen1 {
14940 f(i)
14941 } else {
14942 go f(i)
14943 }
14944
14945 }
14946 wg.Wait()
14947 return ret
14948}
14949
14950func (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 {
14951 return ec.___EnumValue(ctx, sel, &v)
14952}
14953
14954func (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 {
14955 return ec.___Field(ctx, sel, &v)
14956}
14957
14958func (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 {
14959 return ec.___InputValue(ctx, sel, &v)
14960}
14961
14962func (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 {
14963 ret := make(graphql.Array, len(v))
14964 var wg sync.WaitGroup
14965 isLen1 := len(v) == 1
14966 if !isLen1 {
14967 wg.Add(len(v))
14968 }
14969 for i := range v {
14970 i := i
14971 rctx := &graphql.ResolverContext{
14972 Index: &i,
14973 Result: &v[i],
14974 }
14975 ctx := graphql.WithResolverContext(ctx, rctx)
14976 f := func(i int) {
14977 defer func() {
14978 if r := recover(); r != nil {
14979 ec.Error(ctx, ec.Recover(ctx, r))
14980 ret = nil
14981 }
14982 }()
14983 if !isLen1 {
14984 defer wg.Done()
14985 }
14986 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14987 }
14988 if isLen1 {
14989 f(i)
14990 } else {
14991 go f(i)
14992 }
14993
14994 }
14995 wg.Wait()
14996 return ret
14997}
14998
14999func (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 {
15000 return ec.___Type(ctx, sel, &v)
15001}
15002
15003func (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 {
15004 ret := make(graphql.Array, len(v))
15005 var wg sync.WaitGroup
15006 isLen1 := len(v) == 1
15007 if !isLen1 {
15008 wg.Add(len(v))
15009 }
15010 for i := range v {
15011 i := i
15012 rctx := &graphql.ResolverContext{
15013 Index: &i,
15014 Result: &v[i],
15015 }
15016 ctx := graphql.WithResolverContext(ctx, rctx)
15017 f := func(i int) {
15018 defer func() {
15019 if r := recover(); r != nil {
15020 ec.Error(ctx, ec.Recover(ctx, r))
15021 ret = nil
15022 }
15023 }()
15024 if !isLen1 {
15025 defer wg.Done()
15026 }
15027 ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
15028 }
15029 if isLen1 {
15030 f(i)
15031 } else {
15032 go f(i)
15033 }
15034
15035 }
15036 wg.Wait()
15037 return ret
15038}
15039
15040func (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 {
15041 if v == nil {
15042 if !ec.HasError(graphql.GetResolverContext(ctx)) {
15043 ec.Errorf(ctx, "must not be null")
15044 }
15045 return graphql.Null
15046 }
15047 return ec.___Type(ctx, sel, v)
15048}
15049
15050func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
15051 return graphql.UnmarshalString(v)
15052}
15053
15054func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
15055 res := graphql.MarshalString(v)
15056 if res == graphql.Null {
15057 if !ec.HasError(graphql.GetResolverContext(ctx)) {
15058 ec.Errorf(ctx, "must not be null")
15059 }
15060 }
15061 return res
15062}
15063
15064func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
15065 return graphql.UnmarshalBoolean(v)
15066}
15067
15068func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
15069 return graphql.MarshalBoolean(v)
15070}
15071
15072func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
15073 if v == nil {
15074 return nil, nil
15075 }
15076 res, err := ec.unmarshalOBoolean2bool(ctx, v)
15077 return &res, err
15078}
15079
15080func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
15081 if v == nil {
15082 return graphql.Null
15083 }
15084 return ec.marshalOBoolean2bool(ctx, sel, *v)
15085}
15086
15087func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
15088 return ec._Bug(ctx, sel, &v)
15089}
15090
15091func (ec *executionContext) marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
15092 if v == nil {
15093 return graphql.Null
15094 }
15095 return ec._Bug(ctx, sel, v)
15096}
15097
15098func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
15099 return ec.unmarshalInputChangeLabelInput(ctx, v)
15100}
15101
15102func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
15103 if v == nil {
15104 return nil, nil
15105 }
15106 res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
15107 return &res, err
15108}
15109
15110func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
15111 var vSlice []interface{}
15112 if v != nil {
15113 if tmp1, ok := v.([]interface{}); ok {
15114 vSlice = tmp1
15115 } else {
15116 vSlice = []interface{}{v}
15117 }
15118 }
15119 var err error
15120 res := make([]git.Hash, len(vSlice))
15121 for i := range vSlice {
15122 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
15123 if err != nil {
15124 return nil, err
15125 }
15126 }
15127 return res, nil
15128}
15129
15130func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
15131 if v == nil {
15132 return graphql.Null
15133 }
15134 ret := make(graphql.Array, len(v))
15135 for i := range v {
15136 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
15137 }
15138
15139 return ret
15140}
15141
15142func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
15143 return ec._Identity(ctx, sel, &v)
15144}
15145
15146func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
15147 return graphql.UnmarshalInt(v)
15148}
15149
15150func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
15151 return graphql.MarshalInt(v)
15152}
15153
15154func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
15155 if v == nil {
15156 return nil, nil
15157 }
15158 res, err := ec.unmarshalOInt2int(ctx, v)
15159 return &res, err
15160}
15161
15162func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
15163 if v == nil {
15164 return graphql.Null
15165 }
15166 return ec.marshalOInt2int(ctx, sel, *v)
15167}
15168
15169func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
15170 return ec._LabelChangeResult(ctx, sel, &v)
15171}
15172
15173func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
15174 if v == nil {
15175 return graphql.Null
15176 }
15177 return ec._LabelChangeResult(ctx, sel, v)
15178}
15179
15180func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
15181 return ec._Repository(ctx, sel, &v)
15182}
15183
15184func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
15185 if v == nil {
15186 return graphql.Null
15187 }
15188 return ec._Repository(ctx, sel, v)
15189}
15190
15191func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
15192 return graphql.UnmarshalString(v)
15193}
15194
15195func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
15196 return graphql.MarshalString(v)
15197}
15198
15199func (ec *executionContext) unmarshalOString2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
15200 var vSlice []interface{}
15201 if v != nil {
15202 if tmp1, ok := v.([]interface{}); ok {
15203 vSlice = tmp1
15204 } else {
15205 vSlice = []interface{}{v}
15206 }
15207 }
15208 var err error
15209 res := make([]string, len(vSlice))
15210 for i := range vSlice {
15211 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
15212 if err != nil {
15213 return nil, err
15214 }
15215 }
15216 return res, nil
15217}
15218
15219func (ec *executionContext) marshalOString2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
15220 if v == nil {
15221 return graphql.Null
15222 }
15223 ret := make(graphql.Array, len(v))
15224 for i := range v {
15225 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
15226 }
15227
15228 return ret
15229}
15230
15231func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
15232 if v == nil {
15233 return nil, nil
15234 }
15235 res, err := ec.unmarshalOString2string(ctx, v)
15236 return &res, err
15237}
15238
15239func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
15240 if v == nil {
15241 return graphql.Null
15242 }
15243 return ec.marshalOString2string(ctx, sel, *v)
15244}
15245
15246func (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 {
15247 if v == nil {
15248 return graphql.Null
15249 }
15250 ret := make(graphql.Array, len(v))
15251 var wg sync.WaitGroup
15252 isLen1 := len(v) == 1
15253 if !isLen1 {
15254 wg.Add(len(v))
15255 }
15256 for i := range v {
15257 i := i
15258 rctx := &graphql.ResolverContext{
15259 Index: &i,
15260 Result: &v[i],
15261 }
15262 ctx := graphql.WithResolverContext(ctx, rctx)
15263 f := func(i int) {
15264 defer func() {
15265 if r := recover(); r != nil {
15266 ec.Error(ctx, ec.Recover(ctx, r))
15267 ret = nil
15268 }
15269 }()
15270 if !isLen1 {
15271 defer wg.Done()
15272 }
15273 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
15274 }
15275 if isLen1 {
15276 f(i)
15277 } else {
15278 go f(i)
15279 }
15280
15281 }
15282 wg.Wait()
15283 return ret
15284}
15285
15286func (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 {
15287 if v == nil {
15288 return graphql.Null
15289 }
15290 ret := make(graphql.Array, len(v))
15291 var wg sync.WaitGroup
15292 isLen1 := len(v) == 1
15293 if !isLen1 {
15294 wg.Add(len(v))
15295 }
15296 for i := range v {
15297 i := i
15298 rctx := &graphql.ResolverContext{
15299 Index: &i,
15300 Result: &v[i],
15301 }
15302 ctx := graphql.WithResolverContext(ctx, rctx)
15303 f := func(i int) {
15304 defer func() {
15305 if r := recover(); r != nil {
15306 ec.Error(ctx, ec.Recover(ctx, r))
15307 ret = nil
15308 }
15309 }()
15310 if !isLen1 {
15311 defer wg.Done()
15312 }
15313 ret[i] = ec.marshalN__Field2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
15314 }
15315 if isLen1 {
15316 f(i)
15317 } else {
15318 go f(i)
15319 }
15320
15321 }
15322 wg.Wait()
15323 return ret
15324}
15325
15326func (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 {
15327 if v == nil {
15328 return graphql.Null
15329 }
15330 ret := make(graphql.Array, len(v))
15331 var wg sync.WaitGroup
15332 isLen1 := len(v) == 1
15333 if !isLen1 {
15334 wg.Add(len(v))
15335 }
15336 for i := range v {
15337 i := i
15338 rctx := &graphql.ResolverContext{
15339 Index: &i,
15340 Result: &v[i],
15341 }
15342 ctx := graphql.WithResolverContext(ctx, rctx)
15343 f := func(i int) {
15344 defer func() {
15345 if r := recover(); r != nil {
15346 ec.Error(ctx, ec.Recover(ctx, r))
15347 ret = nil
15348 }
15349 }()
15350 if !isLen1 {
15351 defer wg.Done()
15352 }
15353 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
15354 }
15355 if isLen1 {
15356 f(i)
15357 } else {
15358 go f(i)
15359 }
15360
15361 }
15362 wg.Wait()
15363 return ret
15364}
15365
15366func (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 {
15367 return ec.___Schema(ctx, sel, &v)
15368}
15369
15370func (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 {
15371 if v == nil {
15372 return graphql.Null
15373 }
15374 return ec.___Schema(ctx, sel, v)
15375}
15376
15377func (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 {
15378 return ec.___Type(ctx, sel, &v)
15379}
15380
15381func (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 {
15382 if v == nil {
15383 return graphql.Null
15384 }
15385 ret := make(graphql.Array, len(v))
15386 var wg sync.WaitGroup
15387 isLen1 := len(v) == 1
15388 if !isLen1 {
15389 wg.Add(len(v))
15390 }
15391 for i := range v {
15392 i := i
15393 rctx := &graphql.ResolverContext{
15394 Index: &i,
15395 Result: &v[i],
15396 }
15397 ctx := graphql.WithResolverContext(ctx, rctx)
15398 f := func(i int) {
15399 defer func() {
15400 if r := recover(); r != nil {
15401 ec.Error(ctx, ec.Recover(ctx, r))
15402 ret = nil
15403 }
15404 }()
15405 if !isLen1 {
15406 defer wg.Done()
15407 }
15408 ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
15409 }
15410 if isLen1 {
15411 f(i)
15412 } else {
15413 go f(i)
15414 }
15415
15416 }
15417 wg.Wait()
15418 return ret
15419}
15420
15421func (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 {
15422 if v == nil {
15423 return graphql.Null
15424 }
15425 return ec.___Type(ctx, sel, v)
15426}
15427
15428// endregion ***************************** type.gotpl *****************************