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}
424type LabelResolver interface {
425 Name(ctx context.Context, obj *bug.Label) (string, error)
426 Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
427}
428type LabelChangeOperationResolver interface {
429 ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
430
431 Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
432}
433type LabelChangeResultResolver interface {
434 Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
435}
436type LabelChangeTimelineItemResolver interface {
437 ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
438
439 Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
440}
441type MutationResolver interface {
442 NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
443 AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
444 ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
445 OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
446 CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
447 SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
448 Commit(ctx context.Context, input models.CommitInput) (*models.CommitPayload, error)
449 CommitAsNeeded(ctx context.Context, input models.CommitAsNeededInput) (*models.CommitAsNeededPayload, error)
450}
451type QueryResolver interface {
452 DefaultRepository(ctx context.Context) (*models.Repository, error)
453 Repository(ctx context.Context, ref string) (*models.Repository, error)
454}
455type RepositoryResolver interface {
456 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
457 Bug(ctx context.Context, obj *models.Repository, prefix string) (*bug.Snapshot, error)
458 AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
459 Identity(ctx context.Context, obj *models.Repository, prefix string) (identity.Interface, error)
460 UserIdentity(ctx context.Context, obj *models.Repository) (identity.Interface, error)
461 ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
462}
463type SetStatusOperationResolver interface {
464 ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
465
466 Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
467 Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
468}
469type SetStatusTimelineItemResolver interface {
470 ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
471
472 Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
473 Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
474}
475type SetTitleOperationResolver interface {
476 ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
477
478 Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
479}
480type SetTitleTimelineItemResolver interface {
481 ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
482
483 Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
484}
485
486type executableSchema struct {
487 resolvers ResolverRoot
488 directives DirectiveRoot
489 complexity ComplexityRoot
490}
491
492func (e *executableSchema) Schema() *ast.Schema {
493 return parsedSchema
494}
495
496func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
497 ec := executionContext{nil, e}
498 _ = ec
499 switch typeName + "." + field {
500
501 case "AddCommentOperation.author":
502 if e.complexity.AddCommentOperation.Author == nil {
503 break
504 }
505
506 return e.complexity.AddCommentOperation.Author(childComplexity), true
507
508 case "AddCommentOperation.date":
509 if e.complexity.AddCommentOperation.Date == nil {
510 break
511 }
512
513 return e.complexity.AddCommentOperation.Date(childComplexity), true
514
515 case "AddCommentOperation.files":
516 if e.complexity.AddCommentOperation.Files == nil {
517 break
518 }
519
520 return e.complexity.AddCommentOperation.Files(childComplexity), true
521
522 case "AddCommentOperation.id":
523 if e.complexity.AddCommentOperation.ID == nil {
524 break
525 }
526
527 return e.complexity.AddCommentOperation.ID(childComplexity), true
528
529 case "AddCommentOperation.message":
530 if e.complexity.AddCommentOperation.Message == nil {
531 break
532 }
533
534 return e.complexity.AddCommentOperation.Message(childComplexity), true
535
536 case "AddCommentPayload.bug":
537 if e.complexity.AddCommentPayload.Bug == nil {
538 break
539 }
540
541 return e.complexity.AddCommentPayload.Bug(childComplexity), true
542
543 case "AddCommentPayload.clientMutationId":
544 if e.complexity.AddCommentPayload.ClientMutationID == nil {
545 break
546 }
547
548 return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
549
550 case "AddCommentPayload.operation":
551 if e.complexity.AddCommentPayload.Operation == nil {
552 break
553 }
554
555 return e.complexity.AddCommentPayload.Operation(childComplexity), true
556
557 case "AddCommentTimelineItem.author":
558 if e.complexity.AddCommentTimelineItem.Author == nil {
559 break
560 }
561
562 return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
563
564 case "AddCommentTimelineItem.createdAt":
565 if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
566 break
567 }
568
569 return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
570
571 case "AddCommentTimelineItem.edited":
572 if e.complexity.AddCommentTimelineItem.Edited == nil {
573 break
574 }
575
576 return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
577
578 case "AddCommentTimelineItem.files":
579 if e.complexity.AddCommentTimelineItem.Files == nil {
580 break
581 }
582
583 return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
584
585 case "AddCommentTimelineItem.history":
586 if e.complexity.AddCommentTimelineItem.History == nil {
587 break
588 }
589
590 return e.complexity.AddCommentTimelineItem.History(childComplexity), true
591
592 case "AddCommentTimelineItem.id":
593 if e.complexity.AddCommentTimelineItem.ID == nil {
594 break
595 }
596
597 return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
598
599 case "AddCommentTimelineItem.lastEdit":
600 if e.complexity.AddCommentTimelineItem.LastEdit == nil {
601 break
602 }
603
604 return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
605
606 case "AddCommentTimelineItem.message":
607 if e.complexity.AddCommentTimelineItem.Message == nil {
608 break
609 }
610
611 return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
612
613 case "AddCommentTimelineItem.messageIsEmpty":
614 if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
615 break
616 }
617
618 return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
619
620 case "Bug.actors":
621 if e.complexity.Bug.Actors == nil {
622 break
623 }
624
625 args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
626 if err != nil {
627 return 0, false
628 }
629
630 return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
631
632 case "Bug.author":
633 if e.complexity.Bug.Author == nil {
634 break
635 }
636
637 return e.complexity.Bug.Author(childComplexity), true
638
639 case "Bug.comments":
640 if e.complexity.Bug.Comments == nil {
641 break
642 }
643
644 args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
645 if err != nil {
646 return 0, false
647 }
648
649 return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
650
651 case "Bug.createdAt":
652 if e.complexity.Bug.CreatedAt == nil {
653 break
654 }
655
656 return e.complexity.Bug.CreatedAt(childComplexity), true
657
658 case "Bug.humanId":
659 if e.complexity.Bug.HumanID == nil {
660 break
661 }
662
663 return e.complexity.Bug.HumanID(childComplexity), true
664
665 case "Bug.id":
666 if e.complexity.Bug.ID == nil {
667 break
668 }
669
670 return e.complexity.Bug.ID(childComplexity), true
671
672 case "Bug.labels":
673 if e.complexity.Bug.Labels == nil {
674 break
675 }
676
677 return e.complexity.Bug.Labels(childComplexity), true
678
679 case "Bug.lastEdit":
680 if e.complexity.Bug.LastEdit == nil {
681 break
682 }
683
684 return e.complexity.Bug.LastEdit(childComplexity), true
685
686 case "Bug.operations":
687 if e.complexity.Bug.Operations == nil {
688 break
689 }
690
691 args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
692 if err != nil {
693 return 0, false
694 }
695
696 return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
697
698 case "Bug.participants":
699 if e.complexity.Bug.Participants == nil {
700 break
701 }
702
703 args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
704 if err != nil {
705 return 0, false
706 }
707
708 return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
709
710 case "Bug.status":
711 if e.complexity.Bug.Status == nil {
712 break
713 }
714
715 return e.complexity.Bug.Status(childComplexity), true
716
717 case "Bug.timeline":
718 if e.complexity.Bug.Timeline == nil {
719 break
720 }
721
722 args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
723 if err != nil {
724 return 0, false
725 }
726
727 return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
728
729 case "Bug.title":
730 if e.complexity.Bug.Title == nil {
731 break
732 }
733
734 return e.complexity.Bug.Title(childComplexity), true
735
736 case "BugConnection.edges":
737 if e.complexity.BugConnection.Edges == nil {
738 break
739 }
740
741 return e.complexity.BugConnection.Edges(childComplexity), true
742
743 case "BugConnection.nodes":
744 if e.complexity.BugConnection.Nodes == nil {
745 break
746 }
747
748 return e.complexity.BugConnection.Nodes(childComplexity), true
749
750 case "BugConnection.pageInfo":
751 if e.complexity.BugConnection.PageInfo == nil {
752 break
753 }
754
755 return e.complexity.BugConnection.PageInfo(childComplexity), true
756
757 case "BugConnection.totalCount":
758 if e.complexity.BugConnection.TotalCount == nil {
759 break
760 }
761
762 return e.complexity.BugConnection.TotalCount(childComplexity), true
763
764 case "BugEdge.cursor":
765 if e.complexity.BugEdge.Cursor == nil {
766 break
767 }
768
769 return e.complexity.BugEdge.Cursor(childComplexity), true
770
771 case "BugEdge.node":
772 if e.complexity.BugEdge.Node == nil {
773 break
774 }
775
776 return e.complexity.BugEdge.Node(childComplexity), true
777
778 case "ChangeLabelPayload.bug":
779 if e.complexity.ChangeLabelPayload.Bug == nil {
780 break
781 }
782
783 return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
784
785 case "ChangeLabelPayload.clientMutationId":
786 if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
787 break
788 }
789
790 return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
791
792 case "ChangeLabelPayload.operation":
793 if e.complexity.ChangeLabelPayload.Operation == nil {
794 break
795 }
796
797 return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
798
799 case "ChangeLabelPayload.results":
800 if e.complexity.ChangeLabelPayload.Results == nil {
801 break
802 }
803
804 return e.complexity.ChangeLabelPayload.Results(childComplexity), true
805
806 case "CloseBugPayload.bug":
807 if e.complexity.CloseBugPayload.Bug == nil {
808 break
809 }
810
811 return e.complexity.CloseBugPayload.Bug(childComplexity), true
812
813 case "CloseBugPayload.clientMutationId":
814 if e.complexity.CloseBugPayload.ClientMutationID == nil {
815 break
816 }
817
818 return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
819
820 case "CloseBugPayload.operation":
821 if e.complexity.CloseBugPayload.Operation == nil {
822 break
823 }
824
825 return e.complexity.CloseBugPayload.Operation(childComplexity), true
826
827 case "Color.B":
828 if e.complexity.Color.B == nil {
829 break
830 }
831
832 return e.complexity.Color.B(childComplexity), true
833
834 case "Color.G":
835 if e.complexity.Color.G == nil {
836 break
837 }
838
839 return e.complexity.Color.G(childComplexity), true
840
841 case "Color.R":
842 if e.complexity.Color.R == nil {
843 break
844 }
845
846 return e.complexity.Color.R(childComplexity), true
847
848 case "Comment.author":
849 if e.complexity.Comment.Author == nil {
850 break
851 }
852
853 return e.complexity.Comment.Author(childComplexity), true
854
855 case "Comment.files":
856 if e.complexity.Comment.Files == nil {
857 break
858 }
859
860 return e.complexity.Comment.Files(childComplexity), true
861
862 case "Comment.message":
863 if e.complexity.Comment.Message == nil {
864 break
865 }
866
867 return e.complexity.Comment.Message(childComplexity), true
868
869 case "CommentConnection.edges":
870 if e.complexity.CommentConnection.Edges == nil {
871 break
872 }
873
874 return e.complexity.CommentConnection.Edges(childComplexity), true
875
876 case "CommentConnection.nodes":
877 if e.complexity.CommentConnection.Nodes == nil {
878 break
879 }
880
881 return e.complexity.CommentConnection.Nodes(childComplexity), true
882
883 case "CommentConnection.pageInfo":
884 if e.complexity.CommentConnection.PageInfo == nil {
885 break
886 }
887
888 return e.complexity.CommentConnection.PageInfo(childComplexity), true
889
890 case "CommentConnection.totalCount":
891 if e.complexity.CommentConnection.TotalCount == nil {
892 break
893 }
894
895 return e.complexity.CommentConnection.TotalCount(childComplexity), true
896
897 case "CommentEdge.cursor":
898 if e.complexity.CommentEdge.Cursor == nil {
899 break
900 }
901
902 return e.complexity.CommentEdge.Cursor(childComplexity), true
903
904 case "CommentEdge.node":
905 if e.complexity.CommentEdge.Node == nil {
906 break
907 }
908
909 return e.complexity.CommentEdge.Node(childComplexity), true
910
911 case "CommentHistoryStep.date":
912 if e.complexity.CommentHistoryStep.Date == nil {
913 break
914 }
915
916 return e.complexity.CommentHistoryStep.Date(childComplexity), true
917
918 case "CommentHistoryStep.message":
919 if e.complexity.CommentHistoryStep.Message == nil {
920 break
921 }
922
923 return e.complexity.CommentHistoryStep.Message(childComplexity), true
924
925 case "CommitAsNeededPayload.bug":
926 if e.complexity.CommitAsNeededPayload.Bug == nil {
927 break
928 }
929
930 return e.complexity.CommitAsNeededPayload.Bug(childComplexity), true
931
932 case "CommitAsNeededPayload.clientMutationId":
933 if e.complexity.CommitAsNeededPayload.ClientMutationID == nil {
934 break
935 }
936
937 return e.complexity.CommitAsNeededPayload.ClientMutationID(childComplexity), true
938
939 case "CommitPayload.bug":
940 if e.complexity.CommitPayload.Bug == nil {
941 break
942 }
943
944 return e.complexity.CommitPayload.Bug(childComplexity), true
945
946 case "CommitPayload.clientMutationId":
947 if e.complexity.CommitPayload.ClientMutationID == nil {
948 break
949 }
950
951 return e.complexity.CommitPayload.ClientMutationID(childComplexity), true
952
953 case "CreateOperation.author":
954 if e.complexity.CreateOperation.Author == nil {
955 break
956 }
957
958 return e.complexity.CreateOperation.Author(childComplexity), true
959
960 case "CreateOperation.date":
961 if e.complexity.CreateOperation.Date == nil {
962 break
963 }
964
965 return e.complexity.CreateOperation.Date(childComplexity), true
966
967 case "CreateOperation.files":
968 if e.complexity.CreateOperation.Files == nil {
969 break
970 }
971
972 return e.complexity.CreateOperation.Files(childComplexity), true
973
974 case "CreateOperation.id":
975 if e.complexity.CreateOperation.ID == nil {
976 break
977 }
978
979 return e.complexity.CreateOperation.ID(childComplexity), true
980
981 case "CreateOperation.message":
982 if e.complexity.CreateOperation.Message == nil {
983 break
984 }
985
986 return e.complexity.CreateOperation.Message(childComplexity), true
987
988 case "CreateOperation.title":
989 if e.complexity.CreateOperation.Title == nil {
990 break
991 }
992
993 return e.complexity.CreateOperation.Title(childComplexity), true
994
995 case "CreateTimelineItem.author":
996 if e.complexity.CreateTimelineItem.Author == nil {
997 break
998 }
999
1000 return e.complexity.CreateTimelineItem.Author(childComplexity), true
1001
1002 case "CreateTimelineItem.createdAt":
1003 if e.complexity.CreateTimelineItem.CreatedAt == nil {
1004 break
1005 }
1006
1007 return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
1008
1009 case "CreateTimelineItem.edited":
1010 if e.complexity.CreateTimelineItem.Edited == nil {
1011 break
1012 }
1013
1014 return e.complexity.CreateTimelineItem.Edited(childComplexity), true
1015
1016 case "CreateTimelineItem.files":
1017 if e.complexity.CreateTimelineItem.Files == nil {
1018 break
1019 }
1020
1021 return e.complexity.CreateTimelineItem.Files(childComplexity), true
1022
1023 case "CreateTimelineItem.history":
1024 if e.complexity.CreateTimelineItem.History == nil {
1025 break
1026 }
1027
1028 return e.complexity.CreateTimelineItem.History(childComplexity), true
1029
1030 case "CreateTimelineItem.id":
1031 if e.complexity.CreateTimelineItem.ID == nil {
1032 break
1033 }
1034
1035 return e.complexity.CreateTimelineItem.ID(childComplexity), true
1036
1037 case "CreateTimelineItem.lastEdit":
1038 if e.complexity.CreateTimelineItem.LastEdit == nil {
1039 break
1040 }
1041
1042 return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
1043
1044 case "CreateTimelineItem.message":
1045 if e.complexity.CreateTimelineItem.Message == nil {
1046 break
1047 }
1048
1049 return e.complexity.CreateTimelineItem.Message(childComplexity), true
1050
1051 case "CreateTimelineItem.messageIsEmpty":
1052 if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
1053 break
1054 }
1055
1056 return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
1057
1058 case "EditCommentOperation.author":
1059 if e.complexity.EditCommentOperation.Author == nil {
1060 break
1061 }
1062
1063 return e.complexity.EditCommentOperation.Author(childComplexity), true
1064
1065 case "EditCommentOperation.date":
1066 if e.complexity.EditCommentOperation.Date == nil {
1067 break
1068 }
1069
1070 return e.complexity.EditCommentOperation.Date(childComplexity), true
1071
1072 case "EditCommentOperation.files":
1073 if e.complexity.EditCommentOperation.Files == nil {
1074 break
1075 }
1076
1077 return e.complexity.EditCommentOperation.Files(childComplexity), true
1078
1079 case "EditCommentOperation.id":
1080 if e.complexity.EditCommentOperation.ID == nil {
1081 break
1082 }
1083
1084 return e.complexity.EditCommentOperation.ID(childComplexity), true
1085
1086 case "EditCommentOperation.message":
1087 if e.complexity.EditCommentOperation.Message == nil {
1088 break
1089 }
1090
1091 return e.complexity.EditCommentOperation.Message(childComplexity), true
1092
1093 case "EditCommentOperation.target":
1094 if e.complexity.EditCommentOperation.Target == nil {
1095 break
1096 }
1097
1098 return e.complexity.EditCommentOperation.Target(childComplexity), true
1099
1100 case "Identity.avatarUrl":
1101 if e.complexity.Identity.AvatarUrl == nil {
1102 break
1103 }
1104
1105 return e.complexity.Identity.AvatarUrl(childComplexity), true
1106
1107 case "Identity.displayName":
1108 if e.complexity.Identity.DisplayName == nil {
1109 break
1110 }
1111
1112 return e.complexity.Identity.DisplayName(childComplexity), true
1113
1114 case "Identity.email":
1115 if e.complexity.Identity.Email == nil {
1116 break
1117 }
1118
1119 return e.complexity.Identity.Email(childComplexity), true
1120
1121 case "Identity.humanId":
1122 if e.complexity.Identity.HumanID == nil {
1123 break
1124 }
1125
1126 return e.complexity.Identity.HumanID(childComplexity), true
1127
1128 case "Identity.id":
1129 if e.complexity.Identity.ID == nil {
1130 break
1131 }
1132
1133 return e.complexity.Identity.ID(childComplexity), true
1134
1135 case "Identity.isProtected":
1136 if e.complexity.Identity.IsProtected == nil {
1137 break
1138 }
1139
1140 return e.complexity.Identity.IsProtected(childComplexity), true
1141
1142 case "Identity.login":
1143 if e.complexity.Identity.Login == nil {
1144 break
1145 }
1146
1147 return e.complexity.Identity.Login(childComplexity), true
1148
1149 case "Identity.name":
1150 if e.complexity.Identity.Name == nil {
1151 break
1152 }
1153
1154 return e.complexity.Identity.Name(childComplexity), true
1155
1156 case "IdentityConnection.edges":
1157 if e.complexity.IdentityConnection.Edges == nil {
1158 break
1159 }
1160
1161 return e.complexity.IdentityConnection.Edges(childComplexity), true
1162
1163 case "IdentityConnection.nodes":
1164 if e.complexity.IdentityConnection.Nodes == nil {
1165 break
1166 }
1167
1168 return e.complexity.IdentityConnection.Nodes(childComplexity), true
1169
1170 case "IdentityConnection.pageInfo":
1171 if e.complexity.IdentityConnection.PageInfo == nil {
1172 break
1173 }
1174
1175 return e.complexity.IdentityConnection.PageInfo(childComplexity), true
1176
1177 case "IdentityConnection.totalCount":
1178 if e.complexity.IdentityConnection.TotalCount == nil {
1179 break
1180 }
1181
1182 return e.complexity.IdentityConnection.TotalCount(childComplexity), true
1183
1184 case "IdentityEdge.cursor":
1185 if e.complexity.IdentityEdge.Cursor == nil {
1186 break
1187 }
1188
1189 return e.complexity.IdentityEdge.Cursor(childComplexity), true
1190
1191 case "IdentityEdge.node":
1192 if e.complexity.IdentityEdge.Node == nil {
1193 break
1194 }
1195
1196 return e.complexity.IdentityEdge.Node(childComplexity), true
1197
1198 case "Label.color":
1199 if e.complexity.Label.Color == nil {
1200 break
1201 }
1202
1203 return e.complexity.Label.Color(childComplexity), true
1204
1205 case "Label.name":
1206 if e.complexity.Label.Name == nil {
1207 break
1208 }
1209
1210 return e.complexity.Label.Name(childComplexity), true
1211
1212 case "LabelChangeOperation.added":
1213 if e.complexity.LabelChangeOperation.Added == nil {
1214 break
1215 }
1216
1217 return e.complexity.LabelChangeOperation.Added(childComplexity), true
1218
1219 case "LabelChangeOperation.author":
1220 if e.complexity.LabelChangeOperation.Author == nil {
1221 break
1222 }
1223
1224 return e.complexity.LabelChangeOperation.Author(childComplexity), true
1225
1226 case "LabelChangeOperation.date":
1227 if e.complexity.LabelChangeOperation.Date == nil {
1228 break
1229 }
1230
1231 return e.complexity.LabelChangeOperation.Date(childComplexity), true
1232
1233 case "LabelChangeOperation.id":
1234 if e.complexity.LabelChangeOperation.ID == nil {
1235 break
1236 }
1237
1238 return e.complexity.LabelChangeOperation.ID(childComplexity), true
1239
1240 case "LabelChangeOperation.removed":
1241 if e.complexity.LabelChangeOperation.Removed == nil {
1242 break
1243 }
1244
1245 return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1246
1247 case "LabelChangeResult.label":
1248 if e.complexity.LabelChangeResult.Label == nil {
1249 break
1250 }
1251
1252 return e.complexity.LabelChangeResult.Label(childComplexity), true
1253
1254 case "LabelChangeResult.status":
1255 if e.complexity.LabelChangeResult.Status == nil {
1256 break
1257 }
1258
1259 return e.complexity.LabelChangeResult.Status(childComplexity), true
1260
1261 case "LabelChangeTimelineItem.added":
1262 if e.complexity.LabelChangeTimelineItem.Added == nil {
1263 break
1264 }
1265
1266 return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
1267
1268 case "LabelChangeTimelineItem.author":
1269 if e.complexity.LabelChangeTimelineItem.Author == nil {
1270 break
1271 }
1272
1273 return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
1274
1275 case "LabelChangeTimelineItem.date":
1276 if e.complexity.LabelChangeTimelineItem.Date == nil {
1277 break
1278 }
1279
1280 return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
1281
1282 case "LabelChangeTimelineItem.id":
1283 if e.complexity.LabelChangeTimelineItem.ID == nil {
1284 break
1285 }
1286
1287 return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
1288
1289 case "LabelChangeTimelineItem.removed":
1290 if e.complexity.LabelChangeTimelineItem.Removed == nil {
1291 break
1292 }
1293
1294 return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
1295
1296 case "LabelConnection.edges":
1297 if e.complexity.LabelConnection.Edges == nil {
1298 break
1299 }
1300
1301 return e.complexity.LabelConnection.Edges(childComplexity), true
1302
1303 case "LabelConnection.nodes":
1304 if e.complexity.LabelConnection.Nodes == nil {
1305 break
1306 }
1307
1308 return e.complexity.LabelConnection.Nodes(childComplexity), true
1309
1310 case "LabelConnection.pageInfo":
1311 if e.complexity.LabelConnection.PageInfo == nil {
1312 break
1313 }
1314
1315 return e.complexity.LabelConnection.PageInfo(childComplexity), true
1316
1317 case "LabelConnection.totalCount":
1318 if e.complexity.LabelConnection.TotalCount == nil {
1319 break
1320 }
1321
1322 return e.complexity.LabelConnection.TotalCount(childComplexity), true
1323
1324 case "LabelEdge.cursor":
1325 if e.complexity.LabelEdge.Cursor == nil {
1326 break
1327 }
1328
1329 return e.complexity.LabelEdge.Cursor(childComplexity), true
1330
1331 case "LabelEdge.node":
1332 if e.complexity.LabelEdge.Node == nil {
1333 break
1334 }
1335
1336 return e.complexity.LabelEdge.Node(childComplexity), true
1337
1338 case "Mutation.addComment":
1339 if e.complexity.Mutation.AddComment == nil {
1340 break
1341 }
1342
1343 args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
1344 if err != nil {
1345 return 0, false
1346 }
1347
1348 return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
1349
1350 case "Mutation.changeLabels":
1351 if e.complexity.Mutation.ChangeLabels == nil {
1352 break
1353 }
1354
1355 args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
1356 if err != nil {
1357 return 0, false
1358 }
1359
1360 return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
1361
1362 case "Mutation.closeBug":
1363 if e.complexity.Mutation.CloseBug == nil {
1364 break
1365 }
1366
1367 args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
1368 if err != nil {
1369 return 0, false
1370 }
1371
1372 return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
1373
1374 case "Mutation.commit":
1375 if e.complexity.Mutation.Commit == nil {
1376 break
1377 }
1378
1379 args, err := ec.field_Mutation_commit_args(context.TODO(), rawArgs)
1380 if err != nil {
1381 return 0, false
1382 }
1383
1384 return e.complexity.Mutation.Commit(childComplexity, args["input"].(models.CommitInput)), true
1385
1386 case "Mutation.commitAsNeeded":
1387 if e.complexity.Mutation.CommitAsNeeded == nil {
1388 break
1389 }
1390
1391 args, err := ec.field_Mutation_commitAsNeeded_args(context.TODO(), rawArgs)
1392 if err != nil {
1393 return 0, false
1394 }
1395
1396 return e.complexity.Mutation.CommitAsNeeded(childComplexity, args["input"].(models.CommitAsNeededInput)), true
1397
1398 case "Mutation.newBug":
1399 if e.complexity.Mutation.NewBug == nil {
1400 break
1401 }
1402
1403 args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
1404 if err != nil {
1405 return 0, false
1406 }
1407
1408 return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
1409
1410 case "Mutation.openBug":
1411 if e.complexity.Mutation.OpenBug == nil {
1412 break
1413 }
1414
1415 args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
1416 if err != nil {
1417 return 0, false
1418 }
1419
1420 return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
1421
1422 case "Mutation.setTitle":
1423 if e.complexity.Mutation.SetTitle == nil {
1424 break
1425 }
1426
1427 args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
1428 if err != nil {
1429 return 0, false
1430 }
1431
1432 return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
1433
1434 case "NewBugPayload.bug":
1435 if e.complexity.NewBugPayload.Bug == nil {
1436 break
1437 }
1438
1439 return e.complexity.NewBugPayload.Bug(childComplexity), true
1440
1441 case "NewBugPayload.clientMutationId":
1442 if e.complexity.NewBugPayload.ClientMutationID == nil {
1443 break
1444 }
1445
1446 return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
1447
1448 case "NewBugPayload.operation":
1449 if e.complexity.NewBugPayload.Operation == nil {
1450 break
1451 }
1452
1453 return e.complexity.NewBugPayload.Operation(childComplexity), true
1454
1455 case "OpenBugPayload.bug":
1456 if e.complexity.OpenBugPayload.Bug == nil {
1457 break
1458 }
1459
1460 return e.complexity.OpenBugPayload.Bug(childComplexity), true
1461
1462 case "OpenBugPayload.clientMutationId":
1463 if e.complexity.OpenBugPayload.ClientMutationID == nil {
1464 break
1465 }
1466
1467 return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
1468
1469 case "OpenBugPayload.operation":
1470 if e.complexity.OpenBugPayload.Operation == nil {
1471 break
1472 }
1473
1474 return e.complexity.OpenBugPayload.Operation(childComplexity), true
1475
1476 case "OperationConnection.edges":
1477 if e.complexity.OperationConnection.Edges == nil {
1478 break
1479 }
1480
1481 return e.complexity.OperationConnection.Edges(childComplexity), true
1482
1483 case "OperationConnection.nodes":
1484 if e.complexity.OperationConnection.Nodes == nil {
1485 break
1486 }
1487
1488 return e.complexity.OperationConnection.Nodes(childComplexity), true
1489
1490 case "OperationConnection.pageInfo":
1491 if e.complexity.OperationConnection.PageInfo == nil {
1492 break
1493 }
1494
1495 return e.complexity.OperationConnection.PageInfo(childComplexity), true
1496
1497 case "OperationConnection.totalCount":
1498 if e.complexity.OperationConnection.TotalCount == nil {
1499 break
1500 }
1501
1502 return e.complexity.OperationConnection.TotalCount(childComplexity), true
1503
1504 case "OperationEdge.cursor":
1505 if e.complexity.OperationEdge.Cursor == nil {
1506 break
1507 }
1508
1509 return e.complexity.OperationEdge.Cursor(childComplexity), true
1510
1511 case "OperationEdge.node":
1512 if e.complexity.OperationEdge.Node == nil {
1513 break
1514 }
1515
1516 return e.complexity.OperationEdge.Node(childComplexity), true
1517
1518 case "PageInfo.endCursor":
1519 if e.complexity.PageInfo.EndCursor == nil {
1520 break
1521 }
1522
1523 return e.complexity.PageInfo.EndCursor(childComplexity), true
1524
1525 case "PageInfo.hasNextPage":
1526 if e.complexity.PageInfo.HasNextPage == nil {
1527 break
1528 }
1529
1530 return e.complexity.PageInfo.HasNextPage(childComplexity), true
1531
1532 case "PageInfo.hasPreviousPage":
1533 if e.complexity.PageInfo.HasPreviousPage == nil {
1534 break
1535 }
1536
1537 return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1538
1539 case "PageInfo.startCursor":
1540 if e.complexity.PageInfo.StartCursor == nil {
1541 break
1542 }
1543
1544 return e.complexity.PageInfo.StartCursor(childComplexity), true
1545
1546 case "Query.defaultRepository":
1547 if e.complexity.Query.DefaultRepository == nil {
1548 break
1549 }
1550
1551 return e.complexity.Query.DefaultRepository(childComplexity), true
1552
1553 case "Query.repository":
1554 if e.complexity.Query.Repository == nil {
1555 break
1556 }
1557
1558 args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
1559 if err != nil {
1560 return 0, false
1561 }
1562
1563 return e.complexity.Query.Repository(childComplexity, args["ref"].(string)), true
1564
1565 case "Repository.allBugs":
1566 if e.complexity.Repository.AllBugs == nil {
1567 break
1568 }
1569
1570 args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
1571 if err != nil {
1572 return 0, false
1573 }
1574
1575 return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1576
1577 case "Repository.allIdentities":
1578 if e.complexity.Repository.AllIdentities == nil {
1579 break
1580 }
1581
1582 args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
1583 if err != nil {
1584 return 0, false
1585 }
1586
1587 return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1588
1589 case "Repository.bug":
1590 if e.complexity.Repository.Bug == nil {
1591 break
1592 }
1593
1594 args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
1595 if err != nil {
1596 return 0, false
1597 }
1598
1599 return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1600
1601 case "Repository.identity":
1602 if e.complexity.Repository.Identity == nil {
1603 break
1604 }
1605
1606 args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
1607 if err != nil {
1608 return 0, false
1609 }
1610
1611 return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
1612
1613 case "Repository.userIdentity":
1614 if e.complexity.Repository.UserIdentity == nil {
1615 break
1616 }
1617
1618 return e.complexity.Repository.UserIdentity(childComplexity), true
1619
1620 case "Repository.validLabels":
1621 if e.complexity.Repository.ValidLabels == nil {
1622 break
1623 }
1624
1625 args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
1626 if err != nil {
1627 return 0, false
1628 }
1629
1630 return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1631
1632 case "SetStatusOperation.author":
1633 if e.complexity.SetStatusOperation.Author == nil {
1634 break
1635 }
1636
1637 return e.complexity.SetStatusOperation.Author(childComplexity), true
1638
1639 case "SetStatusOperation.date":
1640 if e.complexity.SetStatusOperation.Date == nil {
1641 break
1642 }
1643
1644 return e.complexity.SetStatusOperation.Date(childComplexity), true
1645
1646 case "SetStatusOperation.id":
1647 if e.complexity.SetStatusOperation.ID == nil {
1648 break
1649 }
1650
1651 return e.complexity.SetStatusOperation.ID(childComplexity), true
1652
1653 case "SetStatusOperation.status":
1654 if e.complexity.SetStatusOperation.Status == nil {
1655 break
1656 }
1657
1658 return e.complexity.SetStatusOperation.Status(childComplexity), true
1659
1660 case "SetStatusTimelineItem.author":
1661 if e.complexity.SetStatusTimelineItem.Author == nil {
1662 break
1663 }
1664
1665 return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
1666
1667 case "SetStatusTimelineItem.date":
1668 if e.complexity.SetStatusTimelineItem.Date == nil {
1669 break
1670 }
1671
1672 return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
1673
1674 case "SetStatusTimelineItem.id":
1675 if e.complexity.SetStatusTimelineItem.ID == nil {
1676 break
1677 }
1678
1679 return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
1680
1681 case "SetStatusTimelineItem.status":
1682 if e.complexity.SetStatusTimelineItem.Status == nil {
1683 break
1684 }
1685
1686 return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
1687
1688 case "SetTitleOperation.author":
1689 if e.complexity.SetTitleOperation.Author == nil {
1690 break
1691 }
1692
1693 return e.complexity.SetTitleOperation.Author(childComplexity), true
1694
1695 case "SetTitleOperation.date":
1696 if e.complexity.SetTitleOperation.Date == nil {
1697 break
1698 }
1699
1700 return e.complexity.SetTitleOperation.Date(childComplexity), true
1701
1702 case "SetTitleOperation.id":
1703 if e.complexity.SetTitleOperation.ID == nil {
1704 break
1705 }
1706
1707 return e.complexity.SetTitleOperation.ID(childComplexity), true
1708
1709 case "SetTitleOperation.title":
1710 if e.complexity.SetTitleOperation.Title == nil {
1711 break
1712 }
1713
1714 return e.complexity.SetTitleOperation.Title(childComplexity), true
1715
1716 case "SetTitleOperation.was":
1717 if e.complexity.SetTitleOperation.Was == nil {
1718 break
1719 }
1720
1721 return e.complexity.SetTitleOperation.Was(childComplexity), true
1722
1723 case "SetTitlePayload.bug":
1724 if e.complexity.SetTitlePayload.Bug == nil {
1725 break
1726 }
1727
1728 return e.complexity.SetTitlePayload.Bug(childComplexity), true
1729
1730 case "SetTitlePayload.clientMutationId":
1731 if e.complexity.SetTitlePayload.ClientMutationID == nil {
1732 break
1733 }
1734
1735 return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
1736
1737 case "SetTitlePayload.operation":
1738 if e.complexity.SetTitlePayload.Operation == nil {
1739 break
1740 }
1741
1742 return e.complexity.SetTitlePayload.Operation(childComplexity), true
1743
1744 case "SetTitleTimelineItem.author":
1745 if e.complexity.SetTitleTimelineItem.Author == nil {
1746 break
1747 }
1748
1749 return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
1750
1751 case "SetTitleTimelineItem.date":
1752 if e.complexity.SetTitleTimelineItem.Date == nil {
1753 break
1754 }
1755
1756 return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
1757
1758 case "SetTitleTimelineItem.id":
1759 if e.complexity.SetTitleTimelineItem.ID == nil {
1760 break
1761 }
1762
1763 return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
1764
1765 case "SetTitleTimelineItem.title":
1766 if e.complexity.SetTitleTimelineItem.Title == nil {
1767 break
1768 }
1769
1770 return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
1771
1772 case "SetTitleTimelineItem.was":
1773 if e.complexity.SetTitleTimelineItem.Was == nil {
1774 break
1775 }
1776
1777 return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
1778
1779 case "TimelineItemConnection.edges":
1780 if e.complexity.TimelineItemConnection.Edges == nil {
1781 break
1782 }
1783
1784 return e.complexity.TimelineItemConnection.Edges(childComplexity), true
1785
1786 case "TimelineItemConnection.nodes":
1787 if e.complexity.TimelineItemConnection.Nodes == nil {
1788 break
1789 }
1790
1791 return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
1792
1793 case "TimelineItemConnection.pageInfo":
1794 if e.complexity.TimelineItemConnection.PageInfo == nil {
1795 break
1796 }
1797
1798 return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
1799
1800 case "TimelineItemConnection.totalCount":
1801 if e.complexity.TimelineItemConnection.TotalCount == nil {
1802 break
1803 }
1804
1805 return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
1806
1807 case "TimelineItemEdge.cursor":
1808 if e.complexity.TimelineItemEdge.Cursor == nil {
1809 break
1810 }
1811
1812 return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
1813
1814 case "TimelineItemEdge.node":
1815 if e.complexity.TimelineItemEdge.Node == nil {
1816 break
1817 }
1818
1819 return e.complexity.TimelineItemEdge.Node(childComplexity), true
1820
1821 }
1822 return 0, false
1823}
1824
1825func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
1826 rc := graphql.GetOperationContext(ctx)
1827 ec := executionContext{rc, e}
1828 first := true
1829
1830 switch rc.Operation.Operation {
1831 case ast.Query:
1832 return func(ctx context.Context) *graphql.Response {
1833 if !first {
1834 return nil
1835 }
1836 first = false
1837 data := ec._Query(ctx, rc.Operation.SelectionSet)
1838 var buf bytes.Buffer
1839 data.MarshalGQL(&buf)
1840
1841 return &graphql.Response{
1842 Data: buf.Bytes(),
1843 }
1844 }
1845 case ast.Mutation:
1846 return func(ctx context.Context) *graphql.Response {
1847 if !first {
1848 return nil
1849 }
1850 first = false
1851 data := ec._Mutation(ctx, rc.Operation.SelectionSet)
1852 var buf bytes.Buffer
1853 data.MarshalGQL(&buf)
1854
1855 return &graphql.Response{
1856 Data: buf.Bytes(),
1857 }
1858 }
1859
1860 default:
1861 return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
1862 }
1863}
1864
1865type executionContext struct {
1866 *graphql.OperationContext
1867 *executableSchema
1868}
1869
1870func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
1871 if ec.DisableIntrospection {
1872 return nil, errors.New("introspection disabled")
1873 }
1874 return introspection.WrapSchema(parsedSchema), nil
1875}
1876
1877func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
1878 if ec.DisableIntrospection {
1879 return nil, errors.New("introspection disabled")
1880 }
1881 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
1882}
1883
1884var parsedSchema = gqlparser.MustLoadSchema(
1885 &ast.Source{Name: "schema.graphql", Input: `input AddCommentInput {
1886 """
1887 A unique identifier for the client performing the mutation.
1888 """
1889 clientMutationId: String
1890 """
1891 "The name of the repository. If not set, the default repository is used.
1892 """
1893 repoRef: String
1894 """
1895 The bug ID's prefix.
1896 """
1897 prefix: String!
1898 """
1899 The first message of the new bug.
1900 """
1901 message: String!
1902 """
1903 The collection of file's hash required for the first message.
1904 """
1905 files: [Hash!]
1906}
1907type AddCommentOperation implements Operation & Authored {
1908 """
1909 The identifier of the operation
1910 """
1911 id: String!
1912 """
1913 The author of this object.
1914 """
1915 author: Identity!
1916 """
1917 The datetime when this operation was issued.
1918 """
1919 date: Time!
1920 message: String!
1921 files: [Hash!]!
1922}
1923type AddCommentPayload {
1924 """
1925 A unique identifier for the client performing the mutation.
1926 """
1927 clientMutationId: String
1928 """
1929 The affected bug.
1930 """
1931 bug: Bug!
1932 """
1933 The resulting operation.
1934 """
1935 operation: AddCommentOperation!
1936}
1937"""
1938AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history
1939"""
1940type AddCommentTimelineItem implements TimelineItem & Authored {
1941 """
1942 The identifier of the source operation
1943 """
1944 id: String!
1945 author: Identity!
1946 message: String!
1947 messageIsEmpty: Boolean!
1948 files: [Hash!]!
1949 createdAt: Time!
1950 lastEdit: Time!
1951 edited: Boolean!
1952 history: [CommentHistoryStep!]!
1953}
1954"""
1955An object that has an author.
1956"""
1957interface Authored {
1958 """
1959 The author of this object.
1960 """
1961 author: Identity!
1962}
1963type Bug implements Authored {
1964 """
1965 The identifier for this bug
1966 """
1967 id: String!
1968 """
1969 The human version (truncated) identifier for this bug
1970 """
1971 humanId: String!
1972 status: Status!
1973 title: String!
1974 labels: [Label!]!
1975 author: Identity!
1976 createdAt: Time!
1977 lastEdit: Time!
1978 """
1979 The actors of the bug. Actors are Identity that have interacted with the bug.
1980 """
1981 actors("""
1982 Returns the elements in the list that come after the specified cursor.
1983 """
1984 after: String, """
1985 Returns the elements in the list that come before the specified cursor.
1986 """
1987 before: String, """
1988 Returns the first _n_ elements from the list.
1989 """
1990 first: Int, """
1991 Returns the last _n_ elements from the list.
1992 """
1993 last: Int): IdentityConnection!
1994 """
1995 The participants of the bug. Participants are Identity that have created or
1996 added a comment on the bug.
1997 """
1998 participants("""
1999 Returns the elements in the list that come after the specified cursor.
2000 """
2001 after: String, """
2002 Returns the elements in the list that come before the specified cursor.
2003 """
2004 before: String, """
2005 Returns the first _n_ elements from the list.
2006 """
2007 first: Int, """
2008 Returns the last _n_ elements from the list.
2009 """
2010 last: Int): IdentityConnection!
2011 comments("""
2012 Returns the elements in the list that come after the specified cursor.
2013 """
2014 after: String, """
2015 Returns the elements in the list that come before the specified cursor.
2016 """
2017 before: String, """
2018 Returns the first _n_ elements from the list.
2019 """
2020 first: Int, """
2021 Returns the last _n_ elements from the list.
2022 """
2023 last: Int): CommentConnection!
2024 timeline("""
2025 Returns the elements in the list that come after the specified cursor.
2026 """
2027 after: String, """
2028 Returns the elements in the list that come before the specified cursor.
2029 """
2030 before: String, """
2031 Returns the first _n_ elements from the list.
2032 """
2033 first: Int, """
2034 Returns the last _n_ elements from the list.
2035 """
2036 last: Int): TimelineItemConnection!
2037 operations("""
2038 Returns the elements in the list that come after the specified cursor.
2039 """
2040 after: String, """
2041 Returns the elements in the list that come before the specified cursor.
2042 """
2043 before: String, """
2044 Returns the first _n_ elements from the list.
2045 """
2046 first: Int, """
2047 Returns the last _n_ elements from the list.
2048 """
2049 last: Int): OperationConnection!
2050}
2051"""
2052The connection type for Bug.
2053"""
2054type BugConnection {
2055 """
2056 A list of edges.
2057 """
2058 edges: [BugEdge!]!
2059 nodes: [Bug!]!
2060 """
2061 Information to aid in pagination.
2062 """
2063 pageInfo: PageInfo!
2064 """
2065 Identifies the total count of items in the connection.
2066 """
2067 totalCount: Int!
2068}
2069"""
2070An edge in a connection.
2071"""
2072type BugEdge {
2073 """
2074 A cursor for use in pagination.
2075 """
2076 cursor: String!
2077 """
2078 The item at the end of the edge.
2079 """
2080 node: Bug!
2081}
2082input ChangeLabelInput {
2083 """
2084 A unique identifier for the client performing the mutation.
2085 """
2086 clientMutationId: String
2087 """
2088 "The name of the repository. If not set, the default repository is used.
2089 """
2090 repoRef: String
2091 """
2092 The bug ID's prefix.
2093 """
2094 prefix: String!
2095 """
2096 The list of label to add.
2097 """
2098 added: [String!]
2099 """
2100 The list of label to remove.
2101 """
2102 Removed: [String!]
2103}
2104type ChangeLabelPayload {
2105 """
2106 A unique identifier for the client performing the mutation.
2107 """
2108 clientMutationId: String
2109 """
2110 The affected bug.
2111 """
2112 bug: Bug!
2113 """
2114 The resulting operation.
2115 """
2116 operation: LabelChangeOperation!
2117 """
2118 The effect each source label had.
2119 """
2120 results: [LabelChangeResult]!
2121}
2122input CloseBugInput {
2123 """
2124 A unique identifier for the client performing the mutation.
2125 """
2126 clientMutationId: String
2127 """
2128 "The name of the repository. If not set, the default repository is used.
2129 """
2130 repoRef: String
2131 """
2132 The bug ID's prefix.
2133 """
2134 prefix: String!
2135}
2136type CloseBugPayload {
2137 """
2138 A unique identifier for the client performing the mutation.
2139 """
2140 clientMutationId: String
2141 """
2142 The affected bug.
2143 """
2144 bug: Bug!
2145 """
2146 The resulting operation.
2147 """
2148 operation: SetStatusOperation!
2149}
2150"""
2151Defines a color by red, green and blue components.
2152"""
2153type Color {
2154 """
2155 Red component of the color.
2156 """
2157 R: Int!
2158 """
2159 Green component of the color.
2160 """
2161 G: Int!
2162 """
2163 Blue component of the color.
2164 """
2165 B: Int!
2166}
2167"""
2168Represents a comment on a bug.
2169"""
2170type Comment implements Authored {
2171 """
2172 The author of this comment.
2173 """
2174 author: Identity!
2175 """
2176 The message of this comment.
2177 """
2178 message: String!
2179 """
2180 All media's hash referenced in this comment
2181 """
2182 files: [Hash!]!
2183}
2184type CommentConnection {
2185 edges: [CommentEdge!]!
2186 nodes: [Comment!]!
2187 pageInfo: PageInfo!
2188 totalCount: Int!
2189}
2190type CommentEdge {
2191 cursor: String!
2192 node: Comment!
2193}
2194"""
2195CommentHistoryStep hold one version of a message in the history
2196"""
2197type CommentHistoryStep {
2198 message: String!
2199 date: Time!
2200}
2201input CommitAsNeededInput {
2202 """
2203 A unique identifier for the client performing the mutation.
2204 """
2205 clientMutationId: String
2206 """
2207 "The name of the repository. If not set, the default repository is used.
2208 """
2209 repoRef: String
2210 """
2211 The bug ID's prefix.
2212 """
2213 prefix: String!
2214}
2215type CommitAsNeededPayload {
2216 """
2217 A unique identifier for the client performing the mutation.
2218 """
2219 clientMutationId: String
2220 """
2221 The affected bug.
2222 """
2223 bug: Bug!
2224}
2225input CommitInput {
2226 """
2227 A unique identifier for the client performing the mutation.
2228 """
2229 clientMutationId: String
2230 """
2231 "The name of the repository. If not set, the default repository is used.
2232 """
2233 repoRef: String
2234 """
2235 The bug ID's prefix.
2236 """
2237 prefix: String!
2238}
2239type CommitPayload {
2240 """
2241 A unique identifier for the client performing the mutation.
2242 """
2243 clientMutationId: String
2244 """
2245 The affected bug.
2246 """
2247 bug: Bug!
2248}
2249type CreateOperation implements Operation & Authored {
2250 """
2251 The identifier of the operation
2252 """
2253 id: String!
2254 """
2255 The author of this object.
2256 """
2257 author: Identity!
2258 """
2259 The datetime when this operation was issued.
2260 """
2261 date: Time!
2262 title: String!
2263 message: String!
2264 files: [Hash!]!
2265}
2266"""
2267CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history
2268"""
2269type CreateTimelineItem implements TimelineItem & Authored {
2270 """
2271 The identifier of the source operation
2272 """
2273 id: String!
2274 author: Identity!
2275 message: String!
2276 messageIsEmpty: Boolean!
2277 files: [Hash!]!
2278 createdAt: Time!
2279 lastEdit: Time!
2280 edited: Boolean!
2281 history: [CommentHistoryStep!]!
2282}
2283type EditCommentOperation implements Operation & Authored {
2284 """
2285 The identifier of the operation
2286 """
2287 id: String!
2288 """
2289 The author of this object.
2290 """
2291 author: Identity!
2292 """
2293 The datetime when this operation was issued.
2294 """
2295 date: Time!
2296 target: String!
2297 message: String!
2298 files: [Hash!]!
2299}
2300scalar Hash
2301"""
2302Represents an identity
2303"""
2304type Identity {
2305 """
2306 The identifier for this identity
2307 """
2308 id: String!
2309 """
2310 The human version (truncated) identifier for this identity
2311 """
2312 humanId: String!
2313 """
2314 The name of the person, if known.
2315 """
2316 name: String
2317 """
2318 The email of the person, if known.
2319 """
2320 email: String
2321 """
2322 The login of the person, if known.
2323 """
2324 login: String
2325 """
2326 A string containing the either the name of the person, its login or both
2327 """
2328 displayName: String!
2329 """
2330 An url to an avatar
2331 """
2332 avatarUrl: String
2333 """
2334 isProtected is true if the chain of git commits started to be signed.
2335 If that's the case, only signed commit with a valid key for this identity can be added.
2336 """
2337 isProtected: Boolean!
2338}
2339type IdentityConnection {
2340 edges: [IdentityEdge!]!
2341 nodes: [Identity!]!
2342 pageInfo: PageInfo!
2343 totalCount: Int!
2344}
2345type IdentityEdge {
2346 cursor: String!
2347 node: Identity!
2348}
2349"""
2350Label for a bug.
2351"""
2352type Label {
2353 """
2354 The name of the label.
2355 """
2356 name: String!
2357 """
2358 Color of the label.
2359 """
2360 color: Color!
2361}
2362type LabelChangeOperation implements Operation & Authored {
2363 """
2364 The identifier of the operation
2365 """
2366 id: String!
2367 """
2368 The author of this object.
2369 """
2370 author: Identity!
2371 """
2372 The datetime when this operation was issued.
2373 """
2374 date: Time!
2375 added: [Label!]!
2376 removed: [Label!]!
2377}
2378type LabelChangeResult {
2379 """
2380 The source label.
2381 """
2382 label: Label!
2383 """
2384 The effect this label had.
2385 """
2386 status: LabelChangeStatus!
2387}
2388enum LabelChangeStatus {
2389 ADDED
2390 REMOVED
2391 DUPLICATE_IN_OP
2392 ALREADY_EXIST
2393 DOESNT_EXIST
2394}
2395"""
2396LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug
2397"""
2398type LabelChangeTimelineItem implements TimelineItem & Authored {
2399 """
2400 The identifier of the source operation
2401 """
2402 id: String!
2403 author: Identity!
2404 date: Time!
2405 added: [Label!]!
2406 removed: [Label!]!
2407}
2408type LabelConnection {
2409 edges: [LabelEdge!]!
2410 nodes: [Label!]!
2411 pageInfo: PageInfo!
2412 totalCount: Int!
2413}
2414type LabelEdge {
2415 cursor: String!
2416 node: Label!
2417}
2418type Mutation {
2419 """
2420 Create a new bug
2421 """
2422 newBug(input: NewBugInput!): NewBugPayload!
2423 """
2424 Add a new comment to a bug
2425 """
2426 addComment(input: AddCommentInput!): AddCommentPayload!
2427 """
2428 Add or remove a set of label on a bug
2429 """
2430 changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
2431 """
2432 Change a bug's status to open
2433 """
2434 openBug(input: OpenBugInput!): OpenBugPayload!
2435 """
2436 Change a bug's status to closed
2437 """
2438 closeBug(input: CloseBugInput!): CloseBugPayload!
2439 """
2440 Change a bug's title
2441 """
2442 setTitle(input: SetTitleInput!): SetTitlePayload!
2443 """
2444 Commit write the pending operations into storage. This mutation fail if nothing is pending
2445 """
2446 commit(input: CommitInput!): CommitPayload!
2447 """
2448 Commit write the pending operations into storage. This mutation succed if nothing is pending
2449 """
2450 commitAsNeeded(input: CommitAsNeededInput!): CommitAsNeededPayload!
2451}
2452input NewBugInput {
2453 """
2454 A unique identifier for the client performing the mutation.
2455 """
2456 clientMutationId: String
2457 """
2458 "The name of the repository. If not set, the default repository is used.
2459 """
2460 repoRef: String
2461 """
2462 The title of the new bug.
2463 """
2464 title: String!
2465 """
2466 The first message of the new bug.
2467 """
2468 message: String!
2469 """
2470 The collection of file's hash required for the first message.
2471 """
2472 files: [Hash!]
2473}
2474type NewBugPayload {
2475 """
2476 A unique identifier for the client performing the mutation.
2477 """
2478 clientMutationId: String
2479 """
2480 The created bug.
2481 """
2482 bug: Bug!
2483 """
2484 The resulting operation.
2485 """
2486 operation: CreateOperation!
2487}
2488input OpenBugInput {
2489 """
2490 A unique identifier for the client performing the mutation.
2491 """
2492 clientMutationId: String
2493 """
2494 "The name of the repository. If not set, the default repository is used.
2495 """
2496 repoRef: String
2497 """
2498 The bug ID's prefix.
2499 """
2500 prefix: String!
2501}
2502type OpenBugPayload {
2503 """
2504 A unique identifier for the client performing the mutation.
2505 """
2506 clientMutationId: String
2507 """
2508 The affected bug.
2509 """
2510 bug: Bug!
2511 """
2512 The resulting operation.
2513 """
2514 operation: SetStatusOperation!
2515}
2516"""
2517An operation applied to a bug.
2518"""
2519interface Operation {
2520 """
2521 The identifier of the operation
2522 """
2523 id: String!
2524 """
2525 The operations author.
2526 """
2527 author: Identity!
2528 """
2529 The datetime when this operation was issued.
2530 """
2531 date: Time!
2532}
2533"""
2534The connection type for an Operation
2535"""
2536type OperationConnection {
2537 edges: [OperationEdge!]!
2538 nodes: [Operation!]!
2539 pageInfo: PageInfo!
2540 totalCount: Int!
2541}
2542"""
2543Represent an Operation
2544"""
2545type OperationEdge {
2546 cursor: String!
2547 node: Operation!
2548}
2549"""
2550Information about pagination in a connection.
2551"""
2552type PageInfo {
2553 """
2554 When paginating forwards, are there more items?
2555 """
2556 hasNextPage: Boolean!
2557 """
2558 When paginating backwards, are there more items?
2559 """
2560 hasPreviousPage: Boolean!
2561 """
2562 When paginating backwards, the cursor to continue.
2563 """
2564 startCursor: String!
2565 """
2566 When paginating forwards, the cursor to continue.
2567 """
2568 endCursor: String!
2569}
2570type Query {
2571 """
2572 The default unnamend repository.
2573 """
2574 defaultRepository: Repository
2575 """
2576 Access a repository by reference/name.
2577 """
2578 repository(ref: String!): Repository
2579}
2580type Repository {
2581 """
2582 All the bugs
2583 """
2584 allBugs("""
2585 Returns the elements in the list that come after the specified cursor.
2586 """
2587 after: String, """
2588 Returns the elements in the list that come before the specified cursor.
2589 """
2590 before: String, """
2591 Returns the first _n_ elements from the list.
2592 """
2593 first: Int, """
2594 Returns the last _n_ elements from the list.
2595 """
2596 last: Int, """
2597 A query to select and order bugs
2598 """
2599 query: String): BugConnection!
2600 bug(prefix: String!): Bug
2601 """
2602 All the identities
2603 """
2604 allIdentities("""
2605 Returns the elements in the list that come after the specified cursor.
2606 """
2607 after: String, """
2608 Returns the elements in the list that come before the specified cursor.
2609 """
2610 before: String, """
2611 Returns the first _n_ elements from the list.
2612 """
2613 first: Int, """
2614 Returns the last _n_ elements from the list.
2615 """
2616 last: Int): IdentityConnection!
2617 identity(prefix: String!): Identity
2618 """
2619 The identity created or selected by the user as its own
2620 """
2621 userIdentity: Identity
2622 """
2623 List of valid labels.
2624 """
2625 validLabels("""
2626 Returns the elements in the list that come after the specified cursor.
2627 """
2628 after: String, """
2629 Returns the elements in the list that come before the specified cursor.
2630 """
2631 before: String, """
2632 Returns the first _n_ elements from the list.
2633 """
2634 first: Int, """
2635 Returns the last _n_ elements from the list.
2636 """
2637 last: Int): LabelConnection!
2638}
2639type SetStatusOperation implements Operation & Authored {
2640 """
2641 The identifier of the operation
2642 """
2643 id: String!
2644 """
2645 The author of this object.
2646 """
2647 author: Identity!
2648 """
2649 The datetime when this operation was issued.
2650 """
2651 date: Time!
2652 status: Status!
2653}
2654"""
2655SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug
2656"""
2657type SetStatusTimelineItem implements TimelineItem & Authored {
2658 """
2659 The identifier of the source operation
2660 """
2661 id: String!
2662 author: Identity!
2663 date: Time!
2664 status: Status!
2665}
2666input SetTitleInput {
2667 """
2668 A unique identifier for the client performing the mutation.
2669 """
2670 clientMutationId: String
2671 """
2672 "The name of the repository. If not set, the default repository is used.
2673 """
2674 repoRef: String
2675 """
2676 The bug ID's prefix.
2677 """
2678 prefix: String!
2679 """
2680 The new title.
2681 """
2682 title: String!
2683}
2684type SetTitleOperation implements Operation & Authored {
2685 """
2686 The identifier of the operation
2687 """
2688 id: String!
2689 """
2690 The author of this object.
2691 """
2692 author: Identity!
2693 """
2694 The datetime when this operation was issued.
2695 """
2696 date: Time!
2697 title: String!
2698 was: String!
2699}
2700type SetTitlePayload {
2701 """
2702 A unique identifier for the client performing the mutation.
2703 """
2704 clientMutationId: String
2705 """
2706 The affected bug.
2707 """
2708 bug: Bug!
2709 """
2710 The resulting operation
2711 """
2712 operation: SetTitleOperation!
2713}
2714"""
2715LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug
2716"""
2717type SetTitleTimelineItem implements TimelineItem & Authored {
2718 """
2719 The identifier of the source operation
2720 """
2721 id: String!
2722 author: Identity!
2723 date: Time!
2724 title: String!
2725 was: String!
2726}
2727enum Status {
2728 OPEN
2729 CLOSED
2730}
2731scalar Time
2732"""
2733An item in the timeline of events
2734"""
2735interface TimelineItem {
2736 """
2737 The identifier of the source operation
2738 """
2739 id: String!
2740}
2741"""
2742The connection type for TimelineItem
2743"""
2744type TimelineItemConnection {
2745 edges: [TimelineItemEdge!]!
2746 nodes: [TimelineItem!]!
2747 pageInfo: PageInfo!
2748 totalCount: Int!
2749}
2750"""
2751Represent a TimelineItem
2752"""
2753type TimelineItemEdge {
2754 cursor: String!
2755 node: TimelineItem!
2756}
2757`},
2758)
2759
2760// endregion ************************** generated!.gotpl **************************
2761
2762// region ***************************** args.gotpl *****************************
2763
2764func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2765 var err error
2766 args := map[string]interface{}{}
2767 var arg0 *string
2768 if tmp, ok := rawArgs["after"]; ok {
2769 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2770 if err != nil {
2771 return nil, err
2772 }
2773 }
2774 args["after"] = arg0
2775 var arg1 *string
2776 if tmp, ok := rawArgs["before"]; ok {
2777 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2778 if err != nil {
2779 return nil, err
2780 }
2781 }
2782 args["before"] = arg1
2783 var arg2 *int
2784 if tmp, ok := rawArgs["first"]; ok {
2785 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2786 if err != nil {
2787 return nil, err
2788 }
2789 }
2790 args["first"] = arg2
2791 var arg3 *int
2792 if tmp, ok := rawArgs["last"]; ok {
2793 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2794 if err != nil {
2795 return nil, err
2796 }
2797 }
2798 args["last"] = arg3
2799 return args, nil
2800}
2801
2802func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2803 var err error
2804 args := map[string]interface{}{}
2805 var arg0 *string
2806 if tmp, ok := rawArgs["after"]; ok {
2807 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2808 if err != nil {
2809 return nil, err
2810 }
2811 }
2812 args["after"] = arg0
2813 var arg1 *string
2814 if tmp, ok := rawArgs["before"]; ok {
2815 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2816 if err != nil {
2817 return nil, err
2818 }
2819 }
2820 args["before"] = arg1
2821 var arg2 *int
2822 if tmp, ok := rawArgs["first"]; ok {
2823 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2824 if err != nil {
2825 return nil, err
2826 }
2827 }
2828 args["first"] = arg2
2829 var arg3 *int
2830 if tmp, ok := rawArgs["last"]; ok {
2831 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2832 if err != nil {
2833 return nil, err
2834 }
2835 }
2836 args["last"] = arg3
2837 return args, nil
2838}
2839
2840func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2841 var err error
2842 args := map[string]interface{}{}
2843 var arg0 *string
2844 if tmp, ok := rawArgs["after"]; ok {
2845 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2846 if err != nil {
2847 return nil, err
2848 }
2849 }
2850 args["after"] = arg0
2851 var arg1 *string
2852 if tmp, ok := rawArgs["before"]; ok {
2853 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2854 if err != nil {
2855 return nil, err
2856 }
2857 }
2858 args["before"] = arg1
2859 var arg2 *int
2860 if tmp, ok := rawArgs["first"]; ok {
2861 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2862 if err != nil {
2863 return nil, err
2864 }
2865 }
2866 args["first"] = arg2
2867 var arg3 *int
2868 if tmp, ok := rawArgs["last"]; ok {
2869 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2870 if err != nil {
2871 return nil, err
2872 }
2873 }
2874 args["last"] = arg3
2875 return args, nil
2876}
2877
2878func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2879 var err error
2880 args := map[string]interface{}{}
2881 var arg0 *string
2882 if tmp, ok := rawArgs["after"]; ok {
2883 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2884 if err != nil {
2885 return nil, err
2886 }
2887 }
2888 args["after"] = arg0
2889 var arg1 *string
2890 if tmp, ok := rawArgs["before"]; ok {
2891 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2892 if err != nil {
2893 return nil, err
2894 }
2895 }
2896 args["before"] = arg1
2897 var arg2 *int
2898 if tmp, ok := rawArgs["first"]; ok {
2899 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2900 if err != nil {
2901 return nil, err
2902 }
2903 }
2904 args["first"] = arg2
2905 var arg3 *int
2906 if tmp, ok := rawArgs["last"]; ok {
2907 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2908 if err != nil {
2909 return nil, err
2910 }
2911 }
2912 args["last"] = arg3
2913 return args, nil
2914}
2915
2916func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2917 var err error
2918 args := map[string]interface{}{}
2919 var arg0 *string
2920 if tmp, ok := rawArgs["after"]; ok {
2921 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2922 if err != nil {
2923 return nil, err
2924 }
2925 }
2926 args["after"] = arg0
2927 var arg1 *string
2928 if tmp, ok := rawArgs["before"]; ok {
2929 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2930 if err != nil {
2931 return nil, err
2932 }
2933 }
2934 args["before"] = arg1
2935 var arg2 *int
2936 if tmp, ok := rawArgs["first"]; ok {
2937 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2938 if err != nil {
2939 return nil, err
2940 }
2941 }
2942 args["first"] = arg2
2943 var arg3 *int
2944 if tmp, ok := rawArgs["last"]; ok {
2945 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2946 if err != nil {
2947 return nil, err
2948 }
2949 }
2950 args["last"] = arg3
2951 return args, nil
2952}
2953
2954func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2955 var err error
2956 args := map[string]interface{}{}
2957 var arg0 models.AddCommentInput
2958 if tmp, ok := rawArgs["input"]; ok {
2959 arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
2960 if err != nil {
2961 return nil, err
2962 }
2963 }
2964 args["input"] = arg0
2965 return args, nil
2966}
2967
2968func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2969 var err error
2970 args := map[string]interface{}{}
2971 var arg0 *models.ChangeLabelInput
2972 if tmp, ok := rawArgs["input"]; ok {
2973 arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
2974 if err != nil {
2975 return nil, err
2976 }
2977 }
2978 args["input"] = arg0
2979 return args, nil
2980}
2981
2982func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2983 var err error
2984 args := map[string]interface{}{}
2985 var arg0 models.CloseBugInput
2986 if tmp, ok := rawArgs["input"]; ok {
2987 arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
2988 if err != nil {
2989 return nil, err
2990 }
2991 }
2992 args["input"] = arg0
2993 return args, nil
2994}
2995
2996func (ec *executionContext) field_Mutation_commitAsNeeded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2997 var err error
2998 args := map[string]interface{}{}
2999 var arg0 models.CommitAsNeededInput
3000 if tmp, ok := rawArgs["input"]; ok {
3001 arg0, err = ec.unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx, tmp)
3002 if err != nil {
3003 return nil, err
3004 }
3005 }
3006 args["input"] = arg0
3007 return args, nil
3008}
3009
3010func (ec *executionContext) field_Mutation_commit_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3011 var err error
3012 args := map[string]interface{}{}
3013 var arg0 models.CommitInput
3014 if tmp, ok := rawArgs["input"]; ok {
3015 arg0, err = ec.unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx, tmp)
3016 if err != nil {
3017 return nil, err
3018 }
3019 }
3020 args["input"] = arg0
3021 return args, nil
3022}
3023
3024func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3025 var err error
3026 args := map[string]interface{}{}
3027 var arg0 models.NewBugInput
3028 if tmp, ok := rawArgs["input"]; ok {
3029 arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
3030 if err != nil {
3031 return nil, err
3032 }
3033 }
3034 args["input"] = arg0
3035 return args, nil
3036}
3037
3038func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3039 var err error
3040 args := map[string]interface{}{}
3041 var arg0 models.OpenBugInput
3042 if tmp, ok := rawArgs["input"]; ok {
3043 arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
3044 if err != nil {
3045 return nil, err
3046 }
3047 }
3048 args["input"] = arg0
3049 return args, nil
3050}
3051
3052func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3053 var err error
3054 args := map[string]interface{}{}
3055 var arg0 models.SetTitleInput
3056 if tmp, ok := rawArgs["input"]; ok {
3057 arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
3058 if err != nil {
3059 return nil, err
3060 }
3061 }
3062 args["input"] = arg0
3063 return args, nil
3064}
3065
3066func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3067 var err error
3068 args := map[string]interface{}{}
3069 var arg0 string
3070 if tmp, ok := rawArgs["name"]; ok {
3071 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3072 if err != nil {
3073 return nil, err
3074 }
3075 }
3076 args["name"] = arg0
3077 return args, nil
3078}
3079
3080func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3081 var err error
3082 args := map[string]interface{}{}
3083 var arg0 string
3084 if tmp, ok := rawArgs["ref"]; ok {
3085 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3086 if err != nil {
3087 return nil, err
3088 }
3089 }
3090 args["ref"] = arg0
3091 return args, nil
3092}
3093
3094func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3095 var err error
3096 args := map[string]interface{}{}
3097 var arg0 *string
3098 if tmp, ok := rawArgs["after"]; ok {
3099 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3100 if err != nil {
3101 return nil, err
3102 }
3103 }
3104 args["after"] = arg0
3105 var arg1 *string
3106 if tmp, ok := rawArgs["before"]; ok {
3107 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3108 if err != nil {
3109 return nil, err
3110 }
3111 }
3112 args["before"] = arg1
3113 var arg2 *int
3114 if tmp, ok := rawArgs["first"]; ok {
3115 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3116 if err != nil {
3117 return nil, err
3118 }
3119 }
3120 args["first"] = arg2
3121 var arg3 *int
3122 if tmp, ok := rawArgs["last"]; ok {
3123 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3124 if err != nil {
3125 return nil, err
3126 }
3127 }
3128 args["last"] = arg3
3129 var arg4 *string
3130 if tmp, ok := rawArgs["query"]; ok {
3131 arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3132 if err != nil {
3133 return nil, err
3134 }
3135 }
3136 args["query"] = arg4
3137 return args, nil
3138}
3139
3140func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3141 var err error
3142 args := map[string]interface{}{}
3143 var arg0 *string
3144 if tmp, ok := rawArgs["after"]; ok {
3145 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3146 if err != nil {
3147 return nil, err
3148 }
3149 }
3150 args["after"] = arg0
3151 var arg1 *string
3152 if tmp, ok := rawArgs["before"]; ok {
3153 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3154 if err != nil {
3155 return nil, err
3156 }
3157 }
3158 args["before"] = arg1
3159 var arg2 *int
3160 if tmp, ok := rawArgs["first"]; ok {
3161 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3162 if err != nil {
3163 return nil, err
3164 }
3165 }
3166 args["first"] = arg2
3167 var arg3 *int
3168 if tmp, ok := rawArgs["last"]; ok {
3169 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3170 if err != nil {
3171 return nil, err
3172 }
3173 }
3174 args["last"] = arg3
3175 return args, nil
3176}
3177
3178func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3179 var err error
3180 args := map[string]interface{}{}
3181 var arg0 string
3182 if tmp, ok := rawArgs["prefix"]; ok {
3183 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3184 if err != nil {
3185 return nil, err
3186 }
3187 }
3188 args["prefix"] = arg0
3189 return args, nil
3190}
3191
3192func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3193 var err error
3194 args := map[string]interface{}{}
3195 var arg0 string
3196 if tmp, ok := rawArgs["prefix"]; ok {
3197 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3198 if err != nil {
3199 return nil, err
3200 }
3201 }
3202 args["prefix"] = arg0
3203 return args, nil
3204}
3205
3206func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3207 var err error
3208 args := map[string]interface{}{}
3209 var arg0 *string
3210 if tmp, ok := rawArgs["after"]; ok {
3211 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3212 if err != nil {
3213 return nil, err
3214 }
3215 }
3216 args["after"] = arg0
3217 var arg1 *string
3218 if tmp, ok := rawArgs["before"]; ok {
3219 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3220 if err != nil {
3221 return nil, err
3222 }
3223 }
3224 args["before"] = arg1
3225 var arg2 *int
3226 if tmp, ok := rawArgs["first"]; ok {
3227 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3228 if err != nil {
3229 return nil, err
3230 }
3231 }
3232 args["first"] = arg2
3233 var arg3 *int
3234 if tmp, ok := rawArgs["last"]; ok {
3235 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3236 if err != nil {
3237 return nil, err
3238 }
3239 }
3240 args["last"] = arg3
3241 return args, nil
3242}
3243
3244func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3245 var err error
3246 args := map[string]interface{}{}
3247 var arg0 bool
3248 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3249 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3250 if err != nil {
3251 return nil, err
3252 }
3253 }
3254 args["includeDeprecated"] = arg0
3255 return args, nil
3256}
3257
3258func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3259 var err error
3260 args := map[string]interface{}{}
3261 var arg0 bool
3262 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3263 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3264 if err != nil {
3265 return nil, err
3266 }
3267 }
3268 args["includeDeprecated"] = arg0
3269 return args, nil
3270}
3271
3272// endregion ***************************** args.gotpl *****************************
3273
3274// region ************************** directives.gotpl **************************
3275
3276// endregion ************************** directives.gotpl **************************
3277
3278// region **************************** field.gotpl *****************************
3279
3280func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3281 defer func() {
3282 if r := recover(); r != nil {
3283 ec.Error(ctx, ec.Recover(ctx, r))
3284 ret = graphql.Null
3285 }
3286 }()
3287 fc := &graphql.FieldContext{
3288 Object: "AddCommentOperation",
3289 Field: field,
3290 Args: nil,
3291 IsMethod: true,
3292 }
3293
3294 ctx = graphql.WithFieldContext(ctx, fc)
3295 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3296 ctx = rctx // use context from middleware stack in children
3297 return ec.resolvers.AddCommentOperation().ID(rctx, obj)
3298 })
3299 if err != nil {
3300 ec.Error(ctx, err)
3301 return graphql.Null
3302 }
3303 if resTmp == nil {
3304 if !graphql.HasFieldError(ctx, fc) {
3305 ec.Errorf(ctx, "must not be null")
3306 }
3307 return graphql.Null
3308 }
3309 res := resTmp.(string)
3310 fc.Result = res
3311 return ec.marshalNString2string(ctx, field.Selections, res)
3312}
3313
3314func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3315 defer func() {
3316 if r := recover(); r != nil {
3317 ec.Error(ctx, ec.Recover(ctx, r))
3318 ret = graphql.Null
3319 }
3320 }()
3321 fc := &graphql.FieldContext{
3322 Object: "AddCommentOperation",
3323 Field: field,
3324 Args: nil,
3325 IsMethod: false,
3326 }
3327
3328 ctx = graphql.WithFieldContext(ctx, fc)
3329 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3330 ctx = rctx // use context from middleware stack in children
3331 return obj.Author, nil
3332 })
3333 if err != nil {
3334 ec.Error(ctx, err)
3335 return graphql.Null
3336 }
3337 if resTmp == nil {
3338 if !graphql.HasFieldError(ctx, fc) {
3339 ec.Errorf(ctx, "must not be null")
3340 }
3341 return graphql.Null
3342 }
3343 res := resTmp.(identity.Interface)
3344 fc.Result = res
3345 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
3346}
3347
3348func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3349 defer func() {
3350 if r := recover(); r != nil {
3351 ec.Error(ctx, ec.Recover(ctx, r))
3352 ret = graphql.Null
3353 }
3354 }()
3355 fc := &graphql.FieldContext{
3356 Object: "AddCommentOperation",
3357 Field: field,
3358 Args: nil,
3359 IsMethod: true,
3360 }
3361
3362 ctx = graphql.WithFieldContext(ctx, fc)
3363 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3364 ctx = rctx // use context from middleware stack in children
3365 return ec.resolvers.AddCommentOperation().Date(rctx, obj)
3366 })
3367 if err != nil {
3368 ec.Error(ctx, err)
3369 return graphql.Null
3370 }
3371 if resTmp == nil {
3372 if !graphql.HasFieldError(ctx, fc) {
3373 ec.Errorf(ctx, "must not be null")
3374 }
3375 return graphql.Null
3376 }
3377 res := resTmp.(*time.Time)
3378 fc.Result = res
3379 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3380}
3381
3382func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3383 defer func() {
3384 if r := recover(); r != nil {
3385 ec.Error(ctx, ec.Recover(ctx, r))
3386 ret = graphql.Null
3387 }
3388 }()
3389 fc := &graphql.FieldContext{
3390 Object: "AddCommentOperation",
3391 Field: field,
3392 Args: nil,
3393 IsMethod: false,
3394 }
3395
3396 ctx = graphql.WithFieldContext(ctx, fc)
3397 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3398 ctx = rctx // use context from middleware stack in children
3399 return obj.Message, nil
3400 })
3401 if err != nil {
3402 ec.Error(ctx, err)
3403 return graphql.Null
3404 }
3405 if resTmp == nil {
3406 if !graphql.HasFieldError(ctx, fc) {
3407 ec.Errorf(ctx, "must not be null")
3408 }
3409 return graphql.Null
3410 }
3411 res := resTmp.(string)
3412 fc.Result = res
3413 return ec.marshalNString2string(ctx, field.Selections, res)
3414}
3415
3416func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3417 defer func() {
3418 if r := recover(); r != nil {
3419 ec.Error(ctx, ec.Recover(ctx, r))
3420 ret = graphql.Null
3421 }
3422 }()
3423 fc := &graphql.FieldContext{
3424 Object: "AddCommentOperation",
3425 Field: field,
3426 Args: nil,
3427 IsMethod: false,
3428 }
3429
3430 ctx = graphql.WithFieldContext(ctx, fc)
3431 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3432 ctx = rctx // use context from middleware stack in children
3433 return obj.Files, nil
3434 })
3435 if err != nil {
3436 ec.Error(ctx, err)
3437 return graphql.Null
3438 }
3439 if resTmp == nil {
3440 if !graphql.HasFieldError(ctx, fc) {
3441 ec.Errorf(ctx, "must not be null")
3442 }
3443 return graphql.Null
3444 }
3445 res := resTmp.([]git.Hash)
3446 fc.Result = res
3447 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
3448}
3449
3450func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3451 defer func() {
3452 if r := recover(); r != nil {
3453 ec.Error(ctx, ec.Recover(ctx, r))
3454 ret = graphql.Null
3455 }
3456 }()
3457 fc := &graphql.FieldContext{
3458 Object: "AddCommentPayload",
3459 Field: field,
3460 Args: nil,
3461 IsMethod: false,
3462 }
3463
3464 ctx = graphql.WithFieldContext(ctx, fc)
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.ClientMutationID, nil
3468 })
3469 if err != nil {
3470 ec.Error(ctx, err)
3471 return graphql.Null
3472 }
3473 if resTmp == nil {
3474 return graphql.Null
3475 }
3476 res := resTmp.(*string)
3477 fc.Result = res
3478 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3479}
3480
3481func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3482 defer func() {
3483 if r := recover(); r != nil {
3484 ec.Error(ctx, ec.Recover(ctx, r))
3485 ret = graphql.Null
3486 }
3487 }()
3488 fc := &graphql.FieldContext{
3489 Object: "AddCommentPayload",
3490 Field: field,
3491 Args: nil,
3492 IsMethod: false,
3493 }
3494
3495 ctx = graphql.WithFieldContext(ctx, fc)
3496 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3497 ctx = rctx // use context from middleware stack in children
3498 return obj.Bug, nil
3499 })
3500 if err != nil {
3501 ec.Error(ctx, err)
3502 return graphql.Null
3503 }
3504 if resTmp == nil {
3505 if !graphql.HasFieldError(ctx, fc) {
3506 ec.Errorf(ctx, "must not be null")
3507 }
3508 return graphql.Null
3509 }
3510 res := resTmp.(*bug.Snapshot)
3511 fc.Result = res
3512 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
3513}
3514
3515func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3516 defer func() {
3517 if r := recover(); r != nil {
3518 ec.Error(ctx, ec.Recover(ctx, r))
3519 ret = graphql.Null
3520 }
3521 }()
3522 fc := &graphql.FieldContext{
3523 Object: "AddCommentPayload",
3524 Field: field,
3525 Args: nil,
3526 IsMethod: false,
3527 }
3528
3529 ctx = graphql.WithFieldContext(ctx, fc)
3530 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3531 ctx = rctx // use context from middleware stack in children
3532 return obj.Operation, nil
3533 })
3534 if err != nil {
3535 ec.Error(ctx, err)
3536 return graphql.Null
3537 }
3538 if resTmp == nil {
3539 if !graphql.HasFieldError(ctx, fc) {
3540 ec.Errorf(ctx, "must not be null")
3541 }
3542 return graphql.Null
3543 }
3544 res := resTmp.(*bug.AddCommentOperation)
3545 fc.Result = res
3546 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3547}
3548
3549func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3550 defer func() {
3551 if r := recover(); r != nil {
3552 ec.Error(ctx, ec.Recover(ctx, r))
3553 ret = graphql.Null
3554 }
3555 }()
3556 fc := &graphql.FieldContext{
3557 Object: "AddCommentTimelineItem",
3558 Field: field,
3559 Args: nil,
3560 IsMethod: true,
3561 }
3562
3563 ctx = graphql.WithFieldContext(ctx, fc)
3564 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3565 ctx = rctx // use context from middleware stack in children
3566 return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
3567 })
3568 if err != nil {
3569 ec.Error(ctx, err)
3570 return graphql.Null
3571 }
3572 if resTmp == nil {
3573 if !graphql.HasFieldError(ctx, fc) {
3574 ec.Errorf(ctx, "must not be null")
3575 }
3576 return graphql.Null
3577 }
3578 res := resTmp.(string)
3579 fc.Result = res
3580 return ec.marshalNString2string(ctx, field.Selections, res)
3581}
3582
3583func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3584 defer func() {
3585 if r := recover(); r != nil {
3586 ec.Error(ctx, ec.Recover(ctx, r))
3587 ret = graphql.Null
3588 }
3589 }()
3590 fc := &graphql.FieldContext{
3591 Object: "AddCommentTimelineItem",
3592 Field: field,
3593 Args: nil,
3594 IsMethod: false,
3595 }
3596
3597 ctx = graphql.WithFieldContext(ctx, fc)
3598 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3599 ctx = rctx // use context from middleware stack in children
3600 return obj.Author, nil
3601 })
3602 if err != nil {
3603 ec.Error(ctx, err)
3604 return graphql.Null
3605 }
3606 if resTmp == nil {
3607 if !graphql.HasFieldError(ctx, fc) {
3608 ec.Errorf(ctx, "must not be null")
3609 }
3610 return graphql.Null
3611 }
3612 res := resTmp.(identity.Interface)
3613 fc.Result = res
3614 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
3615}
3616
3617func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3618 defer func() {
3619 if r := recover(); r != nil {
3620 ec.Error(ctx, ec.Recover(ctx, r))
3621 ret = graphql.Null
3622 }
3623 }()
3624 fc := &graphql.FieldContext{
3625 Object: "AddCommentTimelineItem",
3626 Field: field,
3627 Args: nil,
3628 IsMethod: false,
3629 }
3630
3631 ctx = graphql.WithFieldContext(ctx, fc)
3632 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3633 ctx = rctx // use context from middleware stack in children
3634 return obj.Message, nil
3635 })
3636 if err != nil {
3637 ec.Error(ctx, err)
3638 return graphql.Null
3639 }
3640 if resTmp == nil {
3641 if !graphql.HasFieldError(ctx, fc) {
3642 ec.Errorf(ctx, "must not be null")
3643 }
3644 return graphql.Null
3645 }
3646 res := resTmp.(string)
3647 fc.Result = res
3648 return ec.marshalNString2string(ctx, field.Selections, res)
3649}
3650
3651func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3652 defer func() {
3653 if r := recover(); r != nil {
3654 ec.Error(ctx, ec.Recover(ctx, r))
3655 ret = graphql.Null
3656 }
3657 }()
3658 fc := &graphql.FieldContext{
3659 Object: "AddCommentTimelineItem",
3660 Field: field,
3661 Args: nil,
3662 IsMethod: true,
3663 }
3664
3665 ctx = graphql.WithFieldContext(ctx, fc)
3666 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3667 ctx = rctx // use context from middleware stack in children
3668 return obj.MessageIsEmpty(), nil
3669 })
3670 if err != nil {
3671 ec.Error(ctx, err)
3672 return graphql.Null
3673 }
3674 if resTmp == nil {
3675 if !graphql.HasFieldError(ctx, fc) {
3676 ec.Errorf(ctx, "must not be null")
3677 }
3678 return graphql.Null
3679 }
3680 res := resTmp.(bool)
3681 fc.Result = res
3682 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3683}
3684
3685func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3686 defer func() {
3687 if r := recover(); r != nil {
3688 ec.Error(ctx, ec.Recover(ctx, r))
3689 ret = graphql.Null
3690 }
3691 }()
3692 fc := &graphql.FieldContext{
3693 Object: "AddCommentTimelineItem",
3694 Field: field,
3695 Args: nil,
3696 IsMethod: false,
3697 }
3698
3699 ctx = graphql.WithFieldContext(ctx, fc)
3700 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3701 ctx = rctx // use context from middleware stack in children
3702 return obj.Files, nil
3703 })
3704 if err != nil {
3705 ec.Error(ctx, err)
3706 return graphql.Null
3707 }
3708 if resTmp == nil {
3709 if !graphql.HasFieldError(ctx, fc) {
3710 ec.Errorf(ctx, "must not be null")
3711 }
3712 return graphql.Null
3713 }
3714 res := resTmp.([]git.Hash)
3715 fc.Result = res
3716 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
3717}
3718
3719func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3720 defer func() {
3721 if r := recover(); r != nil {
3722 ec.Error(ctx, ec.Recover(ctx, r))
3723 ret = graphql.Null
3724 }
3725 }()
3726 fc := &graphql.FieldContext{
3727 Object: "AddCommentTimelineItem",
3728 Field: field,
3729 Args: nil,
3730 IsMethod: true,
3731 }
3732
3733 ctx = graphql.WithFieldContext(ctx, fc)
3734 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3735 ctx = rctx // use context from middleware stack in children
3736 return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
3737 })
3738 if err != nil {
3739 ec.Error(ctx, err)
3740 return graphql.Null
3741 }
3742 if resTmp == nil {
3743 if !graphql.HasFieldError(ctx, fc) {
3744 ec.Errorf(ctx, "must not be null")
3745 }
3746 return graphql.Null
3747 }
3748 res := resTmp.(*time.Time)
3749 fc.Result = res
3750 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3751}
3752
3753func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3754 defer func() {
3755 if r := recover(); r != nil {
3756 ec.Error(ctx, ec.Recover(ctx, r))
3757 ret = graphql.Null
3758 }
3759 }()
3760 fc := &graphql.FieldContext{
3761 Object: "AddCommentTimelineItem",
3762 Field: field,
3763 Args: nil,
3764 IsMethod: true,
3765 }
3766
3767 ctx = graphql.WithFieldContext(ctx, fc)
3768 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3769 ctx = rctx // use context from middleware stack in children
3770 return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
3771 })
3772 if err != nil {
3773 ec.Error(ctx, err)
3774 return graphql.Null
3775 }
3776 if resTmp == nil {
3777 if !graphql.HasFieldError(ctx, fc) {
3778 ec.Errorf(ctx, "must not be null")
3779 }
3780 return graphql.Null
3781 }
3782 res := resTmp.(*time.Time)
3783 fc.Result = res
3784 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3785}
3786
3787func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3788 defer func() {
3789 if r := recover(); r != nil {
3790 ec.Error(ctx, ec.Recover(ctx, r))
3791 ret = graphql.Null
3792 }
3793 }()
3794 fc := &graphql.FieldContext{
3795 Object: "AddCommentTimelineItem",
3796 Field: field,
3797 Args: nil,
3798 IsMethod: true,
3799 }
3800
3801 ctx = graphql.WithFieldContext(ctx, fc)
3802 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3803 ctx = rctx // use context from middleware stack in children
3804 return obj.Edited(), nil
3805 })
3806 if err != nil {
3807 ec.Error(ctx, err)
3808 return graphql.Null
3809 }
3810 if resTmp == nil {
3811 if !graphql.HasFieldError(ctx, fc) {
3812 ec.Errorf(ctx, "must not be null")
3813 }
3814 return graphql.Null
3815 }
3816 res := resTmp.(bool)
3817 fc.Result = res
3818 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3819}
3820
3821func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3822 defer func() {
3823 if r := recover(); r != nil {
3824 ec.Error(ctx, ec.Recover(ctx, r))
3825 ret = graphql.Null
3826 }
3827 }()
3828 fc := &graphql.FieldContext{
3829 Object: "AddCommentTimelineItem",
3830 Field: field,
3831 Args: nil,
3832 IsMethod: false,
3833 }
3834
3835 ctx = graphql.WithFieldContext(ctx, fc)
3836 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3837 ctx = rctx // use context from middleware stack in children
3838 return obj.History, nil
3839 })
3840 if err != nil {
3841 ec.Error(ctx, err)
3842 return graphql.Null
3843 }
3844 if resTmp == nil {
3845 if !graphql.HasFieldError(ctx, fc) {
3846 ec.Errorf(ctx, "must not be null")
3847 }
3848 return graphql.Null
3849 }
3850 res := resTmp.([]bug.CommentHistoryStep)
3851 fc.Result = res
3852 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
3853}
3854
3855func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3856 defer func() {
3857 if r := recover(); r != nil {
3858 ec.Error(ctx, ec.Recover(ctx, r))
3859 ret = graphql.Null
3860 }
3861 }()
3862 fc := &graphql.FieldContext{
3863 Object: "Bug",
3864 Field: field,
3865 Args: nil,
3866 IsMethod: true,
3867 }
3868
3869 ctx = graphql.WithFieldContext(ctx, fc)
3870 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3871 ctx = rctx // use context from middleware stack in children
3872 return ec.resolvers.Bug().ID(rctx, obj)
3873 })
3874 if err != nil {
3875 ec.Error(ctx, err)
3876 return graphql.Null
3877 }
3878 if resTmp == nil {
3879 if !graphql.HasFieldError(ctx, fc) {
3880 ec.Errorf(ctx, "must not be null")
3881 }
3882 return graphql.Null
3883 }
3884 res := resTmp.(string)
3885 fc.Result = res
3886 return ec.marshalNString2string(ctx, field.Selections, res)
3887}
3888
3889func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3890 defer func() {
3891 if r := recover(); r != nil {
3892 ec.Error(ctx, ec.Recover(ctx, r))
3893 ret = graphql.Null
3894 }
3895 }()
3896 fc := &graphql.FieldContext{
3897 Object: "Bug",
3898 Field: field,
3899 Args: nil,
3900 IsMethod: true,
3901 }
3902
3903 ctx = graphql.WithFieldContext(ctx, fc)
3904 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3905 ctx = rctx // use context from middleware stack in children
3906 return ec.resolvers.Bug().HumanID(rctx, obj)
3907 })
3908 if err != nil {
3909 ec.Error(ctx, err)
3910 return graphql.Null
3911 }
3912 if resTmp == nil {
3913 if !graphql.HasFieldError(ctx, fc) {
3914 ec.Errorf(ctx, "must not be null")
3915 }
3916 return graphql.Null
3917 }
3918 res := resTmp.(string)
3919 fc.Result = res
3920 return ec.marshalNString2string(ctx, field.Selections, res)
3921}
3922
3923func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3924 defer func() {
3925 if r := recover(); r != nil {
3926 ec.Error(ctx, ec.Recover(ctx, r))
3927 ret = graphql.Null
3928 }
3929 }()
3930 fc := &graphql.FieldContext{
3931 Object: "Bug",
3932 Field: field,
3933 Args: nil,
3934 IsMethod: true,
3935 }
3936
3937 ctx = graphql.WithFieldContext(ctx, fc)
3938 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3939 ctx = rctx // use context from middleware stack in children
3940 return ec.resolvers.Bug().Status(rctx, obj)
3941 })
3942 if err != nil {
3943 ec.Error(ctx, err)
3944 return graphql.Null
3945 }
3946 if resTmp == nil {
3947 if !graphql.HasFieldError(ctx, fc) {
3948 ec.Errorf(ctx, "must not be null")
3949 }
3950 return graphql.Null
3951 }
3952 res := resTmp.(models.Status)
3953 fc.Result = res
3954 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
3955}
3956
3957func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3958 defer func() {
3959 if r := recover(); r != nil {
3960 ec.Error(ctx, ec.Recover(ctx, r))
3961 ret = graphql.Null
3962 }
3963 }()
3964 fc := &graphql.FieldContext{
3965 Object: "Bug",
3966 Field: field,
3967 Args: nil,
3968 IsMethod: false,
3969 }
3970
3971 ctx = graphql.WithFieldContext(ctx, fc)
3972 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3973 ctx = rctx // use context from middleware stack in children
3974 return obj.Title, nil
3975 })
3976 if err != nil {
3977 ec.Error(ctx, err)
3978 return graphql.Null
3979 }
3980 if resTmp == nil {
3981 if !graphql.HasFieldError(ctx, fc) {
3982 ec.Errorf(ctx, "must not be null")
3983 }
3984 return graphql.Null
3985 }
3986 res := resTmp.(string)
3987 fc.Result = res
3988 return ec.marshalNString2string(ctx, field.Selections, res)
3989}
3990
3991func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
3992 defer func() {
3993 if r := recover(); r != nil {
3994 ec.Error(ctx, ec.Recover(ctx, r))
3995 ret = graphql.Null
3996 }
3997 }()
3998 fc := &graphql.FieldContext{
3999 Object: "Bug",
4000 Field: field,
4001 Args: nil,
4002 IsMethod: false,
4003 }
4004
4005 ctx = graphql.WithFieldContext(ctx, fc)
4006 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4007 ctx = rctx // use context from middleware stack in children
4008 return obj.Labels, nil
4009 })
4010 if err != nil {
4011 ec.Error(ctx, err)
4012 return graphql.Null
4013 }
4014 if resTmp == nil {
4015 if !graphql.HasFieldError(ctx, fc) {
4016 ec.Errorf(ctx, "must not be null")
4017 }
4018 return graphql.Null
4019 }
4020 res := resTmp.([]bug.Label)
4021 fc.Result = res
4022 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
4023}
4024
4025func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4026 defer func() {
4027 if r := recover(); r != nil {
4028 ec.Error(ctx, ec.Recover(ctx, r))
4029 ret = graphql.Null
4030 }
4031 }()
4032 fc := &graphql.FieldContext{
4033 Object: "Bug",
4034 Field: field,
4035 Args: nil,
4036 IsMethod: false,
4037 }
4038
4039 ctx = graphql.WithFieldContext(ctx, fc)
4040 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4041 ctx = rctx // use context from middleware stack in children
4042 return obj.Author, nil
4043 })
4044 if err != nil {
4045 ec.Error(ctx, err)
4046 return graphql.Null
4047 }
4048 if resTmp == nil {
4049 if !graphql.HasFieldError(ctx, fc) {
4050 ec.Errorf(ctx, "must not be null")
4051 }
4052 return graphql.Null
4053 }
4054 res := resTmp.(identity.Interface)
4055 fc.Result = res
4056 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
4057}
4058
4059func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4060 defer func() {
4061 if r := recover(); r != nil {
4062 ec.Error(ctx, ec.Recover(ctx, r))
4063 ret = graphql.Null
4064 }
4065 }()
4066 fc := &graphql.FieldContext{
4067 Object: "Bug",
4068 Field: field,
4069 Args: nil,
4070 IsMethod: false,
4071 }
4072
4073 ctx = graphql.WithFieldContext(ctx, fc)
4074 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4075 ctx = rctx // use context from middleware stack in children
4076 return obj.CreatedAt, nil
4077 })
4078 if err != nil {
4079 ec.Error(ctx, err)
4080 return graphql.Null
4081 }
4082 if resTmp == nil {
4083 if !graphql.HasFieldError(ctx, fc) {
4084 ec.Errorf(ctx, "must not be null")
4085 }
4086 return graphql.Null
4087 }
4088 res := resTmp.(time.Time)
4089 fc.Result = res
4090 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
4091}
4092
4093func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4094 defer func() {
4095 if r := recover(); r != nil {
4096 ec.Error(ctx, ec.Recover(ctx, r))
4097 ret = graphql.Null
4098 }
4099 }()
4100 fc := &graphql.FieldContext{
4101 Object: "Bug",
4102 Field: field,
4103 Args: nil,
4104 IsMethod: true,
4105 }
4106
4107 ctx = graphql.WithFieldContext(ctx, fc)
4108 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4109 ctx = rctx // use context from middleware stack in children
4110 return ec.resolvers.Bug().LastEdit(rctx, obj)
4111 })
4112 if err != nil {
4113 ec.Error(ctx, err)
4114 return graphql.Null
4115 }
4116 if resTmp == nil {
4117 if !graphql.HasFieldError(ctx, fc) {
4118 ec.Errorf(ctx, "must not be null")
4119 }
4120 return graphql.Null
4121 }
4122 res := resTmp.(*time.Time)
4123 fc.Result = res
4124 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
4125}
4126
4127func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4128 defer func() {
4129 if r := recover(); r != nil {
4130 ec.Error(ctx, ec.Recover(ctx, r))
4131 ret = graphql.Null
4132 }
4133 }()
4134 fc := &graphql.FieldContext{
4135 Object: "Bug",
4136 Field: field,
4137 Args: nil,
4138 IsMethod: true,
4139 }
4140
4141 ctx = graphql.WithFieldContext(ctx, fc)
4142 rawArgs := field.ArgumentMap(ec.Variables)
4143 args, err := ec.field_Bug_actors_args(ctx, rawArgs)
4144 if err != nil {
4145 ec.Error(ctx, err)
4146 return graphql.Null
4147 }
4148 fc.Args = args
4149 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4150 ctx = rctx // use context from middleware stack in children
4151 return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4152 })
4153 if err != nil {
4154 ec.Error(ctx, err)
4155 return graphql.Null
4156 }
4157 if resTmp == nil {
4158 if !graphql.HasFieldError(ctx, fc) {
4159 ec.Errorf(ctx, "must not be null")
4160 }
4161 return graphql.Null
4162 }
4163 res := resTmp.(*models.IdentityConnection)
4164 fc.Result = res
4165 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4166}
4167
4168func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4169 defer func() {
4170 if r := recover(); r != nil {
4171 ec.Error(ctx, ec.Recover(ctx, r))
4172 ret = graphql.Null
4173 }
4174 }()
4175 fc := &graphql.FieldContext{
4176 Object: "Bug",
4177 Field: field,
4178 Args: nil,
4179 IsMethod: true,
4180 }
4181
4182 ctx = graphql.WithFieldContext(ctx, fc)
4183 rawArgs := field.ArgumentMap(ec.Variables)
4184 args, err := ec.field_Bug_participants_args(ctx, rawArgs)
4185 if err != nil {
4186 ec.Error(ctx, err)
4187 return graphql.Null
4188 }
4189 fc.Args = args
4190 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4191 ctx = rctx // use context from middleware stack in children
4192 return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4193 })
4194 if err != nil {
4195 ec.Error(ctx, err)
4196 return graphql.Null
4197 }
4198 if resTmp == nil {
4199 if !graphql.HasFieldError(ctx, fc) {
4200 ec.Errorf(ctx, "must not be null")
4201 }
4202 return graphql.Null
4203 }
4204 res := resTmp.(*models.IdentityConnection)
4205 fc.Result = res
4206 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4207}
4208
4209func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4210 defer func() {
4211 if r := recover(); r != nil {
4212 ec.Error(ctx, ec.Recover(ctx, r))
4213 ret = graphql.Null
4214 }
4215 }()
4216 fc := &graphql.FieldContext{
4217 Object: "Bug",
4218 Field: field,
4219 Args: nil,
4220 IsMethod: true,
4221 }
4222
4223 ctx = graphql.WithFieldContext(ctx, fc)
4224 rawArgs := field.ArgumentMap(ec.Variables)
4225 args, err := ec.field_Bug_comments_args(ctx, rawArgs)
4226 if err != nil {
4227 ec.Error(ctx, err)
4228 return graphql.Null
4229 }
4230 fc.Args = args
4231 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4232 ctx = rctx // use context from middleware stack in children
4233 return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4234 })
4235 if err != nil {
4236 ec.Error(ctx, err)
4237 return graphql.Null
4238 }
4239 if resTmp == nil {
4240 if !graphql.HasFieldError(ctx, fc) {
4241 ec.Errorf(ctx, "must not be null")
4242 }
4243 return graphql.Null
4244 }
4245 res := resTmp.(*models.CommentConnection)
4246 fc.Result = res
4247 return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
4248}
4249
4250func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4251 defer func() {
4252 if r := recover(); r != nil {
4253 ec.Error(ctx, ec.Recover(ctx, r))
4254 ret = graphql.Null
4255 }
4256 }()
4257 fc := &graphql.FieldContext{
4258 Object: "Bug",
4259 Field: field,
4260 Args: nil,
4261 IsMethod: true,
4262 }
4263
4264 ctx = graphql.WithFieldContext(ctx, fc)
4265 rawArgs := field.ArgumentMap(ec.Variables)
4266 args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
4267 if err != nil {
4268 ec.Error(ctx, err)
4269 return graphql.Null
4270 }
4271 fc.Args = args
4272 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4273 ctx = rctx // use context from middleware stack in children
4274 return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4275 })
4276 if err != nil {
4277 ec.Error(ctx, err)
4278 return graphql.Null
4279 }
4280 if resTmp == nil {
4281 if !graphql.HasFieldError(ctx, fc) {
4282 ec.Errorf(ctx, "must not be null")
4283 }
4284 return graphql.Null
4285 }
4286 res := resTmp.(*models.TimelineItemConnection)
4287 fc.Result = res
4288 return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
4289}
4290
4291func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
4292 defer func() {
4293 if r := recover(); r != nil {
4294 ec.Error(ctx, ec.Recover(ctx, r))
4295 ret = graphql.Null
4296 }
4297 }()
4298 fc := &graphql.FieldContext{
4299 Object: "Bug",
4300 Field: field,
4301 Args: nil,
4302 IsMethod: true,
4303 }
4304
4305 ctx = graphql.WithFieldContext(ctx, fc)
4306 rawArgs := field.ArgumentMap(ec.Variables)
4307 args, err := ec.field_Bug_operations_args(ctx, rawArgs)
4308 if err != nil {
4309 ec.Error(ctx, err)
4310 return graphql.Null
4311 }
4312 fc.Args = args
4313 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4314 ctx = rctx // use context from middleware stack in children
4315 return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4316 })
4317 if err != nil {
4318 ec.Error(ctx, err)
4319 return graphql.Null
4320 }
4321 if resTmp == nil {
4322 if !graphql.HasFieldError(ctx, fc) {
4323 ec.Errorf(ctx, "must not be null")
4324 }
4325 return graphql.Null
4326 }
4327 res := resTmp.(*models.OperationConnection)
4328 fc.Result = res
4329 return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
4330}
4331
4332func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4333 defer func() {
4334 if r := recover(); r != nil {
4335 ec.Error(ctx, ec.Recover(ctx, r))
4336 ret = graphql.Null
4337 }
4338 }()
4339 fc := &graphql.FieldContext{
4340 Object: "BugConnection",
4341 Field: field,
4342 Args: nil,
4343 IsMethod: false,
4344 }
4345
4346 ctx = graphql.WithFieldContext(ctx, fc)
4347 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4348 ctx = rctx // use context from middleware stack in children
4349 return obj.Edges, nil
4350 })
4351 if err != nil {
4352 ec.Error(ctx, err)
4353 return graphql.Null
4354 }
4355 if resTmp == nil {
4356 if !graphql.HasFieldError(ctx, fc) {
4357 ec.Errorf(ctx, "must not be null")
4358 }
4359 return graphql.Null
4360 }
4361 res := resTmp.([]*models.BugEdge)
4362 fc.Result = res
4363 return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
4364}
4365
4366func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4367 defer func() {
4368 if r := recover(); r != nil {
4369 ec.Error(ctx, ec.Recover(ctx, r))
4370 ret = graphql.Null
4371 }
4372 }()
4373 fc := &graphql.FieldContext{
4374 Object: "BugConnection",
4375 Field: field,
4376 Args: nil,
4377 IsMethod: false,
4378 }
4379
4380 ctx = graphql.WithFieldContext(ctx, fc)
4381 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4382 ctx = rctx // use context from middleware stack in children
4383 return obj.Nodes, nil
4384 })
4385 if err != nil {
4386 ec.Error(ctx, err)
4387 return graphql.Null
4388 }
4389 if resTmp == nil {
4390 if !graphql.HasFieldError(ctx, fc) {
4391 ec.Errorf(ctx, "must not be null")
4392 }
4393 return graphql.Null
4394 }
4395 res := resTmp.([]*bug.Snapshot)
4396 fc.Result = res
4397 return ec.marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshotᚄ(ctx, field.Selections, res)
4398}
4399
4400func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4401 defer func() {
4402 if r := recover(); r != nil {
4403 ec.Error(ctx, ec.Recover(ctx, r))
4404 ret = graphql.Null
4405 }
4406 }()
4407 fc := &graphql.FieldContext{
4408 Object: "BugConnection",
4409 Field: field,
4410 Args: nil,
4411 IsMethod: false,
4412 }
4413
4414 ctx = graphql.WithFieldContext(ctx, fc)
4415 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4416 ctx = rctx // use context from middleware stack in children
4417 return obj.PageInfo, nil
4418 })
4419 if err != nil {
4420 ec.Error(ctx, err)
4421 return graphql.Null
4422 }
4423 if resTmp == nil {
4424 if !graphql.HasFieldError(ctx, fc) {
4425 ec.Errorf(ctx, "must not be null")
4426 }
4427 return graphql.Null
4428 }
4429 res := resTmp.(*models.PageInfo)
4430 fc.Result = res
4431 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4432}
4433
4434func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4435 defer func() {
4436 if r := recover(); r != nil {
4437 ec.Error(ctx, ec.Recover(ctx, r))
4438 ret = graphql.Null
4439 }
4440 }()
4441 fc := &graphql.FieldContext{
4442 Object: "BugConnection",
4443 Field: field,
4444 Args: nil,
4445 IsMethod: false,
4446 }
4447
4448 ctx = graphql.WithFieldContext(ctx, fc)
4449 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4450 ctx = rctx // use context from middleware stack in children
4451 return obj.TotalCount, nil
4452 })
4453 if err != nil {
4454 ec.Error(ctx, err)
4455 return graphql.Null
4456 }
4457 if resTmp == nil {
4458 if !graphql.HasFieldError(ctx, fc) {
4459 ec.Errorf(ctx, "must not be null")
4460 }
4461 return graphql.Null
4462 }
4463 res := resTmp.(int)
4464 fc.Result = res
4465 return ec.marshalNInt2int(ctx, field.Selections, res)
4466}
4467
4468func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4469 defer func() {
4470 if r := recover(); r != nil {
4471 ec.Error(ctx, ec.Recover(ctx, r))
4472 ret = graphql.Null
4473 }
4474 }()
4475 fc := &graphql.FieldContext{
4476 Object: "BugEdge",
4477 Field: field,
4478 Args: nil,
4479 IsMethod: false,
4480 }
4481
4482 ctx = graphql.WithFieldContext(ctx, fc)
4483 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4484 ctx = rctx // use context from middleware stack in children
4485 return obj.Cursor, nil
4486 })
4487 if err != nil {
4488 ec.Error(ctx, err)
4489 return graphql.Null
4490 }
4491 if resTmp == nil {
4492 if !graphql.HasFieldError(ctx, fc) {
4493 ec.Errorf(ctx, "must not be null")
4494 }
4495 return graphql.Null
4496 }
4497 res := resTmp.(string)
4498 fc.Result = res
4499 return ec.marshalNString2string(ctx, field.Selections, res)
4500}
4501
4502func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4503 defer func() {
4504 if r := recover(); r != nil {
4505 ec.Error(ctx, ec.Recover(ctx, r))
4506 ret = graphql.Null
4507 }
4508 }()
4509 fc := &graphql.FieldContext{
4510 Object: "BugEdge",
4511 Field: field,
4512 Args: nil,
4513 IsMethod: false,
4514 }
4515
4516 ctx = graphql.WithFieldContext(ctx, fc)
4517 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4518 ctx = rctx // use context from middleware stack in children
4519 return obj.Node, nil
4520 })
4521 if err != nil {
4522 ec.Error(ctx, err)
4523 return graphql.Null
4524 }
4525 if resTmp == nil {
4526 if !graphql.HasFieldError(ctx, fc) {
4527 ec.Errorf(ctx, "must not be null")
4528 }
4529 return graphql.Null
4530 }
4531 res := resTmp.(*bug.Snapshot)
4532 fc.Result = res
4533 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
4534}
4535
4536func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4537 defer func() {
4538 if r := recover(); r != nil {
4539 ec.Error(ctx, ec.Recover(ctx, r))
4540 ret = graphql.Null
4541 }
4542 }()
4543 fc := &graphql.FieldContext{
4544 Object: "ChangeLabelPayload",
4545 Field: field,
4546 Args: nil,
4547 IsMethod: false,
4548 }
4549
4550 ctx = graphql.WithFieldContext(ctx, fc)
4551 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4552 ctx = rctx // use context from middleware stack in children
4553 return obj.ClientMutationID, nil
4554 })
4555 if err != nil {
4556 ec.Error(ctx, err)
4557 return graphql.Null
4558 }
4559 if resTmp == nil {
4560 return graphql.Null
4561 }
4562 res := resTmp.(*string)
4563 fc.Result = res
4564 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4565}
4566
4567func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4568 defer func() {
4569 if r := recover(); r != nil {
4570 ec.Error(ctx, ec.Recover(ctx, r))
4571 ret = graphql.Null
4572 }
4573 }()
4574 fc := &graphql.FieldContext{
4575 Object: "ChangeLabelPayload",
4576 Field: field,
4577 Args: nil,
4578 IsMethod: false,
4579 }
4580
4581 ctx = graphql.WithFieldContext(ctx, fc)
4582 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4583 ctx = rctx // use context from middleware stack in children
4584 return obj.Bug, nil
4585 })
4586 if err != nil {
4587 ec.Error(ctx, err)
4588 return graphql.Null
4589 }
4590 if resTmp == nil {
4591 if !graphql.HasFieldError(ctx, fc) {
4592 ec.Errorf(ctx, "must not be null")
4593 }
4594 return graphql.Null
4595 }
4596 res := resTmp.(*bug.Snapshot)
4597 fc.Result = res
4598 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
4599}
4600
4601func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4602 defer func() {
4603 if r := recover(); r != nil {
4604 ec.Error(ctx, ec.Recover(ctx, r))
4605 ret = graphql.Null
4606 }
4607 }()
4608 fc := &graphql.FieldContext{
4609 Object: "ChangeLabelPayload",
4610 Field: field,
4611 Args: nil,
4612 IsMethod: false,
4613 }
4614
4615 ctx = graphql.WithFieldContext(ctx, fc)
4616 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4617 ctx = rctx // use context from middleware stack in children
4618 return obj.Operation, nil
4619 })
4620 if err != nil {
4621 ec.Error(ctx, err)
4622 return graphql.Null
4623 }
4624 if resTmp == nil {
4625 if !graphql.HasFieldError(ctx, fc) {
4626 ec.Errorf(ctx, "must not be null")
4627 }
4628 return graphql.Null
4629 }
4630 res := resTmp.(*bug.LabelChangeOperation)
4631 fc.Result = res
4632 return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
4633}
4634
4635func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4636 defer func() {
4637 if r := recover(); r != nil {
4638 ec.Error(ctx, ec.Recover(ctx, r))
4639 ret = graphql.Null
4640 }
4641 }()
4642 fc := &graphql.FieldContext{
4643 Object: "ChangeLabelPayload",
4644 Field: field,
4645 Args: nil,
4646 IsMethod: false,
4647 }
4648
4649 ctx = graphql.WithFieldContext(ctx, fc)
4650 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4651 ctx = rctx // use context from middleware stack in children
4652 return obj.Results, nil
4653 })
4654 if err != nil {
4655 ec.Error(ctx, err)
4656 return graphql.Null
4657 }
4658 if resTmp == nil {
4659 if !graphql.HasFieldError(ctx, fc) {
4660 ec.Errorf(ctx, "must not be null")
4661 }
4662 return graphql.Null
4663 }
4664 res := resTmp.([]*bug.LabelChangeResult)
4665 fc.Result = res
4666 return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
4667}
4668
4669func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4670 defer func() {
4671 if r := recover(); r != nil {
4672 ec.Error(ctx, ec.Recover(ctx, r))
4673 ret = graphql.Null
4674 }
4675 }()
4676 fc := &graphql.FieldContext{
4677 Object: "CloseBugPayload",
4678 Field: field,
4679 Args: nil,
4680 IsMethod: false,
4681 }
4682
4683 ctx = graphql.WithFieldContext(ctx, fc)
4684 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4685 ctx = rctx // use context from middleware stack in children
4686 return obj.ClientMutationID, nil
4687 })
4688 if err != nil {
4689 ec.Error(ctx, err)
4690 return graphql.Null
4691 }
4692 if resTmp == nil {
4693 return graphql.Null
4694 }
4695 res := resTmp.(*string)
4696 fc.Result = res
4697 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4698}
4699
4700func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4701 defer func() {
4702 if r := recover(); r != nil {
4703 ec.Error(ctx, ec.Recover(ctx, r))
4704 ret = graphql.Null
4705 }
4706 }()
4707 fc := &graphql.FieldContext{
4708 Object: "CloseBugPayload",
4709 Field: field,
4710 Args: nil,
4711 IsMethod: false,
4712 }
4713
4714 ctx = graphql.WithFieldContext(ctx, fc)
4715 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4716 ctx = rctx // use context from middleware stack in children
4717 return obj.Bug, nil
4718 })
4719 if err != nil {
4720 ec.Error(ctx, err)
4721 return graphql.Null
4722 }
4723 if resTmp == nil {
4724 if !graphql.HasFieldError(ctx, fc) {
4725 ec.Errorf(ctx, "must not be null")
4726 }
4727 return graphql.Null
4728 }
4729 res := resTmp.(*bug.Snapshot)
4730 fc.Result = res
4731 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
4732}
4733
4734func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4735 defer func() {
4736 if r := recover(); r != nil {
4737 ec.Error(ctx, ec.Recover(ctx, r))
4738 ret = graphql.Null
4739 }
4740 }()
4741 fc := &graphql.FieldContext{
4742 Object: "CloseBugPayload",
4743 Field: field,
4744 Args: nil,
4745 IsMethod: false,
4746 }
4747
4748 ctx = graphql.WithFieldContext(ctx, fc)
4749 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4750 ctx = rctx // use context from middleware stack in children
4751 return obj.Operation, nil
4752 })
4753 if err != nil {
4754 ec.Error(ctx, err)
4755 return graphql.Null
4756 }
4757 if resTmp == nil {
4758 if !graphql.HasFieldError(ctx, fc) {
4759 ec.Errorf(ctx, "must not be null")
4760 }
4761 return graphql.Null
4762 }
4763 res := resTmp.(*bug.SetStatusOperation)
4764 fc.Result = res
4765 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
4766}
4767
4768func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4769 defer func() {
4770 if r := recover(); r != nil {
4771 ec.Error(ctx, ec.Recover(ctx, r))
4772 ret = graphql.Null
4773 }
4774 }()
4775 fc := &graphql.FieldContext{
4776 Object: "Color",
4777 Field: field,
4778 Args: nil,
4779 IsMethod: true,
4780 }
4781
4782 ctx = graphql.WithFieldContext(ctx, fc)
4783 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4784 ctx = rctx // use context from middleware stack in children
4785 return ec.resolvers.Color().R(rctx, obj)
4786 })
4787 if err != nil {
4788 ec.Error(ctx, err)
4789 return graphql.Null
4790 }
4791 if resTmp == nil {
4792 if !graphql.HasFieldError(ctx, fc) {
4793 ec.Errorf(ctx, "must not be null")
4794 }
4795 return graphql.Null
4796 }
4797 res := resTmp.(int)
4798 fc.Result = res
4799 return ec.marshalNInt2int(ctx, field.Selections, res)
4800}
4801
4802func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4803 defer func() {
4804 if r := recover(); r != nil {
4805 ec.Error(ctx, ec.Recover(ctx, r))
4806 ret = graphql.Null
4807 }
4808 }()
4809 fc := &graphql.FieldContext{
4810 Object: "Color",
4811 Field: field,
4812 Args: nil,
4813 IsMethod: true,
4814 }
4815
4816 ctx = graphql.WithFieldContext(ctx, fc)
4817 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4818 ctx = rctx // use context from middleware stack in children
4819 return ec.resolvers.Color().G(rctx, obj)
4820 })
4821 if err != nil {
4822 ec.Error(ctx, err)
4823 return graphql.Null
4824 }
4825 if resTmp == nil {
4826 if !graphql.HasFieldError(ctx, fc) {
4827 ec.Errorf(ctx, "must not be null")
4828 }
4829 return graphql.Null
4830 }
4831 res := resTmp.(int)
4832 fc.Result = res
4833 return ec.marshalNInt2int(ctx, field.Selections, res)
4834}
4835
4836func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4837 defer func() {
4838 if r := recover(); r != nil {
4839 ec.Error(ctx, ec.Recover(ctx, r))
4840 ret = graphql.Null
4841 }
4842 }()
4843 fc := &graphql.FieldContext{
4844 Object: "Color",
4845 Field: field,
4846 Args: nil,
4847 IsMethod: true,
4848 }
4849
4850 ctx = graphql.WithFieldContext(ctx, fc)
4851 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4852 ctx = rctx // use context from middleware stack in children
4853 return ec.resolvers.Color().B(rctx, obj)
4854 })
4855 if err != nil {
4856 ec.Error(ctx, err)
4857 return graphql.Null
4858 }
4859 if resTmp == nil {
4860 if !graphql.HasFieldError(ctx, fc) {
4861 ec.Errorf(ctx, "must not be null")
4862 }
4863 return graphql.Null
4864 }
4865 res := resTmp.(int)
4866 fc.Result = res
4867 return ec.marshalNInt2int(ctx, field.Selections, res)
4868}
4869
4870func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4871 defer func() {
4872 if r := recover(); r != nil {
4873 ec.Error(ctx, ec.Recover(ctx, r))
4874 ret = graphql.Null
4875 }
4876 }()
4877 fc := &graphql.FieldContext{
4878 Object: "Comment",
4879 Field: field,
4880 Args: nil,
4881 IsMethod: false,
4882 }
4883
4884 ctx = graphql.WithFieldContext(ctx, fc)
4885 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4886 ctx = rctx // use context from middleware stack in children
4887 return obj.Author, nil
4888 })
4889 if err != nil {
4890 ec.Error(ctx, err)
4891 return graphql.Null
4892 }
4893 if resTmp == nil {
4894 if !graphql.HasFieldError(ctx, fc) {
4895 ec.Errorf(ctx, "must not be null")
4896 }
4897 return graphql.Null
4898 }
4899 res := resTmp.(identity.Interface)
4900 fc.Result = res
4901 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
4902}
4903
4904func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4905 defer func() {
4906 if r := recover(); r != nil {
4907 ec.Error(ctx, ec.Recover(ctx, r))
4908 ret = graphql.Null
4909 }
4910 }()
4911 fc := &graphql.FieldContext{
4912 Object: "Comment",
4913 Field: field,
4914 Args: nil,
4915 IsMethod: false,
4916 }
4917
4918 ctx = graphql.WithFieldContext(ctx, fc)
4919 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4920 ctx = rctx // use context from middleware stack in children
4921 return obj.Message, nil
4922 })
4923 if err != nil {
4924 ec.Error(ctx, err)
4925 return graphql.Null
4926 }
4927 if resTmp == nil {
4928 if !graphql.HasFieldError(ctx, fc) {
4929 ec.Errorf(ctx, "must not be null")
4930 }
4931 return graphql.Null
4932 }
4933 res := resTmp.(string)
4934 fc.Result = res
4935 return ec.marshalNString2string(ctx, field.Selections, res)
4936}
4937
4938func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4939 defer func() {
4940 if r := recover(); r != nil {
4941 ec.Error(ctx, ec.Recover(ctx, r))
4942 ret = graphql.Null
4943 }
4944 }()
4945 fc := &graphql.FieldContext{
4946 Object: "Comment",
4947 Field: field,
4948 Args: nil,
4949 IsMethod: false,
4950 }
4951
4952 ctx = graphql.WithFieldContext(ctx, fc)
4953 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4954 ctx = rctx // use context from middleware stack in children
4955 return obj.Files, nil
4956 })
4957 if err != nil {
4958 ec.Error(ctx, err)
4959 return graphql.Null
4960 }
4961 if resTmp == nil {
4962 if !graphql.HasFieldError(ctx, fc) {
4963 ec.Errorf(ctx, "must not be null")
4964 }
4965 return graphql.Null
4966 }
4967 res := resTmp.([]git.Hash)
4968 fc.Result = res
4969 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
4970}
4971
4972func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4973 defer func() {
4974 if r := recover(); r != nil {
4975 ec.Error(ctx, ec.Recover(ctx, r))
4976 ret = graphql.Null
4977 }
4978 }()
4979 fc := &graphql.FieldContext{
4980 Object: "CommentConnection",
4981 Field: field,
4982 Args: nil,
4983 IsMethod: false,
4984 }
4985
4986 ctx = graphql.WithFieldContext(ctx, fc)
4987 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4988 ctx = rctx // use context from middleware stack in children
4989 return obj.Edges, nil
4990 })
4991 if err != nil {
4992 ec.Error(ctx, err)
4993 return graphql.Null
4994 }
4995 if resTmp == nil {
4996 if !graphql.HasFieldError(ctx, fc) {
4997 ec.Errorf(ctx, "must not be null")
4998 }
4999 return graphql.Null
5000 }
5001 res := resTmp.([]*models.CommentEdge)
5002 fc.Result = res
5003 return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
5004}
5005
5006func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
5007 defer func() {
5008 if r := recover(); r != nil {
5009 ec.Error(ctx, ec.Recover(ctx, r))
5010 ret = graphql.Null
5011 }
5012 }()
5013 fc := &graphql.FieldContext{
5014 Object: "CommentConnection",
5015 Field: field,
5016 Args: nil,
5017 IsMethod: false,
5018 }
5019
5020 ctx = graphql.WithFieldContext(ctx, fc)
5021 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5022 ctx = rctx // use context from middleware stack in children
5023 return obj.Nodes, nil
5024 })
5025 if err != nil {
5026 ec.Error(ctx, err)
5027 return graphql.Null
5028 }
5029 if resTmp == nil {
5030 if !graphql.HasFieldError(ctx, fc) {
5031 ec.Errorf(ctx, "must not be null")
5032 }
5033 return graphql.Null
5034 }
5035 res := resTmp.([]*bug.Comment)
5036 fc.Result = res
5037 return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
5038}
5039
5040func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
5041 defer func() {
5042 if r := recover(); r != nil {
5043 ec.Error(ctx, ec.Recover(ctx, r))
5044 ret = graphql.Null
5045 }
5046 }()
5047 fc := &graphql.FieldContext{
5048 Object: "CommentConnection",
5049 Field: field,
5050 Args: nil,
5051 IsMethod: false,
5052 }
5053
5054 ctx = graphql.WithFieldContext(ctx, fc)
5055 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5056 ctx = rctx // use context from middleware stack in children
5057 return obj.PageInfo, nil
5058 })
5059 if err != nil {
5060 ec.Error(ctx, err)
5061 return graphql.Null
5062 }
5063 if resTmp == nil {
5064 if !graphql.HasFieldError(ctx, fc) {
5065 ec.Errorf(ctx, "must not be null")
5066 }
5067 return graphql.Null
5068 }
5069 res := resTmp.(*models.PageInfo)
5070 fc.Result = res
5071 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
5072}
5073
5074func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
5075 defer func() {
5076 if r := recover(); r != nil {
5077 ec.Error(ctx, ec.Recover(ctx, r))
5078 ret = graphql.Null
5079 }
5080 }()
5081 fc := &graphql.FieldContext{
5082 Object: "CommentConnection",
5083 Field: field,
5084 Args: nil,
5085 IsMethod: false,
5086 }
5087
5088 ctx = graphql.WithFieldContext(ctx, fc)
5089 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5090 ctx = rctx // use context from middleware stack in children
5091 return obj.TotalCount, nil
5092 })
5093 if err != nil {
5094 ec.Error(ctx, err)
5095 return graphql.Null
5096 }
5097 if resTmp == nil {
5098 if !graphql.HasFieldError(ctx, fc) {
5099 ec.Errorf(ctx, "must not be null")
5100 }
5101 return graphql.Null
5102 }
5103 res := resTmp.(int)
5104 fc.Result = res
5105 return ec.marshalNInt2int(ctx, field.Selections, res)
5106}
5107
5108func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
5109 defer func() {
5110 if r := recover(); r != nil {
5111 ec.Error(ctx, ec.Recover(ctx, r))
5112 ret = graphql.Null
5113 }
5114 }()
5115 fc := &graphql.FieldContext{
5116 Object: "CommentEdge",
5117 Field: field,
5118 Args: nil,
5119 IsMethod: false,
5120 }
5121
5122 ctx = graphql.WithFieldContext(ctx, fc)
5123 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5124 ctx = rctx // use context from middleware stack in children
5125 return obj.Cursor, nil
5126 })
5127 if err != nil {
5128 ec.Error(ctx, err)
5129 return graphql.Null
5130 }
5131 if resTmp == nil {
5132 if !graphql.HasFieldError(ctx, fc) {
5133 ec.Errorf(ctx, "must not be null")
5134 }
5135 return graphql.Null
5136 }
5137 res := resTmp.(string)
5138 fc.Result = res
5139 return ec.marshalNString2string(ctx, field.Selections, res)
5140}
5141
5142func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
5143 defer func() {
5144 if r := recover(); r != nil {
5145 ec.Error(ctx, ec.Recover(ctx, r))
5146 ret = graphql.Null
5147 }
5148 }()
5149 fc := &graphql.FieldContext{
5150 Object: "CommentEdge",
5151 Field: field,
5152 Args: nil,
5153 IsMethod: false,
5154 }
5155
5156 ctx = graphql.WithFieldContext(ctx, fc)
5157 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5158 ctx = rctx // use context from middleware stack in children
5159 return obj.Node, nil
5160 })
5161 if err != nil {
5162 ec.Error(ctx, err)
5163 return graphql.Null
5164 }
5165 if resTmp == nil {
5166 if !graphql.HasFieldError(ctx, fc) {
5167 ec.Errorf(ctx, "must not be null")
5168 }
5169 return graphql.Null
5170 }
5171 res := resTmp.(*bug.Comment)
5172 fc.Result = res
5173 return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
5174}
5175
5176func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
5177 defer func() {
5178 if r := recover(); r != nil {
5179 ec.Error(ctx, ec.Recover(ctx, r))
5180 ret = graphql.Null
5181 }
5182 }()
5183 fc := &graphql.FieldContext{
5184 Object: "CommentHistoryStep",
5185 Field: field,
5186 Args: nil,
5187 IsMethod: false,
5188 }
5189
5190 ctx = graphql.WithFieldContext(ctx, fc)
5191 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5192 ctx = rctx // use context from middleware stack in children
5193 return obj.Message, nil
5194 })
5195 if err != nil {
5196 ec.Error(ctx, err)
5197 return graphql.Null
5198 }
5199 if resTmp == nil {
5200 if !graphql.HasFieldError(ctx, fc) {
5201 ec.Errorf(ctx, "must not be null")
5202 }
5203 return graphql.Null
5204 }
5205 res := resTmp.(string)
5206 fc.Result = res
5207 return ec.marshalNString2string(ctx, field.Selections, res)
5208}
5209
5210func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
5211 defer func() {
5212 if r := recover(); r != nil {
5213 ec.Error(ctx, ec.Recover(ctx, r))
5214 ret = graphql.Null
5215 }
5216 }()
5217 fc := &graphql.FieldContext{
5218 Object: "CommentHistoryStep",
5219 Field: field,
5220 Args: nil,
5221 IsMethod: true,
5222 }
5223
5224 ctx = graphql.WithFieldContext(ctx, fc)
5225 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5226 ctx = rctx // use context from middleware stack in children
5227 return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
5228 })
5229 if err != nil {
5230 ec.Error(ctx, err)
5231 return graphql.Null
5232 }
5233 if resTmp == nil {
5234 if !graphql.HasFieldError(ctx, fc) {
5235 ec.Errorf(ctx, "must not be null")
5236 }
5237 return graphql.Null
5238 }
5239 res := resTmp.(*time.Time)
5240 fc.Result = res
5241 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5242}
5243
5244func (ec *executionContext) _CommitAsNeededPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
5245 defer func() {
5246 if r := recover(); r != nil {
5247 ec.Error(ctx, ec.Recover(ctx, r))
5248 ret = graphql.Null
5249 }
5250 }()
5251 fc := &graphql.FieldContext{
5252 Object: "CommitAsNeededPayload",
5253 Field: field,
5254 Args: nil,
5255 IsMethod: false,
5256 }
5257
5258 ctx = graphql.WithFieldContext(ctx, fc)
5259 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5260 ctx = rctx // use context from middleware stack in children
5261 return obj.ClientMutationID, nil
5262 })
5263 if err != nil {
5264 ec.Error(ctx, err)
5265 return graphql.Null
5266 }
5267 if resTmp == nil {
5268 return graphql.Null
5269 }
5270 res := resTmp.(*string)
5271 fc.Result = res
5272 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5273}
5274
5275func (ec *executionContext) _CommitAsNeededPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
5276 defer func() {
5277 if r := recover(); r != nil {
5278 ec.Error(ctx, ec.Recover(ctx, r))
5279 ret = graphql.Null
5280 }
5281 }()
5282 fc := &graphql.FieldContext{
5283 Object: "CommitAsNeededPayload",
5284 Field: field,
5285 Args: nil,
5286 IsMethod: false,
5287 }
5288
5289 ctx = graphql.WithFieldContext(ctx, fc)
5290 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5291 ctx = rctx // use context from middleware stack in children
5292 return obj.Bug, nil
5293 })
5294 if err != nil {
5295 ec.Error(ctx, err)
5296 return graphql.Null
5297 }
5298 if resTmp == nil {
5299 if !graphql.HasFieldError(ctx, fc) {
5300 ec.Errorf(ctx, "must not be null")
5301 }
5302 return graphql.Null
5303 }
5304 res := resTmp.(*bug.Snapshot)
5305 fc.Result = res
5306 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
5307}
5308
5309func (ec *executionContext) _CommitPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
5310 defer func() {
5311 if r := recover(); r != nil {
5312 ec.Error(ctx, ec.Recover(ctx, r))
5313 ret = graphql.Null
5314 }
5315 }()
5316 fc := &graphql.FieldContext{
5317 Object: "CommitPayload",
5318 Field: field,
5319 Args: nil,
5320 IsMethod: false,
5321 }
5322
5323 ctx = graphql.WithFieldContext(ctx, fc)
5324 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5325 ctx = rctx // use context from middleware stack in children
5326 return obj.ClientMutationID, nil
5327 })
5328 if err != nil {
5329 ec.Error(ctx, err)
5330 return graphql.Null
5331 }
5332 if resTmp == nil {
5333 return graphql.Null
5334 }
5335 res := resTmp.(*string)
5336 fc.Result = res
5337 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5338}
5339
5340func (ec *executionContext) _CommitPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
5341 defer func() {
5342 if r := recover(); r != nil {
5343 ec.Error(ctx, ec.Recover(ctx, r))
5344 ret = graphql.Null
5345 }
5346 }()
5347 fc := &graphql.FieldContext{
5348 Object: "CommitPayload",
5349 Field: field,
5350 Args: nil,
5351 IsMethod: false,
5352 }
5353
5354 ctx = graphql.WithFieldContext(ctx, fc)
5355 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5356 ctx = rctx // use context from middleware stack in children
5357 return obj.Bug, nil
5358 })
5359 if err != nil {
5360 ec.Error(ctx, err)
5361 return graphql.Null
5362 }
5363 if resTmp == nil {
5364 if !graphql.HasFieldError(ctx, fc) {
5365 ec.Errorf(ctx, "must not be null")
5366 }
5367 return graphql.Null
5368 }
5369 res := resTmp.(*bug.Snapshot)
5370 fc.Result = res
5371 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
5372}
5373
5374func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5375 defer func() {
5376 if r := recover(); r != nil {
5377 ec.Error(ctx, ec.Recover(ctx, r))
5378 ret = graphql.Null
5379 }
5380 }()
5381 fc := &graphql.FieldContext{
5382 Object: "CreateOperation",
5383 Field: field,
5384 Args: nil,
5385 IsMethod: true,
5386 }
5387
5388 ctx = graphql.WithFieldContext(ctx, fc)
5389 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5390 ctx = rctx // use context from middleware stack in children
5391 return ec.resolvers.CreateOperation().ID(rctx, obj)
5392 })
5393 if err != nil {
5394 ec.Error(ctx, err)
5395 return graphql.Null
5396 }
5397 if resTmp == nil {
5398 if !graphql.HasFieldError(ctx, fc) {
5399 ec.Errorf(ctx, "must not be null")
5400 }
5401 return graphql.Null
5402 }
5403 res := resTmp.(string)
5404 fc.Result = res
5405 return ec.marshalNString2string(ctx, field.Selections, res)
5406}
5407
5408func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5409 defer func() {
5410 if r := recover(); r != nil {
5411 ec.Error(ctx, ec.Recover(ctx, r))
5412 ret = graphql.Null
5413 }
5414 }()
5415 fc := &graphql.FieldContext{
5416 Object: "CreateOperation",
5417 Field: field,
5418 Args: nil,
5419 IsMethod: false,
5420 }
5421
5422 ctx = graphql.WithFieldContext(ctx, fc)
5423 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5424 ctx = rctx // use context from middleware stack in children
5425 return obj.Author, nil
5426 })
5427 if err != nil {
5428 ec.Error(ctx, err)
5429 return graphql.Null
5430 }
5431 if resTmp == nil {
5432 if !graphql.HasFieldError(ctx, fc) {
5433 ec.Errorf(ctx, "must not be null")
5434 }
5435 return graphql.Null
5436 }
5437 res := resTmp.(identity.Interface)
5438 fc.Result = res
5439 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
5440}
5441
5442func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5443 defer func() {
5444 if r := recover(); r != nil {
5445 ec.Error(ctx, ec.Recover(ctx, r))
5446 ret = graphql.Null
5447 }
5448 }()
5449 fc := &graphql.FieldContext{
5450 Object: "CreateOperation",
5451 Field: field,
5452 Args: nil,
5453 IsMethod: true,
5454 }
5455
5456 ctx = graphql.WithFieldContext(ctx, fc)
5457 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5458 ctx = rctx // use context from middleware stack in children
5459 return ec.resolvers.CreateOperation().Date(rctx, obj)
5460 })
5461 if err != nil {
5462 ec.Error(ctx, err)
5463 return graphql.Null
5464 }
5465 if resTmp == nil {
5466 if !graphql.HasFieldError(ctx, fc) {
5467 ec.Errorf(ctx, "must not be null")
5468 }
5469 return graphql.Null
5470 }
5471 res := resTmp.(*time.Time)
5472 fc.Result = res
5473 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5474}
5475
5476func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5477 defer func() {
5478 if r := recover(); r != nil {
5479 ec.Error(ctx, ec.Recover(ctx, r))
5480 ret = graphql.Null
5481 }
5482 }()
5483 fc := &graphql.FieldContext{
5484 Object: "CreateOperation",
5485 Field: field,
5486 Args: nil,
5487 IsMethod: false,
5488 }
5489
5490 ctx = graphql.WithFieldContext(ctx, fc)
5491 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5492 ctx = rctx // use context from middleware stack in children
5493 return obj.Title, nil
5494 })
5495 if err != nil {
5496 ec.Error(ctx, err)
5497 return graphql.Null
5498 }
5499 if resTmp == nil {
5500 if !graphql.HasFieldError(ctx, fc) {
5501 ec.Errorf(ctx, "must not be null")
5502 }
5503 return graphql.Null
5504 }
5505 res := resTmp.(string)
5506 fc.Result = res
5507 return ec.marshalNString2string(ctx, field.Selections, res)
5508}
5509
5510func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5511 defer func() {
5512 if r := recover(); r != nil {
5513 ec.Error(ctx, ec.Recover(ctx, r))
5514 ret = graphql.Null
5515 }
5516 }()
5517 fc := &graphql.FieldContext{
5518 Object: "CreateOperation",
5519 Field: field,
5520 Args: nil,
5521 IsMethod: false,
5522 }
5523
5524 ctx = graphql.WithFieldContext(ctx, fc)
5525 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5526 ctx = rctx // use context from middleware stack in children
5527 return obj.Message, nil
5528 })
5529 if err != nil {
5530 ec.Error(ctx, err)
5531 return graphql.Null
5532 }
5533 if resTmp == nil {
5534 if !graphql.HasFieldError(ctx, fc) {
5535 ec.Errorf(ctx, "must not be null")
5536 }
5537 return graphql.Null
5538 }
5539 res := resTmp.(string)
5540 fc.Result = res
5541 return ec.marshalNString2string(ctx, field.Selections, res)
5542}
5543
5544func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5545 defer func() {
5546 if r := recover(); r != nil {
5547 ec.Error(ctx, ec.Recover(ctx, r))
5548 ret = graphql.Null
5549 }
5550 }()
5551 fc := &graphql.FieldContext{
5552 Object: "CreateOperation",
5553 Field: field,
5554 Args: nil,
5555 IsMethod: false,
5556 }
5557
5558 ctx = graphql.WithFieldContext(ctx, fc)
5559 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5560 ctx = rctx // use context from middleware stack in children
5561 return obj.Files, nil
5562 })
5563 if err != nil {
5564 ec.Error(ctx, err)
5565 return graphql.Null
5566 }
5567 if resTmp == nil {
5568 if !graphql.HasFieldError(ctx, fc) {
5569 ec.Errorf(ctx, "must not be null")
5570 }
5571 return graphql.Null
5572 }
5573 res := resTmp.([]git.Hash)
5574 fc.Result = res
5575 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
5576}
5577
5578func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5579 defer func() {
5580 if r := recover(); r != nil {
5581 ec.Error(ctx, ec.Recover(ctx, r))
5582 ret = graphql.Null
5583 }
5584 }()
5585 fc := &graphql.FieldContext{
5586 Object: "CreateTimelineItem",
5587 Field: field,
5588 Args: nil,
5589 IsMethod: true,
5590 }
5591
5592 ctx = graphql.WithFieldContext(ctx, fc)
5593 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5594 ctx = rctx // use context from middleware stack in children
5595 return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
5596 })
5597 if err != nil {
5598 ec.Error(ctx, err)
5599 return graphql.Null
5600 }
5601 if resTmp == nil {
5602 if !graphql.HasFieldError(ctx, fc) {
5603 ec.Errorf(ctx, "must not be null")
5604 }
5605 return graphql.Null
5606 }
5607 res := resTmp.(string)
5608 fc.Result = res
5609 return ec.marshalNString2string(ctx, field.Selections, res)
5610}
5611
5612func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5613 defer func() {
5614 if r := recover(); r != nil {
5615 ec.Error(ctx, ec.Recover(ctx, r))
5616 ret = graphql.Null
5617 }
5618 }()
5619 fc := &graphql.FieldContext{
5620 Object: "CreateTimelineItem",
5621 Field: field,
5622 Args: nil,
5623 IsMethod: false,
5624 }
5625
5626 ctx = graphql.WithFieldContext(ctx, fc)
5627 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5628 ctx = rctx // use context from middleware stack in children
5629 return obj.Author, nil
5630 })
5631 if err != nil {
5632 ec.Error(ctx, err)
5633 return graphql.Null
5634 }
5635 if resTmp == nil {
5636 if !graphql.HasFieldError(ctx, fc) {
5637 ec.Errorf(ctx, "must not be null")
5638 }
5639 return graphql.Null
5640 }
5641 res := resTmp.(identity.Interface)
5642 fc.Result = res
5643 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
5644}
5645
5646func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5647 defer func() {
5648 if r := recover(); r != nil {
5649 ec.Error(ctx, ec.Recover(ctx, r))
5650 ret = graphql.Null
5651 }
5652 }()
5653 fc := &graphql.FieldContext{
5654 Object: "CreateTimelineItem",
5655 Field: field,
5656 Args: nil,
5657 IsMethod: false,
5658 }
5659
5660 ctx = graphql.WithFieldContext(ctx, fc)
5661 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5662 ctx = rctx // use context from middleware stack in children
5663 return obj.Message, nil
5664 })
5665 if err != nil {
5666 ec.Error(ctx, err)
5667 return graphql.Null
5668 }
5669 if resTmp == nil {
5670 if !graphql.HasFieldError(ctx, fc) {
5671 ec.Errorf(ctx, "must not be null")
5672 }
5673 return graphql.Null
5674 }
5675 res := resTmp.(string)
5676 fc.Result = res
5677 return ec.marshalNString2string(ctx, field.Selections, res)
5678}
5679
5680func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5681 defer func() {
5682 if r := recover(); r != nil {
5683 ec.Error(ctx, ec.Recover(ctx, r))
5684 ret = graphql.Null
5685 }
5686 }()
5687 fc := &graphql.FieldContext{
5688 Object: "CreateTimelineItem",
5689 Field: field,
5690 Args: nil,
5691 IsMethod: true,
5692 }
5693
5694 ctx = graphql.WithFieldContext(ctx, fc)
5695 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5696 ctx = rctx // use context from middleware stack in children
5697 return obj.MessageIsEmpty(), nil
5698 })
5699 if err != nil {
5700 ec.Error(ctx, err)
5701 return graphql.Null
5702 }
5703 if resTmp == nil {
5704 if !graphql.HasFieldError(ctx, fc) {
5705 ec.Errorf(ctx, "must not be null")
5706 }
5707 return graphql.Null
5708 }
5709 res := resTmp.(bool)
5710 fc.Result = res
5711 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5712}
5713
5714func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5715 defer func() {
5716 if r := recover(); r != nil {
5717 ec.Error(ctx, ec.Recover(ctx, r))
5718 ret = graphql.Null
5719 }
5720 }()
5721 fc := &graphql.FieldContext{
5722 Object: "CreateTimelineItem",
5723 Field: field,
5724 Args: nil,
5725 IsMethod: false,
5726 }
5727
5728 ctx = graphql.WithFieldContext(ctx, fc)
5729 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5730 ctx = rctx // use context from middleware stack in children
5731 return obj.Files, nil
5732 })
5733 if err != nil {
5734 ec.Error(ctx, err)
5735 return graphql.Null
5736 }
5737 if resTmp == nil {
5738 if !graphql.HasFieldError(ctx, fc) {
5739 ec.Errorf(ctx, "must not be null")
5740 }
5741 return graphql.Null
5742 }
5743 res := resTmp.([]git.Hash)
5744 fc.Result = res
5745 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
5746}
5747
5748func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5749 defer func() {
5750 if r := recover(); r != nil {
5751 ec.Error(ctx, ec.Recover(ctx, r))
5752 ret = graphql.Null
5753 }
5754 }()
5755 fc := &graphql.FieldContext{
5756 Object: "CreateTimelineItem",
5757 Field: field,
5758 Args: nil,
5759 IsMethod: true,
5760 }
5761
5762 ctx = graphql.WithFieldContext(ctx, fc)
5763 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5764 ctx = rctx // use context from middleware stack in children
5765 return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
5766 })
5767 if err != nil {
5768 ec.Error(ctx, err)
5769 return graphql.Null
5770 }
5771 if resTmp == nil {
5772 if !graphql.HasFieldError(ctx, fc) {
5773 ec.Errorf(ctx, "must not be null")
5774 }
5775 return graphql.Null
5776 }
5777 res := resTmp.(*time.Time)
5778 fc.Result = res
5779 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5780}
5781
5782func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5783 defer func() {
5784 if r := recover(); r != nil {
5785 ec.Error(ctx, ec.Recover(ctx, r))
5786 ret = graphql.Null
5787 }
5788 }()
5789 fc := &graphql.FieldContext{
5790 Object: "CreateTimelineItem",
5791 Field: field,
5792 Args: nil,
5793 IsMethod: true,
5794 }
5795
5796 ctx = graphql.WithFieldContext(ctx, fc)
5797 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5798 ctx = rctx // use context from middleware stack in children
5799 return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
5800 })
5801 if err != nil {
5802 ec.Error(ctx, err)
5803 return graphql.Null
5804 }
5805 if resTmp == nil {
5806 if !graphql.HasFieldError(ctx, fc) {
5807 ec.Errorf(ctx, "must not be null")
5808 }
5809 return graphql.Null
5810 }
5811 res := resTmp.(*time.Time)
5812 fc.Result = res
5813 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5814}
5815
5816func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5817 defer func() {
5818 if r := recover(); r != nil {
5819 ec.Error(ctx, ec.Recover(ctx, r))
5820 ret = graphql.Null
5821 }
5822 }()
5823 fc := &graphql.FieldContext{
5824 Object: "CreateTimelineItem",
5825 Field: field,
5826 Args: nil,
5827 IsMethod: true,
5828 }
5829
5830 ctx = graphql.WithFieldContext(ctx, fc)
5831 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5832 ctx = rctx // use context from middleware stack in children
5833 return obj.Edited(), nil
5834 })
5835 if err != nil {
5836 ec.Error(ctx, err)
5837 return graphql.Null
5838 }
5839 if resTmp == nil {
5840 if !graphql.HasFieldError(ctx, fc) {
5841 ec.Errorf(ctx, "must not be null")
5842 }
5843 return graphql.Null
5844 }
5845 res := resTmp.(bool)
5846 fc.Result = res
5847 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5848}
5849
5850func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5851 defer func() {
5852 if r := recover(); r != nil {
5853 ec.Error(ctx, ec.Recover(ctx, r))
5854 ret = graphql.Null
5855 }
5856 }()
5857 fc := &graphql.FieldContext{
5858 Object: "CreateTimelineItem",
5859 Field: field,
5860 Args: nil,
5861 IsMethod: false,
5862 }
5863
5864 ctx = graphql.WithFieldContext(ctx, fc)
5865 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5866 ctx = rctx // use context from middleware stack in children
5867 return obj.History, nil
5868 })
5869 if err != nil {
5870 ec.Error(ctx, err)
5871 return graphql.Null
5872 }
5873 if resTmp == nil {
5874 if !graphql.HasFieldError(ctx, fc) {
5875 ec.Errorf(ctx, "must not be null")
5876 }
5877 return graphql.Null
5878 }
5879 res := resTmp.([]bug.CommentHistoryStep)
5880 fc.Result = res
5881 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
5882}
5883
5884func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5885 defer func() {
5886 if r := recover(); r != nil {
5887 ec.Error(ctx, ec.Recover(ctx, r))
5888 ret = graphql.Null
5889 }
5890 }()
5891 fc := &graphql.FieldContext{
5892 Object: "EditCommentOperation",
5893 Field: field,
5894 Args: nil,
5895 IsMethod: true,
5896 }
5897
5898 ctx = graphql.WithFieldContext(ctx, fc)
5899 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5900 ctx = rctx // use context from middleware stack in children
5901 return ec.resolvers.EditCommentOperation().ID(rctx, obj)
5902 })
5903 if err != nil {
5904 ec.Error(ctx, err)
5905 return graphql.Null
5906 }
5907 if resTmp == nil {
5908 if !graphql.HasFieldError(ctx, fc) {
5909 ec.Errorf(ctx, "must not be null")
5910 }
5911 return graphql.Null
5912 }
5913 res := resTmp.(string)
5914 fc.Result = res
5915 return ec.marshalNString2string(ctx, field.Selections, res)
5916}
5917
5918func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5919 defer func() {
5920 if r := recover(); r != nil {
5921 ec.Error(ctx, ec.Recover(ctx, r))
5922 ret = graphql.Null
5923 }
5924 }()
5925 fc := &graphql.FieldContext{
5926 Object: "EditCommentOperation",
5927 Field: field,
5928 Args: nil,
5929 IsMethod: false,
5930 }
5931
5932 ctx = graphql.WithFieldContext(ctx, fc)
5933 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5934 ctx = rctx // use context from middleware stack in children
5935 return obj.Author, nil
5936 })
5937 if err != nil {
5938 ec.Error(ctx, err)
5939 return graphql.Null
5940 }
5941 if resTmp == nil {
5942 if !graphql.HasFieldError(ctx, fc) {
5943 ec.Errorf(ctx, "must not be null")
5944 }
5945 return graphql.Null
5946 }
5947 res := resTmp.(identity.Interface)
5948 fc.Result = res
5949 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
5950}
5951
5952func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5953 defer func() {
5954 if r := recover(); r != nil {
5955 ec.Error(ctx, ec.Recover(ctx, r))
5956 ret = graphql.Null
5957 }
5958 }()
5959 fc := &graphql.FieldContext{
5960 Object: "EditCommentOperation",
5961 Field: field,
5962 Args: nil,
5963 IsMethod: true,
5964 }
5965
5966 ctx = graphql.WithFieldContext(ctx, fc)
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 !graphql.HasFieldError(ctx, fc) {
5977 ec.Errorf(ctx, "must not be null")
5978 }
5979 return graphql.Null
5980 }
5981 res := resTmp.(*time.Time)
5982 fc.Result = res
5983 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5984}
5985
5986func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5987 defer func() {
5988 if r := recover(); r != nil {
5989 ec.Error(ctx, ec.Recover(ctx, r))
5990 ret = graphql.Null
5991 }
5992 }()
5993 fc := &graphql.FieldContext{
5994 Object: "EditCommentOperation",
5995 Field: field,
5996 Args: nil,
5997 IsMethod: true,
5998 }
5999
6000 ctx = graphql.WithFieldContext(ctx, fc)
6001 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6002 ctx = rctx // use context from middleware stack in children
6003 return ec.resolvers.EditCommentOperation().Target(rctx, obj)
6004 })
6005 if err != nil {
6006 ec.Error(ctx, err)
6007 return graphql.Null
6008 }
6009 if resTmp == nil {
6010 if !graphql.HasFieldError(ctx, fc) {
6011 ec.Errorf(ctx, "must not be null")
6012 }
6013 return graphql.Null
6014 }
6015 res := resTmp.(string)
6016 fc.Result = res
6017 return ec.marshalNString2string(ctx, field.Selections, res)
6018}
6019
6020func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6021 defer func() {
6022 if r := recover(); r != nil {
6023 ec.Error(ctx, ec.Recover(ctx, r))
6024 ret = graphql.Null
6025 }
6026 }()
6027 fc := &graphql.FieldContext{
6028 Object: "EditCommentOperation",
6029 Field: field,
6030 Args: nil,
6031 IsMethod: false,
6032 }
6033
6034 ctx = graphql.WithFieldContext(ctx, fc)
6035 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6036 ctx = rctx // use context from middleware stack in children
6037 return obj.Message, nil
6038 })
6039 if err != nil {
6040 ec.Error(ctx, err)
6041 return graphql.Null
6042 }
6043 if resTmp == nil {
6044 if !graphql.HasFieldError(ctx, fc) {
6045 ec.Errorf(ctx, "must not be null")
6046 }
6047 return graphql.Null
6048 }
6049 res := resTmp.(string)
6050 fc.Result = res
6051 return ec.marshalNString2string(ctx, field.Selections, res)
6052}
6053
6054func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6055 defer func() {
6056 if r := recover(); r != nil {
6057 ec.Error(ctx, ec.Recover(ctx, r))
6058 ret = graphql.Null
6059 }
6060 }()
6061 fc := &graphql.FieldContext{
6062 Object: "EditCommentOperation",
6063 Field: field,
6064 Args: nil,
6065 IsMethod: false,
6066 }
6067
6068 ctx = graphql.WithFieldContext(ctx, fc)
6069 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6070 ctx = rctx // use context from middleware stack in children
6071 return obj.Files, nil
6072 })
6073 if err != nil {
6074 ec.Error(ctx, err)
6075 return graphql.Null
6076 }
6077 if resTmp == nil {
6078 if !graphql.HasFieldError(ctx, fc) {
6079 ec.Errorf(ctx, "must not be null")
6080 }
6081 return graphql.Null
6082 }
6083 res := resTmp.([]git.Hash)
6084 fc.Result = res
6085 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
6086}
6087
6088func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
6089 defer func() {
6090 if r := recover(); r != nil {
6091 ec.Error(ctx, ec.Recover(ctx, r))
6092 ret = graphql.Null
6093 }
6094 }()
6095 fc := &graphql.FieldContext{
6096 Object: "Identity",
6097 Field: field,
6098 Args: nil,
6099 IsMethod: true,
6100 }
6101
6102 ctx = graphql.WithFieldContext(ctx, fc)
6103 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6104 ctx = rctx // use context from middleware stack in children
6105 return ec.resolvers.Identity().ID(rctx, obj)
6106 })
6107 if err != nil {
6108 ec.Error(ctx, err)
6109 return graphql.Null
6110 }
6111 if resTmp == nil {
6112 if !graphql.HasFieldError(ctx, fc) {
6113 ec.Errorf(ctx, "must not be null")
6114 }
6115 return graphql.Null
6116 }
6117 res := resTmp.(string)
6118 fc.Result = res
6119 return ec.marshalNString2string(ctx, field.Selections, res)
6120}
6121
6122func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
6123 defer func() {
6124 if r := recover(); r != nil {
6125 ec.Error(ctx, ec.Recover(ctx, r))
6126 ret = graphql.Null
6127 }
6128 }()
6129 fc := &graphql.FieldContext{
6130 Object: "Identity",
6131 Field: field,
6132 Args: nil,
6133 IsMethod: true,
6134 }
6135
6136 ctx = graphql.WithFieldContext(ctx, fc)
6137 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6138 ctx = rctx // use context from middleware stack in children
6139 return ec.resolvers.Identity().HumanID(rctx, obj)
6140 })
6141 if err != nil {
6142 ec.Error(ctx, err)
6143 return graphql.Null
6144 }
6145 if resTmp == nil {
6146 if !graphql.HasFieldError(ctx, fc) {
6147 ec.Errorf(ctx, "must not be null")
6148 }
6149 return graphql.Null
6150 }
6151 res := resTmp.(string)
6152 fc.Result = res
6153 return ec.marshalNString2string(ctx, field.Selections, res)
6154}
6155
6156func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
6157 defer func() {
6158 if r := recover(); r != nil {
6159 ec.Error(ctx, ec.Recover(ctx, r))
6160 ret = graphql.Null
6161 }
6162 }()
6163 fc := &graphql.FieldContext{
6164 Object: "Identity",
6165 Field: field,
6166 Args: nil,
6167 IsMethod: true,
6168 }
6169
6170 ctx = graphql.WithFieldContext(ctx, fc)
6171 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6172 ctx = rctx // use context from middleware stack in children
6173 return obj.Name(), nil
6174 })
6175 if err != nil {
6176 ec.Error(ctx, err)
6177 return graphql.Null
6178 }
6179 if resTmp == nil {
6180 return graphql.Null
6181 }
6182 res := resTmp.(string)
6183 fc.Result = res
6184 return ec.marshalOString2string(ctx, field.Selections, res)
6185}
6186
6187func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
6188 defer func() {
6189 if r := recover(); r != nil {
6190 ec.Error(ctx, ec.Recover(ctx, r))
6191 ret = graphql.Null
6192 }
6193 }()
6194 fc := &graphql.FieldContext{
6195 Object: "Identity",
6196 Field: field,
6197 Args: nil,
6198 IsMethod: true,
6199 }
6200
6201 ctx = graphql.WithFieldContext(ctx, fc)
6202 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6203 ctx = rctx // use context from middleware stack in children
6204 return obj.Email(), nil
6205 })
6206 if err != nil {
6207 ec.Error(ctx, err)
6208 return graphql.Null
6209 }
6210 if resTmp == nil {
6211 return graphql.Null
6212 }
6213 res := resTmp.(string)
6214 fc.Result = res
6215 return ec.marshalOString2string(ctx, field.Selections, res)
6216}
6217
6218func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
6219 defer func() {
6220 if r := recover(); r != nil {
6221 ec.Error(ctx, ec.Recover(ctx, r))
6222 ret = graphql.Null
6223 }
6224 }()
6225 fc := &graphql.FieldContext{
6226 Object: "Identity",
6227 Field: field,
6228 Args: nil,
6229 IsMethod: true,
6230 }
6231
6232 ctx = graphql.WithFieldContext(ctx, fc)
6233 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6234 ctx = rctx // use context from middleware stack in children
6235 return obj.Login(), nil
6236 })
6237 if err != nil {
6238 ec.Error(ctx, err)
6239 return graphql.Null
6240 }
6241 if resTmp == nil {
6242 return graphql.Null
6243 }
6244 res := resTmp.(string)
6245 fc.Result = res
6246 return ec.marshalOString2string(ctx, field.Selections, res)
6247}
6248
6249func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
6250 defer func() {
6251 if r := recover(); r != nil {
6252 ec.Error(ctx, ec.Recover(ctx, r))
6253 ret = graphql.Null
6254 }
6255 }()
6256 fc := &graphql.FieldContext{
6257 Object: "Identity",
6258 Field: field,
6259 Args: nil,
6260 IsMethod: true,
6261 }
6262
6263 ctx = graphql.WithFieldContext(ctx, fc)
6264 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6265 ctx = rctx // use context from middleware stack in children
6266 return obj.DisplayName(), nil
6267 })
6268 if err != nil {
6269 ec.Error(ctx, err)
6270 return graphql.Null
6271 }
6272 if resTmp == nil {
6273 if !graphql.HasFieldError(ctx, fc) {
6274 ec.Errorf(ctx, "must not be null")
6275 }
6276 return graphql.Null
6277 }
6278 res := resTmp.(string)
6279 fc.Result = res
6280 return ec.marshalNString2string(ctx, field.Selections, res)
6281}
6282
6283func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
6284 defer func() {
6285 if r := recover(); r != nil {
6286 ec.Error(ctx, ec.Recover(ctx, r))
6287 ret = graphql.Null
6288 }
6289 }()
6290 fc := &graphql.FieldContext{
6291 Object: "Identity",
6292 Field: field,
6293 Args: nil,
6294 IsMethod: true,
6295 }
6296
6297 ctx = graphql.WithFieldContext(ctx, fc)
6298 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6299 ctx = rctx // use context from middleware stack in children
6300 return obj.AvatarUrl(), nil
6301 })
6302 if err != nil {
6303 ec.Error(ctx, err)
6304 return graphql.Null
6305 }
6306 if resTmp == nil {
6307 return graphql.Null
6308 }
6309 res := resTmp.(string)
6310 fc.Result = res
6311 return ec.marshalOString2string(ctx, field.Selections, res)
6312}
6313
6314func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
6315 defer func() {
6316 if r := recover(); r != nil {
6317 ec.Error(ctx, ec.Recover(ctx, r))
6318 ret = graphql.Null
6319 }
6320 }()
6321 fc := &graphql.FieldContext{
6322 Object: "Identity",
6323 Field: field,
6324 Args: nil,
6325 IsMethod: true,
6326 }
6327
6328 ctx = graphql.WithFieldContext(ctx, fc)
6329 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6330 ctx = rctx // use context from middleware stack in children
6331 return obj.IsProtected(), nil
6332 })
6333 if err != nil {
6334 ec.Error(ctx, err)
6335 return graphql.Null
6336 }
6337 if resTmp == nil {
6338 if !graphql.HasFieldError(ctx, fc) {
6339 ec.Errorf(ctx, "must not be null")
6340 }
6341 return graphql.Null
6342 }
6343 res := resTmp.(bool)
6344 fc.Result = res
6345 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6346}
6347
6348func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6349 defer func() {
6350 if r := recover(); r != nil {
6351 ec.Error(ctx, ec.Recover(ctx, r))
6352 ret = graphql.Null
6353 }
6354 }()
6355 fc := &graphql.FieldContext{
6356 Object: "IdentityConnection",
6357 Field: field,
6358 Args: nil,
6359 IsMethod: false,
6360 }
6361
6362 ctx = graphql.WithFieldContext(ctx, fc)
6363 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6364 ctx = rctx // use context from middleware stack in children
6365 return obj.Edges, nil
6366 })
6367 if err != nil {
6368 ec.Error(ctx, err)
6369 return graphql.Null
6370 }
6371 if resTmp == nil {
6372 if !graphql.HasFieldError(ctx, fc) {
6373 ec.Errorf(ctx, "must not be null")
6374 }
6375 return graphql.Null
6376 }
6377 res := resTmp.([]*models.IdentityEdge)
6378 fc.Result = res
6379 return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
6380}
6381
6382func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6383 defer func() {
6384 if r := recover(); r != nil {
6385 ec.Error(ctx, ec.Recover(ctx, r))
6386 ret = graphql.Null
6387 }
6388 }()
6389 fc := &graphql.FieldContext{
6390 Object: "IdentityConnection",
6391 Field: field,
6392 Args: nil,
6393 IsMethod: false,
6394 }
6395
6396 ctx = graphql.WithFieldContext(ctx, fc)
6397 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6398 ctx = rctx // use context from middleware stack in children
6399 return obj.Nodes, nil
6400 })
6401 if err != nil {
6402 ec.Error(ctx, err)
6403 return graphql.Null
6404 }
6405 if resTmp == nil {
6406 if !graphql.HasFieldError(ctx, fc) {
6407 ec.Errorf(ctx, "must not be null")
6408 }
6409 return graphql.Null
6410 }
6411 res := resTmp.([]identity.Interface)
6412 fc.Result = res
6413 return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterfaceᚄ(ctx, field.Selections, res)
6414}
6415
6416func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6417 defer func() {
6418 if r := recover(); r != nil {
6419 ec.Error(ctx, ec.Recover(ctx, r))
6420 ret = graphql.Null
6421 }
6422 }()
6423 fc := &graphql.FieldContext{
6424 Object: "IdentityConnection",
6425 Field: field,
6426 Args: nil,
6427 IsMethod: false,
6428 }
6429
6430 ctx = graphql.WithFieldContext(ctx, fc)
6431 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6432 ctx = rctx // use context from middleware stack in children
6433 return obj.PageInfo, nil
6434 })
6435 if err != nil {
6436 ec.Error(ctx, err)
6437 return graphql.Null
6438 }
6439 if resTmp == nil {
6440 if !graphql.HasFieldError(ctx, fc) {
6441 ec.Errorf(ctx, "must not be null")
6442 }
6443 return graphql.Null
6444 }
6445 res := resTmp.(*models.PageInfo)
6446 fc.Result = res
6447 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
6448}
6449
6450func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6451 defer func() {
6452 if r := recover(); r != nil {
6453 ec.Error(ctx, ec.Recover(ctx, r))
6454 ret = graphql.Null
6455 }
6456 }()
6457 fc := &graphql.FieldContext{
6458 Object: "IdentityConnection",
6459 Field: field,
6460 Args: nil,
6461 IsMethod: false,
6462 }
6463
6464 ctx = graphql.WithFieldContext(ctx, fc)
6465 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6466 ctx = rctx // use context from middleware stack in children
6467 return obj.TotalCount, nil
6468 })
6469 if err != nil {
6470 ec.Error(ctx, err)
6471 return graphql.Null
6472 }
6473 if resTmp == nil {
6474 if !graphql.HasFieldError(ctx, fc) {
6475 ec.Errorf(ctx, "must not be null")
6476 }
6477 return graphql.Null
6478 }
6479 res := resTmp.(int)
6480 fc.Result = res
6481 return ec.marshalNInt2int(ctx, field.Selections, res)
6482}
6483
6484func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6485 defer func() {
6486 if r := recover(); r != nil {
6487 ec.Error(ctx, ec.Recover(ctx, r))
6488 ret = graphql.Null
6489 }
6490 }()
6491 fc := &graphql.FieldContext{
6492 Object: "IdentityEdge",
6493 Field: field,
6494 Args: nil,
6495 IsMethod: false,
6496 }
6497
6498 ctx = graphql.WithFieldContext(ctx, fc)
6499 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6500 ctx = rctx // use context from middleware stack in children
6501 return obj.Cursor, nil
6502 })
6503 if err != nil {
6504 ec.Error(ctx, err)
6505 return graphql.Null
6506 }
6507 if resTmp == nil {
6508 if !graphql.HasFieldError(ctx, fc) {
6509 ec.Errorf(ctx, "must not be null")
6510 }
6511 return graphql.Null
6512 }
6513 res := resTmp.(string)
6514 fc.Result = res
6515 return ec.marshalNString2string(ctx, field.Selections, res)
6516}
6517
6518func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6519 defer func() {
6520 if r := recover(); r != nil {
6521 ec.Error(ctx, ec.Recover(ctx, r))
6522 ret = graphql.Null
6523 }
6524 }()
6525 fc := &graphql.FieldContext{
6526 Object: "IdentityEdge",
6527 Field: field,
6528 Args: nil,
6529 IsMethod: false,
6530 }
6531
6532 ctx = graphql.WithFieldContext(ctx, fc)
6533 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6534 ctx = rctx // use context from middleware stack in children
6535 return obj.Node, nil
6536 })
6537 if err != nil {
6538 ec.Error(ctx, err)
6539 return graphql.Null
6540 }
6541 if resTmp == nil {
6542 if !graphql.HasFieldError(ctx, fc) {
6543 ec.Errorf(ctx, "must not be null")
6544 }
6545 return graphql.Null
6546 }
6547 res := resTmp.(identity.Interface)
6548 fc.Result = res
6549 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
6550}
6551
6552func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6553 defer func() {
6554 if r := recover(); r != nil {
6555 ec.Error(ctx, ec.Recover(ctx, r))
6556 ret = graphql.Null
6557 }
6558 }()
6559 fc := &graphql.FieldContext{
6560 Object: "Label",
6561 Field: field,
6562 Args: nil,
6563 IsMethod: true,
6564 }
6565
6566 ctx = graphql.WithFieldContext(ctx, fc)
6567 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6568 ctx = rctx // use context from middleware stack in children
6569 return ec.resolvers.Label().Name(rctx, obj)
6570 })
6571 if err != nil {
6572 ec.Error(ctx, err)
6573 return graphql.Null
6574 }
6575 if resTmp == nil {
6576 if !graphql.HasFieldError(ctx, fc) {
6577 ec.Errorf(ctx, "must not be null")
6578 }
6579 return graphql.Null
6580 }
6581 res := resTmp.(string)
6582 fc.Result = res
6583 return ec.marshalNString2string(ctx, field.Selections, res)
6584}
6585
6586func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6587 defer func() {
6588 if r := recover(); r != nil {
6589 ec.Error(ctx, ec.Recover(ctx, r))
6590 ret = graphql.Null
6591 }
6592 }()
6593 fc := &graphql.FieldContext{
6594 Object: "Label",
6595 Field: field,
6596 Args: nil,
6597 IsMethod: true,
6598 }
6599
6600 ctx = graphql.WithFieldContext(ctx, fc)
6601 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6602 ctx = rctx // use context from middleware stack in children
6603 return ec.resolvers.Label().Color(rctx, obj)
6604 })
6605 if err != nil {
6606 ec.Error(ctx, err)
6607 return graphql.Null
6608 }
6609 if resTmp == nil {
6610 if !graphql.HasFieldError(ctx, fc) {
6611 ec.Errorf(ctx, "must not be null")
6612 }
6613 return graphql.Null
6614 }
6615 res := resTmp.(*color.RGBA)
6616 fc.Result = res
6617 return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
6618}
6619
6620func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6621 defer func() {
6622 if r := recover(); r != nil {
6623 ec.Error(ctx, ec.Recover(ctx, r))
6624 ret = graphql.Null
6625 }
6626 }()
6627 fc := &graphql.FieldContext{
6628 Object: "LabelChangeOperation",
6629 Field: field,
6630 Args: nil,
6631 IsMethod: true,
6632 }
6633
6634 ctx = graphql.WithFieldContext(ctx, fc)
6635 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6636 ctx = rctx // use context from middleware stack in children
6637 return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
6638 })
6639 if err != nil {
6640 ec.Error(ctx, err)
6641 return graphql.Null
6642 }
6643 if resTmp == nil {
6644 if !graphql.HasFieldError(ctx, fc) {
6645 ec.Errorf(ctx, "must not be null")
6646 }
6647 return graphql.Null
6648 }
6649 res := resTmp.(string)
6650 fc.Result = res
6651 return ec.marshalNString2string(ctx, field.Selections, res)
6652}
6653
6654func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6655 defer func() {
6656 if r := recover(); r != nil {
6657 ec.Error(ctx, ec.Recover(ctx, r))
6658 ret = graphql.Null
6659 }
6660 }()
6661 fc := &graphql.FieldContext{
6662 Object: "LabelChangeOperation",
6663 Field: field,
6664 Args: nil,
6665 IsMethod: false,
6666 }
6667
6668 ctx = graphql.WithFieldContext(ctx, fc)
6669 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6670 ctx = rctx // use context from middleware stack in children
6671 return obj.Author, nil
6672 })
6673 if err != nil {
6674 ec.Error(ctx, err)
6675 return graphql.Null
6676 }
6677 if resTmp == nil {
6678 if !graphql.HasFieldError(ctx, fc) {
6679 ec.Errorf(ctx, "must not be null")
6680 }
6681 return graphql.Null
6682 }
6683 res := resTmp.(identity.Interface)
6684 fc.Result = res
6685 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
6686}
6687
6688func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6689 defer func() {
6690 if r := recover(); r != nil {
6691 ec.Error(ctx, ec.Recover(ctx, r))
6692 ret = graphql.Null
6693 }
6694 }()
6695 fc := &graphql.FieldContext{
6696 Object: "LabelChangeOperation",
6697 Field: field,
6698 Args: nil,
6699 IsMethod: true,
6700 }
6701
6702 ctx = graphql.WithFieldContext(ctx, fc)
6703 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6704 ctx = rctx // use context from middleware stack in children
6705 return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
6706 })
6707 if err != nil {
6708 ec.Error(ctx, err)
6709 return graphql.Null
6710 }
6711 if resTmp == nil {
6712 if !graphql.HasFieldError(ctx, fc) {
6713 ec.Errorf(ctx, "must not be null")
6714 }
6715 return graphql.Null
6716 }
6717 res := resTmp.(*time.Time)
6718 fc.Result = res
6719 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6720}
6721
6722func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6723 defer func() {
6724 if r := recover(); r != nil {
6725 ec.Error(ctx, ec.Recover(ctx, r))
6726 ret = graphql.Null
6727 }
6728 }()
6729 fc := &graphql.FieldContext{
6730 Object: "LabelChangeOperation",
6731 Field: field,
6732 Args: nil,
6733 IsMethod: false,
6734 }
6735
6736 ctx = graphql.WithFieldContext(ctx, fc)
6737 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6738 ctx = rctx // use context from middleware stack in children
6739 return obj.Added, nil
6740 })
6741 if err != nil {
6742 ec.Error(ctx, err)
6743 return graphql.Null
6744 }
6745 if resTmp == nil {
6746 if !graphql.HasFieldError(ctx, fc) {
6747 ec.Errorf(ctx, "must not be null")
6748 }
6749 return graphql.Null
6750 }
6751 res := resTmp.([]bug.Label)
6752 fc.Result = res
6753 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6754}
6755
6756func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6757 defer func() {
6758 if r := recover(); r != nil {
6759 ec.Error(ctx, ec.Recover(ctx, r))
6760 ret = graphql.Null
6761 }
6762 }()
6763 fc := &graphql.FieldContext{
6764 Object: "LabelChangeOperation",
6765 Field: field,
6766 Args: nil,
6767 IsMethod: false,
6768 }
6769
6770 ctx = graphql.WithFieldContext(ctx, fc)
6771 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6772 ctx = rctx // use context from middleware stack in children
6773 return obj.Removed, nil
6774 })
6775 if err != nil {
6776 ec.Error(ctx, err)
6777 return graphql.Null
6778 }
6779 if resTmp == nil {
6780 if !graphql.HasFieldError(ctx, fc) {
6781 ec.Errorf(ctx, "must not be null")
6782 }
6783 return graphql.Null
6784 }
6785 res := resTmp.([]bug.Label)
6786 fc.Result = res
6787 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6788}
6789
6790func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6791 defer func() {
6792 if r := recover(); r != nil {
6793 ec.Error(ctx, ec.Recover(ctx, r))
6794 ret = graphql.Null
6795 }
6796 }()
6797 fc := &graphql.FieldContext{
6798 Object: "LabelChangeResult",
6799 Field: field,
6800 Args: nil,
6801 IsMethod: false,
6802 }
6803
6804 ctx = graphql.WithFieldContext(ctx, fc)
6805 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6806 ctx = rctx // use context from middleware stack in children
6807 return obj.Label, nil
6808 })
6809 if err != nil {
6810 ec.Error(ctx, err)
6811 return graphql.Null
6812 }
6813 if resTmp == nil {
6814 if !graphql.HasFieldError(ctx, fc) {
6815 ec.Errorf(ctx, "must not be null")
6816 }
6817 return graphql.Null
6818 }
6819 res := resTmp.(bug.Label)
6820 fc.Result = res
6821 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6822}
6823
6824func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6825 defer func() {
6826 if r := recover(); r != nil {
6827 ec.Error(ctx, ec.Recover(ctx, r))
6828 ret = graphql.Null
6829 }
6830 }()
6831 fc := &graphql.FieldContext{
6832 Object: "LabelChangeResult",
6833 Field: field,
6834 Args: nil,
6835 IsMethod: true,
6836 }
6837
6838 ctx = graphql.WithFieldContext(ctx, fc)
6839 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6840 ctx = rctx // use context from middleware stack in children
6841 return ec.resolvers.LabelChangeResult().Status(rctx, obj)
6842 })
6843 if err != nil {
6844 ec.Error(ctx, err)
6845 return graphql.Null
6846 }
6847 if resTmp == nil {
6848 if !graphql.HasFieldError(ctx, fc) {
6849 ec.Errorf(ctx, "must not be null")
6850 }
6851 return graphql.Null
6852 }
6853 res := resTmp.(models.LabelChangeStatus)
6854 fc.Result = res
6855 return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
6856}
6857
6858func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6859 defer func() {
6860 if r := recover(); r != nil {
6861 ec.Error(ctx, ec.Recover(ctx, r))
6862 ret = graphql.Null
6863 }
6864 }()
6865 fc := &graphql.FieldContext{
6866 Object: "LabelChangeTimelineItem",
6867 Field: field,
6868 Args: nil,
6869 IsMethod: true,
6870 }
6871
6872 ctx = graphql.WithFieldContext(ctx, fc)
6873 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6874 ctx = rctx // use context from middleware stack in children
6875 return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
6876 })
6877 if err != nil {
6878 ec.Error(ctx, err)
6879 return graphql.Null
6880 }
6881 if resTmp == nil {
6882 if !graphql.HasFieldError(ctx, fc) {
6883 ec.Errorf(ctx, "must not be null")
6884 }
6885 return graphql.Null
6886 }
6887 res := resTmp.(string)
6888 fc.Result = res
6889 return ec.marshalNString2string(ctx, field.Selections, res)
6890}
6891
6892func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6893 defer func() {
6894 if r := recover(); r != nil {
6895 ec.Error(ctx, ec.Recover(ctx, r))
6896 ret = graphql.Null
6897 }
6898 }()
6899 fc := &graphql.FieldContext{
6900 Object: "LabelChangeTimelineItem",
6901 Field: field,
6902 Args: nil,
6903 IsMethod: false,
6904 }
6905
6906 ctx = graphql.WithFieldContext(ctx, fc)
6907 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6908 ctx = rctx // use context from middleware stack in children
6909 return obj.Author, nil
6910 })
6911 if err != nil {
6912 ec.Error(ctx, err)
6913 return graphql.Null
6914 }
6915 if resTmp == nil {
6916 if !graphql.HasFieldError(ctx, fc) {
6917 ec.Errorf(ctx, "must not be null")
6918 }
6919 return graphql.Null
6920 }
6921 res := resTmp.(identity.Interface)
6922 fc.Result = res
6923 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
6924}
6925
6926func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6927 defer func() {
6928 if r := recover(); r != nil {
6929 ec.Error(ctx, ec.Recover(ctx, r))
6930 ret = graphql.Null
6931 }
6932 }()
6933 fc := &graphql.FieldContext{
6934 Object: "LabelChangeTimelineItem",
6935 Field: field,
6936 Args: nil,
6937 IsMethod: true,
6938 }
6939
6940 ctx = graphql.WithFieldContext(ctx, fc)
6941 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6942 ctx = rctx // use context from middleware stack in children
6943 return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
6944 })
6945 if err != nil {
6946 ec.Error(ctx, err)
6947 return graphql.Null
6948 }
6949 if resTmp == nil {
6950 if !graphql.HasFieldError(ctx, fc) {
6951 ec.Errorf(ctx, "must not be null")
6952 }
6953 return graphql.Null
6954 }
6955 res := resTmp.(*time.Time)
6956 fc.Result = res
6957 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6958}
6959
6960func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6961 defer func() {
6962 if r := recover(); r != nil {
6963 ec.Error(ctx, ec.Recover(ctx, r))
6964 ret = graphql.Null
6965 }
6966 }()
6967 fc := &graphql.FieldContext{
6968 Object: "LabelChangeTimelineItem",
6969 Field: field,
6970 Args: nil,
6971 IsMethod: false,
6972 }
6973
6974 ctx = graphql.WithFieldContext(ctx, fc)
6975 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6976 ctx = rctx // use context from middleware stack in children
6977 return obj.Added, nil
6978 })
6979 if err != nil {
6980 ec.Error(ctx, err)
6981 return graphql.Null
6982 }
6983 if resTmp == nil {
6984 if !graphql.HasFieldError(ctx, fc) {
6985 ec.Errorf(ctx, "must not be null")
6986 }
6987 return graphql.Null
6988 }
6989 res := resTmp.([]bug.Label)
6990 fc.Result = res
6991 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6992}
6993
6994func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6995 defer func() {
6996 if r := recover(); r != nil {
6997 ec.Error(ctx, ec.Recover(ctx, r))
6998 ret = graphql.Null
6999 }
7000 }()
7001 fc := &graphql.FieldContext{
7002 Object: "LabelChangeTimelineItem",
7003 Field: field,
7004 Args: nil,
7005 IsMethod: false,
7006 }
7007
7008 ctx = graphql.WithFieldContext(ctx, fc)
7009 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7010 ctx = rctx // use context from middleware stack in children
7011 return obj.Removed, nil
7012 })
7013 if err != nil {
7014 ec.Error(ctx, err)
7015 return graphql.Null
7016 }
7017 if resTmp == nil {
7018 if !graphql.HasFieldError(ctx, fc) {
7019 ec.Errorf(ctx, "must not be null")
7020 }
7021 return graphql.Null
7022 }
7023 res := resTmp.([]bug.Label)
7024 fc.Result = res
7025 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
7026}
7027
7028func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7029 defer func() {
7030 if r := recover(); r != nil {
7031 ec.Error(ctx, ec.Recover(ctx, r))
7032 ret = graphql.Null
7033 }
7034 }()
7035 fc := &graphql.FieldContext{
7036 Object: "LabelConnection",
7037 Field: field,
7038 Args: nil,
7039 IsMethod: false,
7040 }
7041
7042 ctx = graphql.WithFieldContext(ctx, fc)
7043 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7044 ctx = rctx // use context from middleware stack in children
7045 return obj.Edges, nil
7046 })
7047 if err != nil {
7048 ec.Error(ctx, err)
7049 return graphql.Null
7050 }
7051 if resTmp == nil {
7052 if !graphql.HasFieldError(ctx, fc) {
7053 ec.Errorf(ctx, "must not be null")
7054 }
7055 return graphql.Null
7056 }
7057 res := resTmp.([]*models.LabelEdge)
7058 fc.Result = res
7059 return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
7060}
7061
7062func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7063 defer func() {
7064 if r := recover(); r != nil {
7065 ec.Error(ctx, ec.Recover(ctx, r))
7066 ret = graphql.Null
7067 }
7068 }()
7069 fc := &graphql.FieldContext{
7070 Object: "LabelConnection",
7071 Field: field,
7072 Args: nil,
7073 IsMethod: false,
7074 }
7075
7076 ctx = graphql.WithFieldContext(ctx, fc)
7077 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7078 ctx = rctx // use context from middleware stack in children
7079 return obj.Nodes, nil
7080 })
7081 if err != nil {
7082 ec.Error(ctx, err)
7083 return graphql.Null
7084 }
7085 if resTmp == nil {
7086 if !graphql.HasFieldError(ctx, fc) {
7087 ec.Errorf(ctx, "must not be null")
7088 }
7089 return graphql.Null
7090 }
7091 res := resTmp.([]bug.Label)
7092 fc.Result = res
7093 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
7094}
7095
7096func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7097 defer func() {
7098 if r := recover(); r != nil {
7099 ec.Error(ctx, ec.Recover(ctx, r))
7100 ret = graphql.Null
7101 }
7102 }()
7103 fc := &graphql.FieldContext{
7104 Object: "LabelConnection",
7105 Field: field,
7106 Args: nil,
7107 IsMethod: false,
7108 }
7109
7110 ctx = graphql.WithFieldContext(ctx, fc)
7111 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7112 ctx = rctx // use context from middleware stack in children
7113 return obj.PageInfo, nil
7114 })
7115 if err != nil {
7116 ec.Error(ctx, err)
7117 return graphql.Null
7118 }
7119 if resTmp == nil {
7120 if !graphql.HasFieldError(ctx, fc) {
7121 ec.Errorf(ctx, "must not be null")
7122 }
7123 return graphql.Null
7124 }
7125 res := resTmp.(*models.PageInfo)
7126 fc.Result = res
7127 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
7128}
7129
7130func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7131 defer func() {
7132 if r := recover(); r != nil {
7133 ec.Error(ctx, ec.Recover(ctx, r))
7134 ret = graphql.Null
7135 }
7136 }()
7137 fc := &graphql.FieldContext{
7138 Object: "LabelConnection",
7139 Field: field,
7140 Args: nil,
7141 IsMethod: false,
7142 }
7143
7144 ctx = graphql.WithFieldContext(ctx, fc)
7145 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7146 ctx = rctx // use context from middleware stack in children
7147 return obj.TotalCount, nil
7148 })
7149 if err != nil {
7150 ec.Error(ctx, err)
7151 return graphql.Null
7152 }
7153 if resTmp == nil {
7154 if !graphql.HasFieldError(ctx, fc) {
7155 ec.Errorf(ctx, "must not be null")
7156 }
7157 return graphql.Null
7158 }
7159 res := resTmp.(int)
7160 fc.Result = res
7161 return ec.marshalNInt2int(ctx, field.Selections, res)
7162}
7163
7164func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
7165 defer func() {
7166 if r := recover(); r != nil {
7167 ec.Error(ctx, ec.Recover(ctx, r))
7168 ret = graphql.Null
7169 }
7170 }()
7171 fc := &graphql.FieldContext{
7172 Object: "LabelEdge",
7173 Field: field,
7174 Args: nil,
7175 IsMethod: false,
7176 }
7177
7178 ctx = graphql.WithFieldContext(ctx, fc)
7179 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7180 ctx = rctx // use context from middleware stack in children
7181 return obj.Cursor, nil
7182 })
7183 if err != nil {
7184 ec.Error(ctx, err)
7185 return graphql.Null
7186 }
7187 if resTmp == nil {
7188 if !graphql.HasFieldError(ctx, fc) {
7189 ec.Errorf(ctx, "must not be null")
7190 }
7191 return graphql.Null
7192 }
7193 res := resTmp.(string)
7194 fc.Result = res
7195 return ec.marshalNString2string(ctx, field.Selections, res)
7196}
7197
7198func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
7199 defer func() {
7200 if r := recover(); r != nil {
7201 ec.Error(ctx, ec.Recover(ctx, r))
7202 ret = graphql.Null
7203 }
7204 }()
7205 fc := &graphql.FieldContext{
7206 Object: "LabelEdge",
7207 Field: field,
7208 Args: nil,
7209 IsMethod: false,
7210 }
7211
7212 ctx = graphql.WithFieldContext(ctx, fc)
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.Node, nil
7216 })
7217 if err != nil {
7218 ec.Error(ctx, err)
7219 return graphql.Null
7220 }
7221 if resTmp == nil {
7222 if !graphql.HasFieldError(ctx, fc) {
7223 ec.Errorf(ctx, "must not be null")
7224 }
7225 return graphql.Null
7226 }
7227 res := resTmp.(bug.Label)
7228 fc.Result = res
7229 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
7230}
7231
7232func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7233 defer func() {
7234 if r := recover(); r != nil {
7235 ec.Error(ctx, ec.Recover(ctx, r))
7236 ret = graphql.Null
7237 }
7238 }()
7239 fc := &graphql.FieldContext{
7240 Object: "Mutation",
7241 Field: field,
7242 Args: nil,
7243 IsMethod: true,
7244 }
7245
7246 ctx = graphql.WithFieldContext(ctx, fc)
7247 rawArgs := field.ArgumentMap(ec.Variables)
7248 args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
7249 if err != nil {
7250 ec.Error(ctx, err)
7251 return graphql.Null
7252 }
7253 fc.Args = args
7254 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7255 ctx = rctx // use context from middleware stack in children
7256 return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
7257 })
7258 if err != nil {
7259 ec.Error(ctx, err)
7260 return graphql.Null
7261 }
7262 if resTmp == nil {
7263 if !graphql.HasFieldError(ctx, fc) {
7264 ec.Errorf(ctx, "must not be null")
7265 }
7266 return graphql.Null
7267 }
7268 res := resTmp.(*models.NewBugPayload)
7269 fc.Result = res
7270 return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
7271}
7272
7273func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7274 defer func() {
7275 if r := recover(); r != nil {
7276 ec.Error(ctx, ec.Recover(ctx, r))
7277 ret = graphql.Null
7278 }
7279 }()
7280 fc := &graphql.FieldContext{
7281 Object: "Mutation",
7282 Field: field,
7283 Args: nil,
7284 IsMethod: true,
7285 }
7286
7287 ctx = graphql.WithFieldContext(ctx, fc)
7288 rawArgs := field.ArgumentMap(ec.Variables)
7289 args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
7290 if err != nil {
7291 ec.Error(ctx, err)
7292 return graphql.Null
7293 }
7294 fc.Args = args
7295 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7296 ctx = rctx // use context from middleware stack in children
7297 return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
7298 })
7299 if err != nil {
7300 ec.Error(ctx, err)
7301 return graphql.Null
7302 }
7303 if resTmp == nil {
7304 if !graphql.HasFieldError(ctx, fc) {
7305 ec.Errorf(ctx, "must not be null")
7306 }
7307 return graphql.Null
7308 }
7309 res := resTmp.(*models.AddCommentPayload)
7310 fc.Result = res
7311 return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
7312}
7313
7314func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7315 defer func() {
7316 if r := recover(); r != nil {
7317 ec.Error(ctx, ec.Recover(ctx, r))
7318 ret = graphql.Null
7319 }
7320 }()
7321 fc := &graphql.FieldContext{
7322 Object: "Mutation",
7323 Field: field,
7324 Args: nil,
7325 IsMethod: true,
7326 }
7327
7328 ctx = graphql.WithFieldContext(ctx, fc)
7329 rawArgs := field.ArgumentMap(ec.Variables)
7330 args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
7331 if err != nil {
7332 ec.Error(ctx, err)
7333 return graphql.Null
7334 }
7335 fc.Args = args
7336 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7337 ctx = rctx // use context from middleware stack in children
7338 return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
7339 })
7340 if err != nil {
7341 ec.Error(ctx, err)
7342 return graphql.Null
7343 }
7344 if resTmp == nil {
7345 if !graphql.HasFieldError(ctx, fc) {
7346 ec.Errorf(ctx, "must not be null")
7347 }
7348 return graphql.Null
7349 }
7350 res := resTmp.(*models.ChangeLabelPayload)
7351 fc.Result = res
7352 return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
7353}
7354
7355func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7356 defer func() {
7357 if r := recover(); r != nil {
7358 ec.Error(ctx, ec.Recover(ctx, r))
7359 ret = graphql.Null
7360 }
7361 }()
7362 fc := &graphql.FieldContext{
7363 Object: "Mutation",
7364 Field: field,
7365 Args: nil,
7366 IsMethod: true,
7367 }
7368
7369 ctx = graphql.WithFieldContext(ctx, fc)
7370 rawArgs := field.ArgumentMap(ec.Variables)
7371 args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
7372 if err != nil {
7373 ec.Error(ctx, err)
7374 return graphql.Null
7375 }
7376 fc.Args = args
7377 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7378 ctx = rctx // use context from middleware stack in children
7379 return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
7380 })
7381 if err != nil {
7382 ec.Error(ctx, err)
7383 return graphql.Null
7384 }
7385 if resTmp == nil {
7386 if !graphql.HasFieldError(ctx, fc) {
7387 ec.Errorf(ctx, "must not be null")
7388 }
7389 return graphql.Null
7390 }
7391 res := resTmp.(*models.OpenBugPayload)
7392 fc.Result = res
7393 return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
7394}
7395
7396func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7397 defer func() {
7398 if r := recover(); r != nil {
7399 ec.Error(ctx, ec.Recover(ctx, r))
7400 ret = graphql.Null
7401 }
7402 }()
7403 fc := &graphql.FieldContext{
7404 Object: "Mutation",
7405 Field: field,
7406 Args: nil,
7407 IsMethod: true,
7408 }
7409
7410 ctx = graphql.WithFieldContext(ctx, fc)
7411 rawArgs := field.ArgumentMap(ec.Variables)
7412 args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
7413 if err != nil {
7414 ec.Error(ctx, err)
7415 return graphql.Null
7416 }
7417 fc.Args = args
7418 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7419 ctx = rctx // use context from middleware stack in children
7420 return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
7421 })
7422 if err != nil {
7423 ec.Error(ctx, err)
7424 return graphql.Null
7425 }
7426 if resTmp == nil {
7427 if !graphql.HasFieldError(ctx, fc) {
7428 ec.Errorf(ctx, "must not be null")
7429 }
7430 return graphql.Null
7431 }
7432 res := resTmp.(*models.CloseBugPayload)
7433 fc.Result = res
7434 return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
7435}
7436
7437func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7438 defer func() {
7439 if r := recover(); r != nil {
7440 ec.Error(ctx, ec.Recover(ctx, r))
7441 ret = graphql.Null
7442 }
7443 }()
7444 fc := &graphql.FieldContext{
7445 Object: "Mutation",
7446 Field: field,
7447 Args: nil,
7448 IsMethod: true,
7449 }
7450
7451 ctx = graphql.WithFieldContext(ctx, fc)
7452 rawArgs := field.ArgumentMap(ec.Variables)
7453 args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
7454 if err != nil {
7455 ec.Error(ctx, err)
7456 return graphql.Null
7457 }
7458 fc.Args = args
7459 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7460 ctx = rctx // use context from middleware stack in children
7461 return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
7462 })
7463 if err != nil {
7464 ec.Error(ctx, err)
7465 return graphql.Null
7466 }
7467 if resTmp == nil {
7468 if !graphql.HasFieldError(ctx, fc) {
7469 ec.Errorf(ctx, "must not be null")
7470 }
7471 return graphql.Null
7472 }
7473 res := resTmp.(*models.SetTitlePayload)
7474 fc.Result = res
7475 return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
7476}
7477
7478func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7479 defer func() {
7480 if r := recover(); r != nil {
7481 ec.Error(ctx, ec.Recover(ctx, r))
7482 ret = graphql.Null
7483 }
7484 }()
7485 fc := &graphql.FieldContext{
7486 Object: "Mutation",
7487 Field: field,
7488 Args: nil,
7489 IsMethod: true,
7490 }
7491
7492 ctx = graphql.WithFieldContext(ctx, fc)
7493 rawArgs := field.ArgumentMap(ec.Variables)
7494 args, err := ec.field_Mutation_commit_args(ctx, rawArgs)
7495 if err != nil {
7496 ec.Error(ctx, err)
7497 return graphql.Null
7498 }
7499 fc.Args = args
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().Commit(rctx, args["input"].(models.CommitInput))
7503 })
7504 if err != nil {
7505 ec.Error(ctx, err)
7506 return graphql.Null
7507 }
7508 if resTmp == nil {
7509 if !graphql.HasFieldError(ctx, fc) {
7510 ec.Errorf(ctx, "must not be null")
7511 }
7512 return graphql.Null
7513 }
7514 res := resTmp.(*models.CommitPayload)
7515 fc.Result = res
7516 return ec.marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx, field.Selections, res)
7517}
7518
7519func (ec *executionContext) _Mutation_commitAsNeeded(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7520 defer func() {
7521 if r := recover(); r != nil {
7522 ec.Error(ctx, ec.Recover(ctx, r))
7523 ret = graphql.Null
7524 }
7525 }()
7526 fc := &graphql.FieldContext{
7527 Object: "Mutation",
7528 Field: field,
7529 Args: nil,
7530 IsMethod: true,
7531 }
7532
7533 ctx = graphql.WithFieldContext(ctx, fc)
7534 rawArgs := field.ArgumentMap(ec.Variables)
7535 args, err := ec.field_Mutation_commitAsNeeded_args(ctx, rawArgs)
7536 if err != nil {
7537 ec.Error(ctx, err)
7538 return graphql.Null
7539 }
7540 fc.Args = args
7541 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7542 ctx = rctx // use context from middleware stack in children
7543 return ec.resolvers.Mutation().CommitAsNeeded(rctx, args["input"].(models.CommitAsNeededInput))
7544 })
7545 if err != nil {
7546 ec.Error(ctx, err)
7547 return graphql.Null
7548 }
7549 if resTmp == nil {
7550 if !graphql.HasFieldError(ctx, fc) {
7551 ec.Errorf(ctx, "must not be null")
7552 }
7553 return graphql.Null
7554 }
7555 res := resTmp.(*models.CommitAsNeededPayload)
7556 fc.Result = res
7557 return ec.marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx, field.Selections, res)
7558}
7559
7560func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7561 defer func() {
7562 if r := recover(); r != nil {
7563 ec.Error(ctx, ec.Recover(ctx, r))
7564 ret = graphql.Null
7565 }
7566 }()
7567 fc := &graphql.FieldContext{
7568 Object: "NewBugPayload",
7569 Field: field,
7570 Args: nil,
7571 IsMethod: false,
7572 }
7573
7574 ctx = graphql.WithFieldContext(ctx, fc)
7575 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7576 ctx = rctx // use context from middleware stack in children
7577 return obj.ClientMutationID, nil
7578 })
7579 if err != nil {
7580 ec.Error(ctx, err)
7581 return graphql.Null
7582 }
7583 if resTmp == nil {
7584 return graphql.Null
7585 }
7586 res := resTmp.(*string)
7587 fc.Result = res
7588 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7589}
7590
7591func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7592 defer func() {
7593 if r := recover(); r != nil {
7594 ec.Error(ctx, ec.Recover(ctx, r))
7595 ret = graphql.Null
7596 }
7597 }()
7598 fc := &graphql.FieldContext{
7599 Object: "NewBugPayload",
7600 Field: field,
7601 Args: nil,
7602 IsMethod: false,
7603 }
7604
7605 ctx = graphql.WithFieldContext(ctx, fc)
7606 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7607 ctx = rctx // use context from middleware stack in children
7608 return obj.Bug, nil
7609 })
7610 if err != nil {
7611 ec.Error(ctx, err)
7612 return graphql.Null
7613 }
7614 if resTmp == nil {
7615 if !graphql.HasFieldError(ctx, fc) {
7616 ec.Errorf(ctx, "must not be null")
7617 }
7618 return graphql.Null
7619 }
7620 res := resTmp.(*bug.Snapshot)
7621 fc.Result = res
7622 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
7623}
7624
7625func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7626 defer func() {
7627 if r := recover(); r != nil {
7628 ec.Error(ctx, ec.Recover(ctx, r))
7629 ret = graphql.Null
7630 }
7631 }()
7632 fc := &graphql.FieldContext{
7633 Object: "NewBugPayload",
7634 Field: field,
7635 Args: nil,
7636 IsMethod: false,
7637 }
7638
7639 ctx = graphql.WithFieldContext(ctx, fc)
7640 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7641 ctx = rctx // use context from middleware stack in children
7642 return obj.Operation, nil
7643 })
7644 if err != nil {
7645 ec.Error(ctx, err)
7646 return graphql.Null
7647 }
7648 if resTmp == nil {
7649 if !graphql.HasFieldError(ctx, fc) {
7650 ec.Errorf(ctx, "must not be null")
7651 }
7652 return graphql.Null
7653 }
7654 res := resTmp.(*bug.CreateOperation)
7655 fc.Result = res
7656 return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
7657}
7658
7659func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7660 defer func() {
7661 if r := recover(); r != nil {
7662 ec.Error(ctx, ec.Recover(ctx, r))
7663 ret = graphql.Null
7664 }
7665 }()
7666 fc := &graphql.FieldContext{
7667 Object: "OpenBugPayload",
7668 Field: field,
7669 Args: nil,
7670 IsMethod: false,
7671 }
7672
7673 ctx = graphql.WithFieldContext(ctx, fc)
7674 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7675 ctx = rctx // use context from middleware stack in children
7676 return obj.ClientMutationID, nil
7677 })
7678 if err != nil {
7679 ec.Error(ctx, err)
7680 return graphql.Null
7681 }
7682 if resTmp == nil {
7683 return graphql.Null
7684 }
7685 res := resTmp.(*string)
7686 fc.Result = res
7687 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7688}
7689
7690func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7691 defer func() {
7692 if r := recover(); r != nil {
7693 ec.Error(ctx, ec.Recover(ctx, r))
7694 ret = graphql.Null
7695 }
7696 }()
7697 fc := &graphql.FieldContext{
7698 Object: "OpenBugPayload",
7699 Field: field,
7700 Args: nil,
7701 IsMethod: false,
7702 }
7703
7704 ctx = graphql.WithFieldContext(ctx, fc)
7705 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7706 ctx = rctx // use context from middleware stack in children
7707 return obj.Bug, nil
7708 })
7709 if err != nil {
7710 ec.Error(ctx, err)
7711 return graphql.Null
7712 }
7713 if resTmp == nil {
7714 if !graphql.HasFieldError(ctx, fc) {
7715 ec.Errorf(ctx, "must not be null")
7716 }
7717 return graphql.Null
7718 }
7719 res := resTmp.(*bug.Snapshot)
7720 fc.Result = res
7721 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
7722}
7723
7724func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7725 defer func() {
7726 if r := recover(); r != nil {
7727 ec.Error(ctx, ec.Recover(ctx, r))
7728 ret = graphql.Null
7729 }
7730 }()
7731 fc := &graphql.FieldContext{
7732 Object: "OpenBugPayload",
7733 Field: field,
7734 Args: nil,
7735 IsMethod: false,
7736 }
7737
7738 ctx = graphql.WithFieldContext(ctx, fc)
7739 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7740 ctx = rctx // use context from middleware stack in children
7741 return obj.Operation, nil
7742 })
7743 if err != nil {
7744 ec.Error(ctx, err)
7745 return graphql.Null
7746 }
7747 if resTmp == nil {
7748 if !graphql.HasFieldError(ctx, fc) {
7749 ec.Errorf(ctx, "must not be null")
7750 }
7751 return graphql.Null
7752 }
7753 res := resTmp.(*bug.SetStatusOperation)
7754 fc.Result = res
7755 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
7756}
7757
7758func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7759 defer func() {
7760 if r := recover(); r != nil {
7761 ec.Error(ctx, ec.Recover(ctx, r))
7762 ret = graphql.Null
7763 }
7764 }()
7765 fc := &graphql.FieldContext{
7766 Object: "OperationConnection",
7767 Field: field,
7768 Args: nil,
7769 IsMethod: false,
7770 }
7771
7772 ctx = graphql.WithFieldContext(ctx, fc)
7773 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7774 ctx = rctx // use context from middleware stack in children
7775 return obj.Edges, nil
7776 })
7777 if err != nil {
7778 ec.Error(ctx, err)
7779 return graphql.Null
7780 }
7781 if resTmp == nil {
7782 if !graphql.HasFieldError(ctx, fc) {
7783 ec.Errorf(ctx, "must not be null")
7784 }
7785 return graphql.Null
7786 }
7787 res := resTmp.([]*models.OperationEdge)
7788 fc.Result = res
7789 return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
7790}
7791
7792func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7793 defer func() {
7794 if r := recover(); r != nil {
7795 ec.Error(ctx, ec.Recover(ctx, r))
7796 ret = graphql.Null
7797 }
7798 }()
7799 fc := &graphql.FieldContext{
7800 Object: "OperationConnection",
7801 Field: field,
7802 Args: nil,
7803 IsMethod: false,
7804 }
7805
7806 ctx = graphql.WithFieldContext(ctx, fc)
7807 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7808 ctx = rctx // use context from middleware stack in children
7809 return obj.Nodes, nil
7810 })
7811 if err != nil {
7812 ec.Error(ctx, err)
7813 return graphql.Null
7814 }
7815 if resTmp == nil {
7816 if !graphql.HasFieldError(ctx, fc) {
7817 ec.Errorf(ctx, "must not be null")
7818 }
7819 return graphql.Null
7820 }
7821 res := resTmp.([]bug.Operation)
7822 fc.Result = res
7823 return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
7824}
7825
7826func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7827 defer func() {
7828 if r := recover(); r != nil {
7829 ec.Error(ctx, ec.Recover(ctx, r))
7830 ret = graphql.Null
7831 }
7832 }()
7833 fc := &graphql.FieldContext{
7834 Object: "OperationConnection",
7835 Field: field,
7836 Args: nil,
7837 IsMethod: false,
7838 }
7839
7840 ctx = graphql.WithFieldContext(ctx, fc)
7841 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7842 ctx = rctx // use context from middleware stack in children
7843 return obj.PageInfo, nil
7844 })
7845 if err != nil {
7846 ec.Error(ctx, err)
7847 return graphql.Null
7848 }
7849 if resTmp == nil {
7850 if !graphql.HasFieldError(ctx, fc) {
7851 ec.Errorf(ctx, "must not be null")
7852 }
7853 return graphql.Null
7854 }
7855 res := resTmp.(*models.PageInfo)
7856 fc.Result = res
7857 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
7858}
7859
7860func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7861 defer func() {
7862 if r := recover(); r != nil {
7863 ec.Error(ctx, ec.Recover(ctx, r))
7864 ret = graphql.Null
7865 }
7866 }()
7867 fc := &graphql.FieldContext{
7868 Object: "OperationConnection",
7869 Field: field,
7870 Args: nil,
7871 IsMethod: false,
7872 }
7873
7874 ctx = graphql.WithFieldContext(ctx, fc)
7875 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7876 ctx = rctx // use context from middleware stack in children
7877 return obj.TotalCount, nil
7878 })
7879 if err != nil {
7880 ec.Error(ctx, err)
7881 return graphql.Null
7882 }
7883 if resTmp == nil {
7884 if !graphql.HasFieldError(ctx, fc) {
7885 ec.Errorf(ctx, "must not be null")
7886 }
7887 return graphql.Null
7888 }
7889 res := resTmp.(int)
7890 fc.Result = res
7891 return ec.marshalNInt2int(ctx, field.Selections, res)
7892}
7893
7894func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
7895 defer func() {
7896 if r := recover(); r != nil {
7897 ec.Error(ctx, ec.Recover(ctx, r))
7898 ret = graphql.Null
7899 }
7900 }()
7901 fc := &graphql.FieldContext{
7902 Object: "OperationEdge",
7903 Field: field,
7904 Args: nil,
7905 IsMethod: false,
7906 }
7907
7908 ctx = graphql.WithFieldContext(ctx, fc)
7909 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7910 ctx = rctx // use context from middleware stack in children
7911 return obj.Cursor, nil
7912 })
7913 if err != nil {
7914 ec.Error(ctx, err)
7915 return graphql.Null
7916 }
7917 if resTmp == nil {
7918 if !graphql.HasFieldError(ctx, fc) {
7919 ec.Errorf(ctx, "must not be null")
7920 }
7921 return graphql.Null
7922 }
7923 res := resTmp.(string)
7924 fc.Result = res
7925 return ec.marshalNString2string(ctx, field.Selections, res)
7926}
7927
7928func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
7929 defer func() {
7930 if r := recover(); r != nil {
7931 ec.Error(ctx, ec.Recover(ctx, r))
7932 ret = graphql.Null
7933 }
7934 }()
7935 fc := &graphql.FieldContext{
7936 Object: "OperationEdge",
7937 Field: field,
7938 Args: nil,
7939 IsMethod: false,
7940 }
7941
7942 ctx = graphql.WithFieldContext(ctx, fc)
7943 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7944 ctx = rctx // use context from middleware stack in children
7945 return obj.Node, nil
7946 })
7947 if err != nil {
7948 ec.Error(ctx, err)
7949 return graphql.Null
7950 }
7951 if resTmp == nil {
7952 if !graphql.HasFieldError(ctx, fc) {
7953 ec.Errorf(ctx, "must not be null")
7954 }
7955 return graphql.Null
7956 }
7957 res := resTmp.(bug.Operation)
7958 fc.Result = res
7959 return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
7960}
7961
7962func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7963 defer func() {
7964 if r := recover(); r != nil {
7965 ec.Error(ctx, ec.Recover(ctx, r))
7966 ret = graphql.Null
7967 }
7968 }()
7969 fc := &graphql.FieldContext{
7970 Object: "PageInfo",
7971 Field: field,
7972 Args: nil,
7973 IsMethod: false,
7974 }
7975
7976 ctx = graphql.WithFieldContext(ctx, fc)
7977 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7978 ctx = rctx // use context from middleware stack in children
7979 return obj.HasNextPage, nil
7980 })
7981 if err != nil {
7982 ec.Error(ctx, err)
7983 return graphql.Null
7984 }
7985 if resTmp == nil {
7986 if !graphql.HasFieldError(ctx, fc) {
7987 ec.Errorf(ctx, "must not be null")
7988 }
7989 return graphql.Null
7990 }
7991 res := resTmp.(bool)
7992 fc.Result = res
7993 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7994}
7995
7996func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7997 defer func() {
7998 if r := recover(); r != nil {
7999 ec.Error(ctx, ec.Recover(ctx, r))
8000 ret = graphql.Null
8001 }
8002 }()
8003 fc := &graphql.FieldContext{
8004 Object: "PageInfo",
8005 Field: field,
8006 Args: nil,
8007 IsMethod: false,
8008 }
8009
8010 ctx = graphql.WithFieldContext(ctx, fc)
8011 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8012 ctx = rctx // use context from middleware stack in children
8013 return obj.HasPreviousPage, nil
8014 })
8015 if err != nil {
8016 ec.Error(ctx, err)
8017 return graphql.Null
8018 }
8019 if resTmp == nil {
8020 if !graphql.HasFieldError(ctx, fc) {
8021 ec.Errorf(ctx, "must not be null")
8022 }
8023 return graphql.Null
8024 }
8025 res := resTmp.(bool)
8026 fc.Result = res
8027 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
8028}
8029
8030func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8031 defer func() {
8032 if r := recover(); r != nil {
8033 ec.Error(ctx, ec.Recover(ctx, r))
8034 ret = graphql.Null
8035 }
8036 }()
8037 fc := &graphql.FieldContext{
8038 Object: "PageInfo",
8039 Field: field,
8040 Args: nil,
8041 IsMethod: false,
8042 }
8043
8044 ctx = graphql.WithFieldContext(ctx, fc)
8045 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8046 ctx = rctx // use context from middleware stack in children
8047 return obj.StartCursor, nil
8048 })
8049 if err != nil {
8050 ec.Error(ctx, err)
8051 return graphql.Null
8052 }
8053 if resTmp == nil {
8054 if !graphql.HasFieldError(ctx, fc) {
8055 ec.Errorf(ctx, "must not be null")
8056 }
8057 return graphql.Null
8058 }
8059 res := resTmp.(string)
8060 fc.Result = res
8061 return ec.marshalNString2string(ctx, field.Selections, res)
8062}
8063
8064func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8065 defer func() {
8066 if r := recover(); r != nil {
8067 ec.Error(ctx, ec.Recover(ctx, r))
8068 ret = graphql.Null
8069 }
8070 }()
8071 fc := &graphql.FieldContext{
8072 Object: "PageInfo",
8073 Field: field,
8074 Args: nil,
8075 IsMethod: false,
8076 }
8077
8078 ctx = graphql.WithFieldContext(ctx, fc)
8079 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8080 ctx = rctx // use context from middleware stack in children
8081 return obj.EndCursor, nil
8082 })
8083 if err != nil {
8084 ec.Error(ctx, err)
8085 return graphql.Null
8086 }
8087 if resTmp == nil {
8088 if !graphql.HasFieldError(ctx, fc) {
8089 ec.Errorf(ctx, "must not be null")
8090 }
8091 return graphql.Null
8092 }
8093 res := resTmp.(string)
8094 fc.Result = res
8095 return ec.marshalNString2string(ctx, field.Selections, res)
8096}
8097
8098func (ec *executionContext) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8099 defer func() {
8100 if r := recover(); r != nil {
8101 ec.Error(ctx, ec.Recover(ctx, r))
8102 ret = graphql.Null
8103 }
8104 }()
8105 fc := &graphql.FieldContext{
8106 Object: "Query",
8107 Field: field,
8108 Args: nil,
8109 IsMethod: true,
8110 }
8111
8112 ctx = graphql.WithFieldContext(ctx, fc)
8113 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8114 ctx = rctx // use context from middleware stack in children
8115 return ec.resolvers.Query().DefaultRepository(rctx)
8116 })
8117 if err != nil {
8118 ec.Error(ctx, err)
8119 return graphql.Null
8120 }
8121 if resTmp == nil {
8122 return graphql.Null
8123 }
8124 res := resTmp.(*models.Repository)
8125 fc.Result = res
8126 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
8127}
8128
8129func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8130 defer func() {
8131 if r := recover(); r != nil {
8132 ec.Error(ctx, ec.Recover(ctx, r))
8133 ret = graphql.Null
8134 }
8135 }()
8136 fc := &graphql.FieldContext{
8137 Object: "Query",
8138 Field: field,
8139 Args: nil,
8140 IsMethod: true,
8141 }
8142
8143 ctx = graphql.WithFieldContext(ctx, fc)
8144 rawArgs := field.ArgumentMap(ec.Variables)
8145 args, err := ec.field_Query_repository_args(ctx, rawArgs)
8146 if err != nil {
8147 ec.Error(ctx, err)
8148 return graphql.Null
8149 }
8150 fc.Args = args
8151 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8152 ctx = rctx // use context from middleware stack in children
8153 return ec.resolvers.Query().Repository(rctx, args["ref"].(string))
8154 })
8155 if err != nil {
8156 ec.Error(ctx, err)
8157 return graphql.Null
8158 }
8159 if resTmp == nil {
8160 return graphql.Null
8161 }
8162 res := resTmp.(*models.Repository)
8163 fc.Result = res
8164 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
8165}
8166
8167func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8168 defer func() {
8169 if r := recover(); r != nil {
8170 ec.Error(ctx, ec.Recover(ctx, r))
8171 ret = graphql.Null
8172 }
8173 }()
8174 fc := &graphql.FieldContext{
8175 Object: "Query",
8176 Field: field,
8177 Args: nil,
8178 IsMethod: true,
8179 }
8180
8181 ctx = graphql.WithFieldContext(ctx, fc)
8182 rawArgs := field.ArgumentMap(ec.Variables)
8183 args, err := ec.field_Query___type_args(ctx, rawArgs)
8184 if err != nil {
8185 ec.Error(ctx, err)
8186 return graphql.Null
8187 }
8188 fc.Args = args
8189 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8190 ctx = rctx // use context from middleware stack in children
8191 return ec.introspectType(args["name"].(string))
8192 })
8193 if err != nil {
8194 ec.Error(ctx, err)
8195 return graphql.Null
8196 }
8197 if resTmp == nil {
8198 return graphql.Null
8199 }
8200 res := resTmp.(*introspection.Type)
8201 fc.Result = res
8202 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
8203}
8204
8205func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8206 defer func() {
8207 if r := recover(); r != nil {
8208 ec.Error(ctx, ec.Recover(ctx, r))
8209 ret = graphql.Null
8210 }
8211 }()
8212 fc := &graphql.FieldContext{
8213 Object: "Query",
8214 Field: field,
8215 Args: nil,
8216 IsMethod: true,
8217 }
8218
8219 ctx = graphql.WithFieldContext(ctx, fc)
8220 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8221 ctx = rctx // use context from middleware stack in children
8222 return ec.introspectSchema()
8223 })
8224 if err != nil {
8225 ec.Error(ctx, err)
8226 return graphql.Null
8227 }
8228 if resTmp == nil {
8229 return graphql.Null
8230 }
8231 res := resTmp.(*introspection.Schema)
8232 fc.Result = res
8233 return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
8234}
8235
8236func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8237 defer func() {
8238 if r := recover(); r != nil {
8239 ec.Error(ctx, ec.Recover(ctx, r))
8240 ret = graphql.Null
8241 }
8242 }()
8243 fc := &graphql.FieldContext{
8244 Object: "Repository",
8245 Field: field,
8246 Args: nil,
8247 IsMethod: true,
8248 }
8249
8250 ctx = graphql.WithFieldContext(ctx, fc)
8251 rawArgs := field.ArgumentMap(ec.Variables)
8252 args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
8253 if err != nil {
8254 ec.Error(ctx, err)
8255 return graphql.Null
8256 }
8257 fc.Args = args
8258 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8259 ctx = rctx // use context from middleware stack in children
8260 return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
8261 })
8262 if err != nil {
8263 ec.Error(ctx, err)
8264 return graphql.Null
8265 }
8266 if resTmp == nil {
8267 if !graphql.HasFieldError(ctx, fc) {
8268 ec.Errorf(ctx, "must not be null")
8269 }
8270 return graphql.Null
8271 }
8272 res := resTmp.(*models.BugConnection)
8273 fc.Result = res
8274 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
8275}
8276
8277func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8278 defer func() {
8279 if r := recover(); r != nil {
8280 ec.Error(ctx, ec.Recover(ctx, r))
8281 ret = graphql.Null
8282 }
8283 }()
8284 fc := &graphql.FieldContext{
8285 Object: "Repository",
8286 Field: field,
8287 Args: nil,
8288 IsMethod: true,
8289 }
8290
8291 ctx = graphql.WithFieldContext(ctx, fc)
8292 rawArgs := field.ArgumentMap(ec.Variables)
8293 args, err := ec.field_Repository_bug_args(ctx, rawArgs)
8294 if err != nil {
8295 ec.Error(ctx, err)
8296 return graphql.Null
8297 }
8298 fc.Args = args
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.Repository().Bug(rctx, obj, args["prefix"].(string))
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.(*bug.Snapshot)
8311 fc.Result = res
8312 return ec.marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
8313}
8314
8315func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8316 defer func() {
8317 if r := recover(); r != nil {
8318 ec.Error(ctx, ec.Recover(ctx, r))
8319 ret = graphql.Null
8320 }
8321 }()
8322 fc := &graphql.FieldContext{
8323 Object: "Repository",
8324 Field: field,
8325 Args: nil,
8326 IsMethod: true,
8327 }
8328
8329 ctx = graphql.WithFieldContext(ctx, fc)
8330 rawArgs := field.ArgumentMap(ec.Variables)
8331 args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
8332 if err != nil {
8333 ec.Error(ctx, err)
8334 return graphql.Null
8335 }
8336 fc.Args = args
8337 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8338 ctx = rctx // use context from middleware stack in children
8339 return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8340 })
8341 if err != nil {
8342 ec.Error(ctx, err)
8343 return graphql.Null
8344 }
8345 if resTmp == nil {
8346 if !graphql.HasFieldError(ctx, fc) {
8347 ec.Errorf(ctx, "must not be null")
8348 }
8349 return graphql.Null
8350 }
8351 res := resTmp.(*models.IdentityConnection)
8352 fc.Result = res
8353 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
8354}
8355
8356func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8357 defer func() {
8358 if r := recover(); r != nil {
8359 ec.Error(ctx, ec.Recover(ctx, r))
8360 ret = graphql.Null
8361 }
8362 }()
8363 fc := &graphql.FieldContext{
8364 Object: "Repository",
8365 Field: field,
8366 Args: nil,
8367 IsMethod: true,
8368 }
8369
8370 ctx = graphql.WithFieldContext(ctx, fc)
8371 rawArgs := field.ArgumentMap(ec.Variables)
8372 args, err := ec.field_Repository_identity_args(ctx, rawArgs)
8373 if err != nil {
8374 ec.Error(ctx, err)
8375 return graphql.Null
8376 }
8377 fc.Args = args
8378 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8379 ctx = rctx // use context from middleware stack in children
8380 return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
8381 })
8382 if err != nil {
8383 ec.Error(ctx, err)
8384 return graphql.Null
8385 }
8386 if resTmp == nil {
8387 return graphql.Null
8388 }
8389 res := resTmp.(identity.Interface)
8390 fc.Result = res
8391 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8392}
8393
8394func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8395 defer func() {
8396 if r := recover(); r != nil {
8397 ec.Error(ctx, ec.Recover(ctx, r))
8398 ret = graphql.Null
8399 }
8400 }()
8401 fc := &graphql.FieldContext{
8402 Object: "Repository",
8403 Field: field,
8404 Args: nil,
8405 IsMethod: true,
8406 }
8407
8408 ctx = graphql.WithFieldContext(ctx, fc)
8409 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8410 ctx = rctx // use context from middleware stack in children
8411 return ec.resolvers.Repository().UserIdentity(rctx, obj)
8412 })
8413 if err != nil {
8414 ec.Error(ctx, err)
8415 return graphql.Null
8416 }
8417 if resTmp == nil {
8418 return graphql.Null
8419 }
8420 res := resTmp.(identity.Interface)
8421 fc.Result = res
8422 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8423}
8424
8425func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8426 defer func() {
8427 if r := recover(); r != nil {
8428 ec.Error(ctx, ec.Recover(ctx, r))
8429 ret = graphql.Null
8430 }
8431 }()
8432 fc := &graphql.FieldContext{
8433 Object: "Repository",
8434 Field: field,
8435 Args: nil,
8436 IsMethod: true,
8437 }
8438
8439 ctx = graphql.WithFieldContext(ctx, fc)
8440 rawArgs := field.ArgumentMap(ec.Variables)
8441 args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
8442 if err != nil {
8443 ec.Error(ctx, err)
8444 return graphql.Null
8445 }
8446 fc.Args = args
8447 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8448 ctx = rctx // use context from middleware stack in children
8449 return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8450 })
8451 if err != nil {
8452 ec.Error(ctx, err)
8453 return graphql.Null
8454 }
8455 if resTmp == nil {
8456 if !graphql.HasFieldError(ctx, fc) {
8457 ec.Errorf(ctx, "must not be null")
8458 }
8459 return graphql.Null
8460 }
8461 res := resTmp.(*models.LabelConnection)
8462 fc.Result = res
8463 return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
8464}
8465
8466func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8467 defer func() {
8468 if r := recover(); r != nil {
8469 ec.Error(ctx, ec.Recover(ctx, r))
8470 ret = graphql.Null
8471 }
8472 }()
8473 fc := &graphql.FieldContext{
8474 Object: "SetStatusOperation",
8475 Field: field,
8476 Args: nil,
8477 IsMethod: true,
8478 }
8479
8480 ctx = graphql.WithFieldContext(ctx, fc)
8481 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8482 ctx = rctx // use context from middleware stack in children
8483 return ec.resolvers.SetStatusOperation().ID(rctx, obj)
8484 })
8485 if err != nil {
8486 ec.Error(ctx, err)
8487 return graphql.Null
8488 }
8489 if resTmp == nil {
8490 if !graphql.HasFieldError(ctx, fc) {
8491 ec.Errorf(ctx, "must not be null")
8492 }
8493 return graphql.Null
8494 }
8495 res := resTmp.(string)
8496 fc.Result = res
8497 return ec.marshalNString2string(ctx, field.Selections, res)
8498}
8499
8500func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8501 defer func() {
8502 if r := recover(); r != nil {
8503 ec.Error(ctx, ec.Recover(ctx, r))
8504 ret = graphql.Null
8505 }
8506 }()
8507 fc := &graphql.FieldContext{
8508 Object: "SetStatusOperation",
8509 Field: field,
8510 Args: nil,
8511 IsMethod: false,
8512 }
8513
8514 ctx = graphql.WithFieldContext(ctx, fc)
8515 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8516 ctx = rctx // use context from middleware stack in children
8517 return obj.Author, nil
8518 })
8519 if err != nil {
8520 ec.Error(ctx, err)
8521 return graphql.Null
8522 }
8523 if resTmp == nil {
8524 if !graphql.HasFieldError(ctx, fc) {
8525 ec.Errorf(ctx, "must not be null")
8526 }
8527 return graphql.Null
8528 }
8529 res := resTmp.(identity.Interface)
8530 fc.Result = res
8531 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8532}
8533
8534func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8535 defer func() {
8536 if r := recover(); r != nil {
8537 ec.Error(ctx, ec.Recover(ctx, r))
8538 ret = graphql.Null
8539 }
8540 }()
8541 fc := &graphql.FieldContext{
8542 Object: "SetStatusOperation",
8543 Field: field,
8544 Args: nil,
8545 IsMethod: true,
8546 }
8547
8548 ctx = graphql.WithFieldContext(ctx, fc)
8549 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8550 ctx = rctx // use context from middleware stack in children
8551 return ec.resolvers.SetStatusOperation().Date(rctx, obj)
8552 })
8553 if err != nil {
8554 ec.Error(ctx, err)
8555 return graphql.Null
8556 }
8557 if resTmp == nil {
8558 if !graphql.HasFieldError(ctx, fc) {
8559 ec.Errorf(ctx, "must not be null")
8560 }
8561 return graphql.Null
8562 }
8563 res := resTmp.(*time.Time)
8564 fc.Result = res
8565 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8566}
8567
8568func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8569 defer func() {
8570 if r := recover(); r != nil {
8571 ec.Error(ctx, ec.Recover(ctx, r))
8572 ret = graphql.Null
8573 }
8574 }()
8575 fc := &graphql.FieldContext{
8576 Object: "SetStatusOperation",
8577 Field: field,
8578 Args: nil,
8579 IsMethod: true,
8580 }
8581
8582 ctx = graphql.WithFieldContext(ctx, fc)
8583 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8584 ctx = rctx // use context from middleware stack in children
8585 return ec.resolvers.SetStatusOperation().Status(rctx, obj)
8586 })
8587 if err != nil {
8588 ec.Error(ctx, err)
8589 return graphql.Null
8590 }
8591 if resTmp == nil {
8592 if !graphql.HasFieldError(ctx, fc) {
8593 ec.Errorf(ctx, "must not be null")
8594 }
8595 return graphql.Null
8596 }
8597 res := resTmp.(models.Status)
8598 fc.Result = res
8599 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8600}
8601
8602func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8603 defer func() {
8604 if r := recover(); r != nil {
8605 ec.Error(ctx, ec.Recover(ctx, r))
8606 ret = graphql.Null
8607 }
8608 }()
8609 fc := &graphql.FieldContext{
8610 Object: "SetStatusTimelineItem",
8611 Field: field,
8612 Args: nil,
8613 IsMethod: true,
8614 }
8615
8616 ctx = graphql.WithFieldContext(ctx, fc)
8617 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8618 ctx = rctx // use context from middleware stack in children
8619 return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
8620 })
8621 if err != nil {
8622 ec.Error(ctx, err)
8623 return graphql.Null
8624 }
8625 if resTmp == nil {
8626 if !graphql.HasFieldError(ctx, fc) {
8627 ec.Errorf(ctx, "must not be null")
8628 }
8629 return graphql.Null
8630 }
8631 res := resTmp.(string)
8632 fc.Result = res
8633 return ec.marshalNString2string(ctx, field.Selections, res)
8634}
8635
8636func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8637 defer func() {
8638 if r := recover(); r != nil {
8639 ec.Error(ctx, ec.Recover(ctx, r))
8640 ret = graphql.Null
8641 }
8642 }()
8643 fc := &graphql.FieldContext{
8644 Object: "SetStatusTimelineItem",
8645 Field: field,
8646 Args: nil,
8647 IsMethod: false,
8648 }
8649
8650 ctx = graphql.WithFieldContext(ctx, fc)
8651 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8652 ctx = rctx // use context from middleware stack in children
8653 return obj.Author, nil
8654 })
8655 if err != nil {
8656 ec.Error(ctx, err)
8657 return graphql.Null
8658 }
8659 if resTmp == nil {
8660 if !graphql.HasFieldError(ctx, fc) {
8661 ec.Errorf(ctx, "must not be null")
8662 }
8663 return graphql.Null
8664 }
8665 res := resTmp.(identity.Interface)
8666 fc.Result = res
8667 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8668}
8669
8670func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8671 defer func() {
8672 if r := recover(); r != nil {
8673 ec.Error(ctx, ec.Recover(ctx, r))
8674 ret = graphql.Null
8675 }
8676 }()
8677 fc := &graphql.FieldContext{
8678 Object: "SetStatusTimelineItem",
8679 Field: field,
8680 Args: nil,
8681 IsMethod: true,
8682 }
8683
8684 ctx = graphql.WithFieldContext(ctx, fc)
8685 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8686 ctx = rctx // use context from middleware stack in children
8687 return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
8688 })
8689 if err != nil {
8690 ec.Error(ctx, err)
8691 return graphql.Null
8692 }
8693 if resTmp == nil {
8694 if !graphql.HasFieldError(ctx, fc) {
8695 ec.Errorf(ctx, "must not be null")
8696 }
8697 return graphql.Null
8698 }
8699 res := resTmp.(*time.Time)
8700 fc.Result = res
8701 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8702}
8703
8704func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8705 defer func() {
8706 if r := recover(); r != nil {
8707 ec.Error(ctx, ec.Recover(ctx, r))
8708 ret = graphql.Null
8709 }
8710 }()
8711 fc := &graphql.FieldContext{
8712 Object: "SetStatusTimelineItem",
8713 Field: field,
8714 Args: nil,
8715 IsMethod: true,
8716 }
8717
8718 ctx = graphql.WithFieldContext(ctx, fc)
8719 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8720 ctx = rctx // use context from middleware stack in children
8721 return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
8722 })
8723 if err != nil {
8724 ec.Error(ctx, err)
8725 return graphql.Null
8726 }
8727 if resTmp == nil {
8728 if !graphql.HasFieldError(ctx, fc) {
8729 ec.Errorf(ctx, "must not be null")
8730 }
8731 return graphql.Null
8732 }
8733 res := resTmp.(models.Status)
8734 fc.Result = res
8735 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8736}
8737
8738func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8739 defer func() {
8740 if r := recover(); r != nil {
8741 ec.Error(ctx, ec.Recover(ctx, r))
8742 ret = graphql.Null
8743 }
8744 }()
8745 fc := &graphql.FieldContext{
8746 Object: "SetTitleOperation",
8747 Field: field,
8748 Args: nil,
8749 IsMethod: true,
8750 }
8751
8752 ctx = graphql.WithFieldContext(ctx, fc)
8753 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8754 ctx = rctx // use context from middleware stack in children
8755 return ec.resolvers.SetTitleOperation().ID(rctx, obj)
8756 })
8757 if err != nil {
8758 ec.Error(ctx, err)
8759 return graphql.Null
8760 }
8761 if resTmp == nil {
8762 if !graphql.HasFieldError(ctx, fc) {
8763 ec.Errorf(ctx, "must not be null")
8764 }
8765 return graphql.Null
8766 }
8767 res := resTmp.(string)
8768 fc.Result = res
8769 return ec.marshalNString2string(ctx, field.Selections, res)
8770}
8771
8772func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8773 defer func() {
8774 if r := recover(); r != nil {
8775 ec.Error(ctx, ec.Recover(ctx, r))
8776 ret = graphql.Null
8777 }
8778 }()
8779 fc := &graphql.FieldContext{
8780 Object: "SetTitleOperation",
8781 Field: field,
8782 Args: nil,
8783 IsMethod: false,
8784 }
8785
8786 ctx = graphql.WithFieldContext(ctx, fc)
8787 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8788 ctx = rctx // use context from middleware stack in children
8789 return obj.Author, nil
8790 })
8791 if err != nil {
8792 ec.Error(ctx, err)
8793 return graphql.Null
8794 }
8795 if resTmp == nil {
8796 if !graphql.HasFieldError(ctx, fc) {
8797 ec.Errorf(ctx, "must not be null")
8798 }
8799 return graphql.Null
8800 }
8801 res := resTmp.(identity.Interface)
8802 fc.Result = res
8803 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
8804}
8805
8806func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8807 defer func() {
8808 if r := recover(); r != nil {
8809 ec.Error(ctx, ec.Recover(ctx, r))
8810 ret = graphql.Null
8811 }
8812 }()
8813 fc := &graphql.FieldContext{
8814 Object: "SetTitleOperation",
8815 Field: field,
8816 Args: nil,
8817 IsMethod: true,
8818 }
8819
8820 ctx = graphql.WithFieldContext(ctx, fc)
8821 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8822 ctx = rctx // use context from middleware stack in children
8823 return ec.resolvers.SetTitleOperation().Date(rctx, obj)
8824 })
8825 if err != nil {
8826 ec.Error(ctx, err)
8827 return graphql.Null
8828 }
8829 if resTmp == nil {
8830 if !graphql.HasFieldError(ctx, fc) {
8831 ec.Errorf(ctx, "must not be null")
8832 }
8833 return graphql.Null
8834 }
8835 res := resTmp.(*time.Time)
8836 fc.Result = res
8837 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8838}
8839
8840func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8841 defer func() {
8842 if r := recover(); r != nil {
8843 ec.Error(ctx, ec.Recover(ctx, r))
8844 ret = graphql.Null
8845 }
8846 }()
8847 fc := &graphql.FieldContext{
8848 Object: "SetTitleOperation",
8849 Field: field,
8850 Args: nil,
8851 IsMethod: false,
8852 }
8853
8854 ctx = graphql.WithFieldContext(ctx, fc)
8855 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8856 ctx = rctx // use context from middleware stack in children
8857 return obj.Title, nil
8858 })
8859 if err != nil {
8860 ec.Error(ctx, err)
8861 return graphql.Null
8862 }
8863 if resTmp == nil {
8864 if !graphql.HasFieldError(ctx, fc) {
8865 ec.Errorf(ctx, "must not be null")
8866 }
8867 return graphql.Null
8868 }
8869 res := resTmp.(string)
8870 fc.Result = res
8871 return ec.marshalNString2string(ctx, field.Selections, res)
8872}
8873
8874func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8875 defer func() {
8876 if r := recover(); r != nil {
8877 ec.Error(ctx, ec.Recover(ctx, r))
8878 ret = graphql.Null
8879 }
8880 }()
8881 fc := &graphql.FieldContext{
8882 Object: "SetTitleOperation",
8883 Field: field,
8884 Args: nil,
8885 IsMethod: false,
8886 }
8887
8888 ctx = graphql.WithFieldContext(ctx, fc)
8889 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8890 ctx = rctx // use context from middleware stack in children
8891 return obj.Was, nil
8892 })
8893 if err != nil {
8894 ec.Error(ctx, err)
8895 return graphql.Null
8896 }
8897 if resTmp == nil {
8898 if !graphql.HasFieldError(ctx, fc) {
8899 ec.Errorf(ctx, "must not be null")
8900 }
8901 return graphql.Null
8902 }
8903 res := resTmp.(string)
8904 fc.Result = res
8905 return ec.marshalNString2string(ctx, field.Selections, res)
8906}
8907
8908func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8909 defer func() {
8910 if r := recover(); r != nil {
8911 ec.Error(ctx, ec.Recover(ctx, r))
8912 ret = graphql.Null
8913 }
8914 }()
8915 fc := &graphql.FieldContext{
8916 Object: "SetTitlePayload",
8917 Field: field,
8918 Args: nil,
8919 IsMethod: false,
8920 }
8921
8922 ctx = graphql.WithFieldContext(ctx, fc)
8923 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8924 ctx = rctx // use context from middleware stack in children
8925 return obj.ClientMutationID, nil
8926 })
8927 if err != nil {
8928 ec.Error(ctx, err)
8929 return graphql.Null
8930 }
8931 if resTmp == nil {
8932 return graphql.Null
8933 }
8934 res := resTmp.(*string)
8935 fc.Result = res
8936 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8937}
8938
8939func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8940 defer func() {
8941 if r := recover(); r != nil {
8942 ec.Error(ctx, ec.Recover(ctx, r))
8943 ret = graphql.Null
8944 }
8945 }()
8946 fc := &graphql.FieldContext{
8947 Object: "SetTitlePayload",
8948 Field: field,
8949 Args: nil,
8950 IsMethod: false,
8951 }
8952
8953 ctx = graphql.WithFieldContext(ctx, fc)
8954 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8955 ctx = rctx // use context from middleware stack in children
8956 return obj.Bug, nil
8957 })
8958 if err != nil {
8959 ec.Error(ctx, err)
8960 return graphql.Null
8961 }
8962 if resTmp == nil {
8963 if !graphql.HasFieldError(ctx, fc) {
8964 ec.Errorf(ctx, "must not be null")
8965 }
8966 return graphql.Null
8967 }
8968 res := resTmp.(*bug.Snapshot)
8969 fc.Result = res
8970 return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
8971}
8972
8973func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8974 defer func() {
8975 if r := recover(); r != nil {
8976 ec.Error(ctx, ec.Recover(ctx, r))
8977 ret = graphql.Null
8978 }
8979 }()
8980 fc := &graphql.FieldContext{
8981 Object: "SetTitlePayload",
8982 Field: field,
8983 Args: nil,
8984 IsMethod: false,
8985 }
8986
8987 ctx = graphql.WithFieldContext(ctx, fc)
8988 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8989 ctx = rctx // use context from middleware stack in children
8990 return obj.Operation, nil
8991 })
8992 if err != nil {
8993 ec.Error(ctx, err)
8994 return graphql.Null
8995 }
8996 if resTmp == nil {
8997 if !graphql.HasFieldError(ctx, fc) {
8998 ec.Errorf(ctx, "must not be null")
8999 }
9000 return graphql.Null
9001 }
9002 res := resTmp.(*bug.SetTitleOperation)
9003 fc.Result = res
9004 return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
9005}
9006
9007func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9008 defer func() {
9009 if r := recover(); r != nil {
9010 ec.Error(ctx, ec.Recover(ctx, r))
9011 ret = graphql.Null
9012 }
9013 }()
9014 fc := &graphql.FieldContext{
9015 Object: "SetTitleTimelineItem",
9016 Field: field,
9017 Args: nil,
9018 IsMethod: true,
9019 }
9020
9021 ctx = graphql.WithFieldContext(ctx, fc)
9022 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9023 ctx = rctx // use context from middleware stack in children
9024 return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
9025 })
9026 if err != nil {
9027 ec.Error(ctx, err)
9028 return graphql.Null
9029 }
9030 if resTmp == nil {
9031 if !graphql.HasFieldError(ctx, fc) {
9032 ec.Errorf(ctx, "must not be null")
9033 }
9034 return graphql.Null
9035 }
9036 res := resTmp.(string)
9037 fc.Result = res
9038 return ec.marshalNString2string(ctx, field.Selections, res)
9039}
9040
9041func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9042 defer func() {
9043 if r := recover(); r != nil {
9044 ec.Error(ctx, ec.Recover(ctx, r))
9045 ret = graphql.Null
9046 }
9047 }()
9048 fc := &graphql.FieldContext{
9049 Object: "SetTitleTimelineItem",
9050 Field: field,
9051 Args: nil,
9052 IsMethod: false,
9053 }
9054
9055 ctx = graphql.WithFieldContext(ctx, fc)
9056 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9057 ctx = rctx // use context from middleware stack in children
9058 return obj.Author, nil
9059 })
9060 if err != nil {
9061 ec.Error(ctx, err)
9062 return graphql.Null
9063 }
9064 if resTmp == nil {
9065 if !graphql.HasFieldError(ctx, fc) {
9066 ec.Errorf(ctx, "must not be null")
9067 }
9068 return graphql.Null
9069 }
9070 res := resTmp.(identity.Interface)
9071 fc.Result = res
9072 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
9073}
9074
9075func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9076 defer func() {
9077 if r := recover(); r != nil {
9078 ec.Error(ctx, ec.Recover(ctx, r))
9079 ret = graphql.Null
9080 }
9081 }()
9082 fc := &graphql.FieldContext{
9083 Object: "SetTitleTimelineItem",
9084 Field: field,
9085 Args: nil,
9086 IsMethod: true,
9087 }
9088
9089 ctx = graphql.WithFieldContext(ctx, fc)
9090 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9091 ctx = rctx // use context from middleware stack in children
9092 return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
9093 })
9094 if err != nil {
9095 ec.Error(ctx, err)
9096 return graphql.Null
9097 }
9098 if resTmp == nil {
9099 if !graphql.HasFieldError(ctx, fc) {
9100 ec.Errorf(ctx, "must not be null")
9101 }
9102 return graphql.Null
9103 }
9104 res := resTmp.(*time.Time)
9105 fc.Result = res
9106 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
9107}
9108
9109func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9110 defer func() {
9111 if r := recover(); r != nil {
9112 ec.Error(ctx, ec.Recover(ctx, r))
9113 ret = graphql.Null
9114 }
9115 }()
9116 fc := &graphql.FieldContext{
9117 Object: "SetTitleTimelineItem",
9118 Field: field,
9119 Args: nil,
9120 IsMethod: false,
9121 }
9122
9123 ctx = graphql.WithFieldContext(ctx, fc)
9124 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9125 ctx = rctx // use context from middleware stack in children
9126 return obj.Title, nil
9127 })
9128 if err != nil {
9129 ec.Error(ctx, err)
9130 return graphql.Null
9131 }
9132 if resTmp == nil {
9133 if !graphql.HasFieldError(ctx, fc) {
9134 ec.Errorf(ctx, "must not be null")
9135 }
9136 return graphql.Null
9137 }
9138 res := resTmp.(string)
9139 fc.Result = res
9140 return ec.marshalNString2string(ctx, field.Selections, res)
9141}
9142
9143func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9144 defer func() {
9145 if r := recover(); r != nil {
9146 ec.Error(ctx, ec.Recover(ctx, r))
9147 ret = graphql.Null
9148 }
9149 }()
9150 fc := &graphql.FieldContext{
9151 Object: "SetTitleTimelineItem",
9152 Field: field,
9153 Args: nil,
9154 IsMethod: false,
9155 }
9156
9157 ctx = graphql.WithFieldContext(ctx, fc)
9158 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9159 ctx = rctx // use context from middleware stack in children
9160 return obj.Was, nil
9161 })
9162 if err != nil {
9163 ec.Error(ctx, err)
9164 return graphql.Null
9165 }
9166 if resTmp == nil {
9167 if !graphql.HasFieldError(ctx, fc) {
9168 ec.Errorf(ctx, "must not be null")
9169 }
9170 return graphql.Null
9171 }
9172 res := resTmp.(string)
9173 fc.Result = res
9174 return ec.marshalNString2string(ctx, field.Selections, res)
9175}
9176
9177func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9178 defer func() {
9179 if r := recover(); r != nil {
9180 ec.Error(ctx, ec.Recover(ctx, r))
9181 ret = graphql.Null
9182 }
9183 }()
9184 fc := &graphql.FieldContext{
9185 Object: "TimelineItemConnection",
9186 Field: field,
9187 Args: nil,
9188 IsMethod: false,
9189 }
9190
9191 ctx = graphql.WithFieldContext(ctx, fc)
9192 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9193 ctx = rctx // use context from middleware stack in children
9194 return obj.Edges, nil
9195 })
9196 if err != nil {
9197 ec.Error(ctx, err)
9198 return graphql.Null
9199 }
9200 if resTmp == nil {
9201 if !graphql.HasFieldError(ctx, fc) {
9202 ec.Errorf(ctx, "must not be null")
9203 }
9204 return graphql.Null
9205 }
9206 res := resTmp.([]*models.TimelineItemEdge)
9207 fc.Result = res
9208 return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
9209}
9210
9211func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9212 defer func() {
9213 if r := recover(); r != nil {
9214 ec.Error(ctx, ec.Recover(ctx, r))
9215 ret = graphql.Null
9216 }
9217 }()
9218 fc := &graphql.FieldContext{
9219 Object: "TimelineItemConnection",
9220 Field: field,
9221 Args: nil,
9222 IsMethod: false,
9223 }
9224
9225 ctx = graphql.WithFieldContext(ctx, fc)
9226 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9227 ctx = rctx // use context from middleware stack in children
9228 return obj.Nodes, nil
9229 })
9230 if err != nil {
9231 ec.Error(ctx, err)
9232 return graphql.Null
9233 }
9234 if resTmp == nil {
9235 if !graphql.HasFieldError(ctx, fc) {
9236 ec.Errorf(ctx, "must not be null")
9237 }
9238 return graphql.Null
9239 }
9240 res := resTmp.([]bug.TimelineItem)
9241 fc.Result = res
9242 return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
9243}
9244
9245func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9246 defer func() {
9247 if r := recover(); r != nil {
9248 ec.Error(ctx, ec.Recover(ctx, r))
9249 ret = graphql.Null
9250 }
9251 }()
9252 fc := &graphql.FieldContext{
9253 Object: "TimelineItemConnection",
9254 Field: field,
9255 Args: nil,
9256 IsMethod: false,
9257 }
9258
9259 ctx = graphql.WithFieldContext(ctx, fc)
9260 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9261 ctx = rctx // use context from middleware stack in children
9262 return obj.PageInfo, nil
9263 })
9264 if err != nil {
9265 ec.Error(ctx, err)
9266 return graphql.Null
9267 }
9268 if resTmp == nil {
9269 if !graphql.HasFieldError(ctx, fc) {
9270 ec.Errorf(ctx, "must not be null")
9271 }
9272 return graphql.Null
9273 }
9274 res := resTmp.(*models.PageInfo)
9275 fc.Result = res
9276 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
9277}
9278
9279func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9280 defer func() {
9281 if r := recover(); r != nil {
9282 ec.Error(ctx, ec.Recover(ctx, r))
9283 ret = graphql.Null
9284 }
9285 }()
9286 fc := &graphql.FieldContext{
9287 Object: "TimelineItemConnection",
9288 Field: field,
9289 Args: nil,
9290 IsMethod: false,
9291 }
9292
9293 ctx = graphql.WithFieldContext(ctx, fc)
9294 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9295 ctx = rctx // use context from middleware stack in children
9296 return obj.TotalCount, nil
9297 })
9298 if err != nil {
9299 ec.Error(ctx, err)
9300 return graphql.Null
9301 }
9302 if resTmp == nil {
9303 if !graphql.HasFieldError(ctx, fc) {
9304 ec.Errorf(ctx, "must not be null")
9305 }
9306 return graphql.Null
9307 }
9308 res := resTmp.(int)
9309 fc.Result = res
9310 return ec.marshalNInt2int(ctx, field.Selections, res)
9311}
9312
9313func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9314 defer func() {
9315 if r := recover(); r != nil {
9316 ec.Error(ctx, ec.Recover(ctx, r))
9317 ret = graphql.Null
9318 }
9319 }()
9320 fc := &graphql.FieldContext{
9321 Object: "TimelineItemEdge",
9322 Field: field,
9323 Args: nil,
9324 IsMethod: false,
9325 }
9326
9327 ctx = graphql.WithFieldContext(ctx, fc)
9328 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9329 ctx = rctx // use context from middleware stack in children
9330 return obj.Cursor, nil
9331 })
9332 if err != nil {
9333 ec.Error(ctx, err)
9334 return graphql.Null
9335 }
9336 if resTmp == nil {
9337 if !graphql.HasFieldError(ctx, fc) {
9338 ec.Errorf(ctx, "must not be null")
9339 }
9340 return graphql.Null
9341 }
9342 res := resTmp.(string)
9343 fc.Result = res
9344 return ec.marshalNString2string(ctx, field.Selections, res)
9345}
9346
9347func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9348 defer func() {
9349 if r := recover(); r != nil {
9350 ec.Error(ctx, ec.Recover(ctx, r))
9351 ret = graphql.Null
9352 }
9353 }()
9354 fc := &graphql.FieldContext{
9355 Object: "TimelineItemEdge",
9356 Field: field,
9357 Args: nil,
9358 IsMethod: false,
9359 }
9360
9361 ctx = graphql.WithFieldContext(ctx, fc)
9362 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9363 ctx = rctx // use context from middleware stack in children
9364 return obj.Node, nil
9365 })
9366 if err != nil {
9367 ec.Error(ctx, err)
9368 return graphql.Null
9369 }
9370 if resTmp == nil {
9371 if !graphql.HasFieldError(ctx, fc) {
9372 ec.Errorf(ctx, "must not be null")
9373 }
9374 return graphql.Null
9375 }
9376 res := resTmp.(bug.TimelineItem)
9377 fc.Result = res
9378 return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
9379}
9380
9381func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9382 defer func() {
9383 if r := recover(); r != nil {
9384 ec.Error(ctx, ec.Recover(ctx, r))
9385 ret = graphql.Null
9386 }
9387 }()
9388 fc := &graphql.FieldContext{
9389 Object: "__Directive",
9390 Field: field,
9391 Args: nil,
9392 IsMethod: false,
9393 }
9394
9395 ctx = graphql.WithFieldContext(ctx, fc)
9396 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9397 ctx = rctx // use context from middleware stack in children
9398 return obj.Name, nil
9399 })
9400 if err != nil {
9401 ec.Error(ctx, err)
9402 return graphql.Null
9403 }
9404 if resTmp == nil {
9405 if !graphql.HasFieldError(ctx, fc) {
9406 ec.Errorf(ctx, "must not be null")
9407 }
9408 return graphql.Null
9409 }
9410 res := resTmp.(string)
9411 fc.Result = res
9412 return ec.marshalNString2string(ctx, field.Selections, res)
9413}
9414
9415func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9416 defer func() {
9417 if r := recover(); r != nil {
9418 ec.Error(ctx, ec.Recover(ctx, r))
9419 ret = graphql.Null
9420 }
9421 }()
9422 fc := &graphql.FieldContext{
9423 Object: "__Directive",
9424 Field: field,
9425 Args: nil,
9426 IsMethod: false,
9427 }
9428
9429 ctx = graphql.WithFieldContext(ctx, fc)
9430 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9431 ctx = rctx // use context from middleware stack in children
9432 return obj.Description, nil
9433 })
9434 if err != nil {
9435 ec.Error(ctx, err)
9436 return graphql.Null
9437 }
9438 if resTmp == nil {
9439 return graphql.Null
9440 }
9441 res := resTmp.(string)
9442 fc.Result = res
9443 return ec.marshalOString2string(ctx, field.Selections, res)
9444}
9445
9446func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9447 defer func() {
9448 if r := recover(); r != nil {
9449 ec.Error(ctx, ec.Recover(ctx, r))
9450 ret = graphql.Null
9451 }
9452 }()
9453 fc := &graphql.FieldContext{
9454 Object: "__Directive",
9455 Field: field,
9456 Args: nil,
9457 IsMethod: false,
9458 }
9459
9460 ctx = graphql.WithFieldContext(ctx, fc)
9461 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9462 ctx = rctx // use context from middleware stack in children
9463 return obj.Locations, nil
9464 })
9465 if err != nil {
9466 ec.Error(ctx, err)
9467 return graphql.Null
9468 }
9469 if resTmp == nil {
9470 if !graphql.HasFieldError(ctx, fc) {
9471 ec.Errorf(ctx, "must not be null")
9472 }
9473 return graphql.Null
9474 }
9475 res := resTmp.([]string)
9476 fc.Result = res
9477 return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
9478}
9479
9480func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9481 defer func() {
9482 if r := recover(); r != nil {
9483 ec.Error(ctx, ec.Recover(ctx, r))
9484 ret = graphql.Null
9485 }
9486 }()
9487 fc := &graphql.FieldContext{
9488 Object: "__Directive",
9489 Field: field,
9490 Args: nil,
9491 IsMethod: false,
9492 }
9493
9494 ctx = graphql.WithFieldContext(ctx, fc)
9495 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9496 ctx = rctx // use context from middleware stack in children
9497 return obj.Args, nil
9498 })
9499 if err != nil {
9500 ec.Error(ctx, err)
9501 return graphql.Null
9502 }
9503 if resTmp == nil {
9504 if !graphql.HasFieldError(ctx, fc) {
9505 ec.Errorf(ctx, "must not be null")
9506 }
9507 return graphql.Null
9508 }
9509 res := resTmp.([]introspection.InputValue)
9510 fc.Result = res
9511 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
9512}
9513
9514func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9515 defer func() {
9516 if r := recover(); r != nil {
9517 ec.Error(ctx, ec.Recover(ctx, r))
9518 ret = graphql.Null
9519 }
9520 }()
9521 fc := &graphql.FieldContext{
9522 Object: "__EnumValue",
9523 Field: field,
9524 Args: nil,
9525 IsMethod: false,
9526 }
9527
9528 ctx = graphql.WithFieldContext(ctx, fc)
9529 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9530 ctx = rctx // use context from middleware stack in children
9531 return obj.Name, nil
9532 })
9533 if err != nil {
9534 ec.Error(ctx, err)
9535 return graphql.Null
9536 }
9537 if resTmp == nil {
9538 if !graphql.HasFieldError(ctx, fc) {
9539 ec.Errorf(ctx, "must not be null")
9540 }
9541 return graphql.Null
9542 }
9543 res := resTmp.(string)
9544 fc.Result = res
9545 return ec.marshalNString2string(ctx, field.Selections, res)
9546}
9547
9548func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9549 defer func() {
9550 if r := recover(); r != nil {
9551 ec.Error(ctx, ec.Recover(ctx, r))
9552 ret = graphql.Null
9553 }
9554 }()
9555 fc := &graphql.FieldContext{
9556 Object: "__EnumValue",
9557 Field: field,
9558 Args: nil,
9559 IsMethod: false,
9560 }
9561
9562 ctx = graphql.WithFieldContext(ctx, fc)
9563 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9564 ctx = rctx // use context from middleware stack in children
9565 return obj.Description, nil
9566 })
9567 if err != nil {
9568 ec.Error(ctx, err)
9569 return graphql.Null
9570 }
9571 if resTmp == nil {
9572 return graphql.Null
9573 }
9574 res := resTmp.(string)
9575 fc.Result = res
9576 return ec.marshalOString2string(ctx, field.Selections, res)
9577}
9578
9579func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9580 defer func() {
9581 if r := recover(); r != nil {
9582 ec.Error(ctx, ec.Recover(ctx, r))
9583 ret = graphql.Null
9584 }
9585 }()
9586 fc := &graphql.FieldContext{
9587 Object: "__EnumValue",
9588 Field: field,
9589 Args: nil,
9590 IsMethod: true,
9591 }
9592
9593 ctx = graphql.WithFieldContext(ctx, fc)
9594 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9595 ctx = rctx // use context from middleware stack in children
9596 return obj.IsDeprecated(), nil
9597 })
9598 if err != nil {
9599 ec.Error(ctx, err)
9600 return graphql.Null
9601 }
9602 if resTmp == nil {
9603 if !graphql.HasFieldError(ctx, fc) {
9604 ec.Errorf(ctx, "must not be null")
9605 }
9606 return graphql.Null
9607 }
9608 res := resTmp.(bool)
9609 fc.Result = res
9610 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9611}
9612
9613func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9614 defer func() {
9615 if r := recover(); r != nil {
9616 ec.Error(ctx, ec.Recover(ctx, r))
9617 ret = graphql.Null
9618 }
9619 }()
9620 fc := &graphql.FieldContext{
9621 Object: "__EnumValue",
9622 Field: field,
9623 Args: nil,
9624 IsMethod: true,
9625 }
9626
9627 ctx = graphql.WithFieldContext(ctx, fc)
9628 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9629 ctx = rctx // use context from middleware stack in children
9630 return obj.DeprecationReason(), nil
9631 })
9632 if err != nil {
9633 ec.Error(ctx, err)
9634 return graphql.Null
9635 }
9636 if resTmp == nil {
9637 return graphql.Null
9638 }
9639 res := resTmp.(*string)
9640 fc.Result = res
9641 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9642}
9643
9644func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9645 defer func() {
9646 if r := recover(); r != nil {
9647 ec.Error(ctx, ec.Recover(ctx, r))
9648 ret = graphql.Null
9649 }
9650 }()
9651 fc := &graphql.FieldContext{
9652 Object: "__Field",
9653 Field: field,
9654 Args: nil,
9655 IsMethod: false,
9656 }
9657
9658 ctx = graphql.WithFieldContext(ctx, fc)
9659 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9660 ctx = rctx // use context from middleware stack in children
9661 return obj.Name, nil
9662 })
9663 if err != nil {
9664 ec.Error(ctx, err)
9665 return graphql.Null
9666 }
9667 if resTmp == nil {
9668 if !graphql.HasFieldError(ctx, fc) {
9669 ec.Errorf(ctx, "must not be null")
9670 }
9671 return graphql.Null
9672 }
9673 res := resTmp.(string)
9674 fc.Result = res
9675 return ec.marshalNString2string(ctx, field.Selections, res)
9676}
9677
9678func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9679 defer func() {
9680 if r := recover(); r != nil {
9681 ec.Error(ctx, ec.Recover(ctx, r))
9682 ret = graphql.Null
9683 }
9684 }()
9685 fc := &graphql.FieldContext{
9686 Object: "__Field",
9687 Field: field,
9688 Args: nil,
9689 IsMethod: false,
9690 }
9691
9692 ctx = graphql.WithFieldContext(ctx, fc)
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.Description, nil
9696 })
9697 if err != nil {
9698 ec.Error(ctx, err)
9699 return graphql.Null
9700 }
9701 if resTmp == nil {
9702 return graphql.Null
9703 }
9704 res := resTmp.(string)
9705 fc.Result = res
9706 return ec.marshalOString2string(ctx, field.Selections, res)
9707}
9708
9709func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9710 defer func() {
9711 if r := recover(); r != nil {
9712 ec.Error(ctx, ec.Recover(ctx, r))
9713 ret = graphql.Null
9714 }
9715 }()
9716 fc := &graphql.FieldContext{
9717 Object: "__Field",
9718 Field: field,
9719 Args: nil,
9720 IsMethod: false,
9721 }
9722
9723 ctx = graphql.WithFieldContext(ctx, fc)
9724 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9725 ctx = rctx // use context from middleware stack in children
9726 return obj.Args, nil
9727 })
9728 if err != nil {
9729 ec.Error(ctx, err)
9730 return graphql.Null
9731 }
9732 if resTmp == nil {
9733 if !graphql.HasFieldError(ctx, fc) {
9734 ec.Errorf(ctx, "must not be null")
9735 }
9736 return graphql.Null
9737 }
9738 res := resTmp.([]introspection.InputValue)
9739 fc.Result = res
9740 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
9741}
9742
9743func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9744 defer func() {
9745 if r := recover(); r != nil {
9746 ec.Error(ctx, ec.Recover(ctx, r))
9747 ret = graphql.Null
9748 }
9749 }()
9750 fc := &graphql.FieldContext{
9751 Object: "__Field",
9752 Field: field,
9753 Args: nil,
9754 IsMethod: false,
9755 }
9756
9757 ctx = graphql.WithFieldContext(ctx, fc)
9758 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9759 ctx = rctx // use context from middleware stack in children
9760 return obj.Type, nil
9761 })
9762 if err != nil {
9763 ec.Error(ctx, err)
9764 return graphql.Null
9765 }
9766 if resTmp == nil {
9767 if !graphql.HasFieldError(ctx, fc) {
9768 ec.Errorf(ctx, "must not be null")
9769 }
9770 return graphql.Null
9771 }
9772 res := resTmp.(*introspection.Type)
9773 fc.Result = res
9774 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9775}
9776
9777func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9778 defer func() {
9779 if r := recover(); r != nil {
9780 ec.Error(ctx, ec.Recover(ctx, r))
9781 ret = graphql.Null
9782 }
9783 }()
9784 fc := &graphql.FieldContext{
9785 Object: "__Field",
9786 Field: field,
9787 Args: nil,
9788 IsMethod: true,
9789 }
9790
9791 ctx = graphql.WithFieldContext(ctx, fc)
9792 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9793 ctx = rctx // use context from middleware stack in children
9794 return obj.IsDeprecated(), nil
9795 })
9796 if err != nil {
9797 ec.Error(ctx, err)
9798 return graphql.Null
9799 }
9800 if resTmp == nil {
9801 if !graphql.HasFieldError(ctx, fc) {
9802 ec.Errorf(ctx, "must not be null")
9803 }
9804 return graphql.Null
9805 }
9806 res := resTmp.(bool)
9807 fc.Result = res
9808 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9809}
9810
9811func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9812 defer func() {
9813 if r := recover(); r != nil {
9814 ec.Error(ctx, ec.Recover(ctx, r))
9815 ret = graphql.Null
9816 }
9817 }()
9818 fc := &graphql.FieldContext{
9819 Object: "__Field",
9820 Field: field,
9821 Args: nil,
9822 IsMethod: true,
9823 }
9824
9825 ctx = graphql.WithFieldContext(ctx, fc)
9826 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9827 ctx = rctx // use context from middleware stack in children
9828 return obj.DeprecationReason(), nil
9829 })
9830 if err != nil {
9831 ec.Error(ctx, err)
9832 return graphql.Null
9833 }
9834 if resTmp == nil {
9835 return graphql.Null
9836 }
9837 res := resTmp.(*string)
9838 fc.Result = res
9839 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9840}
9841
9842func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9843 defer func() {
9844 if r := recover(); r != nil {
9845 ec.Error(ctx, ec.Recover(ctx, r))
9846 ret = graphql.Null
9847 }
9848 }()
9849 fc := &graphql.FieldContext{
9850 Object: "__InputValue",
9851 Field: field,
9852 Args: nil,
9853 IsMethod: false,
9854 }
9855
9856 ctx = graphql.WithFieldContext(ctx, fc)
9857 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9858 ctx = rctx // use context from middleware stack in children
9859 return obj.Name, nil
9860 })
9861 if err != nil {
9862 ec.Error(ctx, err)
9863 return graphql.Null
9864 }
9865 if resTmp == nil {
9866 if !graphql.HasFieldError(ctx, fc) {
9867 ec.Errorf(ctx, "must not be null")
9868 }
9869 return graphql.Null
9870 }
9871 res := resTmp.(string)
9872 fc.Result = res
9873 return ec.marshalNString2string(ctx, field.Selections, res)
9874}
9875
9876func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9877 defer func() {
9878 if r := recover(); r != nil {
9879 ec.Error(ctx, ec.Recover(ctx, r))
9880 ret = graphql.Null
9881 }
9882 }()
9883 fc := &graphql.FieldContext{
9884 Object: "__InputValue",
9885 Field: field,
9886 Args: nil,
9887 IsMethod: false,
9888 }
9889
9890 ctx = graphql.WithFieldContext(ctx, fc)
9891 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9892 ctx = rctx // use context from middleware stack in children
9893 return obj.Description, nil
9894 })
9895 if err != nil {
9896 ec.Error(ctx, err)
9897 return graphql.Null
9898 }
9899 if resTmp == nil {
9900 return graphql.Null
9901 }
9902 res := resTmp.(string)
9903 fc.Result = res
9904 return ec.marshalOString2string(ctx, field.Selections, res)
9905}
9906
9907func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9908 defer func() {
9909 if r := recover(); r != nil {
9910 ec.Error(ctx, ec.Recover(ctx, r))
9911 ret = graphql.Null
9912 }
9913 }()
9914 fc := &graphql.FieldContext{
9915 Object: "__InputValue",
9916 Field: field,
9917 Args: nil,
9918 IsMethod: false,
9919 }
9920
9921 ctx = graphql.WithFieldContext(ctx, fc)
9922 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9923 ctx = rctx // use context from middleware stack in children
9924 return obj.Type, nil
9925 })
9926 if err != nil {
9927 ec.Error(ctx, err)
9928 return graphql.Null
9929 }
9930 if resTmp == nil {
9931 if !graphql.HasFieldError(ctx, fc) {
9932 ec.Errorf(ctx, "must not be null")
9933 }
9934 return graphql.Null
9935 }
9936 res := resTmp.(*introspection.Type)
9937 fc.Result = res
9938 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9939}
9940
9941func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9942 defer func() {
9943 if r := recover(); r != nil {
9944 ec.Error(ctx, ec.Recover(ctx, r))
9945 ret = graphql.Null
9946 }
9947 }()
9948 fc := &graphql.FieldContext{
9949 Object: "__InputValue",
9950 Field: field,
9951 Args: nil,
9952 IsMethod: false,
9953 }
9954
9955 ctx = graphql.WithFieldContext(ctx, fc)
9956 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9957 ctx = rctx // use context from middleware stack in children
9958 return obj.DefaultValue, nil
9959 })
9960 if err != nil {
9961 ec.Error(ctx, err)
9962 return graphql.Null
9963 }
9964 if resTmp == nil {
9965 return graphql.Null
9966 }
9967 res := resTmp.(*string)
9968 fc.Result = res
9969 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9970}
9971
9972func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
9973 defer func() {
9974 if r := recover(); r != nil {
9975 ec.Error(ctx, ec.Recover(ctx, r))
9976 ret = graphql.Null
9977 }
9978 }()
9979 fc := &graphql.FieldContext{
9980 Object: "__Schema",
9981 Field: field,
9982 Args: nil,
9983 IsMethod: true,
9984 }
9985
9986 ctx = graphql.WithFieldContext(ctx, fc)
9987 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9988 ctx = rctx // use context from middleware stack in children
9989 return obj.Types(), nil
9990 })
9991 if err != nil {
9992 ec.Error(ctx, err)
9993 return graphql.Null
9994 }
9995 if resTmp == nil {
9996 if !graphql.HasFieldError(ctx, fc) {
9997 ec.Errorf(ctx, "must not be null")
9998 }
9999 return graphql.Null
10000 }
10001 res := resTmp.([]introspection.Type)
10002 fc.Result = res
10003 return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10004}
10005
10006func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10007 defer func() {
10008 if r := recover(); r != nil {
10009 ec.Error(ctx, ec.Recover(ctx, r))
10010 ret = graphql.Null
10011 }
10012 }()
10013 fc := &graphql.FieldContext{
10014 Object: "__Schema",
10015 Field: field,
10016 Args: nil,
10017 IsMethod: true,
10018 }
10019
10020 ctx = graphql.WithFieldContext(ctx, fc)
10021 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10022 ctx = rctx // use context from middleware stack in children
10023 return obj.QueryType(), nil
10024 })
10025 if err != nil {
10026 ec.Error(ctx, err)
10027 return graphql.Null
10028 }
10029 if resTmp == nil {
10030 if !graphql.HasFieldError(ctx, fc) {
10031 ec.Errorf(ctx, "must not be null")
10032 }
10033 return graphql.Null
10034 }
10035 res := resTmp.(*introspection.Type)
10036 fc.Result = res
10037 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10038}
10039
10040func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10041 defer func() {
10042 if r := recover(); r != nil {
10043 ec.Error(ctx, ec.Recover(ctx, r))
10044 ret = graphql.Null
10045 }
10046 }()
10047 fc := &graphql.FieldContext{
10048 Object: "__Schema",
10049 Field: field,
10050 Args: nil,
10051 IsMethod: true,
10052 }
10053
10054 ctx = graphql.WithFieldContext(ctx, fc)
10055 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10056 ctx = rctx // use context from middleware stack in children
10057 return obj.MutationType(), nil
10058 })
10059 if err != nil {
10060 ec.Error(ctx, err)
10061 return graphql.Null
10062 }
10063 if resTmp == nil {
10064 return graphql.Null
10065 }
10066 res := resTmp.(*introspection.Type)
10067 fc.Result = res
10068 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10069}
10070
10071func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10072 defer func() {
10073 if r := recover(); r != nil {
10074 ec.Error(ctx, ec.Recover(ctx, r))
10075 ret = graphql.Null
10076 }
10077 }()
10078 fc := &graphql.FieldContext{
10079 Object: "__Schema",
10080 Field: field,
10081 Args: nil,
10082 IsMethod: true,
10083 }
10084
10085 ctx = graphql.WithFieldContext(ctx, fc)
10086 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10087 ctx = rctx // use context from middleware stack in children
10088 return obj.SubscriptionType(), nil
10089 })
10090 if err != nil {
10091 ec.Error(ctx, err)
10092 return graphql.Null
10093 }
10094 if resTmp == nil {
10095 return graphql.Null
10096 }
10097 res := resTmp.(*introspection.Type)
10098 fc.Result = res
10099 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10100}
10101
10102func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10103 defer func() {
10104 if r := recover(); r != nil {
10105 ec.Error(ctx, ec.Recover(ctx, r))
10106 ret = graphql.Null
10107 }
10108 }()
10109 fc := &graphql.FieldContext{
10110 Object: "__Schema",
10111 Field: field,
10112 Args: nil,
10113 IsMethod: true,
10114 }
10115
10116 ctx = graphql.WithFieldContext(ctx, fc)
10117 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10118 ctx = rctx // use context from middleware stack in children
10119 return obj.Directives(), nil
10120 })
10121 if err != nil {
10122 ec.Error(ctx, err)
10123 return graphql.Null
10124 }
10125 if resTmp == nil {
10126 if !graphql.HasFieldError(ctx, fc) {
10127 ec.Errorf(ctx, "must not be null")
10128 }
10129 return graphql.Null
10130 }
10131 res := resTmp.([]introspection.Directive)
10132 fc.Result = res
10133 return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
10134}
10135
10136func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10137 defer func() {
10138 if r := recover(); r != nil {
10139 ec.Error(ctx, ec.Recover(ctx, r))
10140 ret = graphql.Null
10141 }
10142 }()
10143 fc := &graphql.FieldContext{
10144 Object: "__Type",
10145 Field: field,
10146 Args: nil,
10147 IsMethod: true,
10148 }
10149
10150 ctx = graphql.WithFieldContext(ctx, fc)
10151 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10152 ctx = rctx // use context from middleware stack in children
10153 return obj.Kind(), nil
10154 })
10155 if err != nil {
10156 ec.Error(ctx, err)
10157 return graphql.Null
10158 }
10159 if resTmp == nil {
10160 if !graphql.HasFieldError(ctx, fc) {
10161 ec.Errorf(ctx, "must not be null")
10162 }
10163 return graphql.Null
10164 }
10165 res := resTmp.(string)
10166 fc.Result = res
10167 return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
10168}
10169
10170func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10171 defer func() {
10172 if r := recover(); r != nil {
10173 ec.Error(ctx, ec.Recover(ctx, r))
10174 ret = graphql.Null
10175 }
10176 }()
10177 fc := &graphql.FieldContext{
10178 Object: "__Type",
10179 Field: field,
10180 Args: nil,
10181 IsMethod: true,
10182 }
10183
10184 ctx = graphql.WithFieldContext(ctx, fc)
10185 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10186 ctx = rctx // use context from middleware stack in children
10187 return obj.Name(), nil
10188 })
10189 if err != nil {
10190 ec.Error(ctx, err)
10191 return graphql.Null
10192 }
10193 if resTmp == nil {
10194 return graphql.Null
10195 }
10196 res := resTmp.(*string)
10197 fc.Result = res
10198 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10199}
10200
10201func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10202 defer func() {
10203 if r := recover(); r != nil {
10204 ec.Error(ctx, ec.Recover(ctx, r))
10205 ret = graphql.Null
10206 }
10207 }()
10208 fc := &graphql.FieldContext{
10209 Object: "__Type",
10210 Field: field,
10211 Args: nil,
10212 IsMethod: true,
10213 }
10214
10215 ctx = graphql.WithFieldContext(ctx, fc)
10216 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10217 ctx = rctx // use context from middleware stack in children
10218 return obj.Description(), nil
10219 })
10220 if err != nil {
10221 ec.Error(ctx, err)
10222 return graphql.Null
10223 }
10224 if resTmp == nil {
10225 return graphql.Null
10226 }
10227 res := resTmp.(string)
10228 fc.Result = res
10229 return ec.marshalOString2string(ctx, field.Selections, res)
10230}
10231
10232func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10233 defer func() {
10234 if r := recover(); r != nil {
10235 ec.Error(ctx, ec.Recover(ctx, r))
10236 ret = graphql.Null
10237 }
10238 }()
10239 fc := &graphql.FieldContext{
10240 Object: "__Type",
10241 Field: field,
10242 Args: nil,
10243 IsMethod: true,
10244 }
10245
10246 ctx = graphql.WithFieldContext(ctx, fc)
10247 rawArgs := field.ArgumentMap(ec.Variables)
10248 args, err := ec.field___Type_fields_args(ctx, rawArgs)
10249 if err != nil {
10250 ec.Error(ctx, err)
10251 return graphql.Null
10252 }
10253 fc.Args = args
10254 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10255 ctx = rctx // use context from middleware stack in children
10256 return obj.Fields(args["includeDeprecated"].(bool)), nil
10257 })
10258 if err != nil {
10259 ec.Error(ctx, err)
10260 return graphql.Null
10261 }
10262 if resTmp == nil {
10263 return graphql.Null
10264 }
10265 res := resTmp.([]introspection.Field)
10266 fc.Result = res
10267 return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
10268}
10269
10270func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10271 defer func() {
10272 if r := recover(); r != nil {
10273 ec.Error(ctx, ec.Recover(ctx, r))
10274 ret = graphql.Null
10275 }
10276 }()
10277 fc := &graphql.FieldContext{
10278 Object: "__Type",
10279 Field: field,
10280 Args: nil,
10281 IsMethod: true,
10282 }
10283
10284 ctx = graphql.WithFieldContext(ctx, fc)
10285 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10286 ctx = rctx // use context from middleware stack in children
10287 return obj.Interfaces(), nil
10288 })
10289 if err != nil {
10290 ec.Error(ctx, err)
10291 return graphql.Null
10292 }
10293 if resTmp == nil {
10294 return graphql.Null
10295 }
10296 res := resTmp.([]introspection.Type)
10297 fc.Result = res
10298 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10299}
10300
10301func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10302 defer func() {
10303 if r := recover(); r != nil {
10304 ec.Error(ctx, ec.Recover(ctx, r))
10305 ret = graphql.Null
10306 }
10307 }()
10308 fc := &graphql.FieldContext{
10309 Object: "__Type",
10310 Field: field,
10311 Args: nil,
10312 IsMethod: true,
10313 }
10314
10315 ctx = graphql.WithFieldContext(ctx, fc)
10316 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10317 ctx = rctx // use context from middleware stack in children
10318 return obj.PossibleTypes(), nil
10319 })
10320 if err != nil {
10321 ec.Error(ctx, err)
10322 return graphql.Null
10323 }
10324 if resTmp == nil {
10325 return graphql.Null
10326 }
10327 res := resTmp.([]introspection.Type)
10328 fc.Result = res
10329 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10330}
10331
10332func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10333 defer func() {
10334 if r := recover(); r != nil {
10335 ec.Error(ctx, ec.Recover(ctx, r))
10336 ret = graphql.Null
10337 }
10338 }()
10339 fc := &graphql.FieldContext{
10340 Object: "__Type",
10341 Field: field,
10342 Args: nil,
10343 IsMethod: true,
10344 }
10345
10346 ctx = graphql.WithFieldContext(ctx, fc)
10347 rawArgs := field.ArgumentMap(ec.Variables)
10348 args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
10349 if err != nil {
10350 ec.Error(ctx, err)
10351 return graphql.Null
10352 }
10353 fc.Args = args
10354 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10355 ctx = rctx // use context from middleware stack in children
10356 return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10357 })
10358 if err != nil {
10359 ec.Error(ctx, err)
10360 return graphql.Null
10361 }
10362 if resTmp == nil {
10363 return graphql.Null
10364 }
10365 res := resTmp.([]introspection.EnumValue)
10366 fc.Result = res
10367 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
10368}
10369
10370func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10371 defer func() {
10372 if r := recover(); r != nil {
10373 ec.Error(ctx, ec.Recover(ctx, r))
10374 ret = graphql.Null
10375 }
10376 }()
10377 fc := &graphql.FieldContext{
10378 Object: "__Type",
10379 Field: field,
10380 Args: nil,
10381 IsMethod: true,
10382 }
10383
10384 ctx = graphql.WithFieldContext(ctx, fc)
10385 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10386 ctx = rctx // use context from middleware stack in children
10387 return obj.InputFields(), nil
10388 })
10389 if err != nil {
10390 ec.Error(ctx, err)
10391 return graphql.Null
10392 }
10393 if resTmp == nil {
10394 return graphql.Null
10395 }
10396 res := resTmp.([]introspection.InputValue)
10397 fc.Result = res
10398 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
10399}
10400
10401func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10402 defer func() {
10403 if r := recover(); r != nil {
10404 ec.Error(ctx, ec.Recover(ctx, r))
10405 ret = graphql.Null
10406 }
10407 }()
10408 fc := &graphql.FieldContext{
10409 Object: "__Type",
10410 Field: field,
10411 Args: nil,
10412 IsMethod: true,
10413 }
10414
10415 ctx = graphql.WithFieldContext(ctx, fc)
10416 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10417 ctx = rctx // use context from middleware stack in children
10418 return obj.OfType(), nil
10419 })
10420 if err != nil {
10421 ec.Error(ctx, err)
10422 return graphql.Null
10423 }
10424 if resTmp == nil {
10425 return graphql.Null
10426 }
10427 res := resTmp.(*introspection.Type)
10428 fc.Result = res
10429 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10430}
10431
10432// endregion **************************** field.gotpl *****************************
10433
10434// region **************************** input.gotpl *****************************
10435
10436func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
10437 var it models.AddCommentInput
10438 var asMap = obj.(map[string]interface{})
10439
10440 for k, v := range asMap {
10441 switch k {
10442 case "clientMutationId":
10443 var err error
10444 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10445 if err != nil {
10446 return it, err
10447 }
10448 case "repoRef":
10449 var err error
10450 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10451 if err != nil {
10452 return it, err
10453 }
10454 case "prefix":
10455 var err error
10456 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10457 if err != nil {
10458 return it, err
10459 }
10460 case "message":
10461 var err error
10462 it.Message, err = ec.unmarshalNString2string(ctx, v)
10463 if err != nil {
10464 return it, err
10465 }
10466 case "files":
10467 var err error
10468 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10469 if err != nil {
10470 return it, err
10471 }
10472 }
10473 }
10474
10475 return it, nil
10476}
10477
10478func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
10479 var it models.ChangeLabelInput
10480 var asMap = obj.(map[string]interface{})
10481
10482 for k, v := range asMap {
10483 switch k {
10484 case "clientMutationId":
10485 var err error
10486 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10487 if err != nil {
10488 return it, err
10489 }
10490 case "repoRef":
10491 var err error
10492 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10493 if err != nil {
10494 return it, err
10495 }
10496 case "prefix":
10497 var err error
10498 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10499 if err != nil {
10500 return it, err
10501 }
10502 case "added":
10503 var err error
10504 it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10505 if err != nil {
10506 return it, err
10507 }
10508 case "Removed":
10509 var err error
10510 it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10511 if err != nil {
10512 return it, err
10513 }
10514 }
10515 }
10516
10517 return it, nil
10518}
10519
10520func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
10521 var it models.CloseBugInput
10522 var asMap = obj.(map[string]interface{})
10523
10524 for k, v := range asMap {
10525 switch k {
10526 case "clientMutationId":
10527 var err error
10528 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10529 if err != nil {
10530 return it, err
10531 }
10532 case "repoRef":
10533 var err error
10534 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10535 if err != nil {
10536 return it, err
10537 }
10538 case "prefix":
10539 var err error
10540 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10541 if err != nil {
10542 return it, err
10543 }
10544 }
10545 }
10546
10547 return it, nil
10548}
10549
10550func (ec *executionContext) unmarshalInputCommitAsNeededInput(ctx context.Context, obj interface{}) (models.CommitAsNeededInput, error) {
10551 var it models.CommitAsNeededInput
10552 var asMap = obj.(map[string]interface{})
10553
10554 for k, v := range asMap {
10555 switch k {
10556 case "clientMutationId":
10557 var err error
10558 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10559 if err != nil {
10560 return it, err
10561 }
10562 case "repoRef":
10563 var err error
10564 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10565 if err != nil {
10566 return it, err
10567 }
10568 case "prefix":
10569 var err error
10570 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10571 if err != nil {
10572 return it, err
10573 }
10574 }
10575 }
10576
10577 return it, nil
10578}
10579
10580func (ec *executionContext) unmarshalInputCommitInput(ctx context.Context, obj interface{}) (models.CommitInput, error) {
10581 var it models.CommitInput
10582 var asMap = obj.(map[string]interface{})
10583
10584 for k, v := range asMap {
10585 switch k {
10586 case "clientMutationId":
10587 var err error
10588 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10589 if err != nil {
10590 return it, err
10591 }
10592 case "repoRef":
10593 var err error
10594 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10595 if err != nil {
10596 return it, err
10597 }
10598 case "prefix":
10599 var err error
10600 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10601 if err != nil {
10602 return it, err
10603 }
10604 }
10605 }
10606
10607 return it, nil
10608}
10609
10610func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
10611 var it models.NewBugInput
10612 var asMap = obj.(map[string]interface{})
10613
10614 for k, v := range asMap {
10615 switch k {
10616 case "clientMutationId":
10617 var err error
10618 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10619 if err != nil {
10620 return it, err
10621 }
10622 case "repoRef":
10623 var err error
10624 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10625 if err != nil {
10626 return it, err
10627 }
10628 case "title":
10629 var err error
10630 it.Title, err = ec.unmarshalNString2string(ctx, v)
10631 if err != nil {
10632 return it, err
10633 }
10634 case "message":
10635 var err error
10636 it.Message, err = ec.unmarshalNString2string(ctx, v)
10637 if err != nil {
10638 return it, err
10639 }
10640 case "files":
10641 var err error
10642 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10643 if err != nil {
10644 return it, err
10645 }
10646 }
10647 }
10648
10649 return it, nil
10650}
10651
10652func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10653 var it models.OpenBugInput
10654 var asMap = obj.(map[string]interface{})
10655
10656 for k, v := range asMap {
10657 switch k {
10658 case "clientMutationId":
10659 var err error
10660 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10661 if err != nil {
10662 return it, err
10663 }
10664 case "repoRef":
10665 var err error
10666 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10667 if err != nil {
10668 return it, err
10669 }
10670 case "prefix":
10671 var err error
10672 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10673 if err != nil {
10674 return it, err
10675 }
10676 }
10677 }
10678
10679 return it, nil
10680}
10681
10682func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10683 var it models.SetTitleInput
10684 var asMap = obj.(map[string]interface{})
10685
10686 for k, v := range asMap {
10687 switch k {
10688 case "clientMutationId":
10689 var err error
10690 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10691 if err != nil {
10692 return it, err
10693 }
10694 case "repoRef":
10695 var err error
10696 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10697 if err != nil {
10698 return it, err
10699 }
10700 case "prefix":
10701 var err error
10702 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10703 if err != nil {
10704 return it, err
10705 }
10706 case "title":
10707 var err error
10708 it.Title, err = ec.unmarshalNString2string(ctx, v)
10709 if err != nil {
10710 return it, err
10711 }
10712 }
10713 }
10714
10715 return it, nil
10716}
10717
10718// endregion **************************** input.gotpl *****************************
10719
10720// region ************************** interface.gotpl ***************************
10721
10722func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
10723 switch obj := (obj).(type) {
10724 case nil:
10725 return graphql.Null
10726 case bug.Comment:
10727 return ec._Comment(ctx, sel, &obj)
10728 case *bug.Comment:
10729 if obj == nil {
10730 return graphql.Null
10731 }
10732 return ec._Comment(ctx, sel, obj)
10733 case *bug.Snapshot:
10734 if obj == nil {
10735 return graphql.Null
10736 }
10737 return ec._Bug(ctx, sel, obj)
10738 case *bug.CreateOperation:
10739 if obj == nil {
10740 return graphql.Null
10741 }
10742 return ec._CreateOperation(ctx, sel, obj)
10743 case *bug.SetTitleOperation:
10744 if obj == nil {
10745 return graphql.Null
10746 }
10747 return ec._SetTitleOperation(ctx, sel, obj)
10748 case *bug.AddCommentOperation:
10749 if obj == nil {
10750 return graphql.Null
10751 }
10752 return ec._AddCommentOperation(ctx, sel, obj)
10753 case *bug.EditCommentOperation:
10754 if obj == nil {
10755 return graphql.Null
10756 }
10757 return ec._EditCommentOperation(ctx, sel, obj)
10758 case *bug.SetStatusOperation:
10759 if obj == nil {
10760 return graphql.Null
10761 }
10762 return ec._SetStatusOperation(ctx, sel, obj)
10763 case *bug.LabelChangeOperation:
10764 if obj == nil {
10765 return graphql.Null
10766 }
10767 return ec._LabelChangeOperation(ctx, sel, obj)
10768 case *bug.CreateTimelineItem:
10769 if obj == nil {
10770 return graphql.Null
10771 }
10772 return ec._CreateTimelineItem(ctx, sel, obj)
10773 case *bug.AddCommentTimelineItem:
10774 if obj == nil {
10775 return graphql.Null
10776 }
10777 return ec._AddCommentTimelineItem(ctx, sel, obj)
10778 case *bug.LabelChangeTimelineItem:
10779 if obj == nil {
10780 return graphql.Null
10781 }
10782 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10783 case *bug.SetStatusTimelineItem:
10784 if obj == nil {
10785 return graphql.Null
10786 }
10787 return ec._SetStatusTimelineItem(ctx, sel, obj)
10788 case *bug.SetTitleTimelineItem:
10789 if obj == nil {
10790 return graphql.Null
10791 }
10792 return ec._SetTitleTimelineItem(ctx, sel, obj)
10793 default:
10794 panic(fmt.Errorf("unexpected type %T", obj))
10795 }
10796}
10797
10798func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
10799 switch obj := (obj).(type) {
10800 case nil:
10801 return graphql.Null
10802 case *bug.CreateOperation:
10803 if obj == nil {
10804 return graphql.Null
10805 }
10806 return ec._CreateOperation(ctx, sel, obj)
10807 case *bug.SetTitleOperation:
10808 if obj == nil {
10809 return graphql.Null
10810 }
10811 return ec._SetTitleOperation(ctx, sel, obj)
10812 case *bug.AddCommentOperation:
10813 if obj == nil {
10814 return graphql.Null
10815 }
10816 return ec._AddCommentOperation(ctx, sel, obj)
10817 case *bug.EditCommentOperation:
10818 if obj == nil {
10819 return graphql.Null
10820 }
10821 return ec._EditCommentOperation(ctx, sel, obj)
10822 case *bug.SetStatusOperation:
10823 if obj == nil {
10824 return graphql.Null
10825 }
10826 return ec._SetStatusOperation(ctx, sel, obj)
10827 case *bug.LabelChangeOperation:
10828 if obj == nil {
10829 return graphql.Null
10830 }
10831 return ec._LabelChangeOperation(ctx, sel, obj)
10832 default:
10833 panic(fmt.Errorf("unexpected type %T", obj))
10834 }
10835}
10836
10837func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
10838 switch obj := (obj).(type) {
10839 case nil:
10840 return graphql.Null
10841 case *bug.CreateTimelineItem:
10842 if obj == nil {
10843 return graphql.Null
10844 }
10845 return ec._CreateTimelineItem(ctx, sel, obj)
10846 case *bug.AddCommentTimelineItem:
10847 if obj == nil {
10848 return graphql.Null
10849 }
10850 return ec._AddCommentTimelineItem(ctx, sel, obj)
10851 case bug.LabelChangeTimelineItem:
10852 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10853 case *bug.LabelChangeTimelineItem:
10854 if obj == nil {
10855 return graphql.Null
10856 }
10857 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10858 case bug.SetStatusTimelineItem:
10859 return ec._SetStatusTimelineItem(ctx, sel, &obj)
10860 case *bug.SetStatusTimelineItem:
10861 if obj == nil {
10862 return graphql.Null
10863 }
10864 return ec._SetStatusTimelineItem(ctx, sel, obj)
10865 case bug.SetTitleTimelineItem:
10866 return ec._SetTitleTimelineItem(ctx, sel, &obj)
10867 case *bug.SetTitleTimelineItem:
10868 if obj == nil {
10869 return graphql.Null
10870 }
10871 return ec._SetTitleTimelineItem(ctx, sel, obj)
10872 default:
10873 panic(fmt.Errorf("unexpected type %T", obj))
10874 }
10875}
10876
10877// endregion ************************** interface.gotpl ***************************
10878
10879// region **************************** object.gotpl ****************************
10880
10881var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10882
10883func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10884 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
10885
10886 out := graphql.NewFieldSet(fields)
10887 var invalids uint32
10888 for i, field := range fields {
10889 switch field.Name {
10890 case "__typename":
10891 out.Values[i] = graphql.MarshalString("AddCommentOperation")
10892 case "id":
10893 field := field
10894 out.Concurrently(i, func() (res graphql.Marshaler) {
10895 defer func() {
10896 if r := recover(); r != nil {
10897 ec.Error(ctx, ec.Recover(ctx, r))
10898 }
10899 }()
10900 res = ec._AddCommentOperation_id(ctx, field, obj)
10901 if res == graphql.Null {
10902 atomic.AddUint32(&invalids, 1)
10903 }
10904 return res
10905 })
10906 case "author":
10907 out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
10908 if out.Values[i] == graphql.Null {
10909 atomic.AddUint32(&invalids, 1)
10910 }
10911 case "date":
10912 field := field
10913 out.Concurrently(i, func() (res graphql.Marshaler) {
10914 defer func() {
10915 if r := recover(); r != nil {
10916 ec.Error(ctx, ec.Recover(ctx, r))
10917 }
10918 }()
10919 res = ec._AddCommentOperation_date(ctx, field, obj)
10920 if res == graphql.Null {
10921 atomic.AddUint32(&invalids, 1)
10922 }
10923 return res
10924 })
10925 case "message":
10926 out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10927 if out.Values[i] == graphql.Null {
10928 atomic.AddUint32(&invalids, 1)
10929 }
10930 case "files":
10931 out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10932 if out.Values[i] == graphql.Null {
10933 atomic.AddUint32(&invalids, 1)
10934 }
10935 default:
10936 panic("unknown field " + strconv.Quote(field.Name))
10937 }
10938 }
10939 out.Dispatch()
10940 if invalids > 0 {
10941 return graphql.Null
10942 }
10943 return out
10944}
10945
10946var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10947
10948func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10949 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
10950
10951 out := graphql.NewFieldSet(fields)
10952 var invalids uint32
10953 for i, field := range fields {
10954 switch field.Name {
10955 case "__typename":
10956 out.Values[i] = graphql.MarshalString("AddCommentPayload")
10957 case "clientMutationId":
10958 out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10959 case "bug":
10960 out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10961 if out.Values[i] == graphql.Null {
10962 invalids++
10963 }
10964 case "operation":
10965 out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10966 if out.Values[i] == graphql.Null {
10967 invalids++
10968 }
10969 default:
10970 panic("unknown field " + strconv.Quote(field.Name))
10971 }
10972 }
10973 out.Dispatch()
10974 if invalids > 0 {
10975 return graphql.Null
10976 }
10977 return out
10978}
10979
10980var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10981
10982func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10983 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
10984
10985 out := graphql.NewFieldSet(fields)
10986 var invalids uint32
10987 for i, field := range fields {
10988 switch field.Name {
10989 case "__typename":
10990 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10991 case "id":
10992 field := field
10993 out.Concurrently(i, func() (res graphql.Marshaler) {
10994 defer func() {
10995 if r := recover(); r != nil {
10996 ec.Error(ctx, ec.Recover(ctx, r))
10997 }
10998 }()
10999 res = ec._AddCommentTimelineItem_id(ctx, field, obj)
11000 if res == graphql.Null {
11001 atomic.AddUint32(&invalids, 1)
11002 }
11003 return res
11004 })
11005 case "author":
11006 out.Values[i] = ec._AddCommentTimelineItem_author(ctx, field, obj)
11007 if out.Values[i] == graphql.Null {
11008 atomic.AddUint32(&invalids, 1)
11009 }
11010 case "message":
11011 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
11012 if out.Values[i] == graphql.Null {
11013 atomic.AddUint32(&invalids, 1)
11014 }
11015 case "messageIsEmpty":
11016 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
11017 if out.Values[i] == graphql.Null {
11018 atomic.AddUint32(&invalids, 1)
11019 }
11020 case "files":
11021 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
11022 if out.Values[i] == graphql.Null {
11023 atomic.AddUint32(&invalids, 1)
11024 }
11025 case "createdAt":
11026 field := field
11027 out.Concurrently(i, func() (res graphql.Marshaler) {
11028 defer func() {
11029 if r := recover(); r != nil {
11030 ec.Error(ctx, ec.Recover(ctx, r))
11031 }
11032 }()
11033 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
11034 if res == graphql.Null {
11035 atomic.AddUint32(&invalids, 1)
11036 }
11037 return res
11038 })
11039 case "lastEdit":
11040 field := field
11041 out.Concurrently(i, func() (res graphql.Marshaler) {
11042 defer func() {
11043 if r := recover(); r != nil {
11044 ec.Error(ctx, ec.Recover(ctx, r))
11045 }
11046 }()
11047 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
11048 if res == graphql.Null {
11049 atomic.AddUint32(&invalids, 1)
11050 }
11051 return res
11052 })
11053 case "edited":
11054 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
11055 if out.Values[i] == graphql.Null {
11056 atomic.AddUint32(&invalids, 1)
11057 }
11058 case "history":
11059 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
11060 if out.Values[i] == graphql.Null {
11061 atomic.AddUint32(&invalids, 1)
11062 }
11063 default:
11064 panic("unknown field " + strconv.Quote(field.Name))
11065 }
11066 }
11067 out.Dispatch()
11068 if invalids > 0 {
11069 return graphql.Null
11070 }
11071 return out
11072}
11073
11074var bugImplementors = []string{"Bug", "Authored"}
11075
11076func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
11077 fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
11078
11079 out := graphql.NewFieldSet(fields)
11080 var invalids uint32
11081 for i, field := range fields {
11082 switch field.Name {
11083 case "__typename":
11084 out.Values[i] = graphql.MarshalString("Bug")
11085 case "id":
11086 field := field
11087 out.Concurrently(i, func() (res graphql.Marshaler) {
11088 defer func() {
11089 if r := recover(); r != nil {
11090 ec.Error(ctx, ec.Recover(ctx, r))
11091 }
11092 }()
11093 res = ec._Bug_id(ctx, field, obj)
11094 if res == graphql.Null {
11095 atomic.AddUint32(&invalids, 1)
11096 }
11097 return res
11098 })
11099 case "humanId":
11100 field := field
11101 out.Concurrently(i, func() (res graphql.Marshaler) {
11102 defer func() {
11103 if r := recover(); r != nil {
11104 ec.Error(ctx, ec.Recover(ctx, r))
11105 }
11106 }()
11107 res = ec._Bug_humanId(ctx, field, obj)
11108 if res == graphql.Null {
11109 atomic.AddUint32(&invalids, 1)
11110 }
11111 return res
11112 })
11113 case "status":
11114 field := field
11115 out.Concurrently(i, func() (res graphql.Marshaler) {
11116 defer func() {
11117 if r := recover(); r != nil {
11118 ec.Error(ctx, ec.Recover(ctx, r))
11119 }
11120 }()
11121 res = ec._Bug_status(ctx, field, obj)
11122 if res == graphql.Null {
11123 atomic.AddUint32(&invalids, 1)
11124 }
11125 return res
11126 })
11127 case "title":
11128 out.Values[i] = ec._Bug_title(ctx, field, obj)
11129 if out.Values[i] == graphql.Null {
11130 atomic.AddUint32(&invalids, 1)
11131 }
11132 case "labels":
11133 out.Values[i] = ec._Bug_labels(ctx, field, obj)
11134 if out.Values[i] == graphql.Null {
11135 atomic.AddUint32(&invalids, 1)
11136 }
11137 case "author":
11138 out.Values[i] = ec._Bug_author(ctx, field, obj)
11139 if out.Values[i] == graphql.Null {
11140 atomic.AddUint32(&invalids, 1)
11141 }
11142 case "createdAt":
11143 out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
11144 if out.Values[i] == graphql.Null {
11145 atomic.AddUint32(&invalids, 1)
11146 }
11147 case "lastEdit":
11148 field := field
11149 out.Concurrently(i, func() (res graphql.Marshaler) {
11150 defer func() {
11151 if r := recover(); r != nil {
11152 ec.Error(ctx, ec.Recover(ctx, r))
11153 }
11154 }()
11155 res = ec._Bug_lastEdit(ctx, field, obj)
11156 if res == graphql.Null {
11157 atomic.AddUint32(&invalids, 1)
11158 }
11159 return res
11160 })
11161 case "actors":
11162 field := field
11163 out.Concurrently(i, func() (res graphql.Marshaler) {
11164 defer func() {
11165 if r := recover(); r != nil {
11166 ec.Error(ctx, ec.Recover(ctx, r))
11167 }
11168 }()
11169 res = ec._Bug_actors(ctx, field, obj)
11170 if res == graphql.Null {
11171 atomic.AddUint32(&invalids, 1)
11172 }
11173 return res
11174 })
11175 case "participants":
11176 field := field
11177 out.Concurrently(i, func() (res graphql.Marshaler) {
11178 defer func() {
11179 if r := recover(); r != nil {
11180 ec.Error(ctx, ec.Recover(ctx, r))
11181 }
11182 }()
11183 res = ec._Bug_participants(ctx, field, obj)
11184 if res == graphql.Null {
11185 atomic.AddUint32(&invalids, 1)
11186 }
11187 return res
11188 })
11189 case "comments":
11190 field := field
11191 out.Concurrently(i, func() (res graphql.Marshaler) {
11192 defer func() {
11193 if r := recover(); r != nil {
11194 ec.Error(ctx, ec.Recover(ctx, r))
11195 }
11196 }()
11197 res = ec._Bug_comments(ctx, field, obj)
11198 if res == graphql.Null {
11199 atomic.AddUint32(&invalids, 1)
11200 }
11201 return res
11202 })
11203 case "timeline":
11204 field := field
11205 out.Concurrently(i, func() (res graphql.Marshaler) {
11206 defer func() {
11207 if r := recover(); r != nil {
11208 ec.Error(ctx, ec.Recover(ctx, r))
11209 }
11210 }()
11211 res = ec._Bug_timeline(ctx, field, obj)
11212 if res == graphql.Null {
11213 atomic.AddUint32(&invalids, 1)
11214 }
11215 return res
11216 })
11217 case "operations":
11218 field := field
11219 out.Concurrently(i, func() (res graphql.Marshaler) {
11220 defer func() {
11221 if r := recover(); r != nil {
11222 ec.Error(ctx, ec.Recover(ctx, r))
11223 }
11224 }()
11225 res = ec._Bug_operations(ctx, field, obj)
11226 if res == graphql.Null {
11227 atomic.AddUint32(&invalids, 1)
11228 }
11229 return res
11230 })
11231 default:
11232 panic("unknown field " + strconv.Quote(field.Name))
11233 }
11234 }
11235 out.Dispatch()
11236 if invalids > 0 {
11237 return graphql.Null
11238 }
11239 return out
11240}
11241
11242var bugConnectionImplementors = []string{"BugConnection"}
11243
11244func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
11245 fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
11246
11247 out := graphql.NewFieldSet(fields)
11248 var invalids uint32
11249 for i, field := range fields {
11250 switch field.Name {
11251 case "__typename":
11252 out.Values[i] = graphql.MarshalString("BugConnection")
11253 case "edges":
11254 out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
11255 if out.Values[i] == graphql.Null {
11256 invalids++
11257 }
11258 case "nodes":
11259 out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
11260 if out.Values[i] == graphql.Null {
11261 invalids++
11262 }
11263 case "pageInfo":
11264 out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
11265 if out.Values[i] == graphql.Null {
11266 invalids++
11267 }
11268 case "totalCount":
11269 out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
11270 if out.Values[i] == graphql.Null {
11271 invalids++
11272 }
11273 default:
11274 panic("unknown field " + strconv.Quote(field.Name))
11275 }
11276 }
11277 out.Dispatch()
11278 if invalids > 0 {
11279 return graphql.Null
11280 }
11281 return out
11282}
11283
11284var bugEdgeImplementors = []string{"BugEdge"}
11285
11286func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
11287 fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
11288
11289 out := graphql.NewFieldSet(fields)
11290 var invalids uint32
11291 for i, field := range fields {
11292 switch field.Name {
11293 case "__typename":
11294 out.Values[i] = graphql.MarshalString("BugEdge")
11295 case "cursor":
11296 out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
11297 if out.Values[i] == graphql.Null {
11298 invalids++
11299 }
11300 case "node":
11301 out.Values[i] = ec._BugEdge_node(ctx, field, obj)
11302 if out.Values[i] == graphql.Null {
11303 invalids++
11304 }
11305 default:
11306 panic("unknown field " + strconv.Quote(field.Name))
11307 }
11308 }
11309 out.Dispatch()
11310 if invalids > 0 {
11311 return graphql.Null
11312 }
11313 return out
11314}
11315
11316var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
11317
11318func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
11319 fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
11320
11321 out := graphql.NewFieldSet(fields)
11322 var invalids uint32
11323 for i, field := range fields {
11324 switch field.Name {
11325 case "__typename":
11326 out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
11327 case "clientMutationId":
11328 out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
11329 case "bug":
11330 out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
11331 if out.Values[i] == graphql.Null {
11332 invalids++
11333 }
11334 case "operation":
11335 out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
11336 if out.Values[i] == graphql.Null {
11337 invalids++
11338 }
11339 case "results":
11340 out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
11341 if out.Values[i] == graphql.Null {
11342 invalids++
11343 }
11344 default:
11345 panic("unknown field " + strconv.Quote(field.Name))
11346 }
11347 }
11348 out.Dispatch()
11349 if invalids > 0 {
11350 return graphql.Null
11351 }
11352 return out
11353}
11354
11355var closeBugPayloadImplementors = []string{"CloseBugPayload"}
11356
11357func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11358 fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
11359
11360 out := graphql.NewFieldSet(fields)
11361 var invalids uint32
11362 for i, field := range fields {
11363 switch field.Name {
11364 case "__typename":
11365 out.Values[i] = graphql.MarshalString("CloseBugPayload")
11366 case "clientMutationId":
11367 out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11368 case "bug":
11369 out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11370 if out.Values[i] == graphql.Null {
11371 invalids++
11372 }
11373 case "operation":
11374 out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11375 if out.Values[i] == graphql.Null {
11376 invalids++
11377 }
11378 default:
11379 panic("unknown field " + strconv.Quote(field.Name))
11380 }
11381 }
11382 out.Dispatch()
11383 if invalids > 0 {
11384 return graphql.Null
11385 }
11386 return out
11387}
11388
11389var colorImplementors = []string{"Color"}
11390
11391func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11392 fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
11393
11394 out := graphql.NewFieldSet(fields)
11395 var invalids uint32
11396 for i, field := range fields {
11397 switch field.Name {
11398 case "__typename":
11399 out.Values[i] = graphql.MarshalString("Color")
11400 case "R":
11401 field := field
11402 out.Concurrently(i, func() (res graphql.Marshaler) {
11403 defer func() {
11404 if r := recover(); r != nil {
11405 ec.Error(ctx, ec.Recover(ctx, r))
11406 }
11407 }()
11408 res = ec._Color_R(ctx, field, obj)
11409 if res == graphql.Null {
11410 atomic.AddUint32(&invalids, 1)
11411 }
11412 return res
11413 })
11414 case "G":
11415 field := field
11416 out.Concurrently(i, func() (res graphql.Marshaler) {
11417 defer func() {
11418 if r := recover(); r != nil {
11419 ec.Error(ctx, ec.Recover(ctx, r))
11420 }
11421 }()
11422 res = ec._Color_G(ctx, field, obj)
11423 if res == graphql.Null {
11424 atomic.AddUint32(&invalids, 1)
11425 }
11426 return res
11427 })
11428 case "B":
11429 field := field
11430 out.Concurrently(i, func() (res graphql.Marshaler) {
11431 defer func() {
11432 if r := recover(); r != nil {
11433 ec.Error(ctx, ec.Recover(ctx, r))
11434 }
11435 }()
11436 res = ec._Color_B(ctx, field, obj)
11437 if res == graphql.Null {
11438 atomic.AddUint32(&invalids, 1)
11439 }
11440 return res
11441 })
11442 default:
11443 panic("unknown field " + strconv.Quote(field.Name))
11444 }
11445 }
11446 out.Dispatch()
11447 if invalids > 0 {
11448 return graphql.Null
11449 }
11450 return out
11451}
11452
11453var commentImplementors = []string{"Comment", "Authored"}
11454
11455func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11456 fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
11457
11458 out := graphql.NewFieldSet(fields)
11459 var invalids uint32
11460 for i, field := range fields {
11461 switch field.Name {
11462 case "__typename":
11463 out.Values[i] = graphql.MarshalString("Comment")
11464 case "author":
11465 out.Values[i] = ec._Comment_author(ctx, field, obj)
11466 if out.Values[i] == graphql.Null {
11467 invalids++
11468 }
11469 case "message":
11470 out.Values[i] = ec._Comment_message(ctx, field, obj)
11471 if out.Values[i] == graphql.Null {
11472 invalids++
11473 }
11474 case "files":
11475 out.Values[i] = ec._Comment_files(ctx, field, obj)
11476 if out.Values[i] == graphql.Null {
11477 invalids++
11478 }
11479 default:
11480 panic("unknown field " + strconv.Quote(field.Name))
11481 }
11482 }
11483 out.Dispatch()
11484 if invalids > 0 {
11485 return graphql.Null
11486 }
11487 return out
11488}
11489
11490var commentConnectionImplementors = []string{"CommentConnection"}
11491
11492func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11493 fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
11494
11495 out := graphql.NewFieldSet(fields)
11496 var invalids uint32
11497 for i, field := range fields {
11498 switch field.Name {
11499 case "__typename":
11500 out.Values[i] = graphql.MarshalString("CommentConnection")
11501 case "edges":
11502 out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11503 if out.Values[i] == graphql.Null {
11504 invalids++
11505 }
11506 case "nodes":
11507 out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11508 if out.Values[i] == graphql.Null {
11509 invalids++
11510 }
11511 case "pageInfo":
11512 out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11513 if out.Values[i] == graphql.Null {
11514 invalids++
11515 }
11516 case "totalCount":
11517 out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11518 if out.Values[i] == graphql.Null {
11519 invalids++
11520 }
11521 default:
11522 panic("unknown field " + strconv.Quote(field.Name))
11523 }
11524 }
11525 out.Dispatch()
11526 if invalids > 0 {
11527 return graphql.Null
11528 }
11529 return out
11530}
11531
11532var commentEdgeImplementors = []string{"CommentEdge"}
11533
11534func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11535 fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
11536
11537 out := graphql.NewFieldSet(fields)
11538 var invalids uint32
11539 for i, field := range fields {
11540 switch field.Name {
11541 case "__typename":
11542 out.Values[i] = graphql.MarshalString("CommentEdge")
11543 case "cursor":
11544 out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11545 if out.Values[i] == graphql.Null {
11546 invalids++
11547 }
11548 case "node":
11549 out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11550 if out.Values[i] == graphql.Null {
11551 invalids++
11552 }
11553 default:
11554 panic("unknown field " + strconv.Quote(field.Name))
11555 }
11556 }
11557 out.Dispatch()
11558 if invalids > 0 {
11559 return graphql.Null
11560 }
11561 return out
11562}
11563
11564var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11565
11566func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11567 fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
11568
11569 out := graphql.NewFieldSet(fields)
11570 var invalids uint32
11571 for i, field := range fields {
11572 switch field.Name {
11573 case "__typename":
11574 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11575 case "message":
11576 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11577 if out.Values[i] == graphql.Null {
11578 atomic.AddUint32(&invalids, 1)
11579 }
11580 case "date":
11581 field := field
11582 out.Concurrently(i, func() (res graphql.Marshaler) {
11583 defer func() {
11584 if r := recover(); r != nil {
11585 ec.Error(ctx, ec.Recover(ctx, r))
11586 }
11587 }()
11588 res = ec._CommentHistoryStep_date(ctx, field, obj)
11589 if res == graphql.Null {
11590 atomic.AddUint32(&invalids, 1)
11591 }
11592 return res
11593 })
11594 default:
11595 panic("unknown field " + strconv.Quote(field.Name))
11596 }
11597 }
11598 out.Dispatch()
11599 if invalids > 0 {
11600 return graphql.Null
11601 }
11602 return out
11603}
11604
11605var commitAsNeededPayloadImplementors = []string{"CommitAsNeededPayload"}
11606
11607func (ec *executionContext) _CommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitAsNeededPayload) graphql.Marshaler {
11608 fields := graphql.CollectFields(ec.OperationContext, sel, commitAsNeededPayloadImplementors)
11609
11610 out := graphql.NewFieldSet(fields)
11611 var invalids uint32
11612 for i, field := range fields {
11613 switch field.Name {
11614 case "__typename":
11615 out.Values[i] = graphql.MarshalString("CommitAsNeededPayload")
11616 case "clientMutationId":
11617 out.Values[i] = ec._CommitAsNeededPayload_clientMutationId(ctx, field, obj)
11618 case "bug":
11619 out.Values[i] = ec._CommitAsNeededPayload_bug(ctx, field, obj)
11620 if out.Values[i] == graphql.Null {
11621 invalids++
11622 }
11623 default:
11624 panic("unknown field " + strconv.Quote(field.Name))
11625 }
11626 }
11627 out.Dispatch()
11628 if invalids > 0 {
11629 return graphql.Null
11630 }
11631 return out
11632}
11633
11634var commitPayloadImplementors = []string{"CommitPayload"}
11635
11636func (ec *executionContext) _CommitPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitPayload) graphql.Marshaler {
11637 fields := graphql.CollectFields(ec.OperationContext, sel, commitPayloadImplementors)
11638
11639 out := graphql.NewFieldSet(fields)
11640 var invalids uint32
11641 for i, field := range fields {
11642 switch field.Name {
11643 case "__typename":
11644 out.Values[i] = graphql.MarshalString("CommitPayload")
11645 case "clientMutationId":
11646 out.Values[i] = ec._CommitPayload_clientMutationId(ctx, field, obj)
11647 case "bug":
11648 out.Values[i] = ec._CommitPayload_bug(ctx, field, obj)
11649 if out.Values[i] == graphql.Null {
11650 invalids++
11651 }
11652 default:
11653 panic("unknown field " + strconv.Quote(field.Name))
11654 }
11655 }
11656 out.Dispatch()
11657 if invalids > 0 {
11658 return graphql.Null
11659 }
11660 return out
11661}
11662
11663var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11664
11665func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11666 fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
11667
11668 out := graphql.NewFieldSet(fields)
11669 var invalids uint32
11670 for i, field := range fields {
11671 switch field.Name {
11672 case "__typename":
11673 out.Values[i] = graphql.MarshalString("CreateOperation")
11674 case "id":
11675 field := field
11676 out.Concurrently(i, func() (res graphql.Marshaler) {
11677 defer func() {
11678 if r := recover(); r != nil {
11679 ec.Error(ctx, ec.Recover(ctx, r))
11680 }
11681 }()
11682 res = ec._CreateOperation_id(ctx, field, obj)
11683 if res == graphql.Null {
11684 atomic.AddUint32(&invalids, 1)
11685 }
11686 return res
11687 })
11688 case "author":
11689 out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
11690 if out.Values[i] == graphql.Null {
11691 atomic.AddUint32(&invalids, 1)
11692 }
11693 case "date":
11694 field := field
11695 out.Concurrently(i, func() (res graphql.Marshaler) {
11696 defer func() {
11697 if r := recover(); r != nil {
11698 ec.Error(ctx, ec.Recover(ctx, r))
11699 }
11700 }()
11701 res = ec._CreateOperation_date(ctx, field, obj)
11702 if res == graphql.Null {
11703 atomic.AddUint32(&invalids, 1)
11704 }
11705 return res
11706 })
11707 case "title":
11708 out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11709 if out.Values[i] == graphql.Null {
11710 atomic.AddUint32(&invalids, 1)
11711 }
11712 case "message":
11713 out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11714 if out.Values[i] == graphql.Null {
11715 atomic.AddUint32(&invalids, 1)
11716 }
11717 case "files":
11718 out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11719 if out.Values[i] == graphql.Null {
11720 atomic.AddUint32(&invalids, 1)
11721 }
11722 default:
11723 panic("unknown field " + strconv.Quote(field.Name))
11724 }
11725 }
11726 out.Dispatch()
11727 if invalids > 0 {
11728 return graphql.Null
11729 }
11730 return out
11731}
11732
11733var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11734
11735func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11736 fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
11737
11738 out := graphql.NewFieldSet(fields)
11739 var invalids uint32
11740 for i, field := range fields {
11741 switch field.Name {
11742 case "__typename":
11743 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11744 case "id":
11745 field := field
11746 out.Concurrently(i, func() (res graphql.Marshaler) {
11747 defer func() {
11748 if r := recover(); r != nil {
11749 ec.Error(ctx, ec.Recover(ctx, r))
11750 }
11751 }()
11752 res = ec._CreateTimelineItem_id(ctx, field, obj)
11753 if res == graphql.Null {
11754 atomic.AddUint32(&invalids, 1)
11755 }
11756 return res
11757 })
11758 case "author":
11759 out.Values[i] = ec._CreateTimelineItem_author(ctx, field, obj)
11760 if out.Values[i] == graphql.Null {
11761 atomic.AddUint32(&invalids, 1)
11762 }
11763 case "message":
11764 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11765 if out.Values[i] == graphql.Null {
11766 atomic.AddUint32(&invalids, 1)
11767 }
11768 case "messageIsEmpty":
11769 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11770 if out.Values[i] == graphql.Null {
11771 atomic.AddUint32(&invalids, 1)
11772 }
11773 case "files":
11774 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11775 if out.Values[i] == graphql.Null {
11776 atomic.AddUint32(&invalids, 1)
11777 }
11778 case "createdAt":
11779 field := field
11780 out.Concurrently(i, func() (res graphql.Marshaler) {
11781 defer func() {
11782 if r := recover(); r != nil {
11783 ec.Error(ctx, ec.Recover(ctx, r))
11784 }
11785 }()
11786 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11787 if res == graphql.Null {
11788 atomic.AddUint32(&invalids, 1)
11789 }
11790 return res
11791 })
11792 case "lastEdit":
11793 field := field
11794 out.Concurrently(i, func() (res graphql.Marshaler) {
11795 defer func() {
11796 if r := recover(); r != nil {
11797 ec.Error(ctx, ec.Recover(ctx, r))
11798 }
11799 }()
11800 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11801 if res == graphql.Null {
11802 atomic.AddUint32(&invalids, 1)
11803 }
11804 return res
11805 })
11806 case "edited":
11807 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11808 if out.Values[i] == graphql.Null {
11809 atomic.AddUint32(&invalids, 1)
11810 }
11811 case "history":
11812 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11813 if out.Values[i] == graphql.Null {
11814 atomic.AddUint32(&invalids, 1)
11815 }
11816 default:
11817 panic("unknown field " + strconv.Quote(field.Name))
11818 }
11819 }
11820 out.Dispatch()
11821 if invalids > 0 {
11822 return graphql.Null
11823 }
11824 return out
11825}
11826
11827var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11828
11829func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11830 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
11831
11832 out := graphql.NewFieldSet(fields)
11833 var invalids uint32
11834 for i, field := range fields {
11835 switch field.Name {
11836 case "__typename":
11837 out.Values[i] = graphql.MarshalString("EditCommentOperation")
11838 case "id":
11839 field := field
11840 out.Concurrently(i, func() (res graphql.Marshaler) {
11841 defer func() {
11842 if r := recover(); r != nil {
11843 ec.Error(ctx, ec.Recover(ctx, r))
11844 }
11845 }()
11846 res = ec._EditCommentOperation_id(ctx, field, obj)
11847 if res == graphql.Null {
11848 atomic.AddUint32(&invalids, 1)
11849 }
11850 return res
11851 })
11852 case "author":
11853 out.Values[i] = ec._EditCommentOperation_author(ctx, field, obj)
11854 if out.Values[i] == graphql.Null {
11855 atomic.AddUint32(&invalids, 1)
11856 }
11857 case "date":
11858 field := field
11859 out.Concurrently(i, func() (res graphql.Marshaler) {
11860 defer func() {
11861 if r := recover(); r != nil {
11862 ec.Error(ctx, ec.Recover(ctx, r))
11863 }
11864 }()
11865 res = ec._EditCommentOperation_date(ctx, field, obj)
11866 if res == graphql.Null {
11867 atomic.AddUint32(&invalids, 1)
11868 }
11869 return res
11870 })
11871 case "target":
11872 field := field
11873 out.Concurrently(i, func() (res graphql.Marshaler) {
11874 defer func() {
11875 if r := recover(); r != nil {
11876 ec.Error(ctx, ec.Recover(ctx, r))
11877 }
11878 }()
11879 res = ec._EditCommentOperation_target(ctx, field, obj)
11880 if res == graphql.Null {
11881 atomic.AddUint32(&invalids, 1)
11882 }
11883 return res
11884 })
11885 case "message":
11886 out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11887 if out.Values[i] == graphql.Null {
11888 atomic.AddUint32(&invalids, 1)
11889 }
11890 case "files":
11891 out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11892 if out.Values[i] == graphql.Null {
11893 atomic.AddUint32(&invalids, 1)
11894 }
11895 default:
11896 panic("unknown field " + strconv.Quote(field.Name))
11897 }
11898 }
11899 out.Dispatch()
11900 if invalids > 0 {
11901 return graphql.Null
11902 }
11903 return out
11904}
11905
11906var identityImplementors = []string{"Identity"}
11907
11908func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj identity.Interface) graphql.Marshaler {
11909 fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
11910
11911 out := graphql.NewFieldSet(fields)
11912 var invalids uint32
11913 for i, field := range fields {
11914 switch field.Name {
11915 case "__typename":
11916 out.Values[i] = graphql.MarshalString("Identity")
11917 case "id":
11918 field := field
11919 out.Concurrently(i, func() (res graphql.Marshaler) {
11920 defer func() {
11921 if r := recover(); r != nil {
11922 ec.Error(ctx, ec.Recover(ctx, r))
11923 }
11924 }()
11925 res = ec._Identity_id(ctx, field, obj)
11926 if res == graphql.Null {
11927 atomic.AddUint32(&invalids, 1)
11928 }
11929 return res
11930 })
11931 case "humanId":
11932 field := field
11933 out.Concurrently(i, func() (res graphql.Marshaler) {
11934 defer func() {
11935 if r := recover(); r != nil {
11936 ec.Error(ctx, ec.Recover(ctx, r))
11937 }
11938 }()
11939 res = ec._Identity_humanId(ctx, field, obj)
11940 if res == graphql.Null {
11941 atomic.AddUint32(&invalids, 1)
11942 }
11943 return res
11944 })
11945 case "name":
11946 out.Values[i] = ec._Identity_name(ctx, field, obj)
11947 case "email":
11948 out.Values[i] = ec._Identity_email(ctx, field, obj)
11949 case "login":
11950 out.Values[i] = ec._Identity_login(ctx, field, obj)
11951 case "displayName":
11952 out.Values[i] = ec._Identity_displayName(ctx, field, obj)
11953 if out.Values[i] == graphql.Null {
11954 atomic.AddUint32(&invalids, 1)
11955 }
11956 case "avatarUrl":
11957 out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
11958 case "isProtected":
11959 out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
11960 if out.Values[i] == graphql.Null {
11961 atomic.AddUint32(&invalids, 1)
11962 }
11963 default:
11964 panic("unknown field " + strconv.Quote(field.Name))
11965 }
11966 }
11967 out.Dispatch()
11968 if invalids > 0 {
11969 return graphql.Null
11970 }
11971 return out
11972}
11973
11974var identityConnectionImplementors = []string{"IdentityConnection"}
11975
11976func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
11977 fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
11978
11979 out := graphql.NewFieldSet(fields)
11980 var invalids uint32
11981 for i, field := range fields {
11982 switch field.Name {
11983 case "__typename":
11984 out.Values[i] = graphql.MarshalString("IdentityConnection")
11985 case "edges":
11986 out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
11987 if out.Values[i] == graphql.Null {
11988 invalids++
11989 }
11990 case "nodes":
11991 out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
11992 if out.Values[i] == graphql.Null {
11993 invalids++
11994 }
11995 case "pageInfo":
11996 out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
11997 if out.Values[i] == graphql.Null {
11998 invalids++
11999 }
12000 case "totalCount":
12001 out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
12002 if out.Values[i] == graphql.Null {
12003 invalids++
12004 }
12005 default:
12006 panic("unknown field " + strconv.Quote(field.Name))
12007 }
12008 }
12009 out.Dispatch()
12010 if invalids > 0 {
12011 return graphql.Null
12012 }
12013 return out
12014}
12015
12016var identityEdgeImplementors = []string{"IdentityEdge"}
12017
12018func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
12019 fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
12020
12021 out := graphql.NewFieldSet(fields)
12022 var invalids uint32
12023 for i, field := range fields {
12024 switch field.Name {
12025 case "__typename":
12026 out.Values[i] = graphql.MarshalString("IdentityEdge")
12027 case "cursor":
12028 out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
12029 if out.Values[i] == graphql.Null {
12030 invalids++
12031 }
12032 case "node":
12033 out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
12034 if out.Values[i] == graphql.Null {
12035 invalids++
12036 }
12037 default:
12038 panic("unknown field " + strconv.Quote(field.Name))
12039 }
12040 }
12041 out.Dispatch()
12042 if invalids > 0 {
12043 return graphql.Null
12044 }
12045 return out
12046}
12047
12048var labelImplementors = []string{"Label"}
12049
12050func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
12051 fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
12052
12053 out := graphql.NewFieldSet(fields)
12054 var invalids uint32
12055 for i, field := range fields {
12056 switch field.Name {
12057 case "__typename":
12058 out.Values[i] = graphql.MarshalString("Label")
12059 case "name":
12060 field := field
12061 out.Concurrently(i, func() (res graphql.Marshaler) {
12062 defer func() {
12063 if r := recover(); r != nil {
12064 ec.Error(ctx, ec.Recover(ctx, r))
12065 }
12066 }()
12067 res = ec._Label_name(ctx, field, obj)
12068 if res == graphql.Null {
12069 atomic.AddUint32(&invalids, 1)
12070 }
12071 return res
12072 })
12073 case "color":
12074 field := field
12075 out.Concurrently(i, func() (res graphql.Marshaler) {
12076 defer func() {
12077 if r := recover(); r != nil {
12078 ec.Error(ctx, ec.Recover(ctx, r))
12079 }
12080 }()
12081 res = ec._Label_color(ctx, field, obj)
12082 if res == graphql.Null {
12083 atomic.AddUint32(&invalids, 1)
12084 }
12085 return res
12086 })
12087 default:
12088 panic("unknown field " + strconv.Quote(field.Name))
12089 }
12090 }
12091 out.Dispatch()
12092 if invalids > 0 {
12093 return graphql.Null
12094 }
12095 return out
12096}
12097
12098var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
12099
12100func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
12101 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
12102
12103 out := graphql.NewFieldSet(fields)
12104 var invalids uint32
12105 for i, field := range fields {
12106 switch field.Name {
12107 case "__typename":
12108 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
12109 case "id":
12110 field := field
12111 out.Concurrently(i, func() (res graphql.Marshaler) {
12112 defer func() {
12113 if r := recover(); r != nil {
12114 ec.Error(ctx, ec.Recover(ctx, r))
12115 }
12116 }()
12117 res = ec._LabelChangeOperation_id(ctx, field, obj)
12118 if res == graphql.Null {
12119 atomic.AddUint32(&invalids, 1)
12120 }
12121 return res
12122 })
12123 case "author":
12124 out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
12125 if out.Values[i] == graphql.Null {
12126 atomic.AddUint32(&invalids, 1)
12127 }
12128 case "date":
12129 field := field
12130 out.Concurrently(i, func() (res graphql.Marshaler) {
12131 defer func() {
12132 if r := recover(); r != nil {
12133 ec.Error(ctx, ec.Recover(ctx, r))
12134 }
12135 }()
12136 res = ec._LabelChangeOperation_date(ctx, field, obj)
12137 if res == graphql.Null {
12138 atomic.AddUint32(&invalids, 1)
12139 }
12140 return res
12141 })
12142 case "added":
12143 out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
12144 if out.Values[i] == graphql.Null {
12145 atomic.AddUint32(&invalids, 1)
12146 }
12147 case "removed":
12148 out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
12149 if out.Values[i] == graphql.Null {
12150 atomic.AddUint32(&invalids, 1)
12151 }
12152 default:
12153 panic("unknown field " + strconv.Quote(field.Name))
12154 }
12155 }
12156 out.Dispatch()
12157 if invalids > 0 {
12158 return graphql.Null
12159 }
12160 return out
12161}
12162
12163var labelChangeResultImplementors = []string{"LabelChangeResult"}
12164
12165func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
12166 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
12167
12168 out := graphql.NewFieldSet(fields)
12169 var invalids uint32
12170 for i, field := range fields {
12171 switch field.Name {
12172 case "__typename":
12173 out.Values[i] = graphql.MarshalString("LabelChangeResult")
12174 case "label":
12175 out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
12176 if out.Values[i] == graphql.Null {
12177 atomic.AddUint32(&invalids, 1)
12178 }
12179 case "status":
12180 field := field
12181 out.Concurrently(i, func() (res graphql.Marshaler) {
12182 defer func() {
12183 if r := recover(); r != nil {
12184 ec.Error(ctx, ec.Recover(ctx, r))
12185 }
12186 }()
12187 res = ec._LabelChangeResult_status(ctx, field, obj)
12188 if res == graphql.Null {
12189 atomic.AddUint32(&invalids, 1)
12190 }
12191 return res
12192 })
12193 default:
12194 panic("unknown field " + strconv.Quote(field.Name))
12195 }
12196 }
12197 out.Dispatch()
12198 if invalids > 0 {
12199 return graphql.Null
12200 }
12201 return out
12202}
12203
12204var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
12205
12206func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
12207 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
12208
12209 out := graphql.NewFieldSet(fields)
12210 var invalids uint32
12211 for i, field := range fields {
12212 switch field.Name {
12213 case "__typename":
12214 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
12215 case "id":
12216 field := field
12217 out.Concurrently(i, func() (res graphql.Marshaler) {
12218 defer func() {
12219 if r := recover(); r != nil {
12220 ec.Error(ctx, ec.Recover(ctx, r))
12221 }
12222 }()
12223 res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
12224 if res == graphql.Null {
12225 atomic.AddUint32(&invalids, 1)
12226 }
12227 return res
12228 })
12229 case "author":
12230 out.Values[i] = ec._LabelChangeTimelineItem_author(ctx, field, obj)
12231 if out.Values[i] == graphql.Null {
12232 atomic.AddUint32(&invalids, 1)
12233 }
12234 case "date":
12235 field := field
12236 out.Concurrently(i, func() (res graphql.Marshaler) {
12237 defer func() {
12238 if r := recover(); r != nil {
12239 ec.Error(ctx, ec.Recover(ctx, r))
12240 }
12241 }()
12242 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
12243 if res == graphql.Null {
12244 atomic.AddUint32(&invalids, 1)
12245 }
12246 return res
12247 })
12248 case "added":
12249 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
12250 if out.Values[i] == graphql.Null {
12251 atomic.AddUint32(&invalids, 1)
12252 }
12253 case "removed":
12254 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
12255 if out.Values[i] == graphql.Null {
12256 atomic.AddUint32(&invalids, 1)
12257 }
12258 default:
12259 panic("unknown field " + strconv.Quote(field.Name))
12260 }
12261 }
12262 out.Dispatch()
12263 if invalids > 0 {
12264 return graphql.Null
12265 }
12266 return out
12267}
12268
12269var labelConnectionImplementors = []string{"LabelConnection"}
12270
12271func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
12272 fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
12273
12274 out := graphql.NewFieldSet(fields)
12275 var invalids uint32
12276 for i, field := range fields {
12277 switch field.Name {
12278 case "__typename":
12279 out.Values[i] = graphql.MarshalString("LabelConnection")
12280 case "edges":
12281 out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
12282 if out.Values[i] == graphql.Null {
12283 invalids++
12284 }
12285 case "nodes":
12286 out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
12287 if out.Values[i] == graphql.Null {
12288 invalids++
12289 }
12290 case "pageInfo":
12291 out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
12292 if out.Values[i] == graphql.Null {
12293 invalids++
12294 }
12295 case "totalCount":
12296 out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
12297 if out.Values[i] == graphql.Null {
12298 invalids++
12299 }
12300 default:
12301 panic("unknown field " + strconv.Quote(field.Name))
12302 }
12303 }
12304 out.Dispatch()
12305 if invalids > 0 {
12306 return graphql.Null
12307 }
12308 return out
12309}
12310
12311var labelEdgeImplementors = []string{"LabelEdge"}
12312
12313func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
12314 fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
12315
12316 out := graphql.NewFieldSet(fields)
12317 var invalids uint32
12318 for i, field := range fields {
12319 switch field.Name {
12320 case "__typename":
12321 out.Values[i] = graphql.MarshalString("LabelEdge")
12322 case "cursor":
12323 out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
12324 if out.Values[i] == graphql.Null {
12325 invalids++
12326 }
12327 case "node":
12328 out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
12329 if out.Values[i] == graphql.Null {
12330 invalids++
12331 }
12332 default:
12333 panic("unknown field " + strconv.Quote(field.Name))
12334 }
12335 }
12336 out.Dispatch()
12337 if invalids > 0 {
12338 return graphql.Null
12339 }
12340 return out
12341}
12342
12343var mutationImplementors = []string{"Mutation"}
12344
12345func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12346 fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
12347
12348 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12349 Object: "Mutation",
12350 })
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("Mutation")
12358 case "newBug":
12359 out.Values[i] = ec._Mutation_newBug(ctx, field)
12360 if out.Values[i] == graphql.Null {
12361 invalids++
12362 }
12363 case "addComment":
12364 out.Values[i] = ec._Mutation_addComment(ctx, field)
12365 if out.Values[i] == graphql.Null {
12366 invalids++
12367 }
12368 case "changeLabels":
12369 out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12370 if out.Values[i] == graphql.Null {
12371 invalids++
12372 }
12373 case "openBug":
12374 out.Values[i] = ec._Mutation_openBug(ctx, field)
12375 if out.Values[i] == graphql.Null {
12376 invalids++
12377 }
12378 case "closeBug":
12379 out.Values[i] = ec._Mutation_closeBug(ctx, field)
12380 if out.Values[i] == graphql.Null {
12381 invalids++
12382 }
12383 case "setTitle":
12384 out.Values[i] = ec._Mutation_setTitle(ctx, field)
12385 if out.Values[i] == graphql.Null {
12386 invalids++
12387 }
12388 case "commit":
12389 out.Values[i] = ec._Mutation_commit(ctx, field)
12390 if out.Values[i] == graphql.Null {
12391 invalids++
12392 }
12393 case "commitAsNeeded":
12394 out.Values[i] = ec._Mutation_commitAsNeeded(ctx, field)
12395 if out.Values[i] == graphql.Null {
12396 invalids++
12397 }
12398 default:
12399 panic("unknown field " + strconv.Quote(field.Name))
12400 }
12401 }
12402 out.Dispatch()
12403 if invalids > 0 {
12404 return graphql.Null
12405 }
12406 return out
12407}
12408
12409var newBugPayloadImplementors = []string{"NewBugPayload"}
12410
12411func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12412 fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
12413
12414 out := graphql.NewFieldSet(fields)
12415 var invalids uint32
12416 for i, field := range fields {
12417 switch field.Name {
12418 case "__typename":
12419 out.Values[i] = graphql.MarshalString("NewBugPayload")
12420 case "clientMutationId":
12421 out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12422 case "bug":
12423 out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12424 if out.Values[i] == graphql.Null {
12425 invalids++
12426 }
12427 case "operation":
12428 out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
12429 if out.Values[i] == graphql.Null {
12430 invalids++
12431 }
12432 default:
12433 panic("unknown field " + strconv.Quote(field.Name))
12434 }
12435 }
12436 out.Dispatch()
12437 if invalids > 0 {
12438 return graphql.Null
12439 }
12440 return out
12441}
12442
12443var openBugPayloadImplementors = []string{"OpenBugPayload"}
12444
12445func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12446 fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
12447
12448 out := graphql.NewFieldSet(fields)
12449 var invalids uint32
12450 for i, field := range fields {
12451 switch field.Name {
12452 case "__typename":
12453 out.Values[i] = graphql.MarshalString("OpenBugPayload")
12454 case "clientMutationId":
12455 out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12456 case "bug":
12457 out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12458 if out.Values[i] == graphql.Null {
12459 invalids++
12460 }
12461 case "operation":
12462 out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12463 if out.Values[i] == graphql.Null {
12464 invalids++
12465 }
12466 default:
12467 panic("unknown field " + strconv.Quote(field.Name))
12468 }
12469 }
12470 out.Dispatch()
12471 if invalids > 0 {
12472 return graphql.Null
12473 }
12474 return out
12475}
12476
12477var operationConnectionImplementors = []string{"OperationConnection"}
12478
12479func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12480 fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
12481
12482 out := graphql.NewFieldSet(fields)
12483 var invalids uint32
12484 for i, field := range fields {
12485 switch field.Name {
12486 case "__typename":
12487 out.Values[i] = graphql.MarshalString("OperationConnection")
12488 case "edges":
12489 out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12490 if out.Values[i] == graphql.Null {
12491 invalids++
12492 }
12493 case "nodes":
12494 out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12495 if out.Values[i] == graphql.Null {
12496 invalids++
12497 }
12498 case "pageInfo":
12499 out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12500 if out.Values[i] == graphql.Null {
12501 invalids++
12502 }
12503 case "totalCount":
12504 out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12505 if out.Values[i] == graphql.Null {
12506 invalids++
12507 }
12508 default:
12509 panic("unknown field " + strconv.Quote(field.Name))
12510 }
12511 }
12512 out.Dispatch()
12513 if invalids > 0 {
12514 return graphql.Null
12515 }
12516 return out
12517}
12518
12519var operationEdgeImplementors = []string{"OperationEdge"}
12520
12521func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12522 fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
12523
12524 out := graphql.NewFieldSet(fields)
12525 var invalids uint32
12526 for i, field := range fields {
12527 switch field.Name {
12528 case "__typename":
12529 out.Values[i] = graphql.MarshalString("OperationEdge")
12530 case "cursor":
12531 out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12532 if out.Values[i] == graphql.Null {
12533 invalids++
12534 }
12535 case "node":
12536 out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12537 if out.Values[i] == graphql.Null {
12538 invalids++
12539 }
12540 default:
12541 panic("unknown field " + strconv.Quote(field.Name))
12542 }
12543 }
12544 out.Dispatch()
12545 if invalids > 0 {
12546 return graphql.Null
12547 }
12548 return out
12549}
12550
12551var pageInfoImplementors = []string{"PageInfo"}
12552
12553func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12554 fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
12555
12556 out := graphql.NewFieldSet(fields)
12557 var invalids uint32
12558 for i, field := range fields {
12559 switch field.Name {
12560 case "__typename":
12561 out.Values[i] = graphql.MarshalString("PageInfo")
12562 case "hasNextPage":
12563 out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12564 if out.Values[i] == graphql.Null {
12565 invalids++
12566 }
12567 case "hasPreviousPage":
12568 out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12569 if out.Values[i] == graphql.Null {
12570 invalids++
12571 }
12572 case "startCursor":
12573 out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12574 if out.Values[i] == graphql.Null {
12575 invalids++
12576 }
12577 case "endCursor":
12578 out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12579 if out.Values[i] == graphql.Null {
12580 invalids++
12581 }
12582 default:
12583 panic("unknown field " + strconv.Quote(field.Name))
12584 }
12585 }
12586 out.Dispatch()
12587 if invalids > 0 {
12588 return graphql.Null
12589 }
12590 return out
12591}
12592
12593var queryImplementors = []string{"Query"}
12594
12595func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12596 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
12597
12598 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12599 Object: "Query",
12600 })
12601
12602 out := graphql.NewFieldSet(fields)
12603 var invalids uint32
12604 for i, field := range fields {
12605 switch field.Name {
12606 case "__typename":
12607 out.Values[i] = graphql.MarshalString("Query")
12608 case "defaultRepository":
12609 field := field
12610 out.Concurrently(i, func() (res graphql.Marshaler) {
12611 defer func() {
12612 if r := recover(); r != nil {
12613 ec.Error(ctx, ec.Recover(ctx, r))
12614 }
12615 }()
12616 res = ec._Query_defaultRepository(ctx, field)
12617 return res
12618 })
12619 case "repository":
12620 field := field
12621 out.Concurrently(i, func() (res graphql.Marshaler) {
12622 defer func() {
12623 if r := recover(); r != nil {
12624 ec.Error(ctx, ec.Recover(ctx, r))
12625 }
12626 }()
12627 res = ec._Query_repository(ctx, field)
12628 return res
12629 })
12630 case "__type":
12631 out.Values[i] = ec._Query___type(ctx, field)
12632 case "__schema":
12633 out.Values[i] = ec._Query___schema(ctx, field)
12634 default:
12635 panic("unknown field " + strconv.Quote(field.Name))
12636 }
12637 }
12638 out.Dispatch()
12639 if invalids > 0 {
12640 return graphql.Null
12641 }
12642 return out
12643}
12644
12645var repositoryImplementors = []string{"Repository"}
12646
12647func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
12648 fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
12649
12650 out := graphql.NewFieldSet(fields)
12651 var invalids uint32
12652 for i, field := range fields {
12653 switch field.Name {
12654 case "__typename":
12655 out.Values[i] = graphql.MarshalString("Repository")
12656 case "allBugs":
12657 field := field
12658 out.Concurrently(i, func() (res graphql.Marshaler) {
12659 defer func() {
12660 if r := recover(); r != nil {
12661 ec.Error(ctx, ec.Recover(ctx, r))
12662 }
12663 }()
12664 res = ec._Repository_allBugs(ctx, field, obj)
12665 if res == graphql.Null {
12666 atomic.AddUint32(&invalids, 1)
12667 }
12668 return res
12669 })
12670 case "bug":
12671 field := field
12672 out.Concurrently(i, func() (res graphql.Marshaler) {
12673 defer func() {
12674 if r := recover(); r != nil {
12675 ec.Error(ctx, ec.Recover(ctx, r))
12676 }
12677 }()
12678 res = ec._Repository_bug(ctx, field, obj)
12679 return res
12680 })
12681 case "allIdentities":
12682 field := field
12683 out.Concurrently(i, func() (res graphql.Marshaler) {
12684 defer func() {
12685 if r := recover(); r != nil {
12686 ec.Error(ctx, ec.Recover(ctx, r))
12687 }
12688 }()
12689 res = ec._Repository_allIdentities(ctx, field, obj)
12690 if res == graphql.Null {
12691 atomic.AddUint32(&invalids, 1)
12692 }
12693 return res
12694 })
12695 case "identity":
12696 field := field
12697 out.Concurrently(i, func() (res graphql.Marshaler) {
12698 defer func() {
12699 if r := recover(); r != nil {
12700 ec.Error(ctx, ec.Recover(ctx, r))
12701 }
12702 }()
12703 res = ec._Repository_identity(ctx, field, obj)
12704 return res
12705 })
12706 case "userIdentity":
12707 field := field
12708 out.Concurrently(i, func() (res graphql.Marshaler) {
12709 defer func() {
12710 if r := recover(); r != nil {
12711 ec.Error(ctx, ec.Recover(ctx, r))
12712 }
12713 }()
12714 res = ec._Repository_userIdentity(ctx, field, obj)
12715 return res
12716 })
12717 case "validLabels":
12718 field := field
12719 out.Concurrently(i, func() (res graphql.Marshaler) {
12720 defer func() {
12721 if r := recover(); r != nil {
12722 ec.Error(ctx, ec.Recover(ctx, r))
12723 }
12724 }()
12725 res = ec._Repository_validLabels(ctx, field, obj)
12726 if res == graphql.Null {
12727 atomic.AddUint32(&invalids, 1)
12728 }
12729 return res
12730 })
12731 default:
12732 panic("unknown field " + strconv.Quote(field.Name))
12733 }
12734 }
12735 out.Dispatch()
12736 if invalids > 0 {
12737 return graphql.Null
12738 }
12739 return out
12740}
12741
12742var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12743
12744func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12745 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
12746
12747 out := graphql.NewFieldSet(fields)
12748 var invalids uint32
12749 for i, field := range fields {
12750 switch field.Name {
12751 case "__typename":
12752 out.Values[i] = graphql.MarshalString("SetStatusOperation")
12753 case "id":
12754 field := field
12755 out.Concurrently(i, func() (res graphql.Marshaler) {
12756 defer func() {
12757 if r := recover(); r != nil {
12758 ec.Error(ctx, ec.Recover(ctx, r))
12759 }
12760 }()
12761 res = ec._SetStatusOperation_id(ctx, field, obj)
12762 if res == graphql.Null {
12763 atomic.AddUint32(&invalids, 1)
12764 }
12765 return res
12766 })
12767 case "author":
12768 out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
12769 if out.Values[i] == graphql.Null {
12770 atomic.AddUint32(&invalids, 1)
12771 }
12772 case "date":
12773 field := field
12774 out.Concurrently(i, func() (res graphql.Marshaler) {
12775 defer func() {
12776 if r := recover(); r != nil {
12777 ec.Error(ctx, ec.Recover(ctx, r))
12778 }
12779 }()
12780 res = ec._SetStatusOperation_date(ctx, field, obj)
12781 if res == graphql.Null {
12782 atomic.AddUint32(&invalids, 1)
12783 }
12784 return res
12785 })
12786 case "status":
12787 field := field
12788 out.Concurrently(i, func() (res graphql.Marshaler) {
12789 defer func() {
12790 if r := recover(); r != nil {
12791 ec.Error(ctx, ec.Recover(ctx, r))
12792 }
12793 }()
12794 res = ec._SetStatusOperation_status(ctx, field, obj)
12795 if res == graphql.Null {
12796 atomic.AddUint32(&invalids, 1)
12797 }
12798 return res
12799 })
12800 default:
12801 panic("unknown field " + strconv.Quote(field.Name))
12802 }
12803 }
12804 out.Dispatch()
12805 if invalids > 0 {
12806 return graphql.Null
12807 }
12808 return out
12809}
12810
12811var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12812
12813func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12814 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
12815
12816 out := graphql.NewFieldSet(fields)
12817 var invalids uint32
12818 for i, field := range fields {
12819 switch field.Name {
12820 case "__typename":
12821 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12822 case "id":
12823 field := field
12824 out.Concurrently(i, func() (res graphql.Marshaler) {
12825 defer func() {
12826 if r := recover(); r != nil {
12827 ec.Error(ctx, ec.Recover(ctx, r))
12828 }
12829 }()
12830 res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12831 if res == graphql.Null {
12832 atomic.AddUint32(&invalids, 1)
12833 }
12834 return res
12835 })
12836 case "author":
12837 out.Values[i] = ec._SetStatusTimelineItem_author(ctx, field, obj)
12838 if out.Values[i] == graphql.Null {
12839 atomic.AddUint32(&invalids, 1)
12840 }
12841 case "date":
12842 field := field
12843 out.Concurrently(i, func() (res graphql.Marshaler) {
12844 defer func() {
12845 if r := recover(); r != nil {
12846 ec.Error(ctx, ec.Recover(ctx, r))
12847 }
12848 }()
12849 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12850 if res == graphql.Null {
12851 atomic.AddUint32(&invalids, 1)
12852 }
12853 return res
12854 })
12855 case "status":
12856 field := field
12857 out.Concurrently(i, func() (res graphql.Marshaler) {
12858 defer func() {
12859 if r := recover(); r != nil {
12860 ec.Error(ctx, ec.Recover(ctx, r))
12861 }
12862 }()
12863 res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12864 if res == graphql.Null {
12865 atomic.AddUint32(&invalids, 1)
12866 }
12867 return res
12868 })
12869 default:
12870 panic("unknown field " + strconv.Quote(field.Name))
12871 }
12872 }
12873 out.Dispatch()
12874 if invalids > 0 {
12875 return graphql.Null
12876 }
12877 return out
12878}
12879
12880var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12881
12882func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12883 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
12884
12885 out := graphql.NewFieldSet(fields)
12886 var invalids uint32
12887 for i, field := range fields {
12888 switch field.Name {
12889 case "__typename":
12890 out.Values[i] = graphql.MarshalString("SetTitleOperation")
12891 case "id":
12892 field := field
12893 out.Concurrently(i, func() (res graphql.Marshaler) {
12894 defer func() {
12895 if r := recover(); r != nil {
12896 ec.Error(ctx, ec.Recover(ctx, r))
12897 }
12898 }()
12899 res = ec._SetTitleOperation_id(ctx, field, obj)
12900 if res == graphql.Null {
12901 atomic.AddUint32(&invalids, 1)
12902 }
12903 return res
12904 })
12905 case "author":
12906 out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
12907 if out.Values[i] == graphql.Null {
12908 atomic.AddUint32(&invalids, 1)
12909 }
12910 case "date":
12911 field := field
12912 out.Concurrently(i, func() (res graphql.Marshaler) {
12913 defer func() {
12914 if r := recover(); r != nil {
12915 ec.Error(ctx, ec.Recover(ctx, r))
12916 }
12917 }()
12918 res = ec._SetTitleOperation_date(ctx, field, obj)
12919 if res == graphql.Null {
12920 atomic.AddUint32(&invalids, 1)
12921 }
12922 return res
12923 })
12924 case "title":
12925 out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12926 if out.Values[i] == graphql.Null {
12927 atomic.AddUint32(&invalids, 1)
12928 }
12929 case "was":
12930 out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12931 if out.Values[i] == graphql.Null {
12932 atomic.AddUint32(&invalids, 1)
12933 }
12934 default:
12935 panic("unknown field " + strconv.Quote(field.Name))
12936 }
12937 }
12938 out.Dispatch()
12939 if invalids > 0 {
12940 return graphql.Null
12941 }
12942 return out
12943}
12944
12945var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12946
12947func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12948 fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
12949
12950 out := graphql.NewFieldSet(fields)
12951 var invalids uint32
12952 for i, field := range fields {
12953 switch field.Name {
12954 case "__typename":
12955 out.Values[i] = graphql.MarshalString("SetTitlePayload")
12956 case "clientMutationId":
12957 out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
12958 case "bug":
12959 out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
12960 if out.Values[i] == graphql.Null {
12961 invalids++
12962 }
12963 case "operation":
12964 out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
12965 if out.Values[i] == graphql.Null {
12966 invalids++
12967 }
12968 default:
12969 panic("unknown field " + strconv.Quote(field.Name))
12970 }
12971 }
12972 out.Dispatch()
12973 if invalids > 0 {
12974 return graphql.Null
12975 }
12976 return out
12977}
12978
12979var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
12980
12981func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
12982 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
12983
12984 out := graphql.NewFieldSet(fields)
12985 var invalids uint32
12986 for i, field := range fields {
12987 switch field.Name {
12988 case "__typename":
12989 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
12990 case "id":
12991 field := field
12992 out.Concurrently(i, func() (res graphql.Marshaler) {
12993 defer func() {
12994 if r := recover(); r != nil {
12995 ec.Error(ctx, ec.Recover(ctx, r))
12996 }
12997 }()
12998 res = ec._SetTitleTimelineItem_id(ctx, field, obj)
12999 if res == graphql.Null {
13000 atomic.AddUint32(&invalids, 1)
13001 }
13002 return res
13003 })
13004 case "author":
13005 out.Values[i] = ec._SetTitleTimelineItem_author(ctx, field, obj)
13006 if out.Values[i] == graphql.Null {
13007 atomic.AddUint32(&invalids, 1)
13008 }
13009 case "date":
13010 field := field
13011 out.Concurrently(i, func() (res graphql.Marshaler) {
13012 defer func() {
13013 if r := recover(); r != nil {
13014 ec.Error(ctx, ec.Recover(ctx, r))
13015 }
13016 }()
13017 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
13018 if res == graphql.Null {
13019 atomic.AddUint32(&invalids, 1)
13020 }
13021 return res
13022 })
13023 case "title":
13024 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
13025 if out.Values[i] == graphql.Null {
13026 atomic.AddUint32(&invalids, 1)
13027 }
13028 case "was":
13029 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
13030 if out.Values[i] == graphql.Null {
13031 atomic.AddUint32(&invalids, 1)
13032 }
13033 default:
13034 panic("unknown field " + strconv.Quote(field.Name))
13035 }
13036 }
13037 out.Dispatch()
13038 if invalids > 0 {
13039 return graphql.Null
13040 }
13041 return out
13042}
13043
13044var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
13045
13046func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
13047 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
13048
13049 out := graphql.NewFieldSet(fields)
13050 var invalids uint32
13051 for i, field := range fields {
13052 switch field.Name {
13053 case "__typename":
13054 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
13055 case "edges":
13056 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
13057 if out.Values[i] == graphql.Null {
13058 invalids++
13059 }
13060 case "nodes":
13061 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
13062 if out.Values[i] == graphql.Null {
13063 invalids++
13064 }
13065 case "pageInfo":
13066 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
13067 if out.Values[i] == graphql.Null {
13068 invalids++
13069 }
13070 case "totalCount":
13071 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
13072 if out.Values[i] == graphql.Null {
13073 invalids++
13074 }
13075 default:
13076 panic("unknown field " + strconv.Quote(field.Name))
13077 }
13078 }
13079 out.Dispatch()
13080 if invalids > 0 {
13081 return graphql.Null
13082 }
13083 return out
13084}
13085
13086var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
13087
13088func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
13089 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
13090
13091 out := graphql.NewFieldSet(fields)
13092 var invalids uint32
13093 for i, field := range fields {
13094 switch field.Name {
13095 case "__typename":
13096 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
13097 case "cursor":
13098 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
13099 if out.Values[i] == graphql.Null {
13100 invalids++
13101 }
13102 case "node":
13103 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
13104 if out.Values[i] == graphql.Null {
13105 invalids++
13106 }
13107 default:
13108 panic("unknown field " + strconv.Quote(field.Name))
13109 }
13110 }
13111 out.Dispatch()
13112 if invalids > 0 {
13113 return graphql.Null
13114 }
13115 return out
13116}
13117
13118var __DirectiveImplementors = []string{"__Directive"}
13119
13120func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
13121 fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
13122
13123 out := graphql.NewFieldSet(fields)
13124 var invalids uint32
13125 for i, field := range fields {
13126 switch field.Name {
13127 case "__typename":
13128 out.Values[i] = graphql.MarshalString("__Directive")
13129 case "name":
13130 out.Values[i] = ec.___Directive_name(ctx, field, obj)
13131 if out.Values[i] == graphql.Null {
13132 invalids++
13133 }
13134 case "description":
13135 out.Values[i] = ec.___Directive_description(ctx, field, obj)
13136 case "locations":
13137 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
13138 if out.Values[i] == graphql.Null {
13139 invalids++
13140 }
13141 case "args":
13142 out.Values[i] = ec.___Directive_args(ctx, field, obj)
13143 if out.Values[i] == graphql.Null {
13144 invalids++
13145 }
13146 default:
13147 panic("unknown field " + strconv.Quote(field.Name))
13148 }
13149 }
13150 out.Dispatch()
13151 if invalids > 0 {
13152 return graphql.Null
13153 }
13154 return out
13155}
13156
13157var __EnumValueImplementors = []string{"__EnumValue"}
13158
13159func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
13160 fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
13161
13162 out := graphql.NewFieldSet(fields)
13163 var invalids uint32
13164 for i, field := range fields {
13165 switch field.Name {
13166 case "__typename":
13167 out.Values[i] = graphql.MarshalString("__EnumValue")
13168 case "name":
13169 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
13170 if out.Values[i] == graphql.Null {
13171 invalids++
13172 }
13173 case "description":
13174 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
13175 case "isDeprecated":
13176 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
13177 if out.Values[i] == graphql.Null {
13178 invalids++
13179 }
13180 case "deprecationReason":
13181 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
13182 default:
13183 panic("unknown field " + strconv.Quote(field.Name))
13184 }
13185 }
13186 out.Dispatch()
13187 if invalids > 0 {
13188 return graphql.Null
13189 }
13190 return out
13191}
13192
13193var __FieldImplementors = []string{"__Field"}
13194
13195func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
13196 fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
13197
13198 out := graphql.NewFieldSet(fields)
13199 var invalids uint32
13200 for i, field := range fields {
13201 switch field.Name {
13202 case "__typename":
13203 out.Values[i] = graphql.MarshalString("__Field")
13204 case "name":
13205 out.Values[i] = ec.___Field_name(ctx, field, obj)
13206 if out.Values[i] == graphql.Null {
13207 invalids++
13208 }
13209 case "description":
13210 out.Values[i] = ec.___Field_description(ctx, field, obj)
13211 case "args":
13212 out.Values[i] = ec.___Field_args(ctx, field, obj)
13213 if out.Values[i] == graphql.Null {
13214 invalids++
13215 }
13216 case "type":
13217 out.Values[i] = ec.___Field_type(ctx, field, obj)
13218 if out.Values[i] == graphql.Null {
13219 invalids++
13220 }
13221 case "isDeprecated":
13222 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
13223 if out.Values[i] == graphql.Null {
13224 invalids++
13225 }
13226 case "deprecationReason":
13227 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
13228 default:
13229 panic("unknown field " + strconv.Quote(field.Name))
13230 }
13231 }
13232 out.Dispatch()
13233 if invalids > 0 {
13234 return graphql.Null
13235 }
13236 return out
13237}
13238
13239var __InputValueImplementors = []string{"__InputValue"}
13240
13241func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
13242 fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
13243
13244 out := graphql.NewFieldSet(fields)
13245 var invalids uint32
13246 for i, field := range fields {
13247 switch field.Name {
13248 case "__typename":
13249 out.Values[i] = graphql.MarshalString("__InputValue")
13250 case "name":
13251 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
13252 if out.Values[i] == graphql.Null {
13253 invalids++
13254 }
13255 case "description":
13256 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
13257 case "type":
13258 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
13259 if out.Values[i] == graphql.Null {
13260 invalids++
13261 }
13262 case "defaultValue":
13263 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
13264 default:
13265 panic("unknown field " + strconv.Quote(field.Name))
13266 }
13267 }
13268 out.Dispatch()
13269 if invalids > 0 {
13270 return graphql.Null
13271 }
13272 return out
13273}
13274
13275var __SchemaImplementors = []string{"__Schema"}
13276
13277func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
13278 fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
13279
13280 out := graphql.NewFieldSet(fields)
13281 var invalids uint32
13282 for i, field := range fields {
13283 switch field.Name {
13284 case "__typename":
13285 out.Values[i] = graphql.MarshalString("__Schema")
13286 case "types":
13287 out.Values[i] = ec.___Schema_types(ctx, field, obj)
13288 if out.Values[i] == graphql.Null {
13289 invalids++
13290 }
13291 case "queryType":
13292 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
13293 if out.Values[i] == graphql.Null {
13294 invalids++
13295 }
13296 case "mutationType":
13297 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13298 case "subscriptionType":
13299 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13300 case "directives":
13301 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13302 if out.Values[i] == graphql.Null {
13303 invalids++
13304 }
13305 default:
13306 panic("unknown field " + strconv.Quote(field.Name))
13307 }
13308 }
13309 out.Dispatch()
13310 if invalids > 0 {
13311 return graphql.Null
13312 }
13313 return out
13314}
13315
13316var __TypeImplementors = []string{"__Type"}
13317
13318func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13319 fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
13320
13321 out := graphql.NewFieldSet(fields)
13322 var invalids uint32
13323 for i, field := range fields {
13324 switch field.Name {
13325 case "__typename":
13326 out.Values[i] = graphql.MarshalString("__Type")
13327 case "kind":
13328 out.Values[i] = ec.___Type_kind(ctx, field, obj)
13329 if out.Values[i] == graphql.Null {
13330 invalids++
13331 }
13332 case "name":
13333 out.Values[i] = ec.___Type_name(ctx, field, obj)
13334 case "description":
13335 out.Values[i] = ec.___Type_description(ctx, field, obj)
13336 case "fields":
13337 out.Values[i] = ec.___Type_fields(ctx, field, obj)
13338 case "interfaces":
13339 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13340 case "possibleTypes":
13341 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13342 case "enumValues":
13343 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13344 case "inputFields":
13345 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13346 case "ofType":
13347 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13348 default:
13349 panic("unknown field " + strconv.Quote(field.Name))
13350 }
13351 }
13352 out.Dispatch()
13353 if invalids > 0 {
13354 return graphql.Null
13355 }
13356 return out
13357}
13358
13359// endregion **************************** object.gotpl ****************************
13360
13361// region ***************************** type.gotpl *****************************
13362
13363func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13364 return ec.unmarshalInputAddCommentInput(ctx, v)
13365}
13366
13367func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13368 return ec._AddCommentOperation(ctx, sel, &v)
13369}
13370
13371func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
13372 if v == nil {
13373 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13374 ec.Errorf(ctx, "must not be null")
13375 }
13376 return graphql.Null
13377 }
13378 return ec._AddCommentOperation(ctx, sel, v)
13379}
13380
13381func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13382 return ec._AddCommentPayload(ctx, sel, &v)
13383}
13384
13385func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13386 if v == nil {
13387 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13388 ec.Errorf(ctx, "must not be null")
13389 }
13390 return graphql.Null
13391 }
13392 return ec._AddCommentPayload(ctx, sel, v)
13393}
13394
13395func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13396 return graphql.UnmarshalBoolean(v)
13397}
13398
13399func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13400 res := graphql.MarshalBoolean(v)
13401 if res == graphql.Null {
13402 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13403 ec.Errorf(ctx, "must not be null")
13404 }
13405 }
13406 return res
13407}
13408
13409func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
13410 return ec._Bug(ctx, sel, &v)
13411}
13412
13413func (ec *executionContext) marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshotᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Snapshot) graphql.Marshaler {
13414 ret := make(graphql.Array, len(v))
13415 var wg sync.WaitGroup
13416 isLen1 := len(v) == 1
13417 if !isLen1 {
13418 wg.Add(len(v))
13419 }
13420 for i := range v {
13421 i := i
13422 fc := &graphql.FieldContext{
13423 Index: &i,
13424 Result: &v[i],
13425 }
13426 ctx := graphql.WithFieldContext(ctx, fc)
13427 f := func(i int) {
13428 defer func() {
13429 if r := recover(); r != nil {
13430 ec.Error(ctx, ec.Recover(ctx, r))
13431 ret = nil
13432 }
13433 }()
13434 if !isLen1 {
13435 defer wg.Done()
13436 }
13437 ret[i] = ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, sel, v[i])
13438 }
13439 if isLen1 {
13440 f(i)
13441 } else {
13442 go f(i)
13443 }
13444
13445 }
13446 wg.Wait()
13447 return ret
13448}
13449
13450func (ec *executionContext) marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
13451 if v == nil {
13452 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13453 ec.Errorf(ctx, "must not be null")
13454 }
13455 return graphql.Null
13456 }
13457 return ec._Bug(ctx, sel, v)
13458}
13459
13460func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13461 return ec._BugConnection(ctx, sel, &v)
13462}
13463
13464func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
13465 if v == nil {
13466 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13467 ec.Errorf(ctx, "must not be null")
13468 }
13469 return graphql.Null
13470 }
13471 return ec._BugConnection(ctx, sel, v)
13472}
13473
13474func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13475 return ec._BugEdge(ctx, sel, &v)
13476}
13477
13478func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13479 ret := make(graphql.Array, len(v))
13480 var wg sync.WaitGroup
13481 isLen1 := len(v) == 1
13482 if !isLen1 {
13483 wg.Add(len(v))
13484 }
13485 for i := range v {
13486 i := i
13487 fc := &graphql.FieldContext{
13488 Index: &i,
13489 Result: &v[i],
13490 }
13491 ctx := graphql.WithFieldContext(ctx, fc)
13492 f := func(i int) {
13493 defer func() {
13494 if r := recover(); r != nil {
13495 ec.Error(ctx, ec.Recover(ctx, r))
13496 ret = nil
13497 }
13498 }()
13499 if !isLen1 {
13500 defer wg.Done()
13501 }
13502 ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13503 }
13504 if isLen1 {
13505 f(i)
13506 } else {
13507 go f(i)
13508 }
13509
13510 }
13511 wg.Wait()
13512 return ret
13513}
13514
13515func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13516 if v == nil {
13517 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13518 ec.Errorf(ctx, "must not be null")
13519 }
13520 return graphql.Null
13521 }
13522 return ec._BugEdge(ctx, sel, v)
13523}
13524
13525func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13526 return ec._ChangeLabelPayload(ctx, sel, &v)
13527}
13528
13529func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13530 if v == nil {
13531 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13532 ec.Errorf(ctx, "must not be null")
13533 }
13534 return graphql.Null
13535 }
13536 return ec._ChangeLabelPayload(ctx, sel, v)
13537}
13538
13539func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13540 return ec.unmarshalInputCloseBugInput(ctx, v)
13541}
13542
13543func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13544 return ec._CloseBugPayload(ctx, sel, &v)
13545}
13546
13547func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
13548 if v == nil {
13549 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13550 ec.Errorf(ctx, "must not be null")
13551 }
13552 return graphql.Null
13553 }
13554 return ec._CloseBugPayload(ctx, sel, v)
13555}
13556
13557func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13558 return ec._Color(ctx, sel, &v)
13559}
13560
13561func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
13562 if v == nil {
13563 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13564 ec.Errorf(ctx, "must not be null")
13565 }
13566 return graphql.Null
13567 }
13568 return ec._Color(ctx, sel, v)
13569}
13570
13571func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
13572 return ec._Comment(ctx, sel, &v)
13573}
13574
13575func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
13576 ret := make(graphql.Array, len(v))
13577 var wg sync.WaitGroup
13578 isLen1 := len(v) == 1
13579 if !isLen1 {
13580 wg.Add(len(v))
13581 }
13582 for i := range v {
13583 i := i
13584 fc := &graphql.FieldContext{
13585 Index: &i,
13586 Result: &v[i],
13587 }
13588 ctx := graphql.WithFieldContext(ctx, fc)
13589 f := func(i int) {
13590 defer func() {
13591 if r := recover(); r != nil {
13592 ec.Error(ctx, ec.Recover(ctx, r))
13593 ret = nil
13594 }
13595 }()
13596 if !isLen1 {
13597 defer wg.Done()
13598 }
13599 ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
13600 }
13601 if isLen1 {
13602 f(i)
13603 } else {
13604 go f(i)
13605 }
13606
13607 }
13608 wg.Wait()
13609 return ret
13610}
13611
13612func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13613 if v == nil {
13614 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13615 ec.Errorf(ctx, "must not be null")
13616 }
13617 return graphql.Null
13618 }
13619 return ec._Comment(ctx, sel, v)
13620}
13621
13622func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13623 return ec._CommentConnection(ctx, sel, &v)
13624}
13625
13626func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13627 if v == nil {
13628 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13629 ec.Errorf(ctx, "must not be null")
13630 }
13631 return graphql.Null
13632 }
13633 return ec._CommentConnection(ctx, sel, v)
13634}
13635
13636func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13637 return ec._CommentEdge(ctx, sel, &v)
13638}
13639
13640func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13641 ret := make(graphql.Array, len(v))
13642 var wg sync.WaitGroup
13643 isLen1 := len(v) == 1
13644 if !isLen1 {
13645 wg.Add(len(v))
13646 }
13647 for i := range v {
13648 i := i
13649 fc := &graphql.FieldContext{
13650 Index: &i,
13651 Result: &v[i],
13652 }
13653 ctx := graphql.WithFieldContext(ctx, fc)
13654 f := func(i int) {
13655 defer func() {
13656 if r := recover(); r != nil {
13657 ec.Error(ctx, ec.Recover(ctx, r))
13658 ret = nil
13659 }
13660 }()
13661 if !isLen1 {
13662 defer wg.Done()
13663 }
13664 ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13665 }
13666 if isLen1 {
13667 f(i)
13668 } else {
13669 go f(i)
13670 }
13671
13672 }
13673 wg.Wait()
13674 return ret
13675}
13676
13677func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13678 if v == nil {
13679 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13680 ec.Errorf(ctx, "must not be null")
13681 }
13682 return graphql.Null
13683 }
13684 return ec._CommentEdge(ctx, sel, v)
13685}
13686
13687func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13688 return ec._CommentHistoryStep(ctx, sel, &v)
13689}
13690
13691func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13692 ret := make(graphql.Array, len(v))
13693 var wg sync.WaitGroup
13694 isLen1 := len(v) == 1
13695 if !isLen1 {
13696 wg.Add(len(v))
13697 }
13698 for i := range v {
13699 i := i
13700 fc := &graphql.FieldContext{
13701 Index: &i,
13702 Result: &v[i],
13703 }
13704 ctx := graphql.WithFieldContext(ctx, fc)
13705 f := func(i int) {
13706 defer func() {
13707 if r := recover(); r != nil {
13708 ec.Error(ctx, ec.Recover(ctx, r))
13709 ret = nil
13710 }
13711 }()
13712 if !isLen1 {
13713 defer wg.Done()
13714 }
13715 ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13716 }
13717 if isLen1 {
13718 f(i)
13719 } else {
13720 go f(i)
13721 }
13722
13723 }
13724 wg.Wait()
13725 return ret
13726}
13727
13728func (ec *executionContext) unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
13729 return ec.unmarshalInputCommitAsNeededInput(ctx, v)
13730}
13731
13732func (ec *executionContext) marshalNCommitAsNeededPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitAsNeededPayload) graphql.Marshaler {
13733 return ec._CommitAsNeededPayload(ctx, sel, &v)
13734}
13735
13736func (ec *executionContext) marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitAsNeededPayload) graphql.Marshaler {
13737 if v == nil {
13738 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13739 ec.Errorf(ctx, "must not be null")
13740 }
13741 return graphql.Null
13742 }
13743 return ec._CommitAsNeededPayload(ctx, sel, v)
13744}
13745
13746func (ec *executionContext) unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
13747 return ec.unmarshalInputCommitInput(ctx, v)
13748}
13749
13750func (ec *executionContext) marshalNCommitPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitPayload) graphql.Marshaler {
13751 return ec._CommitPayload(ctx, sel, &v)
13752}
13753
13754func (ec *executionContext) marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitPayload) graphql.Marshaler {
13755 if v == nil {
13756 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13757 ec.Errorf(ctx, "must not be null")
13758 }
13759 return graphql.Null
13760 }
13761 return ec._CommitPayload(ctx, sel, v)
13762}
13763
13764func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13765 return ec._CreateOperation(ctx, sel, &v)
13766}
13767
13768func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13769 if v == nil {
13770 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13771 ec.Errorf(ctx, "must not be null")
13772 }
13773 return graphql.Null
13774 }
13775 return ec._CreateOperation(ctx, sel, v)
13776}
13777
13778func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
13779 var res git.Hash
13780 return res, res.UnmarshalGQL(v)
13781}
13782
13783func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
13784 return v
13785}
13786
13787func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
13788 var vSlice []interface{}
13789 if v != nil {
13790 if tmp1, ok := v.([]interface{}); ok {
13791 vSlice = tmp1
13792 } else {
13793 vSlice = []interface{}{v}
13794 }
13795 }
13796 var err error
13797 res := make([]git.Hash, len(vSlice))
13798 for i := range vSlice {
13799 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
13800 if err != nil {
13801 return nil, err
13802 }
13803 }
13804 return res, nil
13805}
13806
13807func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
13808 ret := make(graphql.Array, len(v))
13809 for i := range v {
13810 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
13811 }
13812
13813 return ret
13814}
13815
13816func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
13817 if v == nil {
13818 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13819 ec.Errorf(ctx, "must not be null")
13820 }
13821 return graphql.Null
13822 }
13823 return ec._Identity(ctx, sel, v)
13824}
13825
13826func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterfaceᚄ(ctx context.Context, sel ast.SelectionSet, v []identity.Interface) graphql.Marshaler {
13827 ret := make(graphql.Array, len(v))
13828 var wg sync.WaitGroup
13829 isLen1 := len(v) == 1
13830 if !isLen1 {
13831 wg.Add(len(v))
13832 }
13833 for i := range v {
13834 i := i
13835 fc := &graphql.FieldContext{
13836 Index: &i,
13837 Result: &v[i],
13838 }
13839 ctx := graphql.WithFieldContext(ctx, fc)
13840 f := func(i int) {
13841 defer func() {
13842 if r := recover(); r != nil {
13843 ec.Error(ctx, ec.Recover(ctx, r))
13844 ret = nil
13845 }
13846 }()
13847 if !isLen1 {
13848 defer wg.Done()
13849 }
13850 ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, sel, v[i])
13851 }
13852 if isLen1 {
13853 f(i)
13854 } else {
13855 go f(i)
13856 }
13857
13858 }
13859 wg.Wait()
13860 return ret
13861}
13862
13863func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13864 return ec._IdentityConnection(ctx, sel, &v)
13865}
13866
13867func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13868 if v == nil {
13869 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13870 ec.Errorf(ctx, "must not be null")
13871 }
13872 return graphql.Null
13873 }
13874 return ec._IdentityConnection(ctx, sel, v)
13875}
13876
13877func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13878 return ec._IdentityEdge(ctx, sel, &v)
13879}
13880
13881func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13882 ret := make(graphql.Array, len(v))
13883 var wg sync.WaitGroup
13884 isLen1 := len(v) == 1
13885 if !isLen1 {
13886 wg.Add(len(v))
13887 }
13888 for i := range v {
13889 i := i
13890 fc := &graphql.FieldContext{
13891 Index: &i,
13892 Result: &v[i],
13893 }
13894 ctx := graphql.WithFieldContext(ctx, fc)
13895 f := func(i int) {
13896 defer func() {
13897 if r := recover(); r != nil {
13898 ec.Error(ctx, ec.Recover(ctx, r))
13899 ret = nil
13900 }
13901 }()
13902 if !isLen1 {
13903 defer wg.Done()
13904 }
13905 ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13906 }
13907 if isLen1 {
13908 f(i)
13909 } else {
13910 go f(i)
13911 }
13912
13913 }
13914 wg.Wait()
13915 return ret
13916}
13917
13918func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
13919 if v == nil {
13920 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13921 ec.Errorf(ctx, "must not be null")
13922 }
13923 return graphql.Null
13924 }
13925 return ec._IdentityEdge(ctx, sel, v)
13926}
13927
13928func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13929 return graphql.UnmarshalInt(v)
13930}
13931
13932func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13933 res := graphql.MarshalInt(v)
13934 if res == graphql.Null {
13935 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13936 ec.Errorf(ctx, "must not be null")
13937 }
13938 }
13939 return res
13940}
13941
13942func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
13943 return ec._Label(ctx, sel, &v)
13944}
13945
13946func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
13947 ret := make(graphql.Array, len(v))
13948 var wg sync.WaitGroup
13949 isLen1 := len(v) == 1
13950 if !isLen1 {
13951 wg.Add(len(v))
13952 }
13953 for i := range v {
13954 i := i
13955 fc := &graphql.FieldContext{
13956 Index: &i,
13957 Result: &v[i],
13958 }
13959 ctx := graphql.WithFieldContext(ctx, fc)
13960 f := func(i int) {
13961 defer func() {
13962 if r := recover(); r != nil {
13963 ec.Error(ctx, ec.Recover(ctx, r))
13964 ret = nil
13965 }
13966 }()
13967 if !isLen1 {
13968 defer wg.Done()
13969 }
13970 ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
13971 }
13972 if isLen1 {
13973 f(i)
13974 } else {
13975 go f(i)
13976 }
13977
13978 }
13979 wg.Wait()
13980 return ret
13981}
13982
13983func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
13984 return ec._LabelChangeOperation(ctx, sel, &v)
13985}
13986
13987func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
13988 if v == nil {
13989 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13990 ec.Errorf(ctx, "must not be null")
13991 }
13992 return graphql.Null
13993 }
13994 return ec._LabelChangeOperation(ctx, sel, v)
13995}
13996
13997func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
13998 ret := make(graphql.Array, len(v))
13999 var wg sync.WaitGroup
14000 isLen1 := len(v) == 1
14001 if !isLen1 {
14002 wg.Add(len(v))
14003 }
14004 for i := range v {
14005 i := i
14006 fc := &graphql.FieldContext{
14007 Index: &i,
14008 Result: &v[i],
14009 }
14010 ctx := graphql.WithFieldContext(ctx, fc)
14011 f := func(i int) {
14012 defer func() {
14013 if r := recover(); r != nil {
14014 ec.Error(ctx, ec.Recover(ctx, r))
14015 ret = nil
14016 }
14017 }()
14018 if !isLen1 {
14019 defer wg.Done()
14020 }
14021 ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
14022 }
14023 if isLen1 {
14024 f(i)
14025 } else {
14026 go f(i)
14027 }
14028
14029 }
14030 wg.Wait()
14031 return ret
14032}
14033
14034func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
14035 var res models.LabelChangeStatus
14036 return res, res.UnmarshalGQL(v)
14037}
14038
14039func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
14040 return v
14041}
14042
14043func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
14044 return ec._LabelConnection(ctx, sel, &v)
14045}
14046
14047func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
14048 if v == nil {
14049 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14050 ec.Errorf(ctx, "must not be null")
14051 }
14052 return graphql.Null
14053 }
14054 return ec._LabelConnection(ctx, sel, v)
14055}
14056
14057func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
14058 return ec._LabelEdge(ctx, sel, &v)
14059}
14060
14061func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
14062 ret := make(graphql.Array, len(v))
14063 var wg sync.WaitGroup
14064 isLen1 := len(v) == 1
14065 if !isLen1 {
14066 wg.Add(len(v))
14067 }
14068 for i := range v {
14069 i := i
14070 fc := &graphql.FieldContext{
14071 Index: &i,
14072 Result: &v[i],
14073 }
14074 ctx := graphql.WithFieldContext(ctx, fc)
14075 f := func(i int) {
14076 defer func() {
14077 if r := recover(); r != nil {
14078 ec.Error(ctx, ec.Recover(ctx, r))
14079 ret = nil
14080 }
14081 }()
14082 if !isLen1 {
14083 defer wg.Done()
14084 }
14085 ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
14086 }
14087 if isLen1 {
14088 f(i)
14089 } else {
14090 go f(i)
14091 }
14092
14093 }
14094 wg.Wait()
14095 return ret
14096}
14097
14098func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
14099 if v == nil {
14100 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14101 ec.Errorf(ctx, "must not be null")
14102 }
14103 return graphql.Null
14104 }
14105 return ec._LabelEdge(ctx, sel, v)
14106}
14107
14108func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
14109 return ec.unmarshalInputNewBugInput(ctx, v)
14110}
14111
14112func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
14113 return ec._NewBugPayload(ctx, sel, &v)
14114}
14115
14116func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
14117 if v == nil {
14118 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14119 ec.Errorf(ctx, "must not be null")
14120 }
14121 return graphql.Null
14122 }
14123 return ec._NewBugPayload(ctx, sel, v)
14124}
14125
14126func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
14127 return ec.unmarshalInputOpenBugInput(ctx, v)
14128}
14129
14130func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
14131 return ec._OpenBugPayload(ctx, sel, &v)
14132}
14133
14134func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
14135 if v == nil {
14136 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14137 ec.Errorf(ctx, "must not be null")
14138 }
14139 return graphql.Null
14140 }
14141 return ec._OpenBugPayload(ctx, sel, v)
14142}
14143
14144func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
14145 if v == nil {
14146 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14147 ec.Errorf(ctx, "must not be null")
14148 }
14149 return graphql.Null
14150 }
14151 return ec._Operation(ctx, sel, v)
14152}
14153
14154func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
14155 ret := make(graphql.Array, len(v))
14156 var wg sync.WaitGroup
14157 isLen1 := len(v) == 1
14158 if !isLen1 {
14159 wg.Add(len(v))
14160 }
14161 for i := range v {
14162 i := i
14163 fc := &graphql.FieldContext{
14164 Index: &i,
14165 Result: &v[i],
14166 }
14167 ctx := graphql.WithFieldContext(ctx, fc)
14168 f := func(i int) {
14169 defer func() {
14170 if r := recover(); r != nil {
14171 ec.Error(ctx, ec.Recover(ctx, r))
14172 ret = nil
14173 }
14174 }()
14175 if !isLen1 {
14176 defer wg.Done()
14177 }
14178 ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
14179 }
14180 if isLen1 {
14181 f(i)
14182 } else {
14183 go f(i)
14184 }
14185
14186 }
14187 wg.Wait()
14188 return ret
14189}
14190
14191func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
14192 return ec._OperationConnection(ctx, sel, &v)
14193}
14194
14195func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
14196 if v == nil {
14197 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14198 ec.Errorf(ctx, "must not be null")
14199 }
14200 return graphql.Null
14201 }
14202 return ec._OperationConnection(ctx, sel, v)
14203}
14204
14205func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
14206 return ec._OperationEdge(ctx, sel, &v)
14207}
14208
14209func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
14210 ret := make(graphql.Array, len(v))
14211 var wg sync.WaitGroup
14212 isLen1 := len(v) == 1
14213 if !isLen1 {
14214 wg.Add(len(v))
14215 }
14216 for i := range v {
14217 i := i
14218 fc := &graphql.FieldContext{
14219 Index: &i,
14220 Result: &v[i],
14221 }
14222 ctx := graphql.WithFieldContext(ctx, fc)
14223 f := func(i int) {
14224 defer func() {
14225 if r := recover(); r != nil {
14226 ec.Error(ctx, ec.Recover(ctx, r))
14227 ret = nil
14228 }
14229 }()
14230 if !isLen1 {
14231 defer wg.Done()
14232 }
14233 ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
14234 }
14235 if isLen1 {
14236 f(i)
14237 } else {
14238 go f(i)
14239 }
14240
14241 }
14242 wg.Wait()
14243 return ret
14244}
14245
14246func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
14247 if v == nil {
14248 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14249 ec.Errorf(ctx, "must not be null")
14250 }
14251 return graphql.Null
14252 }
14253 return ec._OperationEdge(ctx, sel, v)
14254}
14255
14256func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
14257 return ec._PageInfo(ctx, sel, &v)
14258}
14259
14260func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
14261 if v == nil {
14262 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14263 ec.Errorf(ctx, "must not be null")
14264 }
14265 return graphql.Null
14266 }
14267 return ec._PageInfo(ctx, sel, v)
14268}
14269
14270func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
14271 return ec._SetStatusOperation(ctx, sel, &v)
14272}
14273
14274func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
14275 if v == nil {
14276 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14277 ec.Errorf(ctx, "must not be null")
14278 }
14279 return graphql.Null
14280 }
14281 return ec._SetStatusOperation(ctx, sel, v)
14282}
14283
14284func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
14285 return ec.unmarshalInputSetTitleInput(ctx, v)
14286}
14287
14288func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
14289 return ec._SetTitleOperation(ctx, sel, &v)
14290}
14291
14292func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
14293 if v == nil {
14294 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14295 ec.Errorf(ctx, "must not be null")
14296 }
14297 return graphql.Null
14298 }
14299 return ec._SetTitleOperation(ctx, sel, v)
14300}
14301
14302func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
14303 return ec._SetTitlePayload(ctx, sel, &v)
14304}
14305
14306func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14307 if v == nil {
14308 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14309 ec.Errorf(ctx, "must not be null")
14310 }
14311 return graphql.Null
14312 }
14313 return ec._SetTitlePayload(ctx, sel, v)
14314}
14315
14316func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14317 var res models.Status
14318 return res, res.UnmarshalGQL(v)
14319}
14320
14321func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14322 return v
14323}
14324
14325func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14326 return graphql.UnmarshalString(v)
14327}
14328
14329func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14330 res := graphql.MarshalString(v)
14331 if res == graphql.Null {
14332 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14333 ec.Errorf(ctx, "must not be null")
14334 }
14335 }
14336 return res
14337}
14338
14339func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14340 return graphql.UnmarshalTime(v)
14341}
14342
14343func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14344 res := graphql.MarshalTime(v)
14345 if res == graphql.Null {
14346 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14347 ec.Errorf(ctx, "must not be null")
14348 }
14349 }
14350 return res
14351}
14352
14353func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14354 if v == nil {
14355 return nil, nil
14356 }
14357 res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14358 return &res, err
14359}
14360
14361func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14362 if v == nil {
14363 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14364 ec.Errorf(ctx, "must not be null")
14365 }
14366 return graphql.Null
14367 }
14368 return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14369}
14370
14371func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14372 if v == nil {
14373 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14374 ec.Errorf(ctx, "must not be null")
14375 }
14376 return graphql.Null
14377 }
14378 return ec._TimelineItem(ctx, sel, v)
14379}
14380
14381func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14382 ret := make(graphql.Array, len(v))
14383 var wg sync.WaitGroup
14384 isLen1 := len(v) == 1
14385 if !isLen1 {
14386 wg.Add(len(v))
14387 }
14388 for i := range v {
14389 i := i
14390 fc := &graphql.FieldContext{
14391 Index: &i,
14392 Result: &v[i],
14393 }
14394 ctx := graphql.WithFieldContext(ctx, fc)
14395 f := func(i int) {
14396 defer func() {
14397 if r := recover(); r != nil {
14398 ec.Error(ctx, ec.Recover(ctx, r))
14399 ret = nil
14400 }
14401 }()
14402 if !isLen1 {
14403 defer wg.Done()
14404 }
14405 ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14406 }
14407 if isLen1 {
14408 f(i)
14409 } else {
14410 go f(i)
14411 }
14412
14413 }
14414 wg.Wait()
14415 return ret
14416}
14417
14418func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14419 return ec._TimelineItemConnection(ctx, sel, &v)
14420}
14421
14422func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14423 if v == nil {
14424 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14425 ec.Errorf(ctx, "must not be null")
14426 }
14427 return graphql.Null
14428 }
14429 return ec._TimelineItemConnection(ctx, sel, v)
14430}
14431
14432func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14433 return ec._TimelineItemEdge(ctx, sel, &v)
14434}
14435
14436func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14437 ret := make(graphql.Array, len(v))
14438 var wg sync.WaitGroup
14439 isLen1 := len(v) == 1
14440 if !isLen1 {
14441 wg.Add(len(v))
14442 }
14443 for i := range v {
14444 i := i
14445 fc := &graphql.FieldContext{
14446 Index: &i,
14447 Result: &v[i],
14448 }
14449 ctx := graphql.WithFieldContext(ctx, fc)
14450 f := func(i int) {
14451 defer func() {
14452 if r := recover(); r != nil {
14453 ec.Error(ctx, ec.Recover(ctx, r))
14454 ret = nil
14455 }
14456 }()
14457 if !isLen1 {
14458 defer wg.Done()
14459 }
14460 ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14461 }
14462 if isLen1 {
14463 f(i)
14464 } else {
14465 go f(i)
14466 }
14467
14468 }
14469 wg.Wait()
14470 return ret
14471}
14472
14473func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
14474 if v == nil {
14475 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14476 ec.Errorf(ctx, "must not be null")
14477 }
14478 return graphql.Null
14479 }
14480 return ec._TimelineItemEdge(ctx, sel, v)
14481}
14482
14483func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
14484 return ec.___Directive(ctx, sel, &v)
14485}
14486
14487func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
14488 ret := make(graphql.Array, len(v))
14489 var wg sync.WaitGroup
14490 isLen1 := len(v) == 1
14491 if !isLen1 {
14492 wg.Add(len(v))
14493 }
14494 for i := range v {
14495 i := i
14496 fc := &graphql.FieldContext{
14497 Index: &i,
14498 Result: &v[i],
14499 }
14500 ctx := graphql.WithFieldContext(ctx, fc)
14501 f := func(i int) {
14502 defer func() {
14503 if r := recover(); r != nil {
14504 ec.Error(ctx, ec.Recover(ctx, r))
14505 ret = nil
14506 }
14507 }()
14508 if !isLen1 {
14509 defer wg.Done()
14510 }
14511 ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14512 }
14513 if isLen1 {
14514 f(i)
14515 } else {
14516 go f(i)
14517 }
14518
14519 }
14520 wg.Wait()
14521 return ret
14522}
14523
14524func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14525 return graphql.UnmarshalString(v)
14526}
14527
14528func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14529 res := graphql.MarshalString(v)
14530 if res == graphql.Null {
14531 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14532 ec.Errorf(ctx, "must not be null")
14533 }
14534 }
14535 return res
14536}
14537
14538func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14539 var vSlice []interface{}
14540 if v != nil {
14541 if tmp1, ok := v.([]interface{}); ok {
14542 vSlice = tmp1
14543 } else {
14544 vSlice = []interface{}{v}
14545 }
14546 }
14547 var err error
14548 res := make([]string, len(vSlice))
14549 for i := range vSlice {
14550 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14551 if err != nil {
14552 return nil, err
14553 }
14554 }
14555 return res, nil
14556}
14557
14558func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14559 ret := make(graphql.Array, len(v))
14560 var wg sync.WaitGroup
14561 isLen1 := len(v) == 1
14562 if !isLen1 {
14563 wg.Add(len(v))
14564 }
14565 for i := range v {
14566 i := i
14567 fc := &graphql.FieldContext{
14568 Index: &i,
14569 Result: &v[i],
14570 }
14571 ctx := graphql.WithFieldContext(ctx, fc)
14572 f := func(i int) {
14573 defer func() {
14574 if r := recover(); r != nil {
14575 ec.Error(ctx, ec.Recover(ctx, r))
14576 ret = nil
14577 }
14578 }()
14579 if !isLen1 {
14580 defer wg.Done()
14581 }
14582 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
14583 }
14584 if isLen1 {
14585 f(i)
14586 } else {
14587 go f(i)
14588 }
14589
14590 }
14591 wg.Wait()
14592 return ret
14593}
14594
14595func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
14596 return ec.___EnumValue(ctx, sel, &v)
14597}
14598
14599func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
14600 return ec.___Field(ctx, sel, &v)
14601}
14602
14603func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
14604 return ec.___InputValue(ctx, sel, &v)
14605}
14606
14607func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14608 ret := make(graphql.Array, len(v))
14609 var wg sync.WaitGroup
14610 isLen1 := len(v) == 1
14611 if !isLen1 {
14612 wg.Add(len(v))
14613 }
14614 for i := range v {
14615 i := i
14616 fc := &graphql.FieldContext{
14617 Index: &i,
14618 Result: &v[i],
14619 }
14620 ctx := graphql.WithFieldContext(ctx, fc)
14621 f := func(i int) {
14622 defer func() {
14623 if r := recover(); r != nil {
14624 ec.Error(ctx, ec.Recover(ctx, r))
14625 ret = nil
14626 }
14627 }()
14628 if !isLen1 {
14629 defer wg.Done()
14630 }
14631 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14632 }
14633 if isLen1 {
14634 f(i)
14635 } else {
14636 go f(i)
14637 }
14638
14639 }
14640 wg.Wait()
14641 return ret
14642}
14643
14644func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14645 return ec.___Type(ctx, sel, &v)
14646}
14647
14648func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14649 ret := make(graphql.Array, len(v))
14650 var wg sync.WaitGroup
14651 isLen1 := len(v) == 1
14652 if !isLen1 {
14653 wg.Add(len(v))
14654 }
14655 for i := range v {
14656 i := i
14657 fc := &graphql.FieldContext{
14658 Index: &i,
14659 Result: &v[i],
14660 }
14661 ctx := graphql.WithFieldContext(ctx, fc)
14662 f := func(i int) {
14663 defer func() {
14664 if r := recover(); r != nil {
14665 ec.Error(ctx, ec.Recover(ctx, r))
14666 ret = nil
14667 }
14668 }()
14669 if !isLen1 {
14670 defer wg.Done()
14671 }
14672 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14673 }
14674 if isLen1 {
14675 f(i)
14676 } else {
14677 go f(i)
14678 }
14679
14680 }
14681 wg.Wait()
14682 return ret
14683}
14684
14685func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14686 if v == nil {
14687 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14688 ec.Errorf(ctx, "must not be null")
14689 }
14690 return graphql.Null
14691 }
14692 return ec.___Type(ctx, sel, v)
14693}
14694
14695func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14696 return graphql.UnmarshalString(v)
14697}
14698
14699func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14700 res := graphql.MarshalString(v)
14701 if res == graphql.Null {
14702 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14703 ec.Errorf(ctx, "must not be null")
14704 }
14705 }
14706 return res
14707}
14708
14709func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14710 return graphql.UnmarshalBoolean(v)
14711}
14712
14713func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14714 return graphql.MarshalBoolean(v)
14715}
14716
14717func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14718 if v == nil {
14719 return nil, nil
14720 }
14721 res, err := ec.unmarshalOBoolean2bool(ctx, v)
14722 return &res, err
14723}
14724
14725func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14726 if v == nil {
14727 return graphql.Null
14728 }
14729 return ec.marshalOBoolean2bool(ctx, sel, *v)
14730}
14731
14732func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
14733 return ec._Bug(ctx, sel, &v)
14734}
14735
14736func (ec *executionContext) marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
14737 if v == nil {
14738 return graphql.Null
14739 }
14740 return ec._Bug(ctx, sel, v)
14741}
14742
14743func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14744 return ec.unmarshalInputChangeLabelInput(ctx, v)
14745}
14746
14747func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14748 if v == nil {
14749 return nil, nil
14750 }
14751 res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14752 return &res, err
14753}
14754
14755func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
14756 var vSlice []interface{}
14757 if v != nil {
14758 if tmp1, ok := v.([]interface{}); ok {
14759 vSlice = tmp1
14760 } else {
14761 vSlice = []interface{}{v}
14762 }
14763 }
14764 var err error
14765 res := make([]git.Hash, len(vSlice))
14766 for i := range vSlice {
14767 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14768 if err != nil {
14769 return nil, err
14770 }
14771 }
14772 return res, nil
14773}
14774
14775func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14776 if v == nil {
14777 return graphql.Null
14778 }
14779 ret := make(graphql.Array, len(v))
14780 for i := range v {
14781 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14782 }
14783
14784 return ret
14785}
14786
14787func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
14788 if v == nil {
14789 return graphql.Null
14790 }
14791 return ec._Identity(ctx, sel, v)
14792}
14793
14794func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14795 return graphql.UnmarshalInt(v)
14796}
14797
14798func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14799 return graphql.MarshalInt(v)
14800}
14801
14802func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14803 if v == nil {
14804 return nil, nil
14805 }
14806 res, err := ec.unmarshalOInt2int(ctx, v)
14807 return &res, err
14808}
14809
14810func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14811 if v == nil {
14812 return graphql.Null
14813 }
14814 return ec.marshalOInt2int(ctx, sel, *v)
14815}
14816
14817func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14818 return ec._LabelChangeResult(ctx, sel, &v)
14819}
14820
14821func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14822 if v == nil {
14823 return graphql.Null
14824 }
14825 return ec._LabelChangeResult(ctx, sel, v)
14826}
14827
14828func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14829 return ec._Repository(ctx, sel, &v)
14830}
14831
14832func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14833 if v == nil {
14834 return graphql.Null
14835 }
14836 return ec._Repository(ctx, sel, v)
14837}
14838
14839func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14840 return graphql.UnmarshalString(v)
14841}
14842
14843func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14844 return graphql.MarshalString(v)
14845}
14846
14847func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14848 var vSlice []interface{}
14849 if v != nil {
14850 if tmp1, ok := v.([]interface{}); ok {
14851 vSlice = tmp1
14852 } else {
14853 vSlice = []interface{}{v}
14854 }
14855 }
14856 var err error
14857 res := make([]string, len(vSlice))
14858 for i := range vSlice {
14859 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14860 if err != nil {
14861 return nil, err
14862 }
14863 }
14864 return res, nil
14865}
14866
14867func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14868 if v == nil {
14869 return graphql.Null
14870 }
14871 ret := make(graphql.Array, len(v))
14872 for i := range v {
14873 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14874 }
14875
14876 return ret
14877}
14878
14879func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14880 if v == nil {
14881 return nil, nil
14882 }
14883 res, err := ec.unmarshalOString2string(ctx, v)
14884 return &res, err
14885}
14886
14887func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14888 if v == nil {
14889 return graphql.Null
14890 }
14891 return ec.marshalOString2string(ctx, sel, *v)
14892}
14893
14894func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
14895 if v == nil {
14896 return graphql.Null
14897 }
14898 ret := make(graphql.Array, len(v))
14899 var wg sync.WaitGroup
14900 isLen1 := len(v) == 1
14901 if !isLen1 {
14902 wg.Add(len(v))
14903 }
14904 for i := range v {
14905 i := i
14906 fc := &graphql.FieldContext{
14907 Index: &i,
14908 Result: &v[i],
14909 }
14910 ctx := graphql.WithFieldContext(ctx, fc)
14911 f := func(i int) {
14912 defer func() {
14913 if r := recover(); r != nil {
14914 ec.Error(ctx, ec.Recover(ctx, r))
14915 ret = nil
14916 }
14917 }()
14918 if !isLen1 {
14919 defer wg.Done()
14920 }
14921 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14922 }
14923 if isLen1 {
14924 f(i)
14925 } else {
14926 go f(i)
14927 }
14928
14929 }
14930 wg.Wait()
14931 return ret
14932}
14933
14934func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
14935 if v == nil {
14936 return graphql.Null
14937 }
14938 ret := make(graphql.Array, len(v))
14939 var wg sync.WaitGroup
14940 isLen1 := len(v) == 1
14941 if !isLen1 {
14942 wg.Add(len(v))
14943 }
14944 for i := range v {
14945 i := i
14946 fc := &graphql.FieldContext{
14947 Index: &i,
14948 Result: &v[i],
14949 }
14950 ctx := graphql.WithFieldContext(ctx, fc)
14951 f := func(i int) {
14952 defer func() {
14953 if r := recover(); r != nil {
14954 ec.Error(ctx, ec.Recover(ctx, r))
14955 ret = nil
14956 }
14957 }()
14958 if !isLen1 {
14959 defer wg.Done()
14960 }
14961 ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
14962 }
14963 if isLen1 {
14964 f(i)
14965 } else {
14966 go f(i)
14967 }
14968
14969 }
14970 wg.Wait()
14971 return ret
14972}
14973
14974func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14975 if v == nil {
14976 return graphql.Null
14977 }
14978 ret := make(graphql.Array, len(v))
14979 var wg sync.WaitGroup
14980 isLen1 := len(v) == 1
14981 if !isLen1 {
14982 wg.Add(len(v))
14983 }
14984 for i := range v {
14985 i := i
14986 fc := &graphql.FieldContext{
14987 Index: &i,
14988 Result: &v[i],
14989 }
14990 ctx := graphql.WithFieldContext(ctx, fc)
14991 f := func(i int) {
14992 defer func() {
14993 if r := recover(); r != nil {
14994 ec.Error(ctx, ec.Recover(ctx, r))
14995 ret = nil
14996 }
14997 }()
14998 if !isLen1 {
14999 defer wg.Done()
15000 }
15001 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
15002 }
15003 if isLen1 {
15004 f(i)
15005 } else {
15006 go f(i)
15007 }
15008
15009 }
15010 wg.Wait()
15011 return ret
15012}
15013
15014func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
15015 return ec.___Schema(ctx, sel, &v)
15016}
15017
15018func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
15019 if v == nil {
15020 return graphql.Null
15021 }
15022 return ec.___Schema(ctx, sel, v)
15023}
15024
15025func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
15026 return ec.___Type(ctx, sel, &v)
15027}
15028
15029func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
15030 if v == nil {
15031 return graphql.Null
15032 }
15033 ret := make(graphql.Array, len(v))
15034 var wg sync.WaitGroup
15035 isLen1 := len(v) == 1
15036 if !isLen1 {
15037 wg.Add(len(v))
15038 }
15039 for i := range v {
15040 i := i
15041 fc := &graphql.FieldContext{
15042 Index: &i,
15043 Result: &v[i],
15044 }
15045 ctx := graphql.WithFieldContext(ctx, fc)
15046 f := func(i int) {
15047 defer func() {
15048 if r := recover(); r != nil {
15049 ec.Error(ctx, ec.Recover(ctx, r))
15050 ret = nil
15051 }
15052 }()
15053 if !isLen1 {
15054 defer wg.Done()
15055 }
15056 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
15057 }
15058 if isLen1 {
15059 f(i)
15060 } else {
15061 go f(i)
15062 }
15063
15064 }
15065 wg.Wait()
15066 return ret
15067}
15068
15069func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
15070 if v == nil {
15071 return graphql.Null
15072 }
15073 return ec.___Type(ctx, sel, v)
15074}
15075
15076// endregion ***************************** type.gotpl *****************************