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/util/git"
21 "github.com/vektah/gqlparser"
22 "github.com/vektah/gqlparser/ast"
23)
24
25// region ************************** generated!.gotpl **************************
26
27// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
28func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
29 return &executableSchema{
30 resolvers: cfg.Resolvers,
31 directives: cfg.Directives,
32 complexity: cfg.Complexity,
33 }
34}
35
36type Config struct {
37 Resolvers ResolverRoot
38 Directives DirectiveRoot
39 Complexity ComplexityRoot
40}
41
42type ResolverRoot interface {
43 AddCommentOperation() AddCommentOperationResolver
44 AddCommentTimelineItem() AddCommentTimelineItemResolver
45 Bug() BugResolver
46 Color() ColorResolver
47 Comment() CommentResolver
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 Name func(childComplexity int) int
214 }
215
216 IdentityConnection struct {
217 Edges func(childComplexity int) int
218 Nodes func(childComplexity int) int
219 PageInfo func(childComplexity int) int
220 TotalCount func(childComplexity int) int
221 }
222
223 IdentityEdge struct {
224 Cursor func(childComplexity int) int
225 Node func(childComplexity int) int
226 }
227
228 Label struct {
229 Color func(childComplexity int) int
230 Name func(childComplexity int) int
231 }
232
233 LabelChangeOperation struct {
234 Added func(childComplexity int) int
235 Author func(childComplexity int) int
236 Date func(childComplexity int) int
237 ID func(childComplexity int) int
238 Removed func(childComplexity int) int
239 }
240
241 LabelChangeResult struct {
242 Label func(childComplexity int) int
243 Status func(childComplexity int) int
244 }
245
246 LabelChangeTimelineItem struct {
247 Added func(childComplexity int) int
248 Author func(childComplexity int) int
249 Date func(childComplexity int) int
250 ID func(childComplexity int) int
251 Removed func(childComplexity int) int
252 }
253
254 LabelConnection struct {
255 Edges func(childComplexity int) int
256 Nodes func(childComplexity int) int
257 PageInfo func(childComplexity int) int
258 TotalCount func(childComplexity int) int
259 }
260
261 LabelEdge struct {
262 Cursor func(childComplexity int) int
263 Node func(childComplexity int) int
264 }
265
266 Mutation struct {
267 AddComment func(childComplexity int, input models.AddCommentInput) int
268 ChangeLabels func(childComplexity int, input *models.ChangeLabelInput) int
269 CloseBug func(childComplexity int, input models.CloseBugInput) int
270 Commit func(childComplexity int, input models.CommitInput) int
271 CommitAsNeeded func(childComplexity int, input models.CommitAsNeededInput) int
272 NewBug func(childComplexity int, input models.NewBugInput) int
273 OpenBug func(childComplexity int, input models.OpenBugInput) int
274 SetTitle func(childComplexity int, input models.SetTitleInput) int
275 }
276
277 NewBugPayload struct {
278 Bug func(childComplexity int) int
279 ClientMutationID func(childComplexity int) int
280 Operation func(childComplexity int) int
281 }
282
283 OpenBugPayload struct {
284 Bug func(childComplexity int) int
285 ClientMutationID func(childComplexity int) int
286 Operation func(childComplexity int) int
287 }
288
289 OperationConnection struct {
290 Edges func(childComplexity int) int
291 Nodes func(childComplexity int) int
292 PageInfo func(childComplexity int) int
293 TotalCount func(childComplexity int) int
294 }
295
296 OperationEdge struct {
297 Cursor func(childComplexity int) int
298 Node func(childComplexity int) int
299 }
300
301 PageInfo struct {
302 EndCursor func(childComplexity int) int
303 HasNextPage func(childComplexity int) int
304 HasPreviousPage func(childComplexity int) int
305 StartCursor func(childComplexity int) int
306 }
307
308 Query struct {
309 DefaultRepository func(childComplexity int) int
310 Repository func(childComplexity int, ref string) int
311 }
312
313 Repository struct {
314 AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
315 AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
316 Bug func(childComplexity int, prefix string) int
317 Identity func(childComplexity int, prefix string) int
318 UserIdentity func(childComplexity int) int
319 ValidLabels func(childComplexity int, after *string, before *string, first *int, last *int) int
320 }
321
322 SetStatusOperation struct {
323 Author func(childComplexity int) int
324 Date func(childComplexity int) int
325 ID func(childComplexity int) int
326 Status func(childComplexity int) int
327 }
328
329 SetStatusTimelineItem struct {
330 Author func(childComplexity int) int
331 Date func(childComplexity int) int
332 ID func(childComplexity int) int
333 Status func(childComplexity int) int
334 }
335
336 SetTitleOperation struct {
337 Author func(childComplexity int) int
338 Date func(childComplexity int) int
339 ID func(childComplexity int) int
340 Title func(childComplexity int) int
341 Was func(childComplexity int) int
342 }
343
344 SetTitlePayload struct {
345 Bug func(childComplexity int) int
346 ClientMutationID func(childComplexity int) int
347 Operation func(childComplexity int) int
348 }
349
350 SetTitleTimelineItem struct {
351 Author func(childComplexity int) int
352 Date func(childComplexity int) int
353 ID func(childComplexity int) int
354 Title func(childComplexity int) int
355 Was func(childComplexity int) int
356 }
357
358 TimelineItemConnection struct {
359 Edges func(childComplexity int) int
360 Nodes func(childComplexity int) int
361 PageInfo func(childComplexity int) int
362 TotalCount func(childComplexity int) int
363 }
364
365 TimelineItemEdge struct {
366 Cursor func(childComplexity int) int
367 Node func(childComplexity int) int
368 }
369}
370
371type AddCommentOperationResolver interface {
372 ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
373 Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
374 Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
375}
376type AddCommentTimelineItemResolver interface {
377 ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
378 Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, 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 models.BugWrapper) (string, error)
385 HumanID(ctx context.Context, obj models.BugWrapper) (string, error)
386 Status(ctx context.Context, obj models.BugWrapper) (models.Status, error)
387
388 Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
389 Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
390 Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
391 Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
392 Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
393}
394type ColorResolver interface {
395 R(ctx context.Context, obj *color.RGBA) (int, error)
396 G(ctx context.Context, obj *color.RGBA) (int, error)
397 B(ctx context.Context, obj *color.RGBA) (int, error)
398}
399type CommentResolver interface {
400 Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
401}
402type CommentHistoryStepResolver interface {
403 Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
404}
405type CreateOperationResolver interface {
406 ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
407 Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
408 Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
409}
410type CreateTimelineItemResolver interface {
411 ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
412 Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
413
414 CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
415 LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
416}
417type EditCommentOperationResolver interface {
418 ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
419 Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
420 Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
421 Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
422}
423type IdentityResolver interface {
424 ID(ctx context.Context, obj models.IdentityWrapper) (string, error)
425 HumanID(ctx context.Context, obj models.IdentityWrapper) (string, error)
426}
427type LabelResolver interface {
428 Name(ctx context.Context, obj *bug.Label) (string, error)
429 Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
430}
431type LabelChangeOperationResolver interface {
432 ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
433 Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
434 Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
435}
436type LabelChangeResultResolver interface {
437 Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
438}
439type LabelChangeTimelineItemResolver interface {
440 ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
441 Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
442 Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
443}
444type MutationResolver interface {
445 NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
446 AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
447 ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
448 OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
449 CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
450 SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
451 Commit(ctx context.Context, input models.CommitInput) (*models.CommitPayload, error)
452 CommitAsNeeded(ctx context.Context, input models.CommitAsNeededInput) (*models.CommitAsNeededPayload, error)
453}
454type QueryResolver interface {
455 DefaultRepository(ctx context.Context) (*models.Repository, error)
456 Repository(ctx context.Context, ref string) (*models.Repository, error)
457}
458type RepositoryResolver interface {
459 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
460 Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
461 AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
462 Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
463 UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
464 ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
465}
466type SetStatusOperationResolver interface {
467 ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
468 Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
469 Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
470 Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
471}
472type SetStatusTimelineItemResolver interface {
473 ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
474 Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
475 Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
476 Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
477}
478type SetTitleOperationResolver interface {
479 ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
480 Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
481 Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
482}
483type SetTitleTimelineItemResolver interface {
484 ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
485 Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
486 Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
487}
488
489type executableSchema struct {
490 resolvers ResolverRoot
491 directives DirectiveRoot
492 complexity ComplexityRoot
493}
494
495func (e *executableSchema) Schema() *ast.Schema {
496 return parsedSchema
497}
498
499func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
500 ec := executionContext{nil, e}
501 _ = ec
502 switch typeName + "." + field {
503
504 case "AddCommentOperation.author":
505 if e.complexity.AddCommentOperation.Author == nil {
506 break
507 }
508
509 return e.complexity.AddCommentOperation.Author(childComplexity), true
510
511 case "AddCommentOperation.date":
512 if e.complexity.AddCommentOperation.Date == nil {
513 break
514 }
515
516 return e.complexity.AddCommentOperation.Date(childComplexity), true
517
518 case "AddCommentOperation.files":
519 if e.complexity.AddCommentOperation.Files == nil {
520 break
521 }
522
523 return e.complexity.AddCommentOperation.Files(childComplexity), true
524
525 case "AddCommentOperation.id":
526 if e.complexity.AddCommentOperation.ID == nil {
527 break
528 }
529
530 return e.complexity.AddCommentOperation.ID(childComplexity), true
531
532 case "AddCommentOperation.message":
533 if e.complexity.AddCommentOperation.Message == nil {
534 break
535 }
536
537 return e.complexity.AddCommentOperation.Message(childComplexity), true
538
539 case "AddCommentPayload.bug":
540 if e.complexity.AddCommentPayload.Bug == nil {
541 break
542 }
543
544 return e.complexity.AddCommentPayload.Bug(childComplexity), true
545
546 case "AddCommentPayload.clientMutationId":
547 if e.complexity.AddCommentPayload.ClientMutationID == nil {
548 break
549 }
550
551 return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
552
553 case "AddCommentPayload.operation":
554 if e.complexity.AddCommentPayload.Operation == nil {
555 break
556 }
557
558 return e.complexity.AddCommentPayload.Operation(childComplexity), true
559
560 case "AddCommentTimelineItem.author":
561 if e.complexity.AddCommentTimelineItem.Author == nil {
562 break
563 }
564
565 return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
566
567 case "AddCommentTimelineItem.createdAt":
568 if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
569 break
570 }
571
572 return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
573
574 case "AddCommentTimelineItem.edited":
575 if e.complexity.AddCommentTimelineItem.Edited == nil {
576 break
577 }
578
579 return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
580
581 case "AddCommentTimelineItem.files":
582 if e.complexity.AddCommentTimelineItem.Files == nil {
583 break
584 }
585
586 return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
587
588 case "AddCommentTimelineItem.history":
589 if e.complexity.AddCommentTimelineItem.History == nil {
590 break
591 }
592
593 return e.complexity.AddCommentTimelineItem.History(childComplexity), true
594
595 case "AddCommentTimelineItem.id":
596 if e.complexity.AddCommentTimelineItem.ID == nil {
597 break
598 }
599
600 return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
601
602 case "AddCommentTimelineItem.lastEdit":
603 if e.complexity.AddCommentTimelineItem.LastEdit == nil {
604 break
605 }
606
607 return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
608
609 case "AddCommentTimelineItem.message":
610 if e.complexity.AddCommentTimelineItem.Message == nil {
611 break
612 }
613
614 return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
615
616 case "AddCommentTimelineItem.messageIsEmpty":
617 if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
618 break
619 }
620
621 return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
622
623 case "Bug.actors":
624 if e.complexity.Bug.Actors == nil {
625 break
626 }
627
628 args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
629 if err != nil {
630 return 0, false
631 }
632
633 return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
634
635 case "Bug.author":
636 if e.complexity.Bug.Author == nil {
637 break
638 }
639
640 return e.complexity.Bug.Author(childComplexity), true
641
642 case "Bug.comments":
643 if e.complexity.Bug.Comments == nil {
644 break
645 }
646
647 args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
648 if err != nil {
649 return 0, false
650 }
651
652 return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
653
654 case "Bug.createdAt":
655 if e.complexity.Bug.CreatedAt == nil {
656 break
657 }
658
659 return e.complexity.Bug.CreatedAt(childComplexity), true
660
661 case "Bug.humanId":
662 if e.complexity.Bug.HumanID == nil {
663 break
664 }
665
666 return e.complexity.Bug.HumanID(childComplexity), true
667
668 case "Bug.id":
669 if e.complexity.Bug.ID == nil {
670 break
671 }
672
673 return e.complexity.Bug.ID(childComplexity), true
674
675 case "Bug.labels":
676 if e.complexity.Bug.Labels == nil {
677 break
678 }
679
680 return e.complexity.Bug.Labels(childComplexity), true
681
682 case "Bug.lastEdit":
683 if e.complexity.Bug.LastEdit == nil {
684 break
685 }
686
687 return e.complexity.Bug.LastEdit(childComplexity), true
688
689 case "Bug.operations":
690 if e.complexity.Bug.Operations == nil {
691 break
692 }
693
694 args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
695 if err != nil {
696 return 0, false
697 }
698
699 return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
700
701 case "Bug.participants":
702 if e.complexity.Bug.Participants == nil {
703 break
704 }
705
706 args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
707 if err != nil {
708 return 0, false
709 }
710
711 return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
712
713 case "Bug.status":
714 if e.complexity.Bug.Status == nil {
715 break
716 }
717
718 return e.complexity.Bug.Status(childComplexity), true
719
720 case "Bug.timeline":
721 if e.complexity.Bug.Timeline == nil {
722 break
723 }
724
725 args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
726 if err != nil {
727 return 0, false
728 }
729
730 return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
731
732 case "Bug.title":
733 if e.complexity.Bug.Title == nil {
734 break
735 }
736
737 return e.complexity.Bug.Title(childComplexity), true
738
739 case "BugConnection.edges":
740 if e.complexity.BugConnection.Edges == nil {
741 break
742 }
743
744 return e.complexity.BugConnection.Edges(childComplexity), true
745
746 case "BugConnection.nodes":
747 if e.complexity.BugConnection.Nodes == nil {
748 break
749 }
750
751 return e.complexity.BugConnection.Nodes(childComplexity), true
752
753 case "BugConnection.pageInfo":
754 if e.complexity.BugConnection.PageInfo == nil {
755 break
756 }
757
758 return e.complexity.BugConnection.PageInfo(childComplexity), true
759
760 case "BugConnection.totalCount":
761 if e.complexity.BugConnection.TotalCount == nil {
762 break
763 }
764
765 return e.complexity.BugConnection.TotalCount(childComplexity), true
766
767 case "BugEdge.cursor":
768 if e.complexity.BugEdge.Cursor == nil {
769 break
770 }
771
772 return e.complexity.BugEdge.Cursor(childComplexity), true
773
774 case "BugEdge.node":
775 if e.complexity.BugEdge.Node == nil {
776 break
777 }
778
779 return e.complexity.BugEdge.Node(childComplexity), true
780
781 case "ChangeLabelPayload.bug":
782 if e.complexity.ChangeLabelPayload.Bug == nil {
783 break
784 }
785
786 return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
787
788 case "ChangeLabelPayload.clientMutationId":
789 if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
790 break
791 }
792
793 return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
794
795 case "ChangeLabelPayload.operation":
796 if e.complexity.ChangeLabelPayload.Operation == nil {
797 break
798 }
799
800 return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
801
802 case "ChangeLabelPayload.results":
803 if e.complexity.ChangeLabelPayload.Results == nil {
804 break
805 }
806
807 return e.complexity.ChangeLabelPayload.Results(childComplexity), true
808
809 case "CloseBugPayload.bug":
810 if e.complexity.CloseBugPayload.Bug == nil {
811 break
812 }
813
814 return e.complexity.CloseBugPayload.Bug(childComplexity), true
815
816 case "CloseBugPayload.clientMutationId":
817 if e.complexity.CloseBugPayload.ClientMutationID == nil {
818 break
819 }
820
821 return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
822
823 case "CloseBugPayload.operation":
824 if e.complexity.CloseBugPayload.Operation == nil {
825 break
826 }
827
828 return e.complexity.CloseBugPayload.Operation(childComplexity), true
829
830 case "Color.B":
831 if e.complexity.Color.B == nil {
832 break
833 }
834
835 return e.complexity.Color.B(childComplexity), true
836
837 case "Color.G":
838 if e.complexity.Color.G == nil {
839 break
840 }
841
842 return e.complexity.Color.G(childComplexity), true
843
844 case "Color.R":
845 if e.complexity.Color.R == nil {
846 break
847 }
848
849 return e.complexity.Color.R(childComplexity), true
850
851 case "Comment.author":
852 if e.complexity.Comment.Author == nil {
853 break
854 }
855
856 return e.complexity.Comment.Author(childComplexity), true
857
858 case "Comment.files":
859 if e.complexity.Comment.Files == nil {
860 break
861 }
862
863 return e.complexity.Comment.Files(childComplexity), true
864
865 case "Comment.message":
866 if e.complexity.Comment.Message == nil {
867 break
868 }
869
870 return e.complexity.Comment.Message(childComplexity), true
871
872 case "CommentConnection.edges":
873 if e.complexity.CommentConnection.Edges == nil {
874 break
875 }
876
877 return e.complexity.CommentConnection.Edges(childComplexity), true
878
879 case "CommentConnection.nodes":
880 if e.complexity.CommentConnection.Nodes == nil {
881 break
882 }
883
884 return e.complexity.CommentConnection.Nodes(childComplexity), true
885
886 case "CommentConnection.pageInfo":
887 if e.complexity.CommentConnection.PageInfo == nil {
888 break
889 }
890
891 return e.complexity.CommentConnection.PageInfo(childComplexity), true
892
893 case "CommentConnection.totalCount":
894 if e.complexity.CommentConnection.TotalCount == nil {
895 break
896 }
897
898 return e.complexity.CommentConnection.TotalCount(childComplexity), true
899
900 case "CommentEdge.cursor":
901 if e.complexity.CommentEdge.Cursor == nil {
902 break
903 }
904
905 return e.complexity.CommentEdge.Cursor(childComplexity), true
906
907 case "CommentEdge.node":
908 if e.complexity.CommentEdge.Node == nil {
909 break
910 }
911
912 return e.complexity.CommentEdge.Node(childComplexity), true
913
914 case "CommentHistoryStep.date":
915 if e.complexity.CommentHistoryStep.Date == nil {
916 break
917 }
918
919 return e.complexity.CommentHistoryStep.Date(childComplexity), true
920
921 case "CommentHistoryStep.message":
922 if e.complexity.CommentHistoryStep.Message == nil {
923 break
924 }
925
926 return e.complexity.CommentHistoryStep.Message(childComplexity), true
927
928 case "CommitAsNeededPayload.bug":
929 if e.complexity.CommitAsNeededPayload.Bug == nil {
930 break
931 }
932
933 return e.complexity.CommitAsNeededPayload.Bug(childComplexity), true
934
935 case "CommitAsNeededPayload.clientMutationId":
936 if e.complexity.CommitAsNeededPayload.ClientMutationID == nil {
937 break
938 }
939
940 return e.complexity.CommitAsNeededPayload.ClientMutationID(childComplexity), true
941
942 case "CommitPayload.bug":
943 if e.complexity.CommitPayload.Bug == nil {
944 break
945 }
946
947 return e.complexity.CommitPayload.Bug(childComplexity), true
948
949 case "CommitPayload.clientMutationId":
950 if e.complexity.CommitPayload.ClientMutationID == nil {
951 break
952 }
953
954 return e.complexity.CommitPayload.ClientMutationID(childComplexity), true
955
956 case "CreateOperation.author":
957 if e.complexity.CreateOperation.Author == nil {
958 break
959 }
960
961 return e.complexity.CreateOperation.Author(childComplexity), true
962
963 case "CreateOperation.date":
964 if e.complexity.CreateOperation.Date == nil {
965 break
966 }
967
968 return e.complexity.CreateOperation.Date(childComplexity), true
969
970 case "CreateOperation.files":
971 if e.complexity.CreateOperation.Files == nil {
972 break
973 }
974
975 return e.complexity.CreateOperation.Files(childComplexity), true
976
977 case "CreateOperation.id":
978 if e.complexity.CreateOperation.ID == nil {
979 break
980 }
981
982 return e.complexity.CreateOperation.ID(childComplexity), true
983
984 case "CreateOperation.message":
985 if e.complexity.CreateOperation.Message == nil {
986 break
987 }
988
989 return e.complexity.CreateOperation.Message(childComplexity), true
990
991 case "CreateOperation.title":
992 if e.complexity.CreateOperation.Title == nil {
993 break
994 }
995
996 return e.complexity.CreateOperation.Title(childComplexity), true
997
998 case "CreateTimelineItem.author":
999 if e.complexity.CreateTimelineItem.Author == nil {
1000 break
1001 }
1002
1003 return e.complexity.CreateTimelineItem.Author(childComplexity), true
1004
1005 case "CreateTimelineItem.createdAt":
1006 if e.complexity.CreateTimelineItem.CreatedAt == nil {
1007 break
1008 }
1009
1010 return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
1011
1012 case "CreateTimelineItem.edited":
1013 if e.complexity.CreateTimelineItem.Edited == nil {
1014 break
1015 }
1016
1017 return e.complexity.CreateTimelineItem.Edited(childComplexity), true
1018
1019 case "CreateTimelineItem.files":
1020 if e.complexity.CreateTimelineItem.Files == nil {
1021 break
1022 }
1023
1024 return e.complexity.CreateTimelineItem.Files(childComplexity), true
1025
1026 case "CreateTimelineItem.history":
1027 if e.complexity.CreateTimelineItem.History == nil {
1028 break
1029 }
1030
1031 return e.complexity.CreateTimelineItem.History(childComplexity), true
1032
1033 case "CreateTimelineItem.id":
1034 if e.complexity.CreateTimelineItem.ID == nil {
1035 break
1036 }
1037
1038 return e.complexity.CreateTimelineItem.ID(childComplexity), true
1039
1040 case "CreateTimelineItem.lastEdit":
1041 if e.complexity.CreateTimelineItem.LastEdit == nil {
1042 break
1043 }
1044
1045 return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
1046
1047 case "CreateTimelineItem.message":
1048 if e.complexity.CreateTimelineItem.Message == nil {
1049 break
1050 }
1051
1052 return e.complexity.CreateTimelineItem.Message(childComplexity), true
1053
1054 case "CreateTimelineItem.messageIsEmpty":
1055 if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
1056 break
1057 }
1058
1059 return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
1060
1061 case "EditCommentOperation.author":
1062 if e.complexity.EditCommentOperation.Author == nil {
1063 break
1064 }
1065
1066 return e.complexity.EditCommentOperation.Author(childComplexity), true
1067
1068 case "EditCommentOperation.date":
1069 if e.complexity.EditCommentOperation.Date == nil {
1070 break
1071 }
1072
1073 return e.complexity.EditCommentOperation.Date(childComplexity), true
1074
1075 case "EditCommentOperation.files":
1076 if e.complexity.EditCommentOperation.Files == nil {
1077 break
1078 }
1079
1080 return e.complexity.EditCommentOperation.Files(childComplexity), true
1081
1082 case "EditCommentOperation.id":
1083 if e.complexity.EditCommentOperation.ID == nil {
1084 break
1085 }
1086
1087 return e.complexity.EditCommentOperation.ID(childComplexity), true
1088
1089 case "EditCommentOperation.message":
1090 if e.complexity.EditCommentOperation.Message == nil {
1091 break
1092 }
1093
1094 return e.complexity.EditCommentOperation.Message(childComplexity), true
1095
1096 case "EditCommentOperation.target":
1097 if e.complexity.EditCommentOperation.Target == nil {
1098 break
1099 }
1100
1101 return e.complexity.EditCommentOperation.Target(childComplexity), true
1102
1103 case "Identity.avatarUrl":
1104 if e.complexity.Identity.AvatarUrl == nil {
1105 break
1106 }
1107
1108 return e.complexity.Identity.AvatarUrl(childComplexity), true
1109
1110 case "Identity.displayName":
1111 if e.complexity.Identity.DisplayName == nil {
1112 break
1113 }
1114
1115 return e.complexity.Identity.DisplayName(childComplexity), true
1116
1117 case "Identity.email":
1118 if e.complexity.Identity.Email == nil {
1119 break
1120 }
1121
1122 return e.complexity.Identity.Email(childComplexity), true
1123
1124 case "Identity.humanId":
1125 if e.complexity.Identity.HumanID == nil {
1126 break
1127 }
1128
1129 return e.complexity.Identity.HumanID(childComplexity), true
1130
1131 case "Identity.id":
1132 if e.complexity.Identity.ID == nil {
1133 break
1134 }
1135
1136 return e.complexity.Identity.ID(childComplexity), true
1137
1138 case "Identity.isProtected":
1139 if e.complexity.Identity.IsProtected == nil {
1140 break
1141 }
1142
1143 return e.complexity.Identity.IsProtected(childComplexity), true
1144
1145 case "Identity.name":
1146 if e.complexity.Identity.Name == nil {
1147 break
1148 }
1149
1150 return e.complexity.Identity.Name(childComplexity), true
1151
1152 case "IdentityConnection.edges":
1153 if e.complexity.IdentityConnection.Edges == nil {
1154 break
1155 }
1156
1157 return e.complexity.IdentityConnection.Edges(childComplexity), true
1158
1159 case "IdentityConnection.nodes":
1160 if e.complexity.IdentityConnection.Nodes == nil {
1161 break
1162 }
1163
1164 return e.complexity.IdentityConnection.Nodes(childComplexity), true
1165
1166 case "IdentityConnection.pageInfo":
1167 if e.complexity.IdentityConnection.PageInfo == nil {
1168 break
1169 }
1170
1171 return e.complexity.IdentityConnection.PageInfo(childComplexity), true
1172
1173 case "IdentityConnection.totalCount":
1174 if e.complexity.IdentityConnection.TotalCount == nil {
1175 break
1176 }
1177
1178 return e.complexity.IdentityConnection.TotalCount(childComplexity), true
1179
1180 case "IdentityEdge.cursor":
1181 if e.complexity.IdentityEdge.Cursor == nil {
1182 break
1183 }
1184
1185 return e.complexity.IdentityEdge.Cursor(childComplexity), true
1186
1187 case "IdentityEdge.node":
1188 if e.complexity.IdentityEdge.Node == nil {
1189 break
1190 }
1191
1192 return e.complexity.IdentityEdge.Node(childComplexity), true
1193
1194 case "Label.color":
1195 if e.complexity.Label.Color == nil {
1196 break
1197 }
1198
1199 return e.complexity.Label.Color(childComplexity), true
1200
1201 case "Label.name":
1202 if e.complexity.Label.Name == nil {
1203 break
1204 }
1205
1206 return e.complexity.Label.Name(childComplexity), true
1207
1208 case "LabelChangeOperation.added":
1209 if e.complexity.LabelChangeOperation.Added == nil {
1210 break
1211 }
1212
1213 return e.complexity.LabelChangeOperation.Added(childComplexity), true
1214
1215 case "LabelChangeOperation.author":
1216 if e.complexity.LabelChangeOperation.Author == nil {
1217 break
1218 }
1219
1220 return e.complexity.LabelChangeOperation.Author(childComplexity), true
1221
1222 case "LabelChangeOperation.date":
1223 if e.complexity.LabelChangeOperation.Date == nil {
1224 break
1225 }
1226
1227 return e.complexity.LabelChangeOperation.Date(childComplexity), true
1228
1229 case "LabelChangeOperation.id":
1230 if e.complexity.LabelChangeOperation.ID == nil {
1231 break
1232 }
1233
1234 return e.complexity.LabelChangeOperation.ID(childComplexity), true
1235
1236 case "LabelChangeOperation.removed":
1237 if e.complexity.LabelChangeOperation.Removed == nil {
1238 break
1239 }
1240
1241 return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1242
1243 case "LabelChangeResult.label":
1244 if e.complexity.LabelChangeResult.Label == nil {
1245 break
1246 }
1247
1248 return e.complexity.LabelChangeResult.Label(childComplexity), true
1249
1250 case "LabelChangeResult.status":
1251 if e.complexity.LabelChangeResult.Status == nil {
1252 break
1253 }
1254
1255 return e.complexity.LabelChangeResult.Status(childComplexity), true
1256
1257 case "LabelChangeTimelineItem.added":
1258 if e.complexity.LabelChangeTimelineItem.Added == nil {
1259 break
1260 }
1261
1262 return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
1263
1264 case "LabelChangeTimelineItem.author":
1265 if e.complexity.LabelChangeTimelineItem.Author == nil {
1266 break
1267 }
1268
1269 return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
1270
1271 case "LabelChangeTimelineItem.date":
1272 if e.complexity.LabelChangeTimelineItem.Date == nil {
1273 break
1274 }
1275
1276 return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
1277
1278 case "LabelChangeTimelineItem.id":
1279 if e.complexity.LabelChangeTimelineItem.ID == nil {
1280 break
1281 }
1282
1283 return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
1284
1285 case "LabelChangeTimelineItem.removed":
1286 if e.complexity.LabelChangeTimelineItem.Removed == nil {
1287 break
1288 }
1289
1290 return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
1291
1292 case "LabelConnection.edges":
1293 if e.complexity.LabelConnection.Edges == nil {
1294 break
1295 }
1296
1297 return e.complexity.LabelConnection.Edges(childComplexity), true
1298
1299 case "LabelConnection.nodes":
1300 if e.complexity.LabelConnection.Nodes == nil {
1301 break
1302 }
1303
1304 return e.complexity.LabelConnection.Nodes(childComplexity), true
1305
1306 case "LabelConnection.pageInfo":
1307 if e.complexity.LabelConnection.PageInfo == nil {
1308 break
1309 }
1310
1311 return e.complexity.LabelConnection.PageInfo(childComplexity), true
1312
1313 case "LabelConnection.totalCount":
1314 if e.complexity.LabelConnection.TotalCount == nil {
1315 break
1316 }
1317
1318 return e.complexity.LabelConnection.TotalCount(childComplexity), true
1319
1320 case "LabelEdge.cursor":
1321 if e.complexity.LabelEdge.Cursor == nil {
1322 break
1323 }
1324
1325 return e.complexity.LabelEdge.Cursor(childComplexity), true
1326
1327 case "LabelEdge.node":
1328 if e.complexity.LabelEdge.Node == nil {
1329 break
1330 }
1331
1332 return e.complexity.LabelEdge.Node(childComplexity), true
1333
1334 case "Mutation.addComment":
1335 if e.complexity.Mutation.AddComment == nil {
1336 break
1337 }
1338
1339 args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
1340 if err != nil {
1341 return 0, false
1342 }
1343
1344 return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
1345
1346 case "Mutation.changeLabels":
1347 if e.complexity.Mutation.ChangeLabels == nil {
1348 break
1349 }
1350
1351 args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
1352 if err != nil {
1353 return 0, false
1354 }
1355
1356 return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
1357
1358 case "Mutation.closeBug":
1359 if e.complexity.Mutation.CloseBug == nil {
1360 break
1361 }
1362
1363 args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
1364 if err != nil {
1365 return 0, false
1366 }
1367
1368 return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
1369
1370 case "Mutation.commit":
1371 if e.complexity.Mutation.Commit == nil {
1372 break
1373 }
1374
1375 args, err := ec.field_Mutation_commit_args(context.TODO(), rawArgs)
1376 if err != nil {
1377 return 0, false
1378 }
1379
1380 return e.complexity.Mutation.Commit(childComplexity, args["input"].(models.CommitInput)), true
1381
1382 case "Mutation.commitAsNeeded":
1383 if e.complexity.Mutation.CommitAsNeeded == nil {
1384 break
1385 }
1386
1387 args, err := ec.field_Mutation_commitAsNeeded_args(context.TODO(), rawArgs)
1388 if err != nil {
1389 return 0, false
1390 }
1391
1392 return e.complexity.Mutation.CommitAsNeeded(childComplexity, args["input"].(models.CommitAsNeededInput)), true
1393
1394 case "Mutation.newBug":
1395 if e.complexity.Mutation.NewBug == nil {
1396 break
1397 }
1398
1399 args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
1400 if err != nil {
1401 return 0, false
1402 }
1403
1404 return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
1405
1406 case "Mutation.openBug":
1407 if e.complexity.Mutation.OpenBug == nil {
1408 break
1409 }
1410
1411 args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
1412 if err != nil {
1413 return 0, false
1414 }
1415
1416 return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
1417
1418 case "Mutation.setTitle":
1419 if e.complexity.Mutation.SetTitle == nil {
1420 break
1421 }
1422
1423 args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
1424 if err != nil {
1425 return 0, false
1426 }
1427
1428 return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
1429
1430 case "NewBugPayload.bug":
1431 if e.complexity.NewBugPayload.Bug == nil {
1432 break
1433 }
1434
1435 return e.complexity.NewBugPayload.Bug(childComplexity), true
1436
1437 case "NewBugPayload.clientMutationId":
1438 if e.complexity.NewBugPayload.ClientMutationID == nil {
1439 break
1440 }
1441
1442 return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
1443
1444 case "NewBugPayload.operation":
1445 if e.complexity.NewBugPayload.Operation == nil {
1446 break
1447 }
1448
1449 return e.complexity.NewBugPayload.Operation(childComplexity), true
1450
1451 case "OpenBugPayload.bug":
1452 if e.complexity.OpenBugPayload.Bug == nil {
1453 break
1454 }
1455
1456 return e.complexity.OpenBugPayload.Bug(childComplexity), true
1457
1458 case "OpenBugPayload.clientMutationId":
1459 if e.complexity.OpenBugPayload.ClientMutationID == nil {
1460 break
1461 }
1462
1463 return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
1464
1465 case "OpenBugPayload.operation":
1466 if e.complexity.OpenBugPayload.Operation == nil {
1467 break
1468 }
1469
1470 return e.complexity.OpenBugPayload.Operation(childComplexity), true
1471
1472 case "OperationConnection.edges":
1473 if e.complexity.OperationConnection.Edges == nil {
1474 break
1475 }
1476
1477 return e.complexity.OperationConnection.Edges(childComplexity), true
1478
1479 case "OperationConnection.nodes":
1480 if e.complexity.OperationConnection.Nodes == nil {
1481 break
1482 }
1483
1484 return e.complexity.OperationConnection.Nodes(childComplexity), true
1485
1486 case "OperationConnection.pageInfo":
1487 if e.complexity.OperationConnection.PageInfo == nil {
1488 break
1489 }
1490
1491 return e.complexity.OperationConnection.PageInfo(childComplexity), true
1492
1493 case "OperationConnection.totalCount":
1494 if e.complexity.OperationConnection.TotalCount == nil {
1495 break
1496 }
1497
1498 return e.complexity.OperationConnection.TotalCount(childComplexity), true
1499
1500 case "OperationEdge.cursor":
1501 if e.complexity.OperationEdge.Cursor == nil {
1502 break
1503 }
1504
1505 return e.complexity.OperationEdge.Cursor(childComplexity), true
1506
1507 case "OperationEdge.node":
1508 if e.complexity.OperationEdge.Node == nil {
1509 break
1510 }
1511
1512 return e.complexity.OperationEdge.Node(childComplexity), true
1513
1514 case "PageInfo.endCursor":
1515 if e.complexity.PageInfo.EndCursor == nil {
1516 break
1517 }
1518
1519 return e.complexity.PageInfo.EndCursor(childComplexity), true
1520
1521 case "PageInfo.hasNextPage":
1522 if e.complexity.PageInfo.HasNextPage == nil {
1523 break
1524 }
1525
1526 return e.complexity.PageInfo.HasNextPage(childComplexity), true
1527
1528 case "PageInfo.hasPreviousPage":
1529 if e.complexity.PageInfo.HasPreviousPage == nil {
1530 break
1531 }
1532
1533 return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1534
1535 case "PageInfo.startCursor":
1536 if e.complexity.PageInfo.StartCursor == nil {
1537 break
1538 }
1539
1540 return e.complexity.PageInfo.StartCursor(childComplexity), true
1541
1542 case "Query.defaultRepository":
1543 if e.complexity.Query.DefaultRepository == nil {
1544 break
1545 }
1546
1547 return e.complexity.Query.DefaultRepository(childComplexity), true
1548
1549 case "Query.repository":
1550 if e.complexity.Query.Repository == nil {
1551 break
1552 }
1553
1554 args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
1555 if err != nil {
1556 return 0, false
1557 }
1558
1559 return e.complexity.Query.Repository(childComplexity, args["ref"].(string)), true
1560
1561 case "Repository.allBugs":
1562 if e.complexity.Repository.AllBugs == nil {
1563 break
1564 }
1565
1566 args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
1567 if err != nil {
1568 return 0, false
1569 }
1570
1571 return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1572
1573 case "Repository.allIdentities":
1574 if e.complexity.Repository.AllIdentities == nil {
1575 break
1576 }
1577
1578 args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
1579 if err != nil {
1580 return 0, false
1581 }
1582
1583 return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1584
1585 case "Repository.bug":
1586 if e.complexity.Repository.Bug == nil {
1587 break
1588 }
1589
1590 args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
1591 if err != nil {
1592 return 0, false
1593 }
1594
1595 return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1596
1597 case "Repository.identity":
1598 if e.complexity.Repository.Identity == nil {
1599 break
1600 }
1601
1602 args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
1603 if err != nil {
1604 return 0, false
1605 }
1606
1607 return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
1608
1609 case "Repository.userIdentity":
1610 if e.complexity.Repository.UserIdentity == nil {
1611 break
1612 }
1613
1614 return e.complexity.Repository.UserIdentity(childComplexity), true
1615
1616 case "Repository.validLabels":
1617 if e.complexity.Repository.ValidLabels == nil {
1618 break
1619 }
1620
1621 args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
1622 if err != nil {
1623 return 0, false
1624 }
1625
1626 return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1627
1628 case "SetStatusOperation.author":
1629 if e.complexity.SetStatusOperation.Author == nil {
1630 break
1631 }
1632
1633 return e.complexity.SetStatusOperation.Author(childComplexity), true
1634
1635 case "SetStatusOperation.date":
1636 if e.complexity.SetStatusOperation.Date == nil {
1637 break
1638 }
1639
1640 return e.complexity.SetStatusOperation.Date(childComplexity), true
1641
1642 case "SetStatusOperation.id":
1643 if e.complexity.SetStatusOperation.ID == nil {
1644 break
1645 }
1646
1647 return e.complexity.SetStatusOperation.ID(childComplexity), true
1648
1649 case "SetStatusOperation.status":
1650 if e.complexity.SetStatusOperation.Status == nil {
1651 break
1652 }
1653
1654 return e.complexity.SetStatusOperation.Status(childComplexity), true
1655
1656 case "SetStatusTimelineItem.author":
1657 if e.complexity.SetStatusTimelineItem.Author == nil {
1658 break
1659 }
1660
1661 return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
1662
1663 case "SetStatusTimelineItem.date":
1664 if e.complexity.SetStatusTimelineItem.Date == nil {
1665 break
1666 }
1667
1668 return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
1669
1670 case "SetStatusTimelineItem.id":
1671 if e.complexity.SetStatusTimelineItem.ID == nil {
1672 break
1673 }
1674
1675 return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
1676
1677 case "SetStatusTimelineItem.status":
1678 if e.complexity.SetStatusTimelineItem.Status == nil {
1679 break
1680 }
1681
1682 return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
1683
1684 case "SetTitleOperation.author":
1685 if e.complexity.SetTitleOperation.Author == nil {
1686 break
1687 }
1688
1689 return e.complexity.SetTitleOperation.Author(childComplexity), true
1690
1691 case "SetTitleOperation.date":
1692 if e.complexity.SetTitleOperation.Date == nil {
1693 break
1694 }
1695
1696 return e.complexity.SetTitleOperation.Date(childComplexity), true
1697
1698 case "SetTitleOperation.id":
1699 if e.complexity.SetTitleOperation.ID == nil {
1700 break
1701 }
1702
1703 return e.complexity.SetTitleOperation.ID(childComplexity), true
1704
1705 case "SetTitleOperation.title":
1706 if e.complexity.SetTitleOperation.Title == nil {
1707 break
1708 }
1709
1710 return e.complexity.SetTitleOperation.Title(childComplexity), true
1711
1712 case "SetTitleOperation.was":
1713 if e.complexity.SetTitleOperation.Was == nil {
1714 break
1715 }
1716
1717 return e.complexity.SetTitleOperation.Was(childComplexity), true
1718
1719 case "SetTitlePayload.bug":
1720 if e.complexity.SetTitlePayload.Bug == nil {
1721 break
1722 }
1723
1724 return e.complexity.SetTitlePayload.Bug(childComplexity), true
1725
1726 case "SetTitlePayload.clientMutationId":
1727 if e.complexity.SetTitlePayload.ClientMutationID == nil {
1728 break
1729 }
1730
1731 return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
1732
1733 case "SetTitlePayload.operation":
1734 if e.complexity.SetTitlePayload.Operation == nil {
1735 break
1736 }
1737
1738 return e.complexity.SetTitlePayload.Operation(childComplexity), true
1739
1740 case "SetTitleTimelineItem.author":
1741 if e.complexity.SetTitleTimelineItem.Author == nil {
1742 break
1743 }
1744
1745 return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
1746
1747 case "SetTitleTimelineItem.date":
1748 if e.complexity.SetTitleTimelineItem.Date == nil {
1749 break
1750 }
1751
1752 return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
1753
1754 case "SetTitleTimelineItem.id":
1755 if e.complexity.SetTitleTimelineItem.ID == nil {
1756 break
1757 }
1758
1759 return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
1760
1761 case "SetTitleTimelineItem.title":
1762 if e.complexity.SetTitleTimelineItem.Title == nil {
1763 break
1764 }
1765
1766 return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
1767
1768 case "SetTitleTimelineItem.was":
1769 if e.complexity.SetTitleTimelineItem.Was == nil {
1770 break
1771 }
1772
1773 return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
1774
1775 case "TimelineItemConnection.edges":
1776 if e.complexity.TimelineItemConnection.Edges == nil {
1777 break
1778 }
1779
1780 return e.complexity.TimelineItemConnection.Edges(childComplexity), true
1781
1782 case "TimelineItemConnection.nodes":
1783 if e.complexity.TimelineItemConnection.Nodes == nil {
1784 break
1785 }
1786
1787 return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
1788
1789 case "TimelineItemConnection.pageInfo":
1790 if e.complexity.TimelineItemConnection.PageInfo == nil {
1791 break
1792 }
1793
1794 return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
1795
1796 case "TimelineItemConnection.totalCount":
1797 if e.complexity.TimelineItemConnection.TotalCount == nil {
1798 break
1799 }
1800
1801 return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
1802
1803 case "TimelineItemEdge.cursor":
1804 if e.complexity.TimelineItemEdge.Cursor == nil {
1805 break
1806 }
1807
1808 return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
1809
1810 case "TimelineItemEdge.node":
1811 if e.complexity.TimelineItemEdge.Node == nil {
1812 break
1813 }
1814
1815 return e.complexity.TimelineItemEdge.Node(childComplexity), true
1816
1817 }
1818 return 0, false
1819}
1820
1821func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
1822 rc := graphql.GetOperationContext(ctx)
1823 ec := executionContext{rc, e}
1824 first := true
1825
1826 switch rc.Operation.Operation {
1827 case ast.Query:
1828 return func(ctx context.Context) *graphql.Response {
1829 if !first {
1830 return nil
1831 }
1832 first = false
1833 data := ec._Query(ctx, rc.Operation.SelectionSet)
1834 var buf bytes.Buffer
1835 data.MarshalGQL(&buf)
1836
1837 return &graphql.Response{
1838 Data: buf.Bytes(),
1839 }
1840 }
1841 case ast.Mutation:
1842 return func(ctx context.Context) *graphql.Response {
1843 if !first {
1844 return nil
1845 }
1846 first = false
1847 data := ec._Mutation(ctx, rc.Operation.SelectionSet)
1848 var buf bytes.Buffer
1849 data.MarshalGQL(&buf)
1850
1851 return &graphql.Response{
1852 Data: buf.Bytes(),
1853 }
1854 }
1855
1856 default:
1857 return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
1858 }
1859}
1860
1861type executionContext struct {
1862 *graphql.OperationContext
1863 *executableSchema
1864}
1865
1866func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
1867 if ec.DisableIntrospection {
1868 return nil, errors.New("introspection disabled")
1869 }
1870 return introspection.WrapSchema(parsedSchema), nil
1871}
1872
1873func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
1874 if ec.DisableIntrospection {
1875 return nil, errors.New("introspection disabled")
1876 }
1877 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
1878}
1879
1880var sources = []*ast.Source{
1881 &ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
1882type Comment implements Authored {
1883 """The author of this comment."""
1884 author: Identity!
1885
1886 """The message of this comment."""
1887 message: String!
1888
1889 """All media's hash referenced in this comment"""
1890 files: [Hash!]!
1891}
1892
1893type CommentConnection {
1894 edges: [CommentEdge!]!
1895 nodes: [Comment!]!
1896 pageInfo: PageInfo!
1897 totalCount: Int!
1898}
1899
1900type CommentEdge {
1901 cursor: String!
1902 node: Comment!
1903}
1904
1905enum Status {
1906 OPEN
1907 CLOSED
1908}
1909
1910type Bug implements Authored {
1911 """The identifier for this bug"""
1912 id: String!
1913 """The human version (truncated) identifier for this bug"""
1914 humanId: String!
1915 status: Status!
1916 title: String!
1917 labels: [Label!]!
1918 author: Identity!
1919 createdAt: Time!
1920 lastEdit: Time!
1921
1922 """The actors of the bug. Actors are Identity that have interacted with the bug."""
1923 actors(
1924 """Returns the elements in the list that come after the specified cursor."""
1925 after: String
1926 """Returns the elements in the list that come before the specified cursor."""
1927 before: String
1928 """Returns the first _n_ elements from the list."""
1929 first: Int
1930 """Returns the last _n_ elements from the list."""
1931 last: Int
1932 ): IdentityConnection!
1933
1934 """The participants of the bug. Participants are Identity that have created or
1935 added a comment on the bug."""
1936 participants(
1937 """Returns the elements in the list that come after the specified cursor."""
1938 after: String
1939 """Returns the elements in the list that come before the specified cursor."""
1940 before: String
1941 """Returns the first _n_ elements from the list."""
1942 first: Int
1943 """Returns the last _n_ elements from the list."""
1944 last: Int
1945 ): IdentityConnection!
1946
1947 comments(
1948 """Returns the elements in the list that come after the specified cursor."""
1949 after: String
1950 """Returns the elements in the list that come before the specified cursor."""
1951 before: String
1952 """Returns the first _n_ elements from the list."""
1953 first: Int
1954 """Returns the last _n_ elements from the list."""
1955 last: Int
1956 ): CommentConnection!
1957
1958 timeline(
1959 """Returns the elements in the list that come after the specified cursor."""
1960 after: String
1961 """Returns the elements in the list that come before the specified cursor."""
1962 before: String
1963 """Returns the first _n_ elements from the list."""
1964 first: Int
1965 """Returns the last _n_ elements from the list."""
1966 last: Int
1967 ): TimelineItemConnection!
1968
1969 operations(
1970 """Returns the elements in the list that come after the specified cursor."""
1971 after: String
1972 """Returns the elements in the list that come before the specified cursor."""
1973 before: String
1974 """Returns the first _n_ elements from the list."""
1975 first: Int
1976 """Returns the last _n_ elements from the list."""
1977 last: Int
1978 ): OperationConnection!
1979}
1980
1981"""The connection type for Bug."""
1982type BugConnection {
1983 """A list of edges."""
1984 edges: [BugEdge!]!
1985 nodes: [Bug!]!
1986 """Information to aid in pagination."""
1987 pageInfo: PageInfo!
1988 """Identifies the total count of items in the connection."""
1989 totalCount: Int!
1990}
1991
1992"""An edge in a connection."""
1993type BugEdge {
1994 """A cursor for use in pagination."""
1995 cursor: String!
1996 """The item at the end of the edge."""
1997 node: Bug!
1998}
1999`, BuiltIn: false},
2000 &ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
2001type Identity {
2002 """The identifier for this identity"""
2003 id: String!
2004 """The human version (truncated) identifier for this identity"""
2005 humanId: String!
2006 """The name of the person, if known."""
2007 name: String
2008 """The email of the person, if known."""
2009 email: String
2010 """A non-empty string to display, representing the identity, based on the non-empty values."""
2011 displayName: String!
2012 """An url to an avatar"""
2013 avatarUrl: String
2014 """isProtected is true if the chain of git commits started to be signed.
2015 If that's the case, only signed commit with a valid key for this identity can be added."""
2016 isProtected: Boolean!
2017}
2018
2019type IdentityConnection {
2020 edges: [IdentityEdge!]!
2021 nodes: [Identity!]!
2022 pageInfo: PageInfo!
2023 totalCount: Int!
2024}
2025
2026type IdentityEdge {
2027 cursor: String!
2028 node: Identity!
2029}`, BuiltIn: false},
2030 &ast.Source{Name: "schema/label.graphql", Input: `"""Label for a bug."""
2031type Label {
2032 """The name of the label."""
2033 name: String!
2034 """Color of the label."""
2035 color: Color!
2036}
2037
2038type LabelConnection {
2039 edges: [LabelEdge!]!
2040 nodes: [Label!]!
2041 pageInfo: PageInfo!
2042 totalCount: Int!
2043}
2044
2045type LabelEdge {
2046 cursor: String!
2047 node: Label!
2048}`, BuiltIn: false},
2049 &ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
2050 """A unique identifier for the client performing the mutation."""
2051 clientMutationId: String
2052 """"The name of the repository. If not set, the default repository is used."""
2053 repoRef: String
2054 """The title of the new bug."""
2055 title: String!
2056 """The first message of the new bug."""
2057 message: String!
2058 """The collection of file's hash required for the first message."""
2059 files: [Hash!]
2060}
2061
2062type NewBugPayload {
2063 """A unique identifier for the client performing the mutation."""
2064 clientMutationId: String
2065 """The created bug."""
2066 bug: Bug!
2067 """The resulting operation."""
2068 operation: CreateOperation!
2069}
2070
2071input AddCommentInput {
2072 """A unique identifier for the client performing the mutation."""
2073 clientMutationId: String
2074 """"The name of the repository. If not set, the default repository is used."""
2075 repoRef: String
2076 """The bug ID's prefix."""
2077 prefix: String!
2078 """The first message of the new bug."""
2079 message: String!
2080 """The collection of file's hash required for the first message."""
2081 files: [Hash!]
2082}
2083
2084type AddCommentPayload {
2085 """A unique identifier for the client performing the mutation."""
2086 clientMutationId: String
2087 """The affected bug."""
2088 bug: Bug!
2089 """The resulting operation."""
2090 operation: AddCommentOperation!
2091}
2092
2093input ChangeLabelInput {
2094 """A unique identifier for the client performing the mutation."""
2095 clientMutationId: String
2096 """"The name of the repository. If not set, the default repository is used."""
2097 repoRef: String
2098 """The bug ID's prefix."""
2099 prefix: String!
2100 """The list of label to add."""
2101 added: [String!]
2102 """The list of label to remove."""
2103 Removed: [String!]
2104}
2105
2106enum LabelChangeStatus {
2107 ADDED
2108 REMOVED
2109 DUPLICATE_IN_OP
2110 ALREADY_EXIST
2111 DOESNT_EXIST
2112}
2113
2114type LabelChangeResult {
2115 """The source label."""
2116 label: Label!
2117 """The effect this label had."""
2118 status: LabelChangeStatus!
2119}
2120
2121type ChangeLabelPayload {
2122 """A unique identifier for the client performing the mutation."""
2123 clientMutationId: String
2124 """The affected bug."""
2125 bug: Bug!
2126 """The resulting operation."""
2127 operation: LabelChangeOperation!
2128 """The effect each source label had."""
2129 results: [LabelChangeResult]!
2130}
2131
2132input OpenBugInput {
2133 """A unique identifier for the client performing the mutation."""
2134 clientMutationId: String
2135 """"The name of the repository. If not set, the default repository is used."""
2136 repoRef: String
2137 """The bug ID's prefix."""
2138 prefix: String!
2139}
2140
2141type OpenBugPayload {
2142 """A unique identifier for the client performing the mutation."""
2143 clientMutationId: String
2144 """The affected bug."""
2145 bug: Bug!
2146 """The resulting operation."""
2147 operation: SetStatusOperation!
2148}
2149
2150input CloseBugInput {
2151 """A unique identifier for the client performing the mutation."""
2152 clientMutationId: String
2153 """"The name of the repository. If not set, the default repository is used."""
2154 repoRef: String
2155 """The bug ID's prefix."""
2156 prefix: String!
2157}
2158
2159type CloseBugPayload {
2160 """A unique identifier for the client performing the mutation."""
2161 clientMutationId: String
2162 """The affected bug."""
2163 bug: Bug!
2164 """The resulting operation."""
2165 operation: SetStatusOperation!
2166}
2167
2168input SetTitleInput {
2169 """A unique identifier for the client performing the mutation."""
2170 clientMutationId: String
2171 """"The name of the repository. If not set, the default repository is used."""
2172 repoRef: String
2173 """The bug ID's prefix."""
2174 prefix: String!
2175 """The new title."""
2176 title: String!
2177}
2178
2179type SetTitlePayload {
2180 """A unique identifier for the client performing the mutation."""
2181 clientMutationId: String
2182 """The affected bug."""
2183 bug: Bug!
2184 """The resulting operation"""
2185 operation: SetTitleOperation!
2186}
2187
2188input CommitInput {
2189 """A unique identifier for the client performing the mutation."""
2190 clientMutationId: String
2191 """"The name of the repository. If not set, the default repository is used."""
2192 repoRef: String
2193 """The bug ID's prefix."""
2194 prefix: String!
2195}
2196
2197type CommitPayload {
2198 """A unique identifier for the client performing the mutation."""
2199 clientMutationId: String
2200 """The affected bug."""
2201 bug: Bug!
2202}
2203
2204input CommitAsNeededInput {
2205 """A unique identifier for the client performing the mutation."""
2206 clientMutationId: String
2207 """"The name of the repository. If not set, the default repository is used."""
2208 repoRef: String
2209 """The bug ID's prefix."""
2210 prefix: String!
2211}
2212
2213type CommitAsNeededPayload {
2214 """A unique identifier for the client performing the mutation."""
2215 clientMutationId: String
2216 """The affected bug."""
2217 bug: Bug!
2218}
2219`, BuiltIn: false},
2220 &ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
2221interface Operation {
2222 """The identifier of the operation"""
2223 id: String!
2224 """The operations author."""
2225 author: Identity!
2226 """The datetime when this operation was issued."""
2227 date: Time!
2228}
2229
2230# Connection
2231
2232"""The connection type for an Operation"""
2233type OperationConnection {
2234 edges: [OperationEdge!]!
2235 nodes: [Operation!]!
2236 pageInfo: PageInfo!
2237 totalCount: Int!
2238}
2239
2240"""Represent an Operation"""
2241type OperationEdge {
2242 cursor: String!
2243 node: Operation!
2244}
2245
2246# Operations
2247
2248type CreateOperation implements Operation & Authored {
2249 """The identifier of the operation"""
2250 id: String!
2251 """The author of this object."""
2252 author: Identity!
2253 """The datetime when this operation was issued."""
2254 date: Time!
2255
2256 title: String!
2257 message: String!
2258 files: [Hash!]!
2259}
2260
2261type SetTitleOperation implements Operation & Authored {
2262 """The identifier of the operation"""
2263 id: String!
2264 """The author of this object."""
2265 author: Identity!
2266 """The datetime when this operation was issued."""
2267 date: Time!
2268
2269 title: String!
2270 was: String!
2271}
2272
2273type AddCommentOperation implements Operation & Authored {
2274 """The identifier of the operation"""
2275 id: String!
2276 """The author of this object."""
2277 author: Identity!
2278 """The datetime when this operation was issued."""
2279 date: Time!
2280
2281 message: String!
2282 files: [Hash!]!
2283}
2284
2285type EditCommentOperation implements Operation & Authored {
2286 """The identifier of the operation"""
2287 id: String!
2288 """The author of this object."""
2289 author: Identity!
2290 """The datetime when this operation was issued."""
2291 date: Time!
2292
2293 target: String!
2294 message: String!
2295 files: [Hash!]!
2296}
2297
2298type SetStatusOperation implements Operation & Authored {
2299 """The identifier of the operation"""
2300 id: String!
2301 """The author of this object."""
2302 author: Identity!
2303 """The datetime when this operation was issued."""
2304 date: Time!
2305
2306 status: Status!
2307}
2308
2309type LabelChangeOperation implements Operation & Authored {
2310 """The identifier of the operation"""
2311 id: String!
2312 """The author of this object."""
2313 author: Identity!
2314 """The datetime when this operation was issued."""
2315 date: Time!
2316
2317 added: [Label!]!
2318 removed: [Label!]!
2319}
2320`, BuiltIn: false},
2321 &ast.Source{Name: "schema/repository.graphql", Input: `
2322type Repository {
2323 """All the bugs"""
2324 allBugs(
2325 """Returns the elements in the list that come after the specified cursor."""
2326 after: String
2327 """Returns the elements in the list that come before the specified cursor."""
2328 before: String
2329 """Returns the first _n_ elements from the list."""
2330 first: Int
2331 """Returns the last _n_ elements from the list."""
2332 last: Int
2333 """A query to select and order bugs"""
2334 query: String
2335 ): BugConnection!
2336
2337 bug(prefix: String!): Bug
2338
2339 """All the identities"""
2340 allIdentities(
2341 """Returns the elements in the list that come after the specified cursor."""
2342 after: String
2343 """Returns the elements in the list that come before the specified cursor."""
2344 before: String
2345 """Returns the first _n_ elements from the list."""
2346 first: Int
2347 """Returns the last _n_ elements from the list."""
2348 last: Int
2349 ): IdentityConnection!
2350
2351 identity(prefix: String!): Identity
2352
2353 """The identity created or selected by the user as its own"""
2354 userIdentity: Identity
2355
2356 """List of valid labels."""
2357 validLabels(
2358 """Returns the elements in the list that come after the specified cursor."""
2359 after: String
2360 """Returns the elements in the list that come before the specified cursor."""
2361 before: String
2362 """Returns the first _n_ elements from the list."""
2363 first: Int
2364 """Returns the last _n_ elements from the list."""
2365 last: Int
2366 ): LabelConnection!
2367}`, BuiltIn: false},
2368 &ast.Source{Name: "schema/root.graphql", Input: `type Query {
2369 """The default unnamend repository."""
2370 defaultRepository: Repository
2371 """Access a repository by reference/name."""
2372 repository(ref: String!): Repository
2373
2374 #TODO: connection for all repositories
2375}
2376
2377type Mutation {
2378 """Create a new bug"""
2379 newBug(input: NewBugInput!): NewBugPayload!
2380 """Add a new comment to a bug"""
2381 addComment(input: AddCommentInput!): AddCommentPayload!
2382 """Add or remove a set of label on a bug"""
2383 changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
2384 """Change a bug's status to open"""
2385 openBug(input: OpenBugInput!): OpenBugPayload!
2386 """Change a bug's status to closed"""
2387 closeBug(input: CloseBugInput!): CloseBugPayload!
2388 """Change a bug's title"""
2389 setTitle(input: SetTitleInput!): SetTitlePayload!
2390 """Commit write the pending operations into storage. This mutation fail if nothing is pending"""
2391 commit(input: CommitInput!): CommitPayload!
2392 """Commit write the pending operations into storage. This mutation succed if nothing is pending"""
2393 commitAsNeeded(input: CommitAsNeededInput!): CommitAsNeededPayload!
2394}
2395`, BuiltIn: false},
2396 &ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
2397interface TimelineItem {
2398 """The identifier of the source operation"""
2399 id: String!
2400}
2401
2402"""CommentHistoryStep hold one version of a message in the history"""
2403type CommentHistoryStep {
2404 message: String!
2405 date: Time!
2406}
2407
2408# Connection
2409
2410"""The connection type for TimelineItem"""
2411type TimelineItemConnection {
2412 edges: [TimelineItemEdge!]!
2413 nodes: [TimelineItem!]!
2414 pageInfo: PageInfo!
2415 totalCount: Int!
2416}
2417
2418"""Represent a TimelineItem"""
2419type TimelineItemEdge {
2420 cursor: String!
2421 node: TimelineItem!
2422}
2423
2424# Items
2425
2426"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
2427type CreateTimelineItem implements TimelineItem & Authored {
2428 """The identifier of the source operation"""
2429 id: String!
2430 author: Identity!
2431 message: String!
2432 messageIsEmpty: Boolean!
2433 files: [Hash!]!
2434 createdAt: Time!
2435 lastEdit: Time!
2436 edited: Boolean!
2437 history: [CommentHistoryStep!]!
2438}
2439
2440"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
2441type AddCommentTimelineItem implements TimelineItem & Authored {
2442 """The identifier of the source operation"""
2443 id: String!
2444 author: Identity!
2445 message: String!
2446 messageIsEmpty: Boolean!
2447 files: [Hash!]!
2448 createdAt: Time!
2449 lastEdit: Time!
2450 edited: Boolean!
2451 history: [CommentHistoryStep!]!
2452}
2453
2454"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
2455type LabelChangeTimelineItem implements TimelineItem & Authored {
2456 """The identifier of the source operation"""
2457 id: String!
2458 author: Identity!
2459 date: Time!
2460 added: [Label!]!
2461 removed: [Label!]!
2462}
2463
2464"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
2465type SetStatusTimelineItem implements TimelineItem & Authored {
2466 """The identifier of the source operation"""
2467 id: String!
2468 author: Identity!
2469 date: Time!
2470 status: Status!
2471}
2472
2473"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
2474type SetTitleTimelineItem implements TimelineItem & Authored {
2475 """The identifier of the source operation"""
2476 id: String!
2477 author: Identity!
2478 date: Time!
2479 title: String!
2480 was: String!
2481}
2482`, BuiltIn: false},
2483 &ast.Source{Name: "schema/types.graphql", Input: `scalar Time
2484scalar Hash
2485
2486"""Defines a color by red, green and blue components."""
2487type Color {
2488 """Red component of the color."""
2489 R: Int!
2490 """Green component of the color."""
2491 G: Int!
2492 """Blue component of the color."""
2493 B: Int!
2494}
2495
2496"""Information about pagination in a connection."""
2497type PageInfo {
2498 """When paginating forwards, are there more items?"""
2499 hasNextPage: Boolean!
2500 """When paginating backwards, are there more items?"""
2501 hasPreviousPage: Boolean!
2502 """When paginating backwards, the cursor to continue."""
2503 startCursor: String!
2504 """When paginating forwards, the cursor to continue."""
2505 endCursor: String!
2506}
2507
2508"""An object that has an author."""
2509interface Authored {
2510 """The author of this object."""
2511 author: Identity!
2512}
2513`, BuiltIn: false},
2514}
2515var parsedSchema = gqlparser.MustLoadSchema(sources...)
2516
2517// endregion ************************** generated!.gotpl **************************
2518
2519// region ***************************** args.gotpl *****************************
2520
2521func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2522 var err error
2523 args := map[string]interface{}{}
2524 var arg0 *string
2525 if tmp, ok := rawArgs["after"]; ok {
2526 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2527 if err != nil {
2528 return nil, err
2529 }
2530 }
2531 args["after"] = arg0
2532 var arg1 *string
2533 if tmp, ok := rawArgs["before"]; ok {
2534 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2535 if err != nil {
2536 return nil, err
2537 }
2538 }
2539 args["before"] = arg1
2540 var arg2 *int
2541 if tmp, ok := rawArgs["first"]; ok {
2542 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2543 if err != nil {
2544 return nil, err
2545 }
2546 }
2547 args["first"] = arg2
2548 var arg3 *int
2549 if tmp, ok := rawArgs["last"]; ok {
2550 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2551 if err != nil {
2552 return nil, err
2553 }
2554 }
2555 args["last"] = arg3
2556 return args, nil
2557}
2558
2559func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2560 var err error
2561 args := map[string]interface{}{}
2562 var arg0 *string
2563 if tmp, ok := rawArgs["after"]; ok {
2564 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2565 if err != nil {
2566 return nil, err
2567 }
2568 }
2569 args["after"] = arg0
2570 var arg1 *string
2571 if tmp, ok := rawArgs["before"]; ok {
2572 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2573 if err != nil {
2574 return nil, err
2575 }
2576 }
2577 args["before"] = arg1
2578 var arg2 *int
2579 if tmp, ok := rawArgs["first"]; ok {
2580 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2581 if err != nil {
2582 return nil, err
2583 }
2584 }
2585 args["first"] = arg2
2586 var arg3 *int
2587 if tmp, ok := rawArgs["last"]; ok {
2588 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2589 if err != nil {
2590 return nil, err
2591 }
2592 }
2593 args["last"] = arg3
2594 return args, nil
2595}
2596
2597func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2598 var err error
2599 args := map[string]interface{}{}
2600 var arg0 *string
2601 if tmp, ok := rawArgs["after"]; ok {
2602 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2603 if err != nil {
2604 return nil, err
2605 }
2606 }
2607 args["after"] = arg0
2608 var arg1 *string
2609 if tmp, ok := rawArgs["before"]; ok {
2610 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2611 if err != nil {
2612 return nil, err
2613 }
2614 }
2615 args["before"] = arg1
2616 var arg2 *int
2617 if tmp, ok := rawArgs["first"]; ok {
2618 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2619 if err != nil {
2620 return nil, err
2621 }
2622 }
2623 args["first"] = arg2
2624 var arg3 *int
2625 if tmp, ok := rawArgs["last"]; ok {
2626 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2627 if err != nil {
2628 return nil, err
2629 }
2630 }
2631 args["last"] = arg3
2632 return args, nil
2633}
2634
2635func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2636 var err error
2637 args := map[string]interface{}{}
2638 var arg0 *string
2639 if tmp, ok := rawArgs["after"]; ok {
2640 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2641 if err != nil {
2642 return nil, err
2643 }
2644 }
2645 args["after"] = arg0
2646 var arg1 *string
2647 if tmp, ok := rawArgs["before"]; ok {
2648 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2649 if err != nil {
2650 return nil, err
2651 }
2652 }
2653 args["before"] = arg1
2654 var arg2 *int
2655 if tmp, ok := rawArgs["first"]; ok {
2656 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2657 if err != nil {
2658 return nil, err
2659 }
2660 }
2661 args["first"] = arg2
2662 var arg3 *int
2663 if tmp, ok := rawArgs["last"]; ok {
2664 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2665 if err != nil {
2666 return nil, err
2667 }
2668 }
2669 args["last"] = arg3
2670 return args, nil
2671}
2672
2673func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2674 var err error
2675 args := map[string]interface{}{}
2676 var arg0 *string
2677 if tmp, ok := rawArgs["after"]; ok {
2678 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2679 if err != nil {
2680 return nil, err
2681 }
2682 }
2683 args["after"] = arg0
2684 var arg1 *string
2685 if tmp, ok := rawArgs["before"]; ok {
2686 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2687 if err != nil {
2688 return nil, err
2689 }
2690 }
2691 args["before"] = arg1
2692 var arg2 *int
2693 if tmp, ok := rawArgs["first"]; ok {
2694 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2695 if err != nil {
2696 return nil, err
2697 }
2698 }
2699 args["first"] = arg2
2700 var arg3 *int
2701 if tmp, ok := rawArgs["last"]; ok {
2702 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2703 if err != nil {
2704 return nil, err
2705 }
2706 }
2707 args["last"] = arg3
2708 return args, nil
2709}
2710
2711func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2712 var err error
2713 args := map[string]interface{}{}
2714 var arg0 models.AddCommentInput
2715 if tmp, ok := rawArgs["input"]; ok {
2716 arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
2717 if err != nil {
2718 return nil, err
2719 }
2720 }
2721 args["input"] = arg0
2722 return args, nil
2723}
2724
2725func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2726 var err error
2727 args := map[string]interface{}{}
2728 var arg0 *models.ChangeLabelInput
2729 if tmp, ok := rawArgs["input"]; ok {
2730 arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
2731 if err != nil {
2732 return nil, err
2733 }
2734 }
2735 args["input"] = arg0
2736 return args, nil
2737}
2738
2739func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2740 var err error
2741 args := map[string]interface{}{}
2742 var arg0 models.CloseBugInput
2743 if tmp, ok := rawArgs["input"]; ok {
2744 arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
2745 if err != nil {
2746 return nil, err
2747 }
2748 }
2749 args["input"] = arg0
2750 return args, nil
2751}
2752
2753func (ec *executionContext) field_Mutation_commitAsNeeded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2754 var err error
2755 args := map[string]interface{}{}
2756 var arg0 models.CommitAsNeededInput
2757 if tmp, ok := rawArgs["input"]; ok {
2758 arg0, err = ec.unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx, tmp)
2759 if err != nil {
2760 return nil, err
2761 }
2762 }
2763 args["input"] = arg0
2764 return args, nil
2765}
2766
2767func (ec *executionContext) field_Mutation_commit_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2768 var err error
2769 args := map[string]interface{}{}
2770 var arg0 models.CommitInput
2771 if tmp, ok := rawArgs["input"]; ok {
2772 arg0, err = ec.unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx, tmp)
2773 if err != nil {
2774 return nil, err
2775 }
2776 }
2777 args["input"] = arg0
2778 return args, nil
2779}
2780
2781func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2782 var err error
2783 args := map[string]interface{}{}
2784 var arg0 models.NewBugInput
2785 if tmp, ok := rawArgs["input"]; ok {
2786 arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
2787 if err != nil {
2788 return nil, err
2789 }
2790 }
2791 args["input"] = arg0
2792 return args, nil
2793}
2794
2795func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2796 var err error
2797 args := map[string]interface{}{}
2798 var arg0 models.OpenBugInput
2799 if tmp, ok := rawArgs["input"]; ok {
2800 arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
2801 if err != nil {
2802 return nil, err
2803 }
2804 }
2805 args["input"] = arg0
2806 return args, nil
2807}
2808
2809func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2810 var err error
2811 args := map[string]interface{}{}
2812 var arg0 models.SetTitleInput
2813 if tmp, ok := rawArgs["input"]; ok {
2814 arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
2815 if err != nil {
2816 return nil, err
2817 }
2818 }
2819 args["input"] = arg0
2820 return args, nil
2821}
2822
2823func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2824 var err error
2825 args := map[string]interface{}{}
2826 var arg0 string
2827 if tmp, ok := rawArgs["name"]; ok {
2828 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2829 if err != nil {
2830 return nil, err
2831 }
2832 }
2833 args["name"] = arg0
2834 return args, nil
2835}
2836
2837func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2838 var err error
2839 args := map[string]interface{}{}
2840 var arg0 string
2841 if tmp, ok := rawArgs["ref"]; ok {
2842 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2843 if err != nil {
2844 return nil, err
2845 }
2846 }
2847 args["ref"] = arg0
2848 return args, nil
2849}
2850
2851func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2852 var err error
2853 args := map[string]interface{}{}
2854 var arg0 *string
2855 if tmp, ok := rawArgs["after"]; ok {
2856 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2857 if err != nil {
2858 return nil, err
2859 }
2860 }
2861 args["after"] = arg0
2862 var arg1 *string
2863 if tmp, ok := rawArgs["before"]; ok {
2864 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2865 if err != nil {
2866 return nil, err
2867 }
2868 }
2869 args["before"] = arg1
2870 var arg2 *int
2871 if tmp, ok := rawArgs["first"]; ok {
2872 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2873 if err != nil {
2874 return nil, err
2875 }
2876 }
2877 args["first"] = arg2
2878 var arg3 *int
2879 if tmp, ok := rawArgs["last"]; ok {
2880 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2881 if err != nil {
2882 return nil, err
2883 }
2884 }
2885 args["last"] = arg3
2886 var arg4 *string
2887 if tmp, ok := rawArgs["query"]; ok {
2888 arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2889 if err != nil {
2890 return nil, err
2891 }
2892 }
2893 args["query"] = arg4
2894 return args, nil
2895}
2896
2897func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2898 var err error
2899 args := map[string]interface{}{}
2900 var arg0 *string
2901 if tmp, ok := rawArgs["after"]; ok {
2902 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2903 if err != nil {
2904 return nil, err
2905 }
2906 }
2907 args["after"] = arg0
2908 var arg1 *string
2909 if tmp, ok := rawArgs["before"]; ok {
2910 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2911 if err != nil {
2912 return nil, err
2913 }
2914 }
2915 args["before"] = arg1
2916 var arg2 *int
2917 if tmp, ok := rawArgs["first"]; ok {
2918 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2919 if err != nil {
2920 return nil, err
2921 }
2922 }
2923 args["first"] = arg2
2924 var arg3 *int
2925 if tmp, ok := rawArgs["last"]; ok {
2926 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2927 if err != nil {
2928 return nil, err
2929 }
2930 }
2931 args["last"] = arg3
2932 return args, nil
2933}
2934
2935func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2936 var err error
2937 args := map[string]interface{}{}
2938 var arg0 string
2939 if tmp, ok := rawArgs["prefix"]; ok {
2940 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2941 if err != nil {
2942 return nil, err
2943 }
2944 }
2945 args["prefix"] = arg0
2946 return args, nil
2947}
2948
2949func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2950 var err error
2951 args := map[string]interface{}{}
2952 var arg0 string
2953 if tmp, ok := rawArgs["prefix"]; ok {
2954 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2955 if err != nil {
2956 return nil, err
2957 }
2958 }
2959 args["prefix"] = arg0
2960 return args, nil
2961}
2962
2963func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2964 var err error
2965 args := map[string]interface{}{}
2966 var arg0 *string
2967 if tmp, ok := rawArgs["after"]; ok {
2968 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2969 if err != nil {
2970 return nil, err
2971 }
2972 }
2973 args["after"] = arg0
2974 var arg1 *string
2975 if tmp, ok := rawArgs["before"]; ok {
2976 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2977 if err != nil {
2978 return nil, err
2979 }
2980 }
2981 args["before"] = arg1
2982 var arg2 *int
2983 if tmp, ok := rawArgs["first"]; ok {
2984 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2985 if err != nil {
2986 return nil, err
2987 }
2988 }
2989 args["first"] = arg2
2990 var arg3 *int
2991 if tmp, ok := rawArgs["last"]; ok {
2992 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2993 if err != nil {
2994 return nil, err
2995 }
2996 }
2997 args["last"] = arg3
2998 return args, nil
2999}
3000
3001func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3002 var err error
3003 args := map[string]interface{}{}
3004 var arg0 bool
3005 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3006 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3007 if err != nil {
3008 return nil, err
3009 }
3010 }
3011 args["includeDeprecated"] = arg0
3012 return args, nil
3013}
3014
3015func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3016 var err error
3017 args := map[string]interface{}{}
3018 var arg0 bool
3019 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3020 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3021 if err != nil {
3022 return nil, err
3023 }
3024 }
3025 args["includeDeprecated"] = arg0
3026 return args, nil
3027}
3028
3029// endregion ***************************** args.gotpl *****************************
3030
3031// region ************************** directives.gotpl **************************
3032
3033// endregion ************************** directives.gotpl **************************
3034
3035// region **************************** field.gotpl *****************************
3036
3037func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3038 defer func() {
3039 if r := recover(); r != nil {
3040 ec.Error(ctx, ec.Recover(ctx, r))
3041 ret = graphql.Null
3042 }
3043 }()
3044 fc := &graphql.FieldContext{
3045 Object: "AddCommentOperation",
3046 Field: field,
3047 Args: nil,
3048 IsMethod: true,
3049 }
3050
3051 ctx = graphql.WithFieldContext(ctx, fc)
3052 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3053 ctx = rctx // use context from middleware stack in children
3054 return ec.resolvers.AddCommentOperation().ID(rctx, obj)
3055 })
3056 if err != nil {
3057 ec.Error(ctx, err)
3058 return graphql.Null
3059 }
3060 if resTmp == nil {
3061 if !graphql.HasFieldError(ctx, fc) {
3062 ec.Errorf(ctx, "must not be null")
3063 }
3064 return graphql.Null
3065 }
3066 res := resTmp.(string)
3067 fc.Result = res
3068 return ec.marshalNString2string(ctx, field.Selections, res)
3069}
3070
3071func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3072 defer func() {
3073 if r := recover(); r != nil {
3074 ec.Error(ctx, ec.Recover(ctx, r))
3075 ret = graphql.Null
3076 }
3077 }()
3078 fc := &graphql.FieldContext{
3079 Object: "AddCommentOperation",
3080 Field: field,
3081 Args: nil,
3082 IsMethod: true,
3083 }
3084
3085 ctx = graphql.WithFieldContext(ctx, fc)
3086 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3087 ctx = rctx // use context from middleware stack in children
3088 return ec.resolvers.AddCommentOperation().Author(rctx, obj)
3089 })
3090 if err != nil {
3091 ec.Error(ctx, err)
3092 return graphql.Null
3093 }
3094 if resTmp == nil {
3095 if !graphql.HasFieldError(ctx, fc) {
3096 ec.Errorf(ctx, "must not be null")
3097 }
3098 return graphql.Null
3099 }
3100 res := resTmp.(models.IdentityWrapper)
3101 fc.Result = res
3102 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3103}
3104
3105func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3106 defer func() {
3107 if r := recover(); r != nil {
3108 ec.Error(ctx, ec.Recover(ctx, r))
3109 ret = graphql.Null
3110 }
3111 }()
3112 fc := &graphql.FieldContext{
3113 Object: "AddCommentOperation",
3114 Field: field,
3115 Args: nil,
3116 IsMethod: true,
3117 }
3118
3119 ctx = graphql.WithFieldContext(ctx, fc)
3120 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3121 ctx = rctx // use context from middleware stack in children
3122 return ec.resolvers.AddCommentOperation().Date(rctx, obj)
3123 })
3124 if err != nil {
3125 ec.Error(ctx, err)
3126 return graphql.Null
3127 }
3128 if resTmp == nil {
3129 if !graphql.HasFieldError(ctx, fc) {
3130 ec.Errorf(ctx, "must not be null")
3131 }
3132 return graphql.Null
3133 }
3134 res := resTmp.(*time.Time)
3135 fc.Result = res
3136 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3137}
3138
3139func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3140 defer func() {
3141 if r := recover(); r != nil {
3142 ec.Error(ctx, ec.Recover(ctx, r))
3143 ret = graphql.Null
3144 }
3145 }()
3146 fc := &graphql.FieldContext{
3147 Object: "AddCommentOperation",
3148 Field: field,
3149 Args: nil,
3150 IsMethod: false,
3151 }
3152
3153 ctx = graphql.WithFieldContext(ctx, fc)
3154 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3155 ctx = rctx // use context from middleware stack in children
3156 return obj.Message, nil
3157 })
3158 if err != nil {
3159 ec.Error(ctx, err)
3160 return graphql.Null
3161 }
3162 if resTmp == nil {
3163 if !graphql.HasFieldError(ctx, fc) {
3164 ec.Errorf(ctx, "must not be null")
3165 }
3166 return graphql.Null
3167 }
3168 res := resTmp.(string)
3169 fc.Result = res
3170 return ec.marshalNString2string(ctx, field.Selections, res)
3171}
3172
3173func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3174 defer func() {
3175 if r := recover(); r != nil {
3176 ec.Error(ctx, ec.Recover(ctx, r))
3177 ret = graphql.Null
3178 }
3179 }()
3180 fc := &graphql.FieldContext{
3181 Object: "AddCommentOperation",
3182 Field: field,
3183 Args: nil,
3184 IsMethod: false,
3185 }
3186
3187 ctx = graphql.WithFieldContext(ctx, fc)
3188 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3189 ctx = rctx // use context from middleware stack in children
3190 return obj.Files, nil
3191 })
3192 if err != nil {
3193 ec.Error(ctx, err)
3194 return graphql.Null
3195 }
3196 if resTmp == nil {
3197 if !graphql.HasFieldError(ctx, fc) {
3198 ec.Errorf(ctx, "must not be null")
3199 }
3200 return graphql.Null
3201 }
3202 res := resTmp.([]git.Hash)
3203 fc.Result = res
3204 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
3205}
3206
3207func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3208 defer func() {
3209 if r := recover(); r != nil {
3210 ec.Error(ctx, ec.Recover(ctx, r))
3211 ret = graphql.Null
3212 }
3213 }()
3214 fc := &graphql.FieldContext{
3215 Object: "AddCommentPayload",
3216 Field: field,
3217 Args: nil,
3218 IsMethod: false,
3219 }
3220
3221 ctx = graphql.WithFieldContext(ctx, fc)
3222 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3223 ctx = rctx // use context from middleware stack in children
3224 return obj.ClientMutationID, nil
3225 })
3226 if err != nil {
3227 ec.Error(ctx, err)
3228 return graphql.Null
3229 }
3230 if resTmp == nil {
3231 return graphql.Null
3232 }
3233 res := resTmp.(*string)
3234 fc.Result = res
3235 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3236}
3237
3238func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3239 defer func() {
3240 if r := recover(); r != nil {
3241 ec.Error(ctx, ec.Recover(ctx, r))
3242 ret = graphql.Null
3243 }
3244 }()
3245 fc := &graphql.FieldContext{
3246 Object: "AddCommentPayload",
3247 Field: field,
3248 Args: nil,
3249 IsMethod: false,
3250 }
3251
3252 ctx = graphql.WithFieldContext(ctx, fc)
3253 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3254 ctx = rctx // use context from middleware stack in children
3255 return obj.Bug, nil
3256 })
3257 if err != nil {
3258 ec.Error(ctx, err)
3259 return graphql.Null
3260 }
3261 if resTmp == nil {
3262 if !graphql.HasFieldError(ctx, fc) {
3263 ec.Errorf(ctx, "must not be null")
3264 }
3265 return graphql.Null
3266 }
3267 res := resTmp.(models.BugWrapper)
3268 fc.Result = res
3269 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3270}
3271
3272func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3273 defer func() {
3274 if r := recover(); r != nil {
3275 ec.Error(ctx, ec.Recover(ctx, r))
3276 ret = graphql.Null
3277 }
3278 }()
3279 fc := &graphql.FieldContext{
3280 Object: "AddCommentPayload",
3281 Field: field,
3282 Args: nil,
3283 IsMethod: false,
3284 }
3285
3286 ctx = graphql.WithFieldContext(ctx, fc)
3287 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3288 ctx = rctx // use context from middleware stack in children
3289 return obj.Operation, nil
3290 })
3291 if err != nil {
3292 ec.Error(ctx, err)
3293 return graphql.Null
3294 }
3295 if resTmp == nil {
3296 if !graphql.HasFieldError(ctx, fc) {
3297 ec.Errorf(ctx, "must not be null")
3298 }
3299 return graphql.Null
3300 }
3301 res := resTmp.(*bug.AddCommentOperation)
3302 fc.Result = res
3303 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3304}
3305
3306func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3307 defer func() {
3308 if r := recover(); r != nil {
3309 ec.Error(ctx, ec.Recover(ctx, r))
3310 ret = graphql.Null
3311 }
3312 }()
3313 fc := &graphql.FieldContext{
3314 Object: "AddCommentTimelineItem",
3315 Field: field,
3316 Args: nil,
3317 IsMethod: true,
3318 }
3319
3320 ctx = graphql.WithFieldContext(ctx, fc)
3321 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3322 ctx = rctx // use context from middleware stack in children
3323 return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
3324 })
3325 if err != nil {
3326 ec.Error(ctx, err)
3327 return graphql.Null
3328 }
3329 if resTmp == nil {
3330 if !graphql.HasFieldError(ctx, fc) {
3331 ec.Errorf(ctx, "must not be null")
3332 }
3333 return graphql.Null
3334 }
3335 res := resTmp.(string)
3336 fc.Result = res
3337 return ec.marshalNString2string(ctx, field.Selections, res)
3338}
3339
3340func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3341 defer func() {
3342 if r := recover(); r != nil {
3343 ec.Error(ctx, ec.Recover(ctx, r))
3344 ret = graphql.Null
3345 }
3346 }()
3347 fc := &graphql.FieldContext{
3348 Object: "AddCommentTimelineItem",
3349 Field: field,
3350 Args: nil,
3351 IsMethod: true,
3352 }
3353
3354 ctx = graphql.WithFieldContext(ctx, fc)
3355 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3356 ctx = rctx // use context from middleware stack in children
3357 return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
3358 })
3359 if err != nil {
3360 ec.Error(ctx, err)
3361 return graphql.Null
3362 }
3363 if resTmp == nil {
3364 if !graphql.HasFieldError(ctx, fc) {
3365 ec.Errorf(ctx, "must not be null")
3366 }
3367 return graphql.Null
3368 }
3369 res := resTmp.(models.IdentityWrapper)
3370 fc.Result = res
3371 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3372}
3373
3374func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3375 defer func() {
3376 if r := recover(); r != nil {
3377 ec.Error(ctx, ec.Recover(ctx, r))
3378 ret = graphql.Null
3379 }
3380 }()
3381 fc := &graphql.FieldContext{
3382 Object: "AddCommentTimelineItem",
3383 Field: field,
3384 Args: nil,
3385 IsMethod: false,
3386 }
3387
3388 ctx = graphql.WithFieldContext(ctx, fc)
3389 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3390 ctx = rctx // use context from middleware stack in children
3391 return obj.Message, nil
3392 })
3393 if err != nil {
3394 ec.Error(ctx, err)
3395 return graphql.Null
3396 }
3397 if resTmp == nil {
3398 if !graphql.HasFieldError(ctx, fc) {
3399 ec.Errorf(ctx, "must not be null")
3400 }
3401 return graphql.Null
3402 }
3403 res := resTmp.(string)
3404 fc.Result = res
3405 return ec.marshalNString2string(ctx, field.Selections, res)
3406}
3407
3408func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3409 defer func() {
3410 if r := recover(); r != nil {
3411 ec.Error(ctx, ec.Recover(ctx, r))
3412 ret = graphql.Null
3413 }
3414 }()
3415 fc := &graphql.FieldContext{
3416 Object: "AddCommentTimelineItem",
3417 Field: field,
3418 Args: nil,
3419 IsMethod: true,
3420 }
3421
3422 ctx = graphql.WithFieldContext(ctx, fc)
3423 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3424 ctx = rctx // use context from middleware stack in children
3425 return obj.MessageIsEmpty(), nil
3426 })
3427 if err != nil {
3428 ec.Error(ctx, err)
3429 return graphql.Null
3430 }
3431 if resTmp == nil {
3432 if !graphql.HasFieldError(ctx, fc) {
3433 ec.Errorf(ctx, "must not be null")
3434 }
3435 return graphql.Null
3436 }
3437 res := resTmp.(bool)
3438 fc.Result = res
3439 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3440}
3441
3442func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3443 defer func() {
3444 if r := recover(); r != nil {
3445 ec.Error(ctx, ec.Recover(ctx, r))
3446 ret = graphql.Null
3447 }
3448 }()
3449 fc := &graphql.FieldContext{
3450 Object: "AddCommentTimelineItem",
3451 Field: field,
3452 Args: nil,
3453 IsMethod: false,
3454 }
3455
3456 ctx = graphql.WithFieldContext(ctx, fc)
3457 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3458 ctx = rctx // use context from middleware stack in children
3459 return obj.Files, nil
3460 })
3461 if err != nil {
3462 ec.Error(ctx, err)
3463 return graphql.Null
3464 }
3465 if resTmp == nil {
3466 if !graphql.HasFieldError(ctx, fc) {
3467 ec.Errorf(ctx, "must not be null")
3468 }
3469 return graphql.Null
3470 }
3471 res := resTmp.([]git.Hash)
3472 fc.Result = res
3473 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
3474}
3475
3476func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3477 defer func() {
3478 if r := recover(); r != nil {
3479 ec.Error(ctx, ec.Recover(ctx, r))
3480 ret = graphql.Null
3481 }
3482 }()
3483 fc := &graphql.FieldContext{
3484 Object: "AddCommentTimelineItem",
3485 Field: field,
3486 Args: nil,
3487 IsMethod: true,
3488 }
3489
3490 ctx = graphql.WithFieldContext(ctx, fc)
3491 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3492 ctx = rctx // use context from middleware stack in children
3493 return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
3494 })
3495 if err != nil {
3496 ec.Error(ctx, err)
3497 return graphql.Null
3498 }
3499 if resTmp == nil {
3500 if !graphql.HasFieldError(ctx, fc) {
3501 ec.Errorf(ctx, "must not be null")
3502 }
3503 return graphql.Null
3504 }
3505 res := resTmp.(*time.Time)
3506 fc.Result = res
3507 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3508}
3509
3510func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3511 defer func() {
3512 if r := recover(); r != nil {
3513 ec.Error(ctx, ec.Recover(ctx, r))
3514 ret = graphql.Null
3515 }
3516 }()
3517 fc := &graphql.FieldContext{
3518 Object: "AddCommentTimelineItem",
3519 Field: field,
3520 Args: nil,
3521 IsMethod: true,
3522 }
3523
3524 ctx = graphql.WithFieldContext(ctx, fc)
3525 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3526 ctx = rctx // use context from middleware stack in children
3527 return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
3528 })
3529 if err != nil {
3530 ec.Error(ctx, err)
3531 return graphql.Null
3532 }
3533 if resTmp == nil {
3534 if !graphql.HasFieldError(ctx, fc) {
3535 ec.Errorf(ctx, "must not be null")
3536 }
3537 return graphql.Null
3538 }
3539 res := resTmp.(*time.Time)
3540 fc.Result = res
3541 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3542}
3543
3544func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3545 defer func() {
3546 if r := recover(); r != nil {
3547 ec.Error(ctx, ec.Recover(ctx, r))
3548 ret = graphql.Null
3549 }
3550 }()
3551 fc := &graphql.FieldContext{
3552 Object: "AddCommentTimelineItem",
3553 Field: field,
3554 Args: nil,
3555 IsMethod: true,
3556 }
3557
3558 ctx = graphql.WithFieldContext(ctx, fc)
3559 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3560 ctx = rctx // use context from middleware stack in children
3561 return obj.Edited(), nil
3562 })
3563 if err != nil {
3564 ec.Error(ctx, err)
3565 return graphql.Null
3566 }
3567 if resTmp == nil {
3568 if !graphql.HasFieldError(ctx, fc) {
3569 ec.Errorf(ctx, "must not be null")
3570 }
3571 return graphql.Null
3572 }
3573 res := resTmp.(bool)
3574 fc.Result = res
3575 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3576}
3577
3578func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3579 defer func() {
3580 if r := recover(); r != nil {
3581 ec.Error(ctx, ec.Recover(ctx, r))
3582 ret = graphql.Null
3583 }
3584 }()
3585 fc := &graphql.FieldContext{
3586 Object: "AddCommentTimelineItem",
3587 Field: field,
3588 Args: nil,
3589 IsMethod: false,
3590 }
3591
3592 ctx = graphql.WithFieldContext(ctx, fc)
3593 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3594 ctx = rctx // use context from middleware stack in children
3595 return obj.History, nil
3596 })
3597 if err != nil {
3598 ec.Error(ctx, err)
3599 return graphql.Null
3600 }
3601 if resTmp == nil {
3602 if !graphql.HasFieldError(ctx, fc) {
3603 ec.Errorf(ctx, "must not be null")
3604 }
3605 return graphql.Null
3606 }
3607 res := resTmp.([]bug.CommentHistoryStep)
3608 fc.Result = res
3609 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
3610}
3611
3612func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3613 defer func() {
3614 if r := recover(); r != nil {
3615 ec.Error(ctx, ec.Recover(ctx, r))
3616 ret = graphql.Null
3617 }
3618 }()
3619 fc := &graphql.FieldContext{
3620 Object: "Bug",
3621 Field: field,
3622 Args: nil,
3623 IsMethod: true,
3624 }
3625
3626 ctx = graphql.WithFieldContext(ctx, fc)
3627 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3628 ctx = rctx // use context from middleware stack in children
3629 return ec.resolvers.Bug().ID(rctx, obj)
3630 })
3631 if err != nil {
3632 ec.Error(ctx, err)
3633 return graphql.Null
3634 }
3635 if resTmp == nil {
3636 if !graphql.HasFieldError(ctx, fc) {
3637 ec.Errorf(ctx, "must not be null")
3638 }
3639 return graphql.Null
3640 }
3641 res := resTmp.(string)
3642 fc.Result = res
3643 return ec.marshalNString2string(ctx, field.Selections, res)
3644}
3645
3646func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3647 defer func() {
3648 if r := recover(); r != nil {
3649 ec.Error(ctx, ec.Recover(ctx, r))
3650 ret = graphql.Null
3651 }
3652 }()
3653 fc := &graphql.FieldContext{
3654 Object: "Bug",
3655 Field: field,
3656 Args: nil,
3657 IsMethod: true,
3658 }
3659
3660 ctx = graphql.WithFieldContext(ctx, fc)
3661 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3662 ctx = rctx // use context from middleware stack in children
3663 return ec.resolvers.Bug().HumanID(rctx, obj)
3664 })
3665 if err != nil {
3666 ec.Error(ctx, err)
3667 return graphql.Null
3668 }
3669 if resTmp == nil {
3670 if !graphql.HasFieldError(ctx, fc) {
3671 ec.Errorf(ctx, "must not be null")
3672 }
3673 return graphql.Null
3674 }
3675 res := resTmp.(string)
3676 fc.Result = res
3677 return ec.marshalNString2string(ctx, field.Selections, res)
3678}
3679
3680func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3681 defer func() {
3682 if r := recover(); r != nil {
3683 ec.Error(ctx, ec.Recover(ctx, r))
3684 ret = graphql.Null
3685 }
3686 }()
3687 fc := &graphql.FieldContext{
3688 Object: "Bug",
3689 Field: field,
3690 Args: nil,
3691 IsMethod: true,
3692 }
3693
3694 ctx = graphql.WithFieldContext(ctx, fc)
3695 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3696 ctx = rctx // use context from middleware stack in children
3697 return ec.resolvers.Bug().Status(rctx, obj)
3698 })
3699 if err != nil {
3700 ec.Error(ctx, err)
3701 return graphql.Null
3702 }
3703 if resTmp == nil {
3704 if !graphql.HasFieldError(ctx, fc) {
3705 ec.Errorf(ctx, "must not be null")
3706 }
3707 return graphql.Null
3708 }
3709 res := resTmp.(models.Status)
3710 fc.Result = res
3711 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
3712}
3713
3714func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3715 defer func() {
3716 if r := recover(); r != nil {
3717 ec.Error(ctx, ec.Recover(ctx, r))
3718 ret = graphql.Null
3719 }
3720 }()
3721 fc := &graphql.FieldContext{
3722 Object: "Bug",
3723 Field: field,
3724 Args: nil,
3725 IsMethod: true,
3726 }
3727
3728 ctx = graphql.WithFieldContext(ctx, fc)
3729 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3730 ctx = rctx // use context from middleware stack in children
3731 return obj.Title(), nil
3732 })
3733 if err != nil {
3734 ec.Error(ctx, err)
3735 return graphql.Null
3736 }
3737 if resTmp == nil {
3738 if !graphql.HasFieldError(ctx, fc) {
3739 ec.Errorf(ctx, "must not be null")
3740 }
3741 return graphql.Null
3742 }
3743 res := resTmp.(string)
3744 fc.Result = res
3745 return ec.marshalNString2string(ctx, field.Selections, res)
3746}
3747
3748func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3749 defer func() {
3750 if r := recover(); r != nil {
3751 ec.Error(ctx, ec.Recover(ctx, r))
3752 ret = graphql.Null
3753 }
3754 }()
3755 fc := &graphql.FieldContext{
3756 Object: "Bug",
3757 Field: field,
3758 Args: nil,
3759 IsMethod: true,
3760 }
3761
3762 ctx = graphql.WithFieldContext(ctx, fc)
3763 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3764 ctx = rctx // use context from middleware stack in children
3765 return obj.Labels(), nil
3766 })
3767 if err != nil {
3768 ec.Error(ctx, err)
3769 return graphql.Null
3770 }
3771 if resTmp == nil {
3772 if !graphql.HasFieldError(ctx, fc) {
3773 ec.Errorf(ctx, "must not be null")
3774 }
3775 return graphql.Null
3776 }
3777 res := resTmp.([]bug.Label)
3778 fc.Result = res
3779 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
3780}
3781
3782func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3783 defer func() {
3784 if r := recover(); r != nil {
3785 ec.Error(ctx, ec.Recover(ctx, r))
3786 ret = graphql.Null
3787 }
3788 }()
3789 fc := &graphql.FieldContext{
3790 Object: "Bug",
3791 Field: field,
3792 Args: nil,
3793 IsMethod: true,
3794 }
3795
3796 ctx = graphql.WithFieldContext(ctx, fc)
3797 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3798 ctx = rctx // use context from middleware stack in children
3799 return obj.Author()
3800 })
3801 if err != nil {
3802 ec.Error(ctx, err)
3803 return graphql.Null
3804 }
3805 if resTmp == nil {
3806 if !graphql.HasFieldError(ctx, fc) {
3807 ec.Errorf(ctx, "must not be null")
3808 }
3809 return graphql.Null
3810 }
3811 res := resTmp.(models.IdentityWrapper)
3812 fc.Result = res
3813 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3814}
3815
3816func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3817 defer func() {
3818 if r := recover(); r != nil {
3819 ec.Error(ctx, ec.Recover(ctx, r))
3820 ret = graphql.Null
3821 }
3822 }()
3823 fc := &graphql.FieldContext{
3824 Object: "Bug",
3825 Field: field,
3826 Args: nil,
3827 IsMethod: true,
3828 }
3829
3830 ctx = graphql.WithFieldContext(ctx, fc)
3831 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3832 ctx = rctx // use context from middleware stack in children
3833 return obj.CreatedAt(), nil
3834 })
3835 if err != nil {
3836 ec.Error(ctx, err)
3837 return graphql.Null
3838 }
3839 if resTmp == nil {
3840 if !graphql.HasFieldError(ctx, fc) {
3841 ec.Errorf(ctx, "must not be null")
3842 }
3843 return graphql.Null
3844 }
3845 res := resTmp.(time.Time)
3846 fc.Result = res
3847 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
3848}
3849
3850func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3851 defer func() {
3852 if r := recover(); r != nil {
3853 ec.Error(ctx, ec.Recover(ctx, r))
3854 ret = graphql.Null
3855 }
3856 }()
3857 fc := &graphql.FieldContext{
3858 Object: "Bug",
3859 Field: field,
3860 Args: nil,
3861 IsMethod: true,
3862 }
3863
3864 ctx = graphql.WithFieldContext(ctx, fc)
3865 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3866 ctx = rctx // use context from middleware stack in children
3867 return obj.LastEdit(), nil
3868 })
3869 if err != nil {
3870 ec.Error(ctx, err)
3871 return graphql.Null
3872 }
3873 if resTmp == nil {
3874 if !graphql.HasFieldError(ctx, fc) {
3875 ec.Errorf(ctx, "must not be null")
3876 }
3877 return graphql.Null
3878 }
3879 res := resTmp.(time.Time)
3880 fc.Result = res
3881 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
3882}
3883
3884func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3885 defer func() {
3886 if r := recover(); r != nil {
3887 ec.Error(ctx, ec.Recover(ctx, r))
3888 ret = graphql.Null
3889 }
3890 }()
3891 fc := &graphql.FieldContext{
3892 Object: "Bug",
3893 Field: field,
3894 Args: nil,
3895 IsMethod: true,
3896 }
3897
3898 ctx = graphql.WithFieldContext(ctx, fc)
3899 rawArgs := field.ArgumentMap(ec.Variables)
3900 args, err := ec.field_Bug_actors_args(ctx, rawArgs)
3901 if err != nil {
3902 ec.Error(ctx, err)
3903 return graphql.Null
3904 }
3905 fc.Args = args
3906 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3907 ctx = rctx // use context from middleware stack in children
3908 return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
3909 })
3910 if err != nil {
3911 ec.Error(ctx, err)
3912 return graphql.Null
3913 }
3914 if resTmp == nil {
3915 if !graphql.HasFieldError(ctx, fc) {
3916 ec.Errorf(ctx, "must not be null")
3917 }
3918 return graphql.Null
3919 }
3920 res := resTmp.(*models.IdentityConnection)
3921 fc.Result = res
3922 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
3923}
3924
3925func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3926 defer func() {
3927 if r := recover(); r != nil {
3928 ec.Error(ctx, ec.Recover(ctx, r))
3929 ret = graphql.Null
3930 }
3931 }()
3932 fc := &graphql.FieldContext{
3933 Object: "Bug",
3934 Field: field,
3935 Args: nil,
3936 IsMethod: true,
3937 }
3938
3939 ctx = graphql.WithFieldContext(ctx, fc)
3940 rawArgs := field.ArgumentMap(ec.Variables)
3941 args, err := ec.field_Bug_participants_args(ctx, rawArgs)
3942 if err != nil {
3943 ec.Error(ctx, err)
3944 return graphql.Null
3945 }
3946 fc.Args = args
3947 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3948 ctx = rctx // use context from middleware stack in children
3949 return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
3950 })
3951 if err != nil {
3952 ec.Error(ctx, err)
3953 return graphql.Null
3954 }
3955 if resTmp == nil {
3956 if !graphql.HasFieldError(ctx, fc) {
3957 ec.Errorf(ctx, "must not be null")
3958 }
3959 return graphql.Null
3960 }
3961 res := resTmp.(*models.IdentityConnection)
3962 fc.Result = res
3963 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
3964}
3965
3966func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3967 defer func() {
3968 if r := recover(); r != nil {
3969 ec.Error(ctx, ec.Recover(ctx, r))
3970 ret = graphql.Null
3971 }
3972 }()
3973 fc := &graphql.FieldContext{
3974 Object: "Bug",
3975 Field: field,
3976 Args: nil,
3977 IsMethod: true,
3978 }
3979
3980 ctx = graphql.WithFieldContext(ctx, fc)
3981 rawArgs := field.ArgumentMap(ec.Variables)
3982 args, err := ec.field_Bug_comments_args(ctx, rawArgs)
3983 if err != nil {
3984 ec.Error(ctx, err)
3985 return graphql.Null
3986 }
3987 fc.Args = args
3988 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3989 ctx = rctx // use context from middleware stack in children
3990 return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
3991 })
3992 if err != nil {
3993 ec.Error(ctx, err)
3994 return graphql.Null
3995 }
3996 if resTmp == nil {
3997 if !graphql.HasFieldError(ctx, fc) {
3998 ec.Errorf(ctx, "must not be null")
3999 }
4000 return graphql.Null
4001 }
4002 res := resTmp.(*models.CommentConnection)
4003 fc.Result = res
4004 return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
4005}
4006
4007func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4008 defer func() {
4009 if r := recover(); r != nil {
4010 ec.Error(ctx, ec.Recover(ctx, r))
4011 ret = graphql.Null
4012 }
4013 }()
4014 fc := &graphql.FieldContext{
4015 Object: "Bug",
4016 Field: field,
4017 Args: nil,
4018 IsMethod: true,
4019 }
4020
4021 ctx = graphql.WithFieldContext(ctx, fc)
4022 rawArgs := field.ArgumentMap(ec.Variables)
4023 args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
4024 if err != nil {
4025 ec.Error(ctx, err)
4026 return graphql.Null
4027 }
4028 fc.Args = args
4029 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4030 ctx = rctx // use context from middleware stack in children
4031 return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4032 })
4033 if err != nil {
4034 ec.Error(ctx, err)
4035 return graphql.Null
4036 }
4037 if resTmp == nil {
4038 if !graphql.HasFieldError(ctx, fc) {
4039 ec.Errorf(ctx, "must not be null")
4040 }
4041 return graphql.Null
4042 }
4043 res := resTmp.(*models.TimelineItemConnection)
4044 fc.Result = res
4045 return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
4046}
4047
4048func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4049 defer func() {
4050 if r := recover(); r != nil {
4051 ec.Error(ctx, ec.Recover(ctx, r))
4052 ret = graphql.Null
4053 }
4054 }()
4055 fc := &graphql.FieldContext{
4056 Object: "Bug",
4057 Field: field,
4058 Args: nil,
4059 IsMethod: true,
4060 }
4061
4062 ctx = graphql.WithFieldContext(ctx, fc)
4063 rawArgs := field.ArgumentMap(ec.Variables)
4064 args, err := ec.field_Bug_operations_args(ctx, rawArgs)
4065 if err != nil {
4066 ec.Error(ctx, err)
4067 return graphql.Null
4068 }
4069 fc.Args = args
4070 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4071 ctx = rctx // use context from middleware stack in children
4072 return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4073 })
4074 if err != nil {
4075 ec.Error(ctx, err)
4076 return graphql.Null
4077 }
4078 if resTmp == nil {
4079 if !graphql.HasFieldError(ctx, fc) {
4080 ec.Errorf(ctx, "must not be null")
4081 }
4082 return graphql.Null
4083 }
4084 res := resTmp.(*models.OperationConnection)
4085 fc.Result = res
4086 return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
4087}
4088
4089func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4090 defer func() {
4091 if r := recover(); r != nil {
4092 ec.Error(ctx, ec.Recover(ctx, r))
4093 ret = graphql.Null
4094 }
4095 }()
4096 fc := &graphql.FieldContext{
4097 Object: "BugConnection",
4098 Field: field,
4099 Args: nil,
4100 IsMethod: false,
4101 }
4102
4103 ctx = graphql.WithFieldContext(ctx, fc)
4104 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4105 ctx = rctx // use context from middleware stack in children
4106 return obj.Edges, nil
4107 })
4108 if err != nil {
4109 ec.Error(ctx, err)
4110 return graphql.Null
4111 }
4112 if resTmp == nil {
4113 if !graphql.HasFieldError(ctx, fc) {
4114 ec.Errorf(ctx, "must not be null")
4115 }
4116 return graphql.Null
4117 }
4118 res := resTmp.([]*models.BugEdge)
4119 fc.Result = res
4120 return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
4121}
4122
4123func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4124 defer func() {
4125 if r := recover(); r != nil {
4126 ec.Error(ctx, ec.Recover(ctx, r))
4127 ret = graphql.Null
4128 }
4129 }()
4130 fc := &graphql.FieldContext{
4131 Object: "BugConnection",
4132 Field: field,
4133 Args: nil,
4134 IsMethod: false,
4135 }
4136
4137 ctx = graphql.WithFieldContext(ctx, fc)
4138 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4139 ctx = rctx // use context from middleware stack in children
4140 return obj.Nodes, nil
4141 })
4142 if err != nil {
4143 ec.Error(ctx, err)
4144 return graphql.Null
4145 }
4146 if resTmp == nil {
4147 if !graphql.HasFieldError(ctx, fc) {
4148 ec.Errorf(ctx, "must not be null")
4149 }
4150 return graphql.Null
4151 }
4152 res := resTmp.([]models.BugWrapper)
4153 fc.Result = res
4154 return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
4155}
4156
4157func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4158 defer func() {
4159 if r := recover(); r != nil {
4160 ec.Error(ctx, ec.Recover(ctx, r))
4161 ret = graphql.Null
4162 }
4163 }()
4164 fc := &graphql.FieldContext{
4165 Object: "BugConnection",
4166 Field: field,
4167 Args: nil,
4168 IsMethod: false,
4169 }
4170
4171 ctx = graphql.WithFieldContext(ctx, fc)
4172 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4173 ctx = rctx // use context from middleware stack in children
4174 return obj.PageInfo, nil
4175 })
4176 if err != nil {
4177 ec.Error(ctx, err)
4178 return graphql.Null
4179 }
4180 if resTmp == nil {
4181 if !graphql.HasFieldError(ctx, fc) {
4182 ec.Errorf(ctx, "must not be null")
4183 }
4184 return graphql.Null
4185 }
4186 res := resTmp.(*models.PageInfo)
4187 fc.Result = res
4188 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4189}
4190
4191func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4192 defer func() {
4193 if r := recover(); r != nil {
4194 ec.Error(ctx, ec.Recover(ctx, r))
4195 ret = graphql.Null
4196 }
4197 }()
4198 fc := &graphql.FieldContext{
4199 Object: "BugConnection",
4200 Field: field,
4201 Args: nil,
4202 IsMethod: false,
4203 }
4204
4205 ctx = graphql.WithFieldContext(ctx, fc)
4206 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4207 ctx = rctx // use context from middleware stack in children
4208 return obj.TotalCount, nil
4209 })
4210 if err != nil {
4211 ec.Error(ctx, err)
4212 return graphql.Null
4213 }
4214 if resTmp == nil {
4215 if !graphql.HasFieldError(ctx, fc) {
4216 ec.Errorf(ctx, "must not be null")
4217 }
4218 return graphql.Null
4219 }
4220 res := resTmp.(int)
4221 fc.Result = res
4222 return ec.marshalNInt2int(ctx, field.Selections, res)
4223}
4224
4225func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4226 defer func() {
4227 if r := recover(); r != nil {
4228 ec.Error(ctx, ec.Recover(ctx, r))
4229 ret = graphql.Null
4230 }
4231 }()
4232 fc := &graphql.FieldContext{
4233 Object: "BugEdge",
4234 Field: field,
4235 Args: nil,
4236 IsMethod: false,
4237 }
4238
4239 ctx = graphql.WithFieldContext(ctx, fc)
4240 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4241 ctx = rctx // use context from middleware stack in children
4242 return obj.Cursor, nil
4243 })
4244 if err != nil {
4245 ec.Error(ctx, err)
4246 return graphql.Null
4247 }
4248 if resTmp == nil {
4249 if !graphql.HasFieldError(ctx, fc) {
4250 ec.Errorf(ctx, "must not be null")
4251 }
4252 return graphql.Null
4253 }
4254 res := resTmp.(string)
4255 fc.Result = res
4256 return ec.marshalNString2string(ctx, field.Selections, res)
4257}
4258
4259func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4260 defer func() {
4261 if r := recover(); r != nil {
4262 ec.Error(ctx, ec.Recover(ctx, r))
4263 ret = graphql.Null
4264 }
4265 }()
4266 fc := &graphql.FieldContext{
4267 Object: "BugEdge",
4268 Field: field,
4269 Args: nil,
4270 IsMethod: false,
4271 }
4272
4273 ctx = graphql.WithFieldContext(ctx, fc)
4274 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4275 ctx = rctx // use context from middleware stack in children
4276 return obj.Node, nil
4277 })
4278 if err != nil {
4279 ec.Error(ctx, err)
4280 return graphql.Null
4281 }
4282 if resTmp == nil {
4283 if !graphql.HasFieldError(ctx, fc) {
4284 ec.Errorf(ctx, "must not be null")
4285 }
4286 return graphql.Null
4287 }
4288 res := resTmp.(models.BugWrapper)
4289 fc.Result = res
4290 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4291}
4292
4293func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4294 defer func() {
4295 if r := recover(); r != nil {
4296 ec.Error(ctx, ec.Recover(ctx, r))
4297 ret = graphql.Null
4298 }
4299 }()
4300 fc := &graphql.FieldContext{
4301 Object: "ChangeLabelPayload",
4302 Field: field,
4303 Args: nil,
4304 IsMethod: false,
4305 }
4306
4307 ctx = graphql.WithFieldContext(ctx, fc)
4308 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4309 ctx = rctx // use context from middleware stack in children
4310 return obj.ClientMutationID, nil
4311 })
4312 if err != nil {
4313 ec.Error(ctx, err)
4314 return graphql.Null
4315 }
4316 if resTmp == nil {
4317 return graphql.Null
4318 }
4319 res := resTmp.(*string)
4320 fc.Result = res
4321 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4322}
4323
4324func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4325 defer func() {
4326 if r := recover(); r != nil {
4327 ec.Error(ctx, ec.Recover(ctx, r))
4328 ret = graphql.Null
4329 }
4330 }()
4331 fc := &graphql.FieldContext{
4332 Object: "ChangeLabelPayload",
4333 Field: field,
4334 Args: nil,
4335 IsMethod: false,
4336 }
4337
4338 ctx = graphql.WithFieldContext(ctx, fc)
4339 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4340 ctx = rctx // use context from middleware stack in children
4341 return obj.Bug, nil
4342 })
4343 if err != nil {
4344 ec.Error(ctx, err)
4345 return graphql.Null
4346 }
4347 if resTmp == nil {
4348 if !graphql.HasFieldError(ctx, fc) {
4349 ec.Errorf(ctx, "must not be null")
4350 }
4351 return graphql.Null
4352 }
4353 res := resTmp.(models.BugWrapper)
4354 fc.Result = res
4355 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4356}
4357
4358func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4359 defer func() {
4360 if r := recover(); r != nil {
4361 ec.Error(ctx, ec.Recover(ctx, r))
4362 ret = graphql.Null
4363 }
4364 }()
4365 fc := &graphql.FieldContext{
4366 Object: "ChangeLabelPayload",
4367 Field: field,
4368 Args: nil,
4369 IsMethod: false,
4370 }
4371
4372 ctx = graphql.WithFieldContext(ctx, fc)
4373 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4374 ctx = rctx // use context from middleware stack in children
4375 return obj.Operation, nil
4376 })
4377 if err != nil {
4378 ec.Error(ctx, err)
4379 return graphql.Null
4380 }
4381 if resTmp == nil {
4382 if !graphql.HasFieldError(ctx, fc) {
4383 ec.Errorf(ctx, "must not be null")
4384 }
4385 return graphql.Null
4386 }
4387 res := resTmp.(*bug.LabelChangeOperation)
4388 fc.Result = res
4389 return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
4390}
4391
4392func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4393 defer func() {
4394 if r := recover(); r != nil {
4395 ec.Error(ctx, ec.Recover(ctx, r))
4396 ret = graphql.Null
4397 }
4398 }()
4399 fc := &graphql.FieldContext{
4400 Object: "ChangeLabelPayload",
4401 Field: field,
4402 Args: nil,
4403 IsMethod: false,
4404 }
4405
4406 ctx = graphql.WithFieldContext(ctx, fc)
4407 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4408 ctx = rctx // use context from middleware stack in children
4409 return obj.Results, nil
4410 })
4411 if err != nil {
4412 ec.Error(ctx, err)
4413 return graphql.Null
4414 }
4415 if resTmp == nil {
4416 if !graphql.HasFieldError(ctx, fc) {
4417 ec.Errorf(ctx, "must not be null")
4418 }
4419 return graphql.Null
4420 }
4421 res := resTmp.([]*bug.LabelChangeResult)
4422 fc.Result = res
4423 return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
4424}
4425
4426func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4427 defer func() {
4428 if r := recover(); r != nil {
4429 ec.Error(ctx, ec.Recover(ctx, r))
4430 ret = graphql.Null
4431 }
4432 }()
4433 fc := &graphql.FieldContext{
4434 Object: "CloseBugPayload",
4435 Field: field,
4436 Args: nil,
4437 IsMethod: false,
4438 }
4439
4440 ctx = graphql.WithFieldContext(ctx, fc)
4441 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4442 ctx = rctx // use context from middleware stack in children
4443 return obj.ClientMutationID, nil
4444 })
4445 if err != nil {
4446 ec.Error(ctx, err)
4447 return graphql.Null
4448 }
4449 if resTmp == nil {
4450 return graphql.Null
4451 }
4452 res := resTmp.(*string)
4453 fc.Result = res
4454 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4455}
4456
4457func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4458 defer func() {
4459 if r := recover(); r != nil {
4460 ec.Error(ctx, ec.Recover(ctx, r))
4461 ret = graphql.Null
4462 }
4463 }()
4464 fc := &graphql.FieldContext{
4465 Object: "CloseBugPayload",
4466 Field: field,
4467 Args: nil,
4468 IsMethod: false,
4469 }
4470
4471 ctx = graphql.WithFieldContext(ctx, fc)
4472 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4473 ctx = rctx // use context from middleware stack in children
4474 return obj.Bug, nil
4475 })
4476 if err != nil {
4477 ec.Error(ctx, err)
4478 return graphql.Null
4479 }
4480 if resTmp == nil {
4481 if !graphql.HasFieldError(ctx, fc) {
4482 ec.Errorf(ctx, "must not be null")
4483 }
4484 return graphql.Null
4485 }
4486 res := resTmp.(models.BugWrapper)
4487 fc.Result = res
4488 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4489}
4490
4491func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4492 defer func() {
4493 if r := recover(); r != nil {
4494 ec.Error(ctx, ec.Recover(ctx, r))
4495 ret = graphql.Null
4496 }
4497 }()
4498 fc := &graphql.FieldContext{
4499 Object: "CloseBugPayload",
4500 Field: field,
4501 Args: nil,
4502 IsMethod: false,
4503 }
4504
4505 ctx = graphql.WithFieldContext(ctx, fc)
4506 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4507 ctx = rctx // use context from middleware stack in children
4508 return obj.Operation, nil
4509 })
4510 if err != nil {
4511 ec.Error(ctx, err)
4512 return graphql.Null
4513 }
4514 if resTmp == nil {
4515 if !graphql.HasFieldError(ctx, fc) {
4516 ec.Errorf(ctx, "must not be null")
4517 }
4518 return graphql.Null
4519 }
4520 res := resTmp.(*bug.SetStatusOperation)
4521 fc.Result = res
4522 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
4523}
4524
4525func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4526 defer func() {
4527 if r := recover(); r != nil {
4528 ec.Error(ctx, ec.Recover(ctx, r))
4529 ret = graphql.Null
4530 }
4531 }()
4532 fc := &graphql.FieldContext{
4533 Object: "Color",
4534 Field: field,
4535 Args: nil,
4536 IsMethod: true,
4537 }
4538
4539 ctx = graphql.WithFieldContext(ctx, fc)
4540 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4541 ctx = rctx // use context from middleware stack in children
4542 return ec.resolvers.Color().R(rctx, obj)
4543 })
4544 if err != nil {
4545 ec.Error(ctx, err)
4546 return graphql.Null
4547 }
4548 if resTmp == nil {
4549 if !graphql.HasFieldError(ctx, fc) {
4550 ec.Errorf(ctx, "must not be null")
4551 }
4552 return graphql.Null
4553 }
4554 res := resTmp.(int)
4555 fc.Result = res
4556 return ec.marshalNInt2int(ctx, field.Selections, res)
4557}
4558
4559func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4560 defer func() {
4561 if r := recover(); r != nil {
4562 ec.Error(ctx, ec.Recover(ctx, r))
4563 ret = graphql.Null
4564 }
4565 }()
4566 fc := &graphql.FieldContext{
4567 Object: "Color",
4568 Field: field,
4569 Args: nil,
4570 IsMethod: true,
4571 }
4572
4573 ctx = graphql.WithFieldContext(ctx, fc)
4574 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4575 ctx = rctx // use context from middleware stack in children
4576 return ec.resolvers.Color().G(rctx, obj)
4577 })
4578 if err != nil {
4579 ec.Error(ctx, err)
4580 return graphql.Null
4581 }
4582 if resTmp == nil {
4583 if !graphql.HasFieldError(ctx, fc) {
4584 ec.Errorf(ctx, "must not be null")
4585 }
4586 return graphql.Null
4587 }
4588 res := resTmp.(int)
4589 fc.Result = res
4590 return ec.marshalNInt2int(ctx, field.Selections, res)
4591}
4592
4593func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4594 defer func() {
4595 if r := recover(); r != nil {
4596 ec.Error(ctx, ec.Recover(ctx, r))
4597 ret = graphql.Null
4598 }
4599 }()
4600 fc := &graphql.FieldContext{
4601 Object: "Color",
4602 Field: field,
4603 Args: nil,
4604 IsMethod: true,
4605 }
4606
4607 ctx = graphql.WithFieldContext(ctx, fc)
4608 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4609 ctx = rctx // use context from middleware stack in children
4610 return ec.resolvers.Color().B(rctx, obj)
4611 })
4612 if err != nil {
4613 ec.Error(ctx, err)
4614 return graphql.Null
4615 }
4616 if resTmp == nil {
4617 if !graphql.HasFieldError(ctx, fc) {
4618 ec.Errorf(ctx, "must not be null")
4619 }
4620 return graphql.Null
4621 }
4622 res := resTmp.(int)
4623 fc.Result = res
4624 return ec.marshalNInt2int(ctx, field.Selections, res)
4625}
4626
4627func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4628 defer func() {
4629 if r := recover(); r != nil {
4630 ec.Error(ctx, ec.Recover(ctx, r))
4631 ret = graphql.Null
4632 }
4633 }()
4634 fc := &graphql.FieldContext{
4635 Object: "Comment",
4636 Field: field,
4637 Args: nil,
4638 IsMethod: true,
4639 }
4640
4641 ctx = graphql.WithFieldContext(ctx, fc)
4642 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4643 ctx = rctx // use context from middleware stack in children
4644 return ec.resolvers.Comment().Author(rctx, obj)
4645 })
4646 if err != nil {
4647 ec.Error(ctx, err)
4648 return graphql.Null
4649 }
4650 if resTmp == nil {
4651 if !graphql.HasFieldError(ctx, fc) {
4652 ec.Errorf(ctx, "must not be null")
4653 }
4654 return graphql.Null
4655 }
4656 res := resTmp.(models.IdentityWrapper)
4657 fc.Result = res
4658 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
4659}
4660
4661func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4662 defer func() {
4663 if r := recover(); r != nil {
4664 ec.Error(ctx, ec.Recover(ctx, r))
4665 ret = graphql.Null
4666 }
4667 }()
4668 fc := &graphql.FieldContext{
4669 Object: "Comment",
4670 Field: field,
4671 Args: nil,
4672 IsMethod: false,
4673 }
4674
4675 ctx = graphql.WithFieldContext(ctx, fc)
4676 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4677 ctx = rctx // use context from middleware stack in children
4678 return obj.Message, nil
4679 })
4680 if err != nil {
4681 ec.Error(ctx, err)
4682 return graphql.Null
4683 }
4684 if resTmp == nil {
4685 if !graphql.HasFieldError(ctx, fc) {
4686 ec.Errorf(ctx, "must not be null")
4687 }
4688 return graphql.Null
4689 }
4690 res := resTmp.(string)
4691 fc.Result = res
4692 return ec.marshalNString2string(ctx, field.Selections, res)
4693}
4694
4695func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4696 defer func() {
4697 if r := recover(); r != nil {
4698 ec.Error(ctx, ec.Recover(ctx, r))
4699 ret = graphql.Null
4700 }
4701 }()
4702 fc := &graphql.FieldContext{
4703 Object: "Comment",
4704 Field: field,
4705 Args: nil,
4706 IsMethod: false,
4707 }
4708
4709 ctx = graphql.WithFieldContext(ctx, fc)
4710 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4711 ctx = rctx // use context from middleware stack in children
4712 return obj.Files, nil
4713 })
4714 if err != nil {
4715 ec.Error(ctx, err)
4716 return graphql.Null
4717 }
4718 if resTmp == nil {
4719 if !graphql.HasFieldError(ctx, fc) {
4720 ec.Errorf(ctx, "must not be null")
4721 }
4722 return graphql.Null
4723 }
4724 res := resTmp.([]git.Hash)
4725 fc.Result = res
4726 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
4727}
4728
4729func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4730 defer func() {
4731 if r := recover(); r != nil {
4732 ec.Error(ctx, ec.Recover(ctx, r))
4733 ret = graphql.Null
4734 }
4735 }()
4736 fc := &graphql.FieldContext{
4737 Object: "CommentConnection",
4738 Field: field,
4739 Args: nil,
4740 IsMethod: false,
4741 }
4742
4743 ctx = graphql.WithFieldContext(ctx, fc)
4744 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4745 ctx = rctx // use context from middleware stack in children
4746 return obj.Edges, nil
4747 })
4748 if err != nil {
4749 ec.Error(ctx, err)
4750 return graphql.Null
4751 }
4752 if resTmp == nil {
4753 if !graphql.HasFieldError(ctx, fc) {
4754 ec.Errorf(ctx, "must not be null")
4755 }
4756 return graphql.Null
4757 }
4758 res := resTmp.([]*models.CommentEdge)
4759 fc.Result = res
4760 return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
4761}
4762
4763func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4764 defer func() {
4765 if r := recover(); r != nil {
4766 ec.Error(ctx, ec.Recover(ctx, r))
4767 ret = graphql.Null
4768 }
4769 }()
4770 fc := &graphql.FieldContext{
4771 Object: "CommentConnection",
4772 Field: field,
4773 Args: nil,
4774 IsMethod: false,
4775 }
4776
4777 ctx = graphql.WithFieldContext(ctx, fc)
4778 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4779 ctx = rctx // use context from middleware stack in children
4780 return obj.Nodes, nil
4781 })
4782 if err != nil {
4783 ec.Error(ctx, err)
4784 return graphql.Null
4785 }
4786 if resTmp == nil {
4787 if !graphql.HasFieldError(ctx, fc) {
4788 ec.Errorf(ctx, "must not be null")
4789 }
4790 return graphql.Null
4791 }
4792 res := resTmp.([]*bug.Comment)
4793 fc.Result = res
4794 return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
4795}
4796
4797func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4798 defer func() {
4799 if r := recover(); r != nil {
4800 ec.Error(ctx, ec.Recover(ctx, r))
4801 ret = graphql.Null
4802 }
4803 }()
4804 fc := &graphql.FieldContext{
4805 Object: "CommentConnection",
4806 Field: field,
4807 Args: nil,
4808 IsMethod: false,
4809 }
4810
4811 ctx = graphql.WithFieldContext(ctx, fc)
4812 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4813 ctx = rctx // use context from middleware stack in children
4814 return obj.PageInfo, nil
4815 })
4816 if err != nil {
4817 ec.Error(ctx, err)
4818 return graphql.Null
4819 }
4820 if resTmp == nil {
4821 if !graphql.HasFieldError(ctx, fc) {
4822 ec.Errorf(ctx, "must not be null")
4823 }
4824 return graphql.Null
4825 }
4826 res := resTmp.(*models.PageInfo)
4827 fc.Result = res
4828 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4829}
4830
4831func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4832 defer func() {
4833 if r := recover(); r != nil {
4834 ec.Error(ctx, ec.Recover(ctx, r))
4835 ret = graphql.Null
4836 }
4837 }()
4838 fc := &graphql.FieldContext{
4839 Object: "CommentConnection",
4840 Field: field,
4841 Args: nil,
4842 IsMethod: false,
4843 }
4844
4845 ctx = graphql.WithFieldContext(ctx, fc)
4846 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4847 ctx = rctx // use context from middleware stack in children
4848 return obj.TotalCount, nil
4849 })
4850 if err != nil {
4851 ec.Error(ctx, err)
4852 return graphql.Null
4853 }
4854 if resTmp == nil {
4855 if !graphql.HasFieldError(ctx, fc) {
4856 ec.Errorf(ctx, "must not be null")
4857 }
4858 return graphql.Null
4859 }
4860 res := resTmp.(int)
4861 fc.Result = res
4862 return ec.marshalNInt2int(ctx, field.Selections, res)
4863}
4864
4865func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
4866 defer func() {
4867 if r := recover(); r != nil {
4868 ec.Error(ctx, ec.Recover(ctx, r))
4869 ret = graphql.Null
4870 }
4871 }()
4872 fc := &graphql.FieldContext{
4873 Object: "CommentEdge",
4874 Field: field,
4875 Args: nil,
4876 IsMethod: false,
4877 }
4878
4879 ctx = graphql.WithFieldContext(ctx, fc)
4880 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4881 ctx = rctx // use context from middleware stack in children
4882 return obj.Cursor, nil
4883 })
4884 if err != nil {
4885 ec.Error(ctx, err)
4886 return graphql.Null
4887 }
4888 if resTmp == nil {
4889 if !graphql.HasFieldError(ctx, fc) {
4890 ec.Errorf(ctx, "must not be null")
4891 }
4892 return graphql.Null
4893 }
4894 res := resTmp.(string)
4895 fc.Result = res
4896 return ec.marshalNString2string(ctx, field.Selections, res)
4897}
4898
4899func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
4900 defer func() {
4901 if r := recover(); r != nil {
4902 ec.Error(ctx, ec.Recover(ctx, r))
4903 ret = graphql.Null
4904 }
4905 }()
4906 fc := &graphql.FieldContext{
4907 Object: "CommentEdge",
4908 Field: field,
4909 Args: nil,
4910 IsMethod: false,
4911 }
4912
4913 ctx = graphql.WithFieldContext(ctx, fc)
4914 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4915 ctx = rctx // use context from middleware stack in children
4916 return obj.Node, nil
4917 })
4918 if err != nil {
4919 ec.Error(ctx, err)
4920 return graphql.Null
4921 }
4922 if resTmp == nil {
4923 if !graphql.HasFieldError(ctx, fc) {
4924 ec.Errorf(ctx, "must not be null")
4925 }
4926 return graphql.Null
4927 }
4928 res := resTmp.(*bug.Comment)
4929 fc.Result = res
4930 return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
4931}
4932
4933func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
4934 defer func() {
4935 if r := recover(); r != nil {
4936 ec.Error(ctx, ec.Recover(ctx, r))
4937 ret = graphql.Null
4938 }
4939 }()
4940 fc := &graphql.FieldContext{
4941 Object: "CommentHistoryStep",
4942 Field: field,
4943 Args: nil,
4944 IsMethod: false,
4945 }
4946
4947 ctx = graphql.WithFieldContext(ctx, fc)
4948 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4949 ctx = rctx // use context from middleware stack in children
4950 return obj.Message, nil
4951 })
4952 if err != nil {
4953 ec.Error(ctx, err)
4954 return graphql.Null
4955 }
4956 if resTmp == nil {
4957 if !graphql.HasFieldError(ctx, fc) {
4958 ec.Errorf(ctx, "must not be null")
4959 }
4960 return graphql.Null
4961 }
4962 res := resTmp.(string)
4963 fc.Result = res
4964 return ec.marshalNString2string(ctx, field.Selections, res)
4965}
4966
4967func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
4968 defer func() {
4969 if r := recover(); r != nil {
4970 ec.Error(ctx, ec.Recover(ctx, r))
4971 ret = graphql.Null
4972 }
4973 }()
4974 fc := &graphql.FieldContext{
4975 Object: "CommentHistoryStep",
4976 Field: field,
4977 Args: nil,
4978 IsMethod: true,
4979 }
4980
4981 ctx = graphql.WithFieldContext(ctx, fc)
4982 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4983 ctx = rctx // use context from middleware stack in children
4984 return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
4985 })
4986 if err != nil {
4987 ec.Error(ctx, err)
4988 return graphql.Null
4989 }
4990 if resTmp == nil {
4991 if !graphql.HasFieldError(ctx, fc) {
4992 ec.Errorf(ctx, "must not be null")
4993 }
4994 return graphql.Null
4995 }
4996 res := resTmp.(*time.Time)
4997 fc.Result = res
4998 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
4999}
5000
5001func (ec *executionContext) _CommitAsNeededPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
5002 defer func() {
5003 if r := recover(); r != nil {
5004 ec.Error(ctx, ec.Recover(ctx, r))
5005 ret = graphql.Null
5006 }
5007 }()
5008 fc := &graphql.FieldContext{
5009 Object: "CommitAsNeededPayload",
5010 Field: field,
5011 Args: nil,
5012 IsMethod: false,
5013 }
5014
5015 ctx = graphql.WithFieldContext(ctx, fc)
5016 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5017 ctx = rctx // use context from middleware stack in children
5018 return obj.ClientMutationID, nil
5019 })
5020 if err != nil {
5021 ec.Error(ctx, err)
5022 return graphql.Null
5023 }
5024 if resTmp == nil {
5025 return graphql.Null
5026 }
5027 res := resTmp.(*string)
5028 fc.Result = res
5029 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5030}
5031
5032func (ec *executionContext) _CommitAsNeededPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
5033 defer func() {
5034 if r := recover(); r != nil {
5035 ec.Error(ctx, ec.Recover(ctx, r))
5036 ret = graphql.Null
5037 }
5038 }()
5039 fc := &graphql.FieldContext{
5040 Object: "CommitAsNeededPayload",
5041 Field: field,
5042 Args: nil,
5043 IsMethod: false,
5044 }
5045
5046 ctx = graphql.WithFieldContext(ctx, fc)
5047 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5048 ctx = rctx // use context from middleware stack in children
5049 return obj.Bug, nil
5050 })
5051 if err != nil {
5052 ec.Error(ctx, err)
5053 return graphql.Null
5054 }
5055 if resTmp == nil {
5056 if !graphql.HasFieldError(ctx, fc) {
5057 ec.Errorf(ctx, "must not be null")
5058 }
5059 return graphql.Null
5060 }
5061 res := resTmp.(models.BugWrapper)
5062 fc.Result = res
5063 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
5064}
5065
5066func (ec *executionContext) _CommitPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
5067 defer func() {
5068 if r := recover(); r != nil {
5069 ec.Error(ctx, ec.Recover(ctx, r))
5070 ret = graphql.Null
5071 }
5072 }()
5073 fc := &graphql.FieldContext{
5074 Object: "CommitPayload",
5075 Field: field,
5076 Args: nil,
5077 IsMethod: false,
5078 }
5079
5080 ctx = graphql.WithFieldContext(ctx, fc)
5081 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5082 ctx = rctx // use context from middleware stack in children
5083 return obj.ClientMutationID, nil
5084 })
5085 if err != nil {
5086 ec.Error(ctx, err)
5087 return graphql.Null
5088 }
5089 if resTmp == nil {
5090 return graphql.Null
5091 }
5092 res := resTmp.(*string)
5093 fc.Result = res
5094 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5095}
5096
5097func (ec *executionContext) _CommitPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
5098 defer func() {
5099 if r := recover(); r != nil {
5100 ec.Error(ctx, ec.Recover(ctx, r))
5101 ret = graphql.Null
5102 }
5103 }()
5104 fc := &graphql.FieldContext{
5105 Object: "CommitPayload",
5106 Field: field,
5107 Args: nil,
5108 IsMethod: false,
5109 }
5110
5111 ctx = graphql.WithFieldContext(ctx, fc)
5112 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5113 ctx = rctx // use context from middleware stack in children
5114 return obj.Bug, nil
5115 })
5116 if err != nil {
5117 ec.Error(ctx, err)
5118 return graphql.Null
5119 }
5120 if resTmp == nil {
5121 if !graphql.HasFieldError(ctx, fc) {
5122 ec.Errorf(ctx, "must not be null")
5123 }
5124 return graphql.Null
5125 }
5126 res := resTmp.(models.BugWrapper)
5127 fc.Result = res
5128 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
5129}
5130
5131func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5132 defer func() {
5133 if r := recover(); r != nil {
5134 ec.Error(ctx, ec.Recover(ctx, r))
5135 ret = graphql.Null
5136 }
5137 }()
5138 fc := &graphql.FieldContext{
5139 Object: "CreateOperation",
5140 Field: field,
5141 Args: nil,
5142 IsMethod: true,
5143 }
5144
5145 ctx = graphql.WithFieldContext(ctx, fc)
5146 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5147 ctx = rctx // use context from middleware stack in children
5148 return ec.resolvers.CreateOperation().ID(rctx, obj)
5149 })
5150 if err != nil {
5151 ec.Error(ctx, err)
5152 return graphql.Null
5153 }
5154 if resTmp == nil {
5155 if !graphql.HasFieldError(ctx, fc) {
5156 ec.Errorf(ctx, "must not be null")
5157 }
5158 return graphql.Null
5159 }
5160 res := resTmp.(string)
5161 fc.Result = res
5162 return ec.marshalNString2string(ctx, field.Selections, res)
5163}
5164
5165func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5166 defer func() {
5167 if r := recover(); r != nil {
5168 ec.Error(ctx, ec.Recover(ctx, r))
5169 ret = graphql.Null
5170 }
5171 }()
5172 fc := &graphql.FieldContext{
5173 Object: "CreateOperation",
5174 Field: field,
5175 Args: nil,
5176 IsMethod: true,
5177 }
5178
5179 ctx = graphql.WithFieldContext(ctx, fc)
5180 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5181 ctx = rctx // use context from middleware stack in children
5182 return ec.resolvers.CreateOperation().Author(rctx, obj)
5183 })
5184 if err != nil {
5185 ec.Error(ctx, err)
5186 return graphql.Null
5187 }
5188 if resTmp == nil {
5189 if !graphql.HasFieldError(ctx, fc) {
5190 ec.Errorf(ctx, "must not be null")
5191 }
5192 return graphql.Null
5193 }
5194 res := resTmp.(models.IdentityWrapper)
5195 fc.Result = res
5196 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5197}
5198
5199func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5200 defer func() {
5201 if r := recover(); r != nil {
5202 ec.Error(ctx, ec.Recover(ctx, r))
5203 ret = graphql.Null
5204 }
5205 }()
5206 fc := &graphql.FieldContext{
5207 Object: "CreateOperation",
5208 Field: field,
5209 Args: nil,
5210 IsMethod: true,
5211 }
5212
5213 ctx = graphql.WithFieldContext(ctx, fc)
5214 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5215 ctx = rctx // use context from middleware stack in children
5216 return ec.resolvers.CreateOperation().Date(rctx, obj)
5217 })
5218 if err != nil {
5219 ec.Error(ctx, err)
5220 return graphql.Null
5221 }
5222 if resTmp == nil {
5223 if !graphql.HasFieldError(ctx, fc) {
5224 ec.Errorf(ctx, "must not be null")
5225 }
5226 return graphql.Null
5227 }
5228 res := resTmp.(*time.Time)
5229 fc.Result = res
5230 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5231}
5232
5233func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5234 defer func() {
5235 if r := recover(); r != nil {
5236 ec.Error(ctx, ec.Recover(ctx, r))
5237 ret = graphql.Null
5238 }
5239 }()
5240 fc := &graphql.FieldContext{
5241 Object: "CreateOperation",
5242 Field: field,
5243 Args: nil,
5244 IsMethod: false,
5245 }
5246
5247 ctx = graphql.WithFieldContext(ctx, fc)
5248 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5249 ctx = rctx // use context from middleware stack in children
5250 return obj.Title, nil
5251 })
5252 if err != nil {
5253 ec.Error(ctx, err)
5254 return graphql.Null
5255 }
5256 if resTmp == nil {
5257 if !graphql.HasFieldError(ctx, fc) {
5258 ec.Errorf(ctx, "must not be null")
5259 }
5260 return graphql.Null
5261 }
5262 res := resTmp.(string)
5263 fc.Result = res
5264 return ec.marshalNString2string(ctx, field.Selections, res)
5265}
5266
5267func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5268 defer func() {
5269 if r := recover(); r != nil {
5270 ec.Error(ctx, ec.Recover(ctx, r))
5271 ret = graphql.Null
5272 }
5273 }()
5274 fc := &graphql.FieldContext{
5275 Object: "CreateOperation",
5276 Field: field,
5277 Args: nil,
5278 IsMethod: false,
5279 }
5280
5281 ctx = graphql.WithFieldContext(ctx, fc)
5282 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5283 ctx = rctx // use context from middleware stack in children
5284 return obj.Message, nil
5285 })
5286 if err != nil {
5287 ec.Error(ctx, err)
5288 return graphql.Null
5289 }
5290 if resTmp == nil {
5291 if !graphql.HasFieldError(ctx, fc) {
5292 ec.Errorf(ctx, "must not be null")
5293 }
5294 return graphql.Null
5295 }
5296 res := resTmp.(string)
5297 fc.Result = res
5298 return ec.marshalNString2string(ctx, field.Selections, res)
5299}
5300
5301func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5302 defer func() {
5303 if r := recover(); r != nil {
5304 ec.Error(ctx, ec.Recover(ctx, r))
5305 ret = graphql.Null
5306 }
5307 }()
5308 fc := &graphql.FieldContext{
5309 Object: "CreateOperation",
5310 Field: field,
5311 Args: nil,
5312 IsMethod: false,
5313 }
5314
5315 ctx = graphql.WithFieldContext(ctx, fc)
5316 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5317 ctx = rctx // use context from middleware stack in children
5318 return obj.Files, nil
5319 })
5320 if err != nil {
5321 ec.Error(ctx, err)
5322 return graphql.Null
5323 }
5324 if resTmp == nil {
5325 if !graphql.HasFieldError(ctx, fc) {
5326 ec.Errorf(ctx, "must not be null")
5327 }
5328 return graphql.Null
5329 }
5330 res := resTmp.([]git.Hash)
5331 fc.Result = res
5332 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
5333}
5334
5335func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5336 defer func() {
5337 if r := recover(); r != nil {
5338 ec.Error(ctx, ec.Recover(ctx, r))
5339 ret = graphql.Null
5340 }
5341 }()
5342 fc := &graphql.FieldContext{
5343 Object: "CreateTimelineItem",
5344 Field: field,
5345 Args: nil,
5346 IsMethod: true,
5347 }
5348
5349 ctx = graphql.WithFieldContext(ctx, fc)
5350 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5351 ctx = rctx // use context from middleware stack in children
5352 return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
5353 })
5354 if err != nil {
5355 ec.Error(ctx, err)
5356 return graphql.Null
5357 }
5358 if resTmp == nil {
5359 if !graphql.HasFieldError(ctx, fc) {
5360 ec.Errorf(ctx, "must not be null")
5361 }
5362 return graphql.Null
5363 }
5364 res := resTmp.(string)
5365 fc.Result = res
5366 return ec.marshalNString2string(ctx, field.Selections, res)
5367}
5368
5369func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5370 defer func() {
5371 if r := recover(); r != nil {
5372 ec.Error(ctx, ec.Recover(ctx, r))
5373 ret = graphql.Null
5374 }
5375 }()
5376 fc := &graphql.FieldContext{
5377 Object: "CreateTimelineItem",
5378 Field: field,
5379 Args: nil,
5380 IsMethod: true,
5381 }
5382
5383 ctx = graphql.WithFieldContext(ctx, fc)
5384 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5385 ctx = rctx // use context from middleware stack in children
5386 return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
5387 })
5388 if err != nil {
5389 ec.Error(ctx, err)
5390 return graphql.Null
5391 }
5392 if resTmp == nil {
5393 if !graphql.HasFieldError(ctx, fc) {
5394 ec.Errorf(ctx, "must not be null")
5395 }
5396 return graphql.Null
5397 }
5398 res := resTmp.(models.IdentityWrapper)
5399 fc.Result = res
5400 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5401}
5402
5403func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5404 defer func() {
5405 if r := recover(); r != nil {
5406 ec.Error(ctx, ec.Recover(ctx, r))
5407 ret = graphql.Null
5408 }
5409 }()
5410 fc := &graphql.FieldContext{
5411 Object: "CreateTimelineItem",
5412 Field: field,
5413 Args: nil,
5414 IsMethod: false,
5415 }
5416
5417 ctx = graphql.WithFieldContext(ctx, fc)
5418 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5419 ctx = rctx // use context from middleware stack in children
5420 return obj.Message, nil
5421 })
5422 if err != nil {
5423 ec.Error(ctx, err)
5424 return graphql.Null
5425 }
5426 if resTmp == nil {
5427 if !graphql.HasFieldError(ctx, fc) {
5428 ec.Errorf(ctx, "must not be null")
5429 }
5430 return graphql.Null
5431 }
5432 res := resTmp.(string)
5433 fc.Result = res
5434 return ec.marshalNString2string(ctx, field.Selections, res)
5435}
5436
5437func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5438 defer func() {
5439 if r := recover(); r != nil {
5440 ec.Error(ctx, ec.Recover(ctx, r))
5441 ret = graphql.Null
5442 }
5443 }()
5444 fc := &graphql.FieldContext{
5445 Object: "CreateTimelineItem",
5446 Field: field,
5447 Args: nil,
5448 IsMethod: true,
5449 }
5450
5451 ctx = graphql.WithFieldContext(ctx, fc)
5452 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5453 ctx = rctx // use context from middleware stack in children
5454 return obj.MessageIsEmpty(), nil
5455 })
5456 if err != nil {
5457 ec.Error(ctx, err)
5458 return graphql.Null
5459 }
5460 if resTmp == nil {
5461 if !graphql.HasFieldError(ctx, fc) {
5462 ec.Errorf(ctx, "must not be null")
5463 }
5464 return graphql.Null
5465 }
5466 res := resTmp.(bool)
5467 fc.Result = res
5468 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5469}
5470
5471func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5472 defer func() {
5473 if r := recover(); r != nil {
5474 ec.Error(ctx, ec.Recover(ctx, r))
5475 ret = graphql.Null
5476 }
5477 }()
5478 fc := &graphql.FieldContext{
5479 Object: "CreateTimelineItem",
5480 Field: field,
5481 Args: nil,
5482 IsMethod: false,
5483 }
5484
5485 ctx = graphql.WithFieldContext(ctx, fc)
5486 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5487 ctx = rctx // use context from middleware stack in children
5488 return obj.Files, nil
5489 })
5490 if err != nil {
5491 ec.Error(ctx, err)
5492 return graphql.Null
5493 }
5494 if resTmp == nil {
5495 if !graphql.HasFieldError(ctx, fc) {
5496 ec.Errorf(ctx, "must not be null")
5497 }
5498 return graphql.Null
5499 }
5500 res := resTmp.([]git.Hash)
5501 fc.Result = res
5502 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
5503}
5504
5505func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5506 defer func() {
5507 if r := recover(); r != nil {
5508 ec.Error(ctx, ec.Recover(ctx, r))
5509 ret = graphql.Null
5510 }
5511 }()
5512 fc := &graphql.FieldContext{
5513 Object: "CreateTimelineItem",
5514 Field: field,
5515 Args: nil,
5516 IsMethod: true,
5517 }
5518
5519 ctx = graphql.WithFieldContext(ctx, fc)
5520 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5521 ctx = rctx // use context from middleware stack in children
5522 return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
5523 })
5524 if err != nil {
5525 ec.Error(ctx, err)
5526 return graphql.Null
5527 }
5528 if resTmp == nil {
5529 if !graphql.HasFieldError(ctx, fc) {
5530 ec.Errorf(ctx, "must not be null")
5531 }
5532 return graphql.Null
5533 }
5534 res := resTmp.(*time.Time)
5535 fc.Result = res
5536 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5537}
5538
5539func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5540 defer func() {
5541 if r := recover(); r != nil {
5542 ec.Error(ctx, ec.Recover(ctx, r))
5543 ret = graphql.Null
5544 }
5545 }()
5546 fc := &graphql.FieldContext{
5547 Object: "CreateTimelineItem",
5548 Field: field,
5549 Args: nil,
5550 IsMethod: true,
5551 }
5552
5553 ctx = graphql.WithFieldContext(ctx, fc)
5554 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5555 ctx = rctx // use context from middleware stack in children
5556 return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
5557 })
5558 if err != nil {
5559 ec.Error(ctx, err)
5560 return graphql.Null
5561 }
5562 if resTmp == nil {
5563 if !graphql.HasFieldError(ctx, fc) {
5564 ec.Errorf(ctx, "must not be null")
5565 }
5566 return graphql.Null
5567 }
5568 res := resTmp.(*time.Time)
5569 fc.Result = res
5570 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5571}
5572
5573func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5574 defer func() {
5575 if r := recover(); r != nil {
5576 ec.Error(ctx, ec.Recover(ctx, r))
5577 ret = graphql.Null
5578 }
5579 }()
5580 fc := &graphql.FieldContext{
5581 Object: "CreateTimelineItem",
5582 Field: field,
5583 Args: nil,
5584 IsMethod: true,
5585 }
5586
5587 ctx = graphql.WithFieldContext(ctx, fc)
5588 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5589 ctx = rctx // use context from middleware stack in children
5590 return obj.Edited(), nil
5591 })
5592 if err != nil {
5593 ec.Error(ctx, err)
5594 return graphql.Null
5595 }
5596 if resTmp == nil {
5597 if !graphql.HasFieldError(ctx, fc) {
5598 ec.Errorf(ctx, "must not be null")
5599 }
5600 return graphql.Null
5601 }
5602 res := resTmp.(bool)
5603 fc.Result = res
5604 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5605}
5606
5607func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5608 defer func() {
5609 if r := recover(); r != nil {
5610 ec.Error(ctx, ec.Recover(ctx, r))
5611 ret = graphql.Null
5612 }
5613 }()
5614 fc := &graphql.FieldContext{
5615 Object: "CreateTimelineItem",
5616 Field: field,
5617 Args: nil,
5618 IsMethod: false,
5619 }
5620
5621 ctx = graphql.WithFieldContext(ctx, fc)
5622 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5623 ctx = rctx // use context from middleware stack in children
5624 return obj.History, nil
5625 })
5626 if err != nil {
5627 ec.Error(ctx, err)
5628 return graphql.Null
5629 }
5630 if resTmp == nil {
5631 if !graphql.HasFieldError(ctx, fc) {
5632 ec.Errorf(ctx, "must not be null")
5633 }
5634 return graphql.Null
5635 }
5636 res := resTmp.([]bug.CommentHistoryStep)
5637 fc.Result = res
5638 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
5639}
5640
5641func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5642 defer func() {
5643 if r := recover(); r != nil {
5644 ec.Error(ctx, ec.Recover(ctx, r))
5645 ret = graphql.Null
5646 }
5647 }()
5648 fc := &graphql.FieldContext{
5649 Object: "EditCommentOperation",
5650 Field: field,
5651 Args: nil,
5652 IsMethod: true,
5653 }
5654
5655 ctx = graphql.WithFieldContext(ctx, fc)
5656 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5657 ctx = rctx // use context from middleware stack in children
5658 return ec.resolvers.EditCommentOperation().ID(rctx, obj)
5659 })
5660 if err != nil {
5661 ec.Error(ctx, err)
5662 return graphql.Null
5663 }
5664 if resTmp == nil {
5665 if !graphql.HasFieldError(ctx, fc) {
5666 ec.Errorf(ctx, "must not be null")
5667 }
5668 return graphql.Null
5669 }
5670 res := resTmp.(string)
5671 fc.Result = res
5672 return ec.marshalNString2string(ctx, field.Selections, res)
5673}
5674
5675func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5676 defer func() {
5677 if r := recover(); r != nil {
5678 ec.Error(ctx, ec.Recover(ctx, r))
5679 ret = graphql.Null
5680 }
5681 }()
5682 fc := &graphql.FieldContext{
5683 Object: "EditCommentOperation",
5684 Field: field,
5685 Args: nil,
5686 IsMethod: true,
5687 }
5688
5689 ctx = graphql.WithFieldContext(ctx, fc)
5690 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5691 ctx = rctx // use context from middleware stack in children
5692 return ec.resolvers.EditCommentOperation().Author(rctx, obj)
5693 })
5694 if err != nil {
5695 ec.Error(ctx, err)
5696 return graphql.Null
5697 }
5698 if resTmp == nil {
5699 if !graphql.HasFieldError(ctx, fc) {
5700 ec.Errorf(ctx, "must not be null")
5701 }
5702 return graphql.Null
5703 }
5704 res := resTmp.(models.IdentityWrapper)
5705 fc.Result = res
5706 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5707}
5708
5709func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5710 defer func() {
5711 if r := recover(); r != nil {
5712 ec.Error(ctx, ec.Recover(ctx, r))
5713 ret = graphql.Null
5714 }
5715 }()
5716 fc := &graphql.FieldContext{
5717 Object: "EditCommentOperation",
5718 Field: field,
5719 Args: nil,
5720 IsMethod: true,
5721 }
5722
5723 ctx = graphql.WithFieldContext(ctx, fc)
5724 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5725 ctx = rctx // use context from middleware stack in children
5726 return ec.resolvers.EditCommentOperation().Date(rctx, obj)
5727 })
5728 if err != nil {
5729 ec.Error(ctx, err)
5730 return graphql.Null
5731 }
5732 if resTmp == nil {
5733 if !graphql.HasFieldError(ctx, fc) {
5734 ec.Errorf(ctx, "must not be null")
5735 }
5736 return graphql.Null
5737 }
5738 res := resTmp.(*time.Time)
5739 fc.Result = res
5740 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5741}
5742
5743func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5744 defer func() {
5745 if r := recover(); r != nil {
5746 ec.Error(ctx, ec.Recover(ctx, r))
5747 ret = graphql.Null
5748 }
5749 }()
5750 fc := &graphql.FieldContext{
5751 Object: "EditCommentOperation",
5752 Field: field,
5753 Args: nil,
5754 IsMethod: true,
5755 }
5756
5757 ctx = graphql.WithFieldContext(ctx, fc)
5758 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5759 ctx = rctx // use context from middleware stack in children
5760 return ec.resolvers.EditCommentOperation().Target(rctx, obj)
5761 })
5762 if err != nil {
5763 ec.Error(ctx, err)
5764 return graphql.Null
5765 }
5766 if resTmp == nil {
5767 if !graphql.HasFieldError(ctx, fc) {
5768 ec.Errorf(ctx, "must not be null")
5769 }
5770 return graphql.Null
5771 }
5772 res := resTmp.(string)
5773 fc.Result = res
5774 return ec.marshalNString2string(ctx, field.Selections, res)
5775}
5776
5777func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5778 defer func() {
5779 if r := recover(); r != nil {
5780 ec.Error(ctx, ec.Recover(ctx, r))
5781 ret = graphql.Null
5782 }
5783 }()
5784 fc := &graphql.FieldContext{
5785 Object: "EditCommentOperation",
5786 Field: field,
5787 Args: nil,
5788 IsMethod: false,
5789 }
5790
5791 ctx = graphql.WithFieldContext(ctx, fc)
5792 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5793 ctx = rctx // use context from middleware stack in children
5794 return obj.Message, nil
5795 })
5796 if err != nil {
5797 ec.Error(ctx, err)
5798 return graphql.Null
5799 }
5800 if resTmp == nil {
5801 if !graphql.HasFieldError(ctx, fc) {
5802 ec.Errorf(ctx, "must not be null")
5803 }
5804 return graphql.Null
5805 }
5806 res := resTmp.(string)
5807 fc.Result = res
5808 return ec.marshalNString2string(ctx, field.Selections, res)
5809}
5810
5811func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5812 defer func() {
5813 if r := recover(); r != nil {
5814 ec.Error(ctx, ec.Recover(ctx, r))
5815 ret = graphql.Null
5816 }
5817 }()
5818 fc := &graphql.FieldContext{
5819 Object: "EditCommentOperation",
5820 Field: field,
5821 Args: nil,
5822 IsMethod: false,
5823 }
5824
5825 ctx = graphql.WithFieldContext(ctx, fc)
5826 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5827 ctx = rctx // use context from middleware stack in children
5828 return obj.Files, nil
5829 })
5830 if err != nil {
5831 ec.Error(ctx, err)
5832 return graphql.Null
5833 }
5834 if resTmp == nil {
5835 if !graphql.HasFieldError(ctx, fc) {
5836 ec.Errorf(ctx, "must not be null")
5837 }
5838 return graphql.Null
5839 }
5840 res := resTmp.([]git.Hash)
5841 fc.Result = res
5842 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
5843}
5844
5845func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
5846 defer func() {
5847 if r := recover(); r != nil {
5848 ec.Error(ctx, ec.Recover(ctx, r))
5849 ret = graphql.Null
5850 }
5851 }()
5852 fc := &graphql.FieldContext{
5853 Object: "Identity",
5854 Field: field,
5855 Args: nil,
5856 IsMethod: true,
5857 }
5858
5859 ctx = graphql.WithFieldContext(ctx, fc)
5860 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5861 ctx = rctx // use context from middleware stack in children
5862 return ec.resolvers.Identity().ID(rctx, obj)
5863 })
5864 if err != nil {
5865 ec.Error(ctx, err)
5866 return graphql.Null
5867 }
5868 if resTmp == nil {
5869 if !graphql.HasFieldError(ctx, fc) {
5870 ec.Errorf(ctx, "must not be null")
5871 }
5872 return graphql.Null
5873 }
5874 res := resTmp.(string)
5875 fc.Result = res
5876 return ec.marshalNString2string(ctx, field.Selections, res)
5877}
5878
5879func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
5880 defer func() {
5881 if r := recover(); r != nil {
5882 ec.Error(ctx, ec.Recover(ctx, r))
5883 ret = graphql.Null
5884 }
5885 }()
5886 fc := &graphql.FieldContext{
5887 Object: "Identity",
5888 Field: field,
5889 Args: nil,
5890 IsMethod: true,
5891 }
5892
5893 ctx = graphql.WithFieldContext(ctx, fc)
5894 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5895 ctx = rctx // use context from middleware stack in children
5896 return ec.resolvers.Identity().HumanID(rctx, obj)
5897 })
5898 if err != nil {
5899 ec.Error(ctx, err)
5900 return graphql.Null
5901 }
5902 if resTmp == nil {
5903 if !graphql.HasFieldError(ctx, fc) {
5904 ec.Errorf(ctx, "must not be null")
5905 }
5906 return graphql.Null
5907 }
5908 res := resTmp.(string)
5909 fc.Result = res
5910 return ec.marshalNString2string(ctx, field.Selections, res)
5911}
5912
5913func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
5914 defer func() {
5915 if r := recover(); r != nil {
5916 ec.Error(ctx, ec.Recover(ctx, r))
5917 ret = graphql.Null
5918 }
5919 }()
5920 fc := &graphql.FieldContext{
5921 Object: "Identity",
5922 Field: field,
5923 Args: nil,
5924 IsMethod: true,
5925 }
5926
5927 ctx = graphql.WithFieldContext(ctx, fc)
5928 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5929 ctx = rctx // use context from middleware stack in children
5930 return obj.Name(), nil
5931 })
5932 if err != nil {
5933 ec.Error(ctx, err)
5934 return graphql.Null
5935 }
5936 if resTmp == nil {
5937 return graphql.Null
5938 }
5939 res := resTmp.(string)
5940 fc.Result = res
5941 return ec.marshalOString2string(ctx, field.Selections, res)
5942}
5943
5944func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
5945 defer func() {
5946 if r := recover(); r != nil {
5947 ec.Error(ctx, ec.Recover(ctx, r))
5948 ret = graphql.Null
5949 }
5950 }()
5951 fc := &graphql.FieldContext{
5952 Object: "Identity",
5953 Field: field,
5954 Args: nil,
5955 IsMethod: true,
5956 }
5957
5958 ctx = graphql.WithFieldContext(ctx, fc)
5959 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5960 ctx = rctx // use context from middleware stack in children
5961 return obj.Email()
5962 })
5963 if err != nil {
5964 ec.Error(ctx, err)
5965 return graphql.Null
5966 }
5967 if resTmp == nil {
5968 return graphql.Null
5969 }
5970 res := resTmp.(string)
5971 fc.Result = res
5972 return ec.marshalOString2string(ctx, field.Selections, res)
5973}
5974
5975func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
5976 defer func() {
5977 if r := recover(); r != nil {
5978 ec.Error(ctx, ec.Recover(ctx, r))
5979 ret = graphql.Null
5980 }
5981 }()
5982 fc := &graphql.FieldContext{
5983 Object: "Identity",
5984 Field: field,
5985 Args: nil,
5986 IsMethod: true,
5987 }
5988
5989 ctx = graphql.WithFieldContext(ctx, fc)
5990 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5991 ctx = rctx // use context from middleware stack in children
5992 return obj.DisplayName(), nil
5993 })
5994 if err != nil {
5995 ec.Error(ctx, err)
5996 return graphql.Null
5997 }
5998 if resTmp == nil {
5999 if !graphql.HasFieldError(ctx, fc) {
6000 ec.Errorf(ctx, "must not be null")
6001 }
6002 return graphql.Null
6003 }
6004 res := resTmp.(string)
6005 fc.Result = res
6006 return ec.marshalNString2string(ctx, field.Selections, res)
6007}
6008
6009func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6010 defer func() {
6011 if r := recover(); r != nil {
6012 ec.Error(ctx, ec.Recover(ctx, r))
6013 ret = graphql.Null
6014 }
6015 }()
6016 fc := &graphql.FieldContext{
6017 Object: "Identity",
6018 Field: field,
6019 Args: nil,
6020 IsMethod: true,
6021 }
6022
6023 ctx = graphql.WithFieldContext(ctx, fc)
6024 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6025 ctx = rctx // use context from middleware stack in children
6026 return obj.AvatarUrl()
6027 })
6028 if err != nil {
6029 ec.Error(ctx, err)
6030 return graphql.Null
6031 }
6032 if resTmp == nil {
6033 return graphql.Null
6034 }
6035 res := resTmp.(string)
6036 fc.Result = res
6037 return ec.marshalOString2string(ctx, field.Selections, res)
6038}
6039
6040func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6041 defer func() {
6042 if r := recover(); r != nil {
6043 ec.Error(ctx, ec.Recover(ctx, r))
6044 ret = graphql.Null
6045 }
6046 }()
6047 fc := &graphql.FieldContext{
6048 Object: "Identity",
6049 Field: field,
6050 Args: nil,
6051 IsMethod: true,
6052 }
6053
6054 ctx = graphql.WithFieldContext(ctx, fc)
6055 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6056 ctx = rctx // use context from middleware stack in children
6057 return obj.IsProtected()
6058 })
6059 if err != nil {
6060 ec.Error(ctx, err)
6061 return graphql.Null
6062 }
6063 if resTmp == nil {
6064 if !graphql.HasFieldError(ctx, fc) {
6065 ec.Errorf(ctx, "must not be null")
6066 }
6067 return graphql.Null
6068 }
6069 res := resTmp.(bool)
6070 fc.Result = res
6071 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6072}
6073
6074func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6075 defer func() {
6076 if r := recover(); r != nil {
6077 ec.Error(ctx, ec.Recover(ctx, r))
6078 ret = graphql.Null
6079 }
6080 }()
6081 fc := &graphql.FieldContext{
6082 Object: "IdentityConnection",
6083 Field: field,
6084 Args: nil,
6085 IsMethod: false,
6086 }
6087
6088 ctx = graphql.WithFieldContext(ctx, fc)
6089 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6090 ctx = rctx // use context from middleware stack in children
6091 return obj.Edges, nil
6092 })
6093 if err != nil {
6094 ec.Error(ctx, err)
6095 return graphql.Null
6096 }
6097 if resTmp == nil {
6098 if !graphql.HasFieldError(ctx, fc) {
6099 ec.Errorf(ctx, "must not be null")
6100 }
6101 return graphql.Null
6102 }
6103 res := resTmp.([]*models.IdentityEdge)
6104 fc.Result = res
6105 return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
6106}
6107
6108func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6109 defer func() {
6110 if r := recover(); r != nil {
6111 ec.Error(ctx, ec.Recover(ctx, r))
6112 ret = graphql.Null
6113 }
6114 }()
6115 fc := &graphql.FieldContext{
6116 Object: "IdentityConnection",
6117 Field: field,
6118 Args: nil,
6119 IsMethod: false,
6120 }
6121
6122 ctx = graphql.WithFieldContext(ctx, fc)
6123 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6124 ctx = rctx // use context from middleware stack in children
6125 return obj.Nodes, nil
6126 })
6127 if err != nil {
6128 ec.Error(ctx, err)
6129 return graphql.Null
6130 }
6131 if resTmp == nil {
6132 if !graphql.HasFieldError(ctx, fc) {
6133 ec.Errorf(ctx, "must not be null")
6134 }
6135 return graphql.Null
6136 }
6137 res := resTmp.([]models.IdentityWrapper)
6138 fc.Result = res
6139 return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx, field.Selections, res)
6140}
6141
6142func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6143 defer func() {
6144 if r := recover(); r != nil {
6145 ec.Error(ctx, ec.Recover(ctx, r))
6146 ret = graphql.Null
6147 }
6148 }()
6149 fc := &graphql.FieldContext{
6150 Object: "IdentityConnection",
6151 Field: field,
6152 Args: nil,
6153 IsMethod: false,
6154 }
6155
6156 ctx = graphql.WithFieldContext(ctx, fc)
6157 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6158 ctx = rctx // use context from middleware stack in children
6159 return obj.PageInfo, nil
6160 })
6161 if err != nil {
6162 ec.Error(ctx, err)
6163 return graphql.Null
6164 }
6165 if resTmp == nil {
6166 if !graphql.HasFieldError(ctx, fc) {
6167 ec.Errorf(ctx, "must not be null")
6168 }
6169 return graphql.Null
6170 }
6171 res := resTmp.(*models.PageInfo)
6172 fc.Result = res
6173 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
6174}
6175
6176func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6177 defer func() {
6178 if r := recover(); r != nil {
6179 ec.Error(ctx, ec.Recover(ctx, r))
6180 ret = graphql.Null
6181 }
6182 }()
6183 fc := &graphql.FieldContext{
6184 Object: "IdentityConnection",
6185 Field: field,
6186 Args: nil,
6187 IsMethod: false,
6188 }
6189
6190 ctx = graphql.WithFieldContext(ctx, fc)
6191 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6192 ctx = rctx // use context from middleware stack in children
6193 return obj.TotalCount, nil
6194 })
6195 if err != nil {
6196 ec.Error(ctx, err)
6197 return graphql.Null
6198 }
6199 if resTmp == nil {
6200 if !graphql.HasFieldError(ctx, fc) {
6201 ec.Errorf(ctx, "must not be null")
6202 }
6203 return graphql.Null
6204 }
6205 res := resTmp.(int)
6206 fc.Result = res
6207 return ec.marshalNInt2int(ctx, field.Selections, res)
6208}
6209
6210func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6211 defer func() {
6212 if r := recover(); r != nil {
6213 ec.Error(ctx, ec.Recover(ctx, r))
6214 ret = graphql.Null
6215 }
6216 }()
6217 fc := &graphql.FieldContext{
6218 Object: "IdentityEdge",
6219 Field: field,
6220 Args: nil,
6221 IsMethod: false,
6222 }
6223
6224 ctx = graphql.WithFieldContext(ctx, fc)
6225 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6226 ctx = rctx // use context from middleware stack in children
6227 return obj.Cursor, nil
6228 })
6229 if err != nil {
6230 ec.Error(ctx, err)
6231 return graphql.Null
6232 }
6233 if resTmp == nil {
6234 if !graphql.HasFieldError(ctx, fc) {
6235 ec.Errorf(ctx, "must not be null")
6236 }
6237 return graphql.Null
6238 }
6239 res := resTmp.(string)
6240 fc.Result = res
6241 return ec.marshalNString2string(ctx, field.Selections, res)
6242}
6243
6244func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6245 defer func() {
6246 if r := recover(); r != nil {
6247 ec.Error(ctx, ec.Recover(ctx, r))
6248 ret = graphql.Null
6249 }
6250 }()
6251 fc := &graphql.FieldContext{
6252 Object: "IdentityEdge",
6253 Field: field,
6254 Args: nil,
6255 IsMethod: false,
6256 }
6257
6258 ctx = graphql.WithFieldContext(ctx, fc)
6259 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6260 ctx = rctx // use context from middleware stack in children
6261 return obj.Node, nil
6262 })
6263 if err != nil {
6264 ec.Error(ctx, err)
6265 return graphql.Null
6266 }
6267 if resTmp == nil {
6268 if !graphql.HasFieldError(ctx, fc) {
6269 ec.Errorf(ctx, "must not be null")
6270 }
6271 return graphql.Null
6272 }
6273 res := resTmp.(models.IdentityWrapper)
6274 fc.Result = res
6275 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6276}
6277
6278func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6279 defer func() {
6280 if r := recover(); r != nil {
6281 ec.Error(ctx, ec.Recover(ctx, r))
6282 ret = graphql.Null
6283 }
6284 }()
6285 fc := &graphql.FieldContext{
6286 Object: "Label",
6287 Field: field,
6288 Args: nil,
6289 IsMethod: true,
6290 }
6291
6292 ctx = graphql.WithFieldContext(ctx, fc)
6293 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6294 ctx = rctx // use context from middleware stack in children
6295 return ec.resolvers.Label().Name(rctx, obj)
6296 })
6297 if err != nil {
6298 ec.Error(ctx, err)
6299 return graphql.Null
6300 }
6301 if resTmp == nil {
6302 if !graphql.HasFieldError(ctx, fc) {
6303 ec.Errorf(ctx, "must not be null")
6304 }
6305 return graphql.Null
6306 }
6307 res := resTmp.(string)
6308 fc.Result = res
6309 return ec.marshalNString2string(ctx, field.Selections, res)
6310}
6311
6312func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6313 defer func() {
6314 if r := recover(); r != nil {
6315 ec.Error(ctx, ec.Recover(ctx, r))
6316 ret = graphql.Null
6317 }
6318 }()
6319 fc := &graphql.FieldContext{
6320 Object: "Label",
6321 Field: field,
6322 Args: nil,
6323 IsMethod: true,
6324 }
6325
6326 ctx = graphql.WithFieldContext(ctx, fc)
6327 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6328 ctx = rctx // use context from middleware stack in children
6329 return ec.resolvers.Label().Color(rctx, obj)
6330 })
6331 if err != nil {
6332 ec.Error(ctx, err)
6333 return graphql.Null
6334 }
6335 if resTmp == nil {
6336 if !graphql.HasFieldError(ctx, fc) {
6337 ec.Errorf(ctx, "must not be null")
6338 }
6339 return graphql.Null
6340 }
6341 res := resTmp.(*color.RGBA)
6342 fc.Result = res
6343 return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
6344}
6345
6346func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6347 defer func() {
6348 if r := recover(); r != nil {
6349 ec.Error(ctx, ec.Recover(ctx, r))
6350 ret = graphql.Null
6351 }
6352 }()
6353 fc := &graphql.FieldContext{
6354 Object: "LabelChangeOperation",
6355 Field: field,
6356 Args: nil,
6357 IsMethod: true,
6358 }
6359
6360 ctx = graphql.WithFieldContext(ctx, fc)
6361 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6362 ctx = rctx // use context from middleware stack in children
6363 return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
6364 })
6365 if err != nil {
6366 ec.Error(ctx, err)
6367 return graphql.Null
6368 }
6369 if resTmp == nil {
6370 if !graphql.HasFieldError(ctx, fc) {
6371 ec.Errorf(ctx, "must not be null")
6372 }
6373 return graphql.Null
6374 }
6375 res := resTmp.(string)
6376 fc.Result = res
6377 return ec.marshalNString2string(ctx, field.Selections, res)
6378}
6379
6380func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6381 defer func() {
6382 if r := recover(); r != nil {
6383 ec.Error(ctx, ec.Recover(ctx, r))
6384 ret = graphql.Null
6385 }
6386 }()
6387 fc := &graphql.FieldContext{
6388 Object: "LabelChangeOperation",
6389 Field: field,
6390 Args: nil,
6391 IsMethod: true,
6392 }
6393
6394 ctx = graphql.WithFieldContext(ctx, fc)
6395 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6396 ctx = rctx // use context from middleware stack in children
6397 return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
6398 })
6399 if err != nil {
6400 ec.Error(ctx, err)
6401 return graphql.Null
6402 }
6403 if resTmp == nil {
6404 if !graphql.HasFieldError(ctx, fc) {
6405 ec.Errorf(ctx, "must not be null")
6406 }
6407 return graphql.Null
6408 }
6409 res := resTmp.(models.IdentityWrapper)
6410 fc.Result = res
6411 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6412}
6413
6414func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6415 defer func() {
6416 if r := recover(); r != nil {
6417 ec.Error(ctx, ec.Recover(ctx, r))
6418 ret = graphql.Null
6419 }
6420 }()
6421 fc := &graphql.FieldContext{
6422 Object: "LabelChangeOperation",
6423 Field: field,
6424 Args: nil,
6425 IsMethod: true,
6426 }
6427
6428 ctx = graphql.WithFieldContext(ctx, fc)
6429 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6430 ctx = rctx // use context from middleware stack in children
6431 return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
6432 })
6433 if err != nil {
6434 ec.Error(ctx, err)
6435 return graphql.Null
6436 }
6437 if resTmp == nil {
6438 if !graphql.HasFieldError(ctx, fc) {
6439 ec.Errorf(ctx, "must not be null")
6440 }
6441 return graphql.Null
6442 }
6443 res := resTmp.(*time.Time)
6444 fc.Result = res
6445 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6446}
6447
6448func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6449 defer func() {
6450 if r := recover(); r != nil {
6451 ec.Error(ctx, ec.Recover(ctx, r))
6452 ret = graphql.Null
6453 }
6454 }()
6455 fc := &graphql.FieldContext{
6456 Object: "LabelChangeOperation",
6457 Field: field,
6458 Args: nil,
6459 IsMethod: false,
6460 }
6461
6462 ctx = graphql.WithFieldContext(ctx, fc)
6463 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6464 ctx = rctx // use context from middleware stack in children
6465 return obj.Added, nil
6466 })
6467 if err != nil {
6468 ec.Error(ctx, err)
6469 return graphql.Null
6470 }
6471 if resTmp == nil {
6472 if !graphql.HasFieldError(ctx, fc) {
6473 ec.Errorf(ctx, "must not be null")
6474 }
6475 return graphql.Null
6476 }
6477 res := resTmp.([]bug.Label)
6478 fc.Result = res
6479 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6480}
6481
6482func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6483 defer func() {
6484 if r := recover(); r != nil {
6485 ec.Error(ctx, ec.Recover(ctx, r))
6486 ret = graphql.Null
6487 }
6488 }()
6489 fc := &graphql.FieldContext{
6490 Object: "LabelChangeOperation",
6491 Field: field,
6492 Args: nil,
6493 IsMethod: false,
6494 }
6495
6496 ctx = graphql.WithFieldContext(ctx, fc)
6497 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6498 ctx = rctx // use context from middleware stack in children
6499 return obj.Removed, nil
6500 })
6501 if err != nil {
6502 ec.Error(ctx, err)
6503 return graphql.Null
6504 }
6505 if resTmp == nil {
6506 if !graphql.HasFieldError(ctx, fc) {
6507 ec.Errorf(ctx, "must not be null")
6508 }
6509 return graphql.Null
6510 }
6511 res := resTmp.([]bug.Label)
6512 fc.Result = res
6513 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6514}
6515
6516func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6517 defer func() {
6518 if r := recover(); r != nil {
6519 ec.Error(ctx, ec.Recover(ctx, r))
6520 ret = graphql.Null
6521 }
6522 }()
6523 fc := &graphql.FieldContext{
6524 Object: "LabelChangeResult",
6525 Field: field,
6526 Args: nil,
6527 IsMethod: false,
6528 }
6529
6530 ctx = graphql.WithFieldContext(ctx, fc)
6531 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6532 ctx = rctx // use context from middleware stack in children
6533 return obj.Label, nil
6534 })
6535 if err != nil {
6536 ec.Error(ctx, err)
6537 return graphql.Null
6538 }
6539 if resTmp == nil {
6540 if !graphql.HasFieldError(ctx, fc) {
6541 ec.Errorf(ctx, "must not be null")
6542 }
6543 return graphql.Null
6544 }
6545 res := resTmp.(bug.Label)
6546 fc.Result = res
6547 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6548}
6549
6550func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6551 defer func() {
6552 if r := recover(); r != nil {
6553 ec.Error(ctx, ec.Recover(ctx, r))
6554 ret = graphql.Null
6555 }
6556 }()
6557 fc := &graphql.FieldContext{
6558 Object: "LabelChangeResult",
6559 Field: field,
6560 Args: nil,
6561 IsMethod: true,
6562 }
6563
6564 ctx = graphql.WithFieldContext(ctx, fc)
6565 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6566 ctx = rctx // use context from middleware stack in children
6567 return ec.resolvers.LabelChangeResult().Status(rctx, obj)
6568 })
6569 if err != nil {
6570 ec.Error(ctx, err)
6571 return graphql.Null
6572 }
6573 if resTmp == nil {
6574 if !graphql.HasFieldError(ctx, fc) {
6575 ec.Errorf(ctx, "must not be null")
6576 }
6577 return graphql.Null
6578 }
6579 res := resTmp.(models.LabelChangeStatus)
6580 fc.Result = res
6581 return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
6582}
6583
6584func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6585 defer func() {
6586 if r := recover(); r != nil {
6587 ec.Error(ctx, ec.Recover(ctx, r))
6588 ret = graphql.Null
6589 }
6590 }()
6591 fc := &graphql.FieldContext{
6592 Object: "LabelChangeTimelineItem",
6593 Field: field,
6594 Args: nil,
6595 IsMethod: true,
6596 }
6597
6598 ctx = graphql.WithFieldContext(ctx, fc)
6599 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6600 ctx = rctx // use context from middleware stack in children
6601 return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
6602 })
6603 if err != nil {
6604 ec.Error(ctx, err)
6605 return graphql.Null
6606 }
6607 if resTmp == nil {
6608 if !graphql.HasFieldError(ctx, fc) {
6609 ec.Errorf(ctx, "must not be null")
6610 }
6611 return graphql.Null
6612 }
6613 res := resTmp.(string)
6614 fc.Result = res
6615 return ec.marshalNString2string(ctx, field.Selections, res)
6616}
6617
6618func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6619 defer func() {
6620 if r := recover(); r != nil {
6621 ec.Error(ctx, ec.Recover(ctx, r))
6622 ret = graphql.Null
6623 }
6624 }()
6625 fc := &graphql.FieldContext{
6626 Object: "LabelChangeTimelineItem",
6627 Field: field,
6628 Args: nil,
6629 IsMethod: true,
6630 }
6631
6632 ctx = graphql.WithFieldContext(ctx, fc)
6633 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6634 ctx = rctx // use context from middleware stack in children
6635 return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
6636 })
6637 if err != nil {
6638 ec.Error(ctx, err)
6639 return graphql.Null
6640 }
6641 if resTmp == nil {
6642 if !graphql.HasFieldError(ctx, fc) {
6643 ec.Errorf(ctx, "must not be null")
6644 }
6645 return graphql.Null
6646 }
6647 res := resTmp.(models.IdentityWrapper)
6648 fc.Result = res
6649 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6650}
6651
6652func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6653 defer func() {
6654 if r := recover(); r != nil {
6655 ec.Error(ctx, ec.Recover(ctx, r))
6656 ret = graphql.Null
6657 }
6658 }()
6659 fc := &graphql.FieldContext{
6660 Object: "LabelChangeTimelineItem",
6661 Field: field,
6662 Args: nil,
6663 IsMethod: true,
6664 }
6665
6666 ctx = graphql.WithFieldContext(ctx, fc)
6667 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6668 ctx = rctx // use context from middleware stack in children
6669 return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
6670 })
6671 if err != nil {
6672 ec.Error(ctx, err)
6673 return graphql.Null
6674 }
6675 if resTmp == nil {
6676 if !graphql.HasFieldError(ctx, fc) {
6677 ec.Errorf(ctx, "must not be null")
6678 }
6679 return graphql.Null
6680 }
6681 res := resTmp.(*time.Time)
6682 fc.Result = res
6683 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6684}
6685
6686func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6687 defer func() {
6688 if r := recover(); r != nil {
6689 ec.Error(ctx, ec.Recover(ctx, r))
6690 ret = graphql.Null
6691 }
6692 }()
6693 fc := &graphql.FieldContext{
6694 Object: "LabelChangeTimelineItem",
6695 Field: field,
6696 Args: nil,
6697 IsMethod: false,
6698 }
6699
6700 ctx = graphql.WithFieldContext(ctx, fc)
6701 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6702 ctx = rctx // use context from middleware stack in children
6703 return obj.Added, nil
6704 })
6705 if err != nil {
6706 ec.Error(ctx, err)
6707 return graphql.Null
6708 }
6709 if resTmp == nil {
6710 if !graphql.HasFieldError(ctx, fc) {
6711 ec.Errorf(ctx, "must not be null")
6712 }
6713 return graphql.Null
6714 }
6715 res := resTmp.([]bug.Label)
6716 fc.Result = res
6717 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6718}
6719
6720func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6721 defer func() {
6722 if r := recover(); r != nil {
6723 ec.Error(ctx, ec.Recover(ctx, r))
6724 ret = graphql.Null
6725 }
6726 }()
6727 fc := &graphql.FieldContext{
6728 Object: "LabelChangeTimelineItem",
6729 Field: field,
6730 Args: nil,
6731 IsMethod: false,
6732 }
6733
6734 ctx = graphql.WithFieldContext(ctx, fc)
6735 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6736 ctx = rctx // use context from middleware stack in children
6737 return obj.Removed, nil
6738 })
6739 if err != nil {
6740 ec.Error(ctx, err)
6741 return graphql.Null
6742 }
6743 if resTmp == nil {
6744 if !graphql.HasFieldError(ctx, fc) {
6745 ec.Errorf(ctx, "must not be null")
6746 }
6747 return graphql.Null
6748 }
6749 res := resTmp.([]bug.Label)
6750 fc.Result = res
6751 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6752}
6753
6754func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
6755 defer func() {
6756 if r := recover(); r != nil {
6757 ec.Error(ctx, ec.Recover(ctx, r))
6758 ret = graphql.Null
6759 }
6760 }()
6761 fc := &graphql.FieldContext{
6762 Object: "LabelConnection",
6763 Field: field,
6764 Args: nil,
6765 IsMethod: false,
6766 }
6767
6768 ctx = graphql.WithFieldContext(ctx, fc)
6769 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6770 ctx = rctx // use context from middleware stack in children
6771 return obj.Edges, nil
6772 })
6773 if err != nil {
6774 ec.Error(ctx, err)
6775 return graphql.Null
6776 }
6777 if resTmp == nil {
6778 if !graphql.HasFieldError(ctx, fc) {
6779 ec.Errorf(ctx, "must not be null")
6780 }
6781 return graphql.Null
6782 }
6783 res := resTmp.([]*models.LabelEdge)
6784 fc.Result = res
6785 return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
6786}
6787
6788func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
6789 defer func() {
6790 if r := recover(); r != nil {
6791 ec.Error(ctx, ec.Recover(ctx, r))
6792 ret = graphql.Null
6793 }
6794 }()
6795 fc := &graphql.FieldContext{
6796 Object: "LabelConnection",
6797 Field: field,
6798 Args: nil,
6799 IsMethod: false,
6800 }
6801
6802 ctx = graphql.WithFieldContext(ctx, fc)
6803 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6804 ctx = rctx // use context from middleware stack in children
6805 return obj.Nodes, nil
6806 })
6807 if err != nil {
6808 ec.Error(ctx, err)
6809 return graphql.Null
6810 }
6811 if resTmp == nil {
6812 if !graphql.HasFieldError(ctx, fc) {
6813 ec.Errorf(ctx, "must not be null")
6814 }
6815 return graphql.Null
6816 }
6817 res := resTmp.([]bug.Label)
6818 fc.Result = res
6819 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6820}
6821
6822func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
6823 defer func() {
6824 if r := recover(); r != nil {
6825 ec.Error(ctx, ec.Recover(ctx, r))
6826 ret = graphql.Null
6827 }
6828 }()
6829 fc := &graphql.FieldContext{
6830 Object: "LabelConnection",
6831 Field: field,
6832 Args: nil,
6833 IsMethod: false,
6834 }
6835
6836 ctx = graphql.WithFieldContext(ctx, fc)
6837 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6838 ctx = rctx // use context from middleware stack in children
6839 return obj.PageInfo, nil
6840 })
6841 if err != nil {
6842 ec.Error(ctx, err)
6843 return graphql.Null
6844 }
6845 if resTmp == nil {
6846 if !graphql.HasFieldError(ctx, fc) {
6847 ec.Errorf(ctx, "must not be null")
6848 }
6849 return graphql.Null
6850 }
6851 res := resTmp.(*models.PageInfo)
6852 fc.Result = res
6853 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
6854}
6855
6856func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
6857 defer func() {
6858 if r := recover(); r != nil {
6859 ec.Error(ctx, ec.Recover(ctx, r))
6860 ret = graphql.Null
6861 }
6862 }()
6863 fc := &graphql.FieldContext{
6864 Object: "LabelConnection",
6865 Field: field,
6866 Args: nil,
6867 IsMethod: false,
6868 }
6869
6870 ctx = graphql.WithFieldContext(ctx, fc)
6871 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6872 ctx = rctx // use context from middleware stack in children
6873 return obj.TotalCount, nil
6874 })
6875 if err != nil {
6876 ec.Error(ctx, err)
6877 return graphql.Null
6878 }
6879 if resTmp == nil {
6880 if !graphql.HasFieldError(ctx, fc) {
6881 ec.Errorf(ctx, "must not be null")
6882 }
6883 return graphql.Null
6884 }
6885 res := resTmp.(int)
6886 fc.Result = res
6887 return ec.marshalNInt2int(ctx, field.Selections, res)
6888}
6889
6890func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
6891 defer func() {
6892 if r := recover(); r != nil {
6893 ec.Error(ctx, ec.Recover(ctx, r))
6894 ret = graphql.Null
6895 }
6896 }()
6897 fc := &graphql.FieldContext{
6898 Object: "LabelEdge",
6899 Field: field,
6900 Args: nil,
6901 IsMethod: false,
6902 }
6903
6904 ctx = graphql.WithFieldContext(ctx, fc)
6905 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6906 ctx = rctx // use context from middleware stack in children
6907 return obj.Cursor, nil
6908 })
6909 if err != nil {
6910 ec.Error(ctx, err)
6911 return graphql.Null
6912 }
6913 if resTmp == nil {
6914 if !graphql.HasFieldError(ctx, fc) {
6915 ec.Errorf(ctx, "must not be null")
6916 }
6917 return graphql.Null
6918 }
6919 res := resTmp.(string)
6920 fc.Result = res
6921 return ec.marshalNString2string(ctx, field.Selections, res)
6922}
6923
6924func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
6925 defer func() {
6926 if r := recover(); r != nil {
6927 ec.Error(ctx, ec.Recover(ctx, r))
6928 ret = graphql.Null
6929 }
6930 }()
6931 fc := &graphql.FieldContext{
6932 Object: "LabelEdge",
6933 Field: field,
6934 Args: nil,
6935 IsMethod: false,
6936 }
6937
6938 ctx = graphql.WithFieldContext(ctx, fc)
6939 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6940 ctx = rctx // use context from middleware stack in children
6941 return obj.Node, nil
6942 })
6943 if err != nil {
6944 ec.Error(ctx, err)
6945 return graphql.Null
6946 }
6947 if resTmp == nil {
6948 if !graphql.HasFieldError(ctx, fc) {
6949 ec.Errorf(ctx, "must not be null")
6950 }
6951 return graphql.Null
6952 }
6953 res := resTmp.(bug.Label)
6954 fc.Result = res
6955 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6956}
6957
6958func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
6959 defer func() {
6960 if r := recover(); r != nil {
6961 ec.Error(ctx, ec.Recover(ctx, r))
6962 ret = graphql.Null
6963 }
6964 }()
6965 fc := &graphql.FieldContext{
6966 Object: "Mutation",
6967 Field: field,
6968 Args: nil,
6969 IsMethod: true,
6970 }
6971
6972 ctx = graphql.WithFieldContext(ctx, fc)
6973 rawArgs := field.ArgumentMap(ec.Variables)
6974 args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
6975 if err != nil {
6976 ec.Error(ctx, err)
6977 return graphql.Null
6978 }
6979 fc.Args = args
6980 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6981 ctx = rctx // use context from middleware stack in children
6982 return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
6983 })
6984 if err != nil {
6985 ec.Error(ctx, err)
6986 return graphql.Null
6987 }
6988 if resTmp == nil {
6989 if !graphql.HasFieldError(ctx, fc) {
6990 ec.Errorf(ctx, "must not be null")
6991 }
6992 return graphql.Null
6993 }
6994 res := resTmp.(*models.NewBugPayload)
6995 fc.Result = res
6996 return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
6997}
6998
6999func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7000 defer func() {
7001 if r := recover(); r != nil {
7002 ec.Error(ctx, ec.Recover(ctx, r))
7003 ret = graphql.Null
7004 }
7005 }()
7006 fc := &graphql.FieldContext{
7007 Object: "Mutation",
7008 Field: field,
7009 Args: nil,
7010 IsMethod: true,
7011 }
7012
7013 ctx = graphql.WithFieldContext(ctx, fc)
7014 rawArgs := field.ArgumentMap(ec.Variables)
7015 args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
7016 if err != nil {
7017 ec.Error(ctx, err)
7018 return graphql.Null
7019 }
7020 fc.Args = args
7021 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7022 ctx = rctx // use context from middleware stack in children
7023 return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
7024 })
7025 if err != nil {
7026 ec.Error(ctx, err)
7027 return graphql.Null
7028 }
7029 if resTmp == nil {
7030 if !graphql.HasFieldError(ctx, fc) {
7031 ec.Errorf(ctx, "must not be null")
7032 }
7033 return graphql.Null
7034 }
7035 res := resTmp.(*models.AddCommentPayload)
7036 fc.Result = res
7037 return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
7038}
7039
7040func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7041 defer func() {
7042 if r := recover(); r != nil {
7043 ec.Error(ctx, ec.Recover(ctx, r))
7044 ret = graphql.Null
7045 }
7046 }()
7047 fc := &graphql.FieldContext{
7048 Object: "Mutation",
7049 Field: field,
7050 Args: nil,
7051 IsMethod: true,
7052 }
7053
7054 ctx = graphql.WithFieldContext(ctx, fc)
7055 rawArgs := field.ArgumentMap(ec.Variables)
7056 args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
7057 if err != nil {
7058 ec.Error(ctx, err)
7059 return graphql.Null
7060 }
7061 fc.Args = args
7062 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7063 ctx = rctx // use context from middleware stack in children
7064 return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
7065 })
7066 if err != nil {
7067 ec.Error(ctx, err)
7068 return graphql.Null
7069 }
7070 if resTmp == nil {
7071 if !graphql.HasFieldError(ctx, fc) {
7072 ec.Errorf(ctx, "must not be null")
7073 }
7074 return graphql.Null
7075 }
7076 res := resTmp.(*models.ChangeLabelPayload)
7077 fc.Result = res
7078 return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
7079}
7080
7081func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7082 defer func() {
7083 if r := recover(); r != nil {
7084 ec.Error(ctx, ec.Recover(ctx, r))
7085 ret = graphql.Null
7086 }
7087 }()
7088 fc := &graphql.FieldContext{
7089 Object: "Mutation",
7090 Field: field,
7091 Args: nil,
7092 IsMethod: true,
7093 }
7094
7095 ctx = graphql.WithFieldContext(ctx, fc)
7096 rawArgs := field.ArgumentMap(ec.Variables)
7097 args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
7098 if err != nil {
7099 ec.Error(ctx, err)
7100 return graphql.Null
7101 }
7102 fc.Args = args
7103 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7104 ctx = rctx // use context from middleware stack in children
7105 return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
7106 })
7107 if err != nil {
7108 ec.Error(ctx, err)
7109 return graphql.Null
7110 }
7111 if resTmp == nil {
7112 if !graphql.HasFieldError(ctx, fc) {
7113 ec.Errorf(ctx, "must not be null")
7114 }
7115 return graphql.Null
7116 }
7117 res := resTmp.(*models.OpenBugPayload)
7118 fc.Result = res
7119 return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
7120}
7121
7122func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7123 defer func() {
7124 if r := recover(); r != nil {
7125 ec.Error(ctx, ec.Recover(ctx, r))
7126 ret = graphql.Null
7127 }
7128 }()
7129 fc := &graphql.FieldContext{
7130 Object: "Mutation",
7131 Field: field,
7132 Args: nil,
7133 IsMethod: true,
7134 }
7135
7136 ctx = graphql.WithFieldContext(ctx, fc)
7137 rawArgs := field.ArgumentMap(ec.Variables)
7138 args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
7139 if err != nil {
7140 ec.Error(ctx, err)
7141 return graphql.Null
7142 }
7143 fc.Args = args
7144 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7145 ctx = rctx // use context from middleware stack in children
7146 return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
7147 })
7148 if err != nil {
7149 ec.Error(ctx, err)
7150 return graphql.Null
7151 }
7152 if resTmp == nil {
7153 if !graphql.HasFieldError(ctx, fc) {
7154 ec.Errorf(ctx, "must not be null")
7155 }
7156 return graphql.Null
7157 }
7158 res := resTmp.(*models.CloseBugPayload)
7159 fc.Result = res
7160 return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
7161}
7162
7163func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7164 defer func() {
7165 if r := recover(); r != nil {
7166 ec.Error(ctx, ec.Recover(ctx, r))
7167 ret = graphql.Null
7168 }
7169 }()
7170 fc := &graphql.FieldContext{
7171 Object: "Mutation",
7172 Field: field,
7173 Args: nil,
7174 IsMethod: true,
7175 }
7176
7177 ctx = graphql.WithFieldContext(ctx, fc)
7178 rawArgs := field.ArgumentMap(ec.Variables)
7179 args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
7180 if err != nil {
7181 ec.Error(ctx, err)
7182 return graphql.Null
7183 }
7184 fc.Args = args
7185 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7186 ctx = rctx // use context from middleware stack in children
7187 return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
7188 })
7189 if err != nil {
7190 ec.Error(ctx, err)
7191 return graphql.Null
7192 }
7193 if resTmp == nil {
7194 if !graphql.HasFieldError(ctx, fc) {
7195 ec.Errorf(ctx, "must not be null")
7196 }
7197 return graphql.Null
7198 }
7199 res := resTmp.(*models.SetTitlePayload)
7200 fc.Result = res
7201 return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
7202}
7203
7204func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7205 defer func() {
7206 if r := recover(); r != nil {
7207 ec.Error(ctx, ec.Recover(ctx, r))
7208 ret = graphql.Null
7209 }
7210 }()
7211 fc := &graphql.FieldContext{
7212 Object: "Mutation",
7213 Field: field,
7214 Args: nil,
7215 IsMethod: true,
7216 }
7217
7218 ctx = graphql.WithFieldContext(ctx, fc)
7219 rawArgs := field.ArgumentMap(ec.Variables)
7220 args, err := ec.field_Mutation_commit_args(ctx, rawArgs)
7221 if err != nil {
7222 ec.Error(ctx, err)
7223 return graphql.Null
7224 }
7225 fc.Args = args
7226 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7227 ctx = rctx // use context from middleware stack in children
7228 return ec.resolvers.Mutation().Commit(rctx, args["input"].(models.CommitInput))
7229 })
7230 if err != nil {
7231 ec.Error(ctx, err)
7232 return graphql.Null
7233 }
7234 if resTmp == nil {
7235 if !graphql.HasFieldError(ctx, fc) {
7236 ec.Errorf(ctx, "must not be null")
7237 }
7238 return graphql.Null
7239 }
7240 res := resTmp.(*models.CommitPayload)
7241 fc.Result = res
7242 return ec.marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx, field.Selections, res)
7243}
7244
7245func (ec *executionContext) _Mutation_commitAsNeeded(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7246 defer func() {
7247 if r := recover(); r != nil {
7248 ec.Error(ctx, ec.Recover(ctx, r))
7249 ret = graphql.Null
7250 }
7251 }()
7252 fc := &graphql.FieldContext{
7253 Object: "Mutation",
7254 Field: field,
7255 Args: nil,
7256 IsMethod: true,
7257 }
7258
7259 ctx = graphql.WithFieldContext(ctx, fc)
7260 rawArgs := field.ArgumentMap(ec.Variables)
7261 args, err := ec.field_Mutation_commitAsNeeded_args(ctx, rawArgs)
7262 if err != nil {
7263 ec.Error(ctx, err)
7264 return graphql.Null
7265 }
7266 fc.Args = args
7267 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7268 ctx = rctx // use context from middleware stack in children
7269 return ec.resolvers.Mutation().CommitAsNeeded(rctx, args["input"].(models.CommitAsNeededInput))
7270 })
7271 if err != nil {
7272 ec.Error(ctx, err)
7273 return graphql.Null
7274 }
7275 if resTmp == nil {
7276 if !graphql.HasFieldError(ctx, fc) {
7277 ec.Errorf(ctx, "must not be null")
7278 }
7279 return graphql.Null
7280 }
7281 res := resTmp.(*models.CommitAsNeededPayload)
7282 fc.Result = res
7283 return ec.marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx, field.Selections, res)
7284}
7285
7286func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7287 defer func() {
7288 if r := recover(); r != nil {
7289 ec.Error(ctx, ec.Recover(ctx, r))
7290 ret = graphql.Null
7291 }
7292 }()
7293 fc := &graphql.FieldContext{
7294 Object: "NewBugPayload",
7295 Field: field,
7296 Args: nil,
7297 IsMethod: false,
7298 }
7299
7300 ctx = graphql.WithFieldContext(ctx, fc)
7301 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7302 ctx = rctx // use context from middleware stack in children
7303 return obj.ClientMutationID, nil
7304 })
7305 if err != nil {
7306 ec.Error(ctx, err)
7307 return graphql.Null
7308 }
7309 if resTmp == nil {
7310 return graphql.Null
7311 }
7312 res := resTmp.(*string)
7313 fc.Result = res
7314 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7315}
7316
7317func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7318 defer func() {
7319 if r := recover(); r != nil {
7320 ec.Error(ctx, ec.Recover(ctx, r))
7321 ret = graphql.Null
7322 }
7323 }()
7324 fc := &graphql.FieldContext{
7325 Object: "NewBugPayload",
7326 Field: field,
7327 Args: nil,
7328 IsMethod: false,
7329 }
7330
7331 ctx = graphql.WithFieldContext(ctx, fc)
7332 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7333 ctx = rctx // use context from middleware stack in children
7334 return obj.Bug, nil
7335 })
7336 if err != nil {
7337 ec.Error(ctx, err)
7338 return graphql.Null
7339 }
7340 if resTmp == nil {
7341 if !graphql.HasFieldError(ctx, fc) {
7342 ec.Errorf(ctx, "must not be null")
7343 }
7344 return graphql.Null
7345 }
7346 res := resTmp.(models.BugWrapper)
7347 fc.Result = res
7348 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
7349}
7350
7351func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7352 defer func() {
7353 if r := recover(); r != nil {
7354 ec.Error(ctx, ec.Recover(ctx, r))
7355 ret = graphql.Null
7356 }
7357 }()
7358 fc := &graphql.FieldContext{
7359 Object: "NewBugPayload",
7360 Field: field,
7361 Args: nil,
7362 IsMethod: false,
7363 }
7364
7365 ctx = graphql.WithFieldContext(ctx, fc)
7366 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7367 ctx = rctx // use context from middleware stack in children
7368 return obj.Operation, nil
7369 })
7370 if err != nil {
7371 ec.Error(ctx, err)
7372 return graphql.Null
7373 }
7374 if resTmp == nil {
7375 if !graphql.HasFieldError(ctx, fc) {
7376 ec.Errorf(ctx, "must not be null")
7377 }
7378 return graphql.Null
7379 }
7380 res := resTmp.(*bug.CreateOperation)
7381 fc.Result = res
7382 return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
7383}
7384
7385func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7386 defer func() {
7387 if r := recover(); r != nil {
7388 ec.Error(ctx, ec.Recover(ctx, r))
7389 ret = graphql.Null
7390 }
7391 }()
7392 fc := &graphql.FieldContext{
7393 Object: "OpenBugPayload",
7394 Field: field,
7395 Args: nil,
7396 IsMethod: false,
7397 }
7398
7399 ctx = graphql.WithFieldContext(ctx, fc)
7400 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7401 ctx = rctx // use context from middleware stack in children
7402 return obj.ClientMutationID, nil
7403 })
7404 if err != nil {
7405 ec.Error(ctx, err)
7406 return graphql.Null
7407 }
7408 if resTmp == nil {
7409 return graphql.Null
7410 }
7411 res := resTmp.(*string)
7412 fc.Result = res
7413 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7414}
7415
7416func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7417 defer func() {
7418 if r := recover(); r != nil {
7419 ec.Error(ctx, ec.Recover(ctx, r))
7420 ret = graphql.Null
7421 }
7422 }()
7423 fc := &graphql.FieldContext{
7424 Object: "OpenBugPayload",
7425 Field: field,
7426 Args: nil,
7427 IsMethod: false,
7428 }
7429
7430 ctx = graphql.WithFieldContext(ctx, fc)
7431 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7432 ctx = rctx // use context from middleware stack in children
7433 return obj.Bug, nil
7434 })
7435 if err != nil {
7436 ec.Error(ctx, err)
7437 return graphql.Null
7438 }
7439 if resTmp == nil {
7440 if !graphql.HasFieldError(ctx, fc) {
7441 ec.Errorf(ctx, "must not be null")
7442 }
7443 return graphql.Null
7444 }
7445 res := resTmp.(models.BugWrapper)
7446 fc.Result = res
7447 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
7448}
7449
7450func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7451 defer func() {
7452 if r := recover(); r != nil {
7453 ec.Error(ctx, ec.Recover(ctx, r))
7454 ret = graphql.Null
7455 }
7456 }()
7457 fc := &graphql.FieldContext{
7458 Object: "OpenBugPayload",
7459 Field: field,
7460 Args: nil,
7461 IsMethod: false,
7462 }
7463
7464 ctx = graphql.WithFieldContext(ctx, fc)
7465 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7466 ctx = rctx // use context from middleware stack in children
7467 return obj.Operation, nil
7468 })
7469 if err != nil {
7470 ec.Error(ctx, err)
7471 return graphql.Null
7472 }
7473 if resTmp == nil {
7474 if !graphql.HasFieldError(ctx, fc) {
7475 ec.Errorf(ctx, "must not be null")
7476 }
7477 return graphql.Null
7478 }
7479 res := resTmp.(*bug.SetStatusOperation)
7480 fc.Result = res
7481 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
7482}
7483
7484func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7485 defer func() {
7486 if r := recover(); r != nil {
7487 ec.Error(ctx, ec.Recover(ctx, r))
7488 ret = graphql.Null
7489 }
7490 }()
7491 fc := &graphql.FieldContext{
7492 Object: "OperationConnection",
7493 Field: field,
7494 Args: nil,
7495 IsMethod: false,
7496 }
7497
7498 ctx = graphql.WithFieldContext(ctx, fc)
7499 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7500 ctx = rctx // use context from middleware stack in children
7501 return obj.Edges, nil
7502 })
7503 if err != nil {
7504 ec.Error(ctx, err)
7505 return graphql.Null
7506 }
7507 if resTmp == nil {
7508 if !graphql.HasFieldError(ctx, fc) {
7509 ec.Errorf(ctx, "must not be null")
7510 }
7511 return graphql.Null
7512 }
7513 res := resTmp.([]*models.OperationEdge)
7514 fc.Result = res
7515 return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
7516}
7517
7518func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7519 defer func() {
7520 if r := recover(); r != nil {
7521 ec.Error(ctx, ec.Recover(ctx, r))
7522 ret = graphql.Null
7523 }
7524 }()
7525 fc := &graphql.FieldContext{
7526 Object: "OperationConnection",
7527 Field: field,
7528 Args: nil,
7529 IsMethod: false,
7530 }
7531
7532 ctx = graphql.WithFieldContext(ctx, fc)
7533 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7534 ctx = rctx // use context from middleware stack in children
7535 return obj.Nodes, nil
7536 })
7537 if err != nil {
7538 ec.Error(ctx, err)
7539 return graphql.Null
7540 }
7541 if resTmp == nil {
7542 if !graphql.HasFieldError(ctx, fc) {
7543 ec.Errorf(ctx, "must not be null")
7544 }
7545 return graphql.Null
7546 }
7547 res := resTmp.([]bug.Operation)
7548 fc.Result = res
7549 return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
7550}
7551
7552func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7553 defer func() {
7554 if r := recover(); r != nil {
7555 ec.Error(ctx, ec.Recover(ctx, r))
7556 ret = graphql.Null
7557 }
7558 }()
7559 fc := &graphql.FieldContext{
7560 Object: "OperationConnection",
7561 Field: field,
7562 Args: nil,
7563 IsMethod: false,
7564 }
7565
7566 ctx = graphql.WithFieldContext(ctx, fc)
7567 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7568 ctx = rctx // use context from middleware stack in children
7569 return obj.PageInfo, nil
7570 })
7571 if err != nil {
7572 ec.Error(ctx, err)
7573 return graphql.Null
7574 }
7575 if resTmp == nil {
7576 if !graphql.HasFieldError(ctx, fc) {
7577 ec.Errorf(ctx, "must not be null")
7578 }
7579 return graphql.Null
7580 }
7581 res := resTmp.(*models.PageInfo)
7582 fc.Result = res
7583 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
7584}
7585
7586func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7587 defer func() {
7588 if r := recover(); r != nil {
7589 ec.Error(ctx, ec.Recover(ctx, r))
7590 ret = graphql.Null
7591 }
7592 }()
7593 fc := &graphql.FieldContext{
7594 Object: "OperationConnection",
7595 Field: field,
7596 Args: nil,
7597 IsMethod: false,
7598 }
7599
7600 ctx = graphql.WithFieldContext(ctx, fc)
7601 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7602 ctx = rctx // use context from middleware stack in children
7603 return obj.TotalCount, nil
7604 })
7605 if err != nil {
7606 ec.Error(ctx, err)
7607 return graphql.Null
7608 }
7609 if resTmp == nil {
7610 if !graphql.HasFieldError(ctx, fc) {
7611 ec.Errorf(ctx, "must not be null")
7612 }
7613 return graphql.Null
7614 }
7615 res := resTmp.(int)
7616 fc.Result = res
7617 return ec.marshalNInt2int(ctx, field.Selections, res)
7618}
7619
7620func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
7621 defer func() {
7622 if r := recover(); r != nil {
7623 ec.Error(ctx, ec.Recover(ctx, r))
7624 ret = graphql.Null
7625 }
7626 }()
7627 fc := &graphql.FieldContext{
7628 Object: "OperationEdge",
7629 Field: field,
7630 Args: nil,
7631 IsMethod: false,
7632 }
7633
7634 ctx = graphql.WithFieldContext(ctx, fc)
7635 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7636 ctx = rctx // use context from middleware stack in children
7637 return obj.Cursor, nil
7638 })
7639 if err != nil {
7640 ec.Error(ctx, err)
7641 return graphql.Null
7642 }
7643 if resTmp == nil {
7644 if !graphql.HasFieldError(ctx, fc) {
7645 ec.Errorf(ctx, "must not be null")
7646 }
7647 return graphql.Null
7648 }
7649 res := resTmp.(string)
7650 fc.Result = res
7651 return ec.marshalNString2string(ctx, field.Selections, res)
7652}
7653
7654func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
7655 defer func() {
7656 if r := recover(); r != nil {
7657 ec.Error(ctx, ec.Recover(ctx, r))
7658 ret = graphql.Null
7659 }
7660 }()
7661 fc := &graphql.FieldContext{
7662 Object: "OperationEdge",
7663 Field: field,
7664 Args: nil,
7665 IsMethod: false,
7666 }
7667
7668 ctx = graphql.WithFieldContext(ctx, fc)
7669 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7670 ctx = rctx // use context from middleware stack in children
7671 return obj.Node, nil
7672 })
7673 if err != nil {
7674 ec.Error(ctx, err)
7675 return graphql.Null
7676 }
7677 if resTmp == nil {
7678 if !graphql.HasFieldError(ctx, fc) {
7679 ec.Errorf(ctx, "must not be null")
7680 }
7681 return graphql.Null
7682 }
7683 res := resTmp.(bug.Operation)
7684 fc.Result = res
7685 return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
7686}
7687
7688func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7689 defer func() {
7690 if r := recover(); r != nil {
7691 ec.Error(ctx, ec.Recover(ctx, r))
7692 ret = graphql.Null
7693 }
7694 }()
7695 fc := &graphql.FieldContext{
7696 Object: "PageInfo",
7697 Field: field,
7698 Args: nil,
7699 IsMethod: false,
7700 }
7701
7702 ctx = graphql.WithFieldContext(ctx, fc)
7703 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7704 ctx = rctx // use context from middleware stack in children
7705 return obj.HasNextPage, nil
7706 })
7707 if err != nil {
7708 ec.Error(ctx, err)
7709 return graphql.Null
7710 }
7711 if resTmp == nil {
7712 if !graphql.HasFieldError(ctx, fc) {
7713 ec.Errorf(ctx, "must not be null")
7714 }
7715 return graphql.Null
7716 }
7717 res := resTmp.(bool)
7718 fc.Result = res
7719 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7720}
7721
7722func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7723 defer func() {
7724 if r := recover(); r != nil {
7725 ec.Error(ctx, ec.Recover(ctx, r))
7726 ret = graphql.Null
7727 }
7728 }()
7729 fc := &graphql.FieldContext{
7730 Object: "PageInfo",
7731 Field: field,
7732 Args: nil,
7733 IsMethod: false,
7734 }
7735
7736 ctx = graphql.WithFieldContext(ctx, fc)
7737 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7738 ctx = rctx // use context from middleware stack in children
7739 return obj.HasPreviousPage, nil
7740 })
7741 if err != nil {
7742 ec.Error(ctx, err)
7743 return graphql.Null
7744 }
7745 if resTmp == nil {
7746 if !graphql.HasFieldError(ctx, fc) {
7747 ec.Errorf(ctx, "must not be null")
7748 }
7749 return graphql.Null
7750 }
7751 res := resTmp.(bool)
7752 fc.Result = res
7753 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7754}
7755
7756func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7757 defer func() {
7758 if r := recover(); r != nil {
7759 ec.Error(ctx, ec.Recover(ctx, r))
7760 ret = graphql.Null
7761 }
7762 }()
7763 fc := &graphql.FieldContext{
7764 Object: "PageInfo",
7765 Field: field,
7766 Args: nil,
7767 IsMethod: false,
7768 }
7769
7770 ctx = graphql.WithFieldContext(ctx, fc)
7771 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7772 ctx = rctx // use context from middleware stack in children
7773 return obj.StartCursor, nil
7774 })
7775 if err != nil {
7776 ec.Error(ctx, err)
7777 return graphql.Null
7778 }
7779 if resTmp == nil {
7780 if !graphql.HasFieldError(ctx, fc) {
7781 ec.Errorf(ctx, "must not be null")
7782 }
7783 return graphql.Null
7784 }
7785 res := resTmp.(string)
7786 fc.Result = res
7787 return ec.marshalNString2string(ctx, field.Selections, res)
7788}
7789
7790func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7791 defer func() {
7792 if r := recover(); r != nil {
7793 ec.Error(ctx, ec.Recover(ctx, r))
7794 ret = graphql.Null
7795 }
7796 }()
7797 fc := &graphql.FieldContext{
7798 Object: "PageInfo",
7799 Field: field,
7800 Args: nil,
7801 IsMethod: false,
7802 }
7803
7804 ctx = graphql.WithFieldContext(ctx, fc)
7805 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7806 ctx = rctx // use context from middleware stack in children
7807 return obj.EndCursor, nil
7808 })
7809 if err != nil {
7810 ec.Error(ctx, err)
7811 return graphql.Null
7812 }
7813 if resTmp == nil {
7814 if !graphql.HasFieldError(ctx, fc) {
7815 ec.Errorf(ctx, "must not be null")
7816 }
7817 return graphql.Null
7818 }
7819 res := resTmp.(string)
7820 fc.Result = res
7821 return ec.marshalNString2string(ctx, field.Selections, res)
7822}
7823
7824func (ec *executionContext) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7825 defer func() {
7826 if r := recover(); r != nil {
7827 ec.Error(ctx, ec.Recover(ctx, r))
7828 ret = graphql.Null
7829 }
7830 }()
7831 fc := &graphql.FieldContext{
7832 Object: "Query",
7833 Field: field,
7834 Args: nil,
7835 IsMethod: true,
7836 }
7837
7838 ctx = graphql.WithFieldContext(ctx, fc)
7839 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7840 ctx = rctx // use context from middleware stack in children
7841 return ec.resolvers.Query().DefaultRepository(rctx)
7842 })
7843 if err != nil {
7844 ec.Error(ctx, err)
7845 return graphql.Null
7846 }
7847 if resTmp == nil {
7848 return graphql.Null
7849 }
7850 res := resTmp.(*models.Repository)
7851 fc.Result = res
7852 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
7853}
7854
7855func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7856 defer func() {
7857 if r := recover(); r != nil {
7858 ec.Error(ctx, ec.Recover(ctx, r))
7859 ret = graphql.Null
7860 }
7861 }()
7862 fc := &graphql.FieldContext{
7863 Object: "Query",
7864 Field: field,
7865 Args: nil,
7866 IsMethod: true,
7867 }
7868
7869 ctx = graphql.WithFieldContext(ctx, fc)
7870 rawArgs := field.ArgumentMap(ec.Variables)
7871 args, err := ec.field_Query_repository_args(ctx, rawArgs)
7872 if err != nil {
7873 ec.Error(ctx, err)
7874 return graphql.Null
7875 }
7876 fc.Args = args
7877 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7878 ctx = rctx // use context from middleware stack in children
7879 return ec.resolvers.Query().Repository(rctx, args["ref"].(string))
7880 })
7881 if err != nil {
7882 ec.Error(ctx, err)
7883 return graphql.Null
7884 }
7885 if resTmp == nil {
7886 return graphql.Null
7887 }
7888 res := resTmp.(*models.Repository)
7889 fc.Result = res
7890 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
7891}
7892
7893func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7894 defer func() {
7895 if r := recover(); r != nil {
7896 ec.Error(ctx, ec.Recover(ctx, r))
7897 ret = graphql.Null
7898 }
7899 }()
7900 fc := &graphql.FieldContext{
7901 Object: "Query",
7902 Field: field,
7903 Args: nil,
7904 IsMethod: true,
7905 }
7906
7907 ctx = graphql.WithFieldContext(ctx, fc)
7908 rawArgs := field.ArgumentMap(ec.Variables)
7909 args, err := ec.field_Query___type_args(ctx, rawArgs)
7910 if err != nil {
7911 ec.Error(ctx, err)
7912 return graphql.Null
7913 }
7914 fc.Args = args
7915 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7916 ctx = rctx // use context from middleware stack in children
7917 return ec.introspectType(args["name"].(string))
7918 })
7919 if err != nil {
7920 ec.Error(ctx, err)
7921 return graphql.Null
7922 }
7923 if resTmp == nil {
7924 return graphql.Null
7925 }
7926 res := resTmp.(*introspection.Type)
7927 fc.Result = res
7928 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
7929}
7930
7931func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7932 defer func() {
7933 if r := recover(); r != nil {
7934 ec.Error(ctx, ec.Recover(ctx, r))
7935 ret = graphql.Null
7936 }
7937 }()
7938 fc := &graphql.FieldContext{
7939 Object: "Query",
7940 Field: field,
7941 Args: nil,
7942 IsMethod: true,
7943 }
7944
7945 ctx = graphql.WithFieldContext(ctx, fc)
7946 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7947 ctx = rctx // use context from middleware stack in children
7948 return ec.introspectSchema()
7949 })
7950 if err != nil {
7951 ec.Error(ctx, err)
7952 return graphql.Null
7953 }
7954 if resTmp == nil {
7955 return graphql.Null
7956 }
7957 res := resTmp.(*introspection.Schema)
7958 fc.Result = res
7959 return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
7960}
7961
7962func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (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: "Repository",
7971 Field: field,
7972 Args: nil,
7973 IsMethod: true,
7974 }
7975
7976 ctx = graphql.WithFieldContext(ctx, fc)
7977 rawArgs := field.ArgumentMap(ec.Variables)
7978 args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
7979 if err != nil {
7980 ec.Error(ctx, err)
7981 return graphql.Null
7982 }
7983 fc.Args = args
7984 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7985 ctx = rctx // use context from middleware stack in children
7986 return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
7987 })
7988 if err != nil {
7989 ec.Error(ctx, err)
7990 return graphql.Null
7991 }
7992 if resTmp == nil {
7993 if !graphql.HasFieldError(ctx, fc) {
7994 ec.Errorf(ctx, "must not be null")
7995 }
7996 return graphql.Null
7997 }
7998 res := resTmp.(*models.BugConnection)
7999 fc.Result = res
8000 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
8001}
8002
8003func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8004 defer func() {
8005 if r := recover(); r != nil {
8006 ec.Error(ctx, ec.Recover(ctx, r))
8007 ret = graphql.Null
8008 }
8009 }()
8010 fc := &graphql.FieldContext{
8011 Object: "Repository",
8012 Field: field,
8013 Args: nil,
8014 IsMethod: true,
8015 }
8016
8017 ctx = graphql.WithFieldContext(ctx, fc)
8018 rawArgs := field.ArgumentMap(ec.Variables)
8019 args, err := ec.field_Repository_bug_args(ctx, rawArgs)
8020 if err != nil {
8021 ec.Error(ctx, err)
8022 return graphql.Null
8023 }
8024 fc.Args = args
8025 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8026 ctx = rctx // use context from middleware stack in children
8027 return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
8028 })
8029 if err != nil {
8030 ec.Error(ctx, err)
8031 return graphql.Null
8032 }
8033 if resTmp == nil {
8034 return graphql.Null
8035 }
8036 res := resTmp.(models.BugWrapper)
8037 fc.Result = res
8038 return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
8039}
8040
8041func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8042 defer func() {
8043 if r := recover(); r != nil {
8044 ec.Error(ctx, ec.Recover(ctx, r))
8045 ret = graphql.Null
8046 }
8047 }()
8048 fc := &graphql.FieldContext{
8049 Object: "Repository",
8050 Field: field,
8051 Args: nil,
8052 IsMethod: true,
8053 }
8054
8055 ctx = graphql.WithFieldContext(ctx, fc)
8056 rawArgs := field.ArgumentMap(ec.Variables)
8057 args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
8058 if err != nil {
8059 ec.Error(ctx, err)
8060 return graphql.Null
8061 }
8062 fc.Args = args
8063 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8064 ctx = rctx // use context from middleware stack in children
8065 return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8066 })
8067 if err != nil {
8068 ec.Error(ctx, err)
8069 return graphql.Null
8070 }
8071 if resTmp == nil {
8072 if !graphql.HasFieldError(ctx, fc) {
8073 ec.Errorf(ctx, "must not be null")
8074 }
8075 return graphql.Null
8076 }
8077 res := resTmp.(*models.IdentityConnection)
8078 fc.Result = res
8079 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
8080}
8081
8082func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8083 defer func() {
8084 if r := recover(); r != nil {
8085 ec.Error(ctx, ec.Recover(ctx, r))
8086 ret = graphql.Null
8087 }
8088 }()
8089 fc := &graphql.FieldContext{
8090 Object: "Repository",
8091 Field: field,
8092 Args: nil,
8093 IsMethod: true,
8094 }
8095
8096 ctx = graphql.WithFieldContext(ctx, fc)
8097 rawArgs := field.ArgumentMap(ec.Variables)
8098 args, err := ec.field_Repository_identity_args(ctx, rawArgs)
8099 if err != nil {
8100 ec.Error(ctx, err)
8101 return graphql.Null
8102 }
8103 fc.Args = args
8104 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8105 ctx = rctx // use context from middleware stack in children
8106 return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
8107 })
8108 if err != nil {
8109 ec.Error(ctx, err)
8110 return graphql.Null
8111 }
8112 if resTmp == nil {
8113 return graphql.Null
8114 }
8115 res := resTmp.(models.IdentityWrapper)
8116 fc.Result = res
8117 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8118}
8119
8120func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8121 defer func() {
8122 if r := recover(); r != nil {
8123 ec.Error(ctx, ec.Recover(ctx, r))
8124 ret = graphql.Null
8125 }
8126 }()
8127 fc := &graphql.FieldContext{
8128 Object: "Repository",
8129 Field: field,
8130 Args: nil,
8131 IsMethod: true,
8132 }
8133
8134 ctx = graphql.WithFieldContext(ctx, fc)
8135 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8136 ctx = rctx // use context from middleware stack in children
8137 return ec.resolvers.Repository().UserIdentity(rctx, obj)
8138 })
8139 if err != nil {
8140 ec.Error(ctx, err)
8141 return graphql.Null
8142 }
8143 if resTmp == nil {
8144 return graphql.Null
8145 }
8146 res := resTmp.(models.IdentityWrapper)
8147 fc.Result = res
8148 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8149}
8150
8151func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8152 defer func() {
8153 if r := recover(); r != nil {
8154 ec.Error(ctx, ec.Recover(ctx, r))
8155 ret = graphql.Null
8156 }
8157 }()
8158 fc := &graphql.FieldContext{
8159 Object: "Repository",
8160 Field: field,
8161 Args: nil,
8162 IsMethod: true,
8163 }
8164
8165 ctx = graphql.WithFieldContext(ctx, fc)
8166 rawArgs := field.ArgumentMap(ec.Variables)
8167 args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
8168 if err != nil {
8169 ec.Error(ctx, err)
8170 return graphql.Null
8171 }
8172 fc.Args = args
8173 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8174 ctx = rctx // use context from middleware stack in children
8175 return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8176 })
8177 if err != nil {
8178 ec.Error(ctx, err)
8179 return graphql.Null
8180 }
8181 if resTmp == nil {
8182 if !graphql.HasFieldError(ctx, fc) {
8183 ec.Errorf(ctx, "must not be null")
8184 }
8185 return graphql.Null
8186 }
8187 res := resTmp.(*models.LabelConnection)
8188 fc.Result = res
8189 return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
8190}
8191
8192func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8193 defer func() {
8194 if r := recover(); r != nil {
8195 ec.Error(ctx, ec.Recover(ctx, r))
8196 ret = graphql.Null
8197 }
8198 }()
8199 fc := &graphql.FieldContext{
8200 Object: "SetStatusOperation",
8201 Field: field,
8202 Args: nil,
8203 IsMethod: true,
8204 }
8205
8206 ctx = graphql.WithFieldContext(ctx, fc)
8207 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8208 ctx = rctx // use context from middleware stack in children
8209 return ec.resolvers.SetStatusOperation().ID(rctx, obj)
8210 })
8211 if err != nil {
8212 ec.Error(ctx, err)
8213 return graphql.Null
8214 }
8215 if resTmp == nil {
8216 if !graphql.HasFieldError(ctx, fc) {
8217 ec.Errorf(ctx, "must not be null")
8218 }
8219 return graphql.Null
8220 }
8221 res := resTmp.(string)
8222 fc.Result = res
8223 return ec.marshalNString2string(ctx, field.Selections, res)
8224}
8225
8226func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8227 defer func() {
8228 if r := recover(); r != nil {
8229 ec.Error(ctx, ec.Recover(ctx, r))
8230 ret = graphql.Null
8231 }
8232 }()
8233 fc := &graphql.FieldContext{
8234 Object: "SetStatusOperation",
8235 Field: field,
8236 Args: nil,
8237 IsMethod: true,
8238 }
8239
8240 ctx = graphql.WithFieldContext(ctx, fc)
8241 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8242 ctx = rctx // use context from middleware stack in children
8243 return ec.resolvers.SetStatusOperation().Author(rctx, obj)
8244 })
8245 if err != nil {
8246 ec.Error(ctx, err)
8247 return graphql.Null
8248 }
8249 if resTmp == nil {
8250 if !graphql.HasFieldError(ctx, fc) {
8251 ec.Errorf(ctx, "must not be null")
8252 }
8253 return graphql.Null
8254 }
8255 res := resTmp.(models.IdentityWrapper)
8256 fc.Result = res
8257 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8258}
8259
8260func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8261 defer func() {
8262 if r := recover(); r != nil {
8263 ec.Error(ctx, ec.Recover(ctx, r))
8264 ret = graphql.Null
8265 }
8266 }()
8267 fc := &graphql.FieldContext{
8268 Object: "SetStatusOperation",
8269 Field: field,
8270 Args: nil,
8271 IsMethod: true,
8272 }
8273
8274 ctx = graphql.WithFieldContext(ctx, fc)
8275 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8276 ctx = rctx // use context from middleware stack in children
8277 return ec.resolvers.SetStatusOperation().Date(rctx, obj)
8278 })
8279 if err != nil {
8280 ec.Error(ctx, err)
8281 return graphql.Null
8282 }
8283 if resTmp == nil {
8284 if !graphql.HasFieldError(ctx, fc) {
8285 ec.Errorf(ctx, "must not be null")
8286 }
8287 return graphql.Null
8288 }
8289 res := resTmp.(*time.Time)
8290 fc.Result = res
8291 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8292}
8293
8294func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8295 defer func() {
8296 if r := recover(); r != nil {
8297 ec.Error(ctx, ec.Recover(ctx, r))
8298 ret = graphql.Null
8299 }
8300 }()
8301 fc := &graphql.FieldContext{
8302 Object: "SetStatusOperation",
8303 Field: field,
8304 Args: nil,
8305 IsMethod: true,
8306 }
8307
8308 ctx = graphql.WithFieldContext(ctx, fc)
8309 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8310 ctx = rctx // use context from middleware stack in children
8311 return ec.resolvers.SetStatusOperation().Status(rctx, obj)
8312 })
8313 if err != nil {
8314 ec.Error(ctx, err)
8315 return graphql.Null
8316 }
8317 if resTmp == nil {
8318 if !graphql.HasFieldError(ctx, fc) {
8319 ec.Errorf(ctx, "must not be null")
8320 }
8321 return graphql.Null
8322 }
8323 res := resTmp.(models.Status)
8324 fc.Result = res
8325 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8326}
8327
8328func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8329 defer func() {
8330 if r := recover(); r != nil {
8331 ec.Error(ctx, ec.Recover(ctx, r))
8332 ret = graphql.Null
8333 }
8334 }()
8335 fc := &graphql.FieldContext{
8336 Object: "SetStatusTimelineItem",
8337 Field: field,
8338 Args: nil,
8339 IsMethod: true,
8340 }
8341
8342 ctx = graphql.WithFieldContext(ctx, fc)
8343 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8344 ctx = rctx // use context from middleware stack in children
8345 return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
8346 })
8347 if err != nil {
8348 ec.Error(ctx, err)
8349 return graphql.Null
8350 }
8351 if resTmp == nil {
8352 if !graphql.HasFieldError(ctx, fc) {
8353 ec.Errorf(ctx, "must not be null")
8354 }
8355 return graphql.Null
8356 }
8357 res := resTmp.(string)
8358 fc.Result = res
8359 return ec.marshalNString2string(ctx, field.Selections, res)
8360}
8361
8362func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8363 defer func() {
8364 if r := recover(); r != nil {
8365 ec.Error(ctx, ec.Recover(ctx, r))
8366 ret = graphql.Null
8367 }
8368 }()
8369 fc := &graphql.FieldContext{
8370 Object: "SetStatusTimelineItem",
8371 Field: field,
8372 Args: nil,
8373 IsMethod: true,
8374 }
8375
8376 ctx = graphql.WithFieldContext(ctx, fc)
8377 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8378 ctx = rctx // use context from middleware stack in children
8379 return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
8380 })
8381 if err != nil {
8382 ec.Error(ctx, err)
8383 return graphql.Null
8384 }
8385 if resTmp == nil {
8386 if !graphql.HasFieldError(ctx, fc) {
8387 ec.Errorf(ctx, "must not be null")
8388 }
8389 return graphql.Null
8390 }
8391 res := resTmp.(models.IdentityWrapper)
8392 fc.Result = res
8393 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8394}
8395
8396func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8397 defer func() {
8398 if r := recover(); r != nil {
8399 ec.Error(ctx, ec.Recover(ctx, r))
8400 ret = graphql.Null
8401 }
8402 }()
8403 fc := &graphql.FieldContext{
8404 Object: "SetStatusTimelineItem",
8405 Field: field,
8406 Args: nil,
8407 IsMethod: true,
8408 }
8409
8410 ctx = graphql.WithFieldContext(ctx, fc)
8411 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8412 ctx = rctx // use context from middleware stack in children
8413 return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
8414 })
8415 if err != nil {
8416 ec.Error(ctx, err)
8417 return graphql.Null
8418 }
8419 if resTmp == nil {
8420 if !graphql.HasFieldError(ctx, fc) {
8421 ec.Errorf(ctx, "must not be null")
8422 }
8423 return graphql.Null
8424 }
8425 res := resTmp.(*time.Time)
8426 fc.Result = res
8427 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8428}
8429
8430func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8431 defer func() {
8432 if r := recover(); r != nil {
8433 ec.Error(ctx, ec.Recover(ctx, r))
8434 ret = graphql.Null
8435 }
8436 }()
8437 fc := &graphql.FieldContext{
8438 Object: "SetStatusTimelineItem",
8439 Field: field,
8440 Args: nil,
8441 IsMethod: true,
8442 }
8443
8444 ctx = graphql.WithFieldContext(ctx, fc)
8445 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8446 ctx = rctx // use context from middleware stack in children
8447 return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
8448 })
8449 if err != nil {
8450 ec.Error(ctx, err)
8451 return graphql.Null
8452 }
8453 if resTmp == nil {
8454 if !graphql.HasFieldError(ctx, fc) {
8455 ec.Errorf(ctx, "must not be null")
8456 }
8457 return graphql.Null
8458 }
8459 res := resTmp.(models.Status)
8460 fc.Result = res
8461 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8462}
8463
8464func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8465 defer func() {
8466 if r := recover(); r != nil {
8467 ec.Error(ctx, ec.Recover(ctx, r))
8468 ret = graphql.Null
8469 }
8470 }()
8471 fc := &graphql.FieldContext{
8472 Object: "SetTitleOperation",
8473 Field: field,
8474 Args: nil,
8475 IsMethod: true,
8476 }
8477
8478 ctx = graphql.WithFieldContext(ctx, fc)
8479 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8480 ctx = rctx // use context from middleware stack in children
8481 return ec.resolvers.SetTitleOperation().ID(rctx, obj)
8482 })
8483 if err != nil {
8484 ec.Error(ctx, err)
8485 return graphql.Null
8486 }
8487 if resTmp == nil {
8488 if !graphql.HasFieldError(ctx, fc) {
8489 ec.Errorf(ctx, "must not be null")
8490 }
8491 return graphql.Null
8492 }
8493 res := resTmp.(string)
8494 fc.Result = res
8495 return ec.marshalNString2string(ctx, field.Selections, res)
8496}
8497
8498func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8499 defer func() {
8500 if r := recover(); r != nil {
8501 ec.Error(ctx, ec.Recover(ctx, r))
8502 ret = graphql.Null
8503 }
8504 }()
8505 fc := &graphql.FieldContext{
8506 Object: "SetTitleOperation",
8507 Field: field,
8508 Args: nil,
8509 IsMethod: true,
8510 }
8511
8512 ctx = graphql.WithFieldContext(ctx, fc)
8513 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8514 ctx = rctx // use context from middleware stack in children
8515 return ec.resolvers.SetTitleOperation().Author(rctx, obj)
8516 })
8517 if err != nil {
8518 ec.Error(ctx, err)
8519 return graphql.Null
8520 }
8521 if resTmp == nil {
8522 if !graphql.HasFieldError(ctx, fc) {
8523 ec.Errorf(ctx, "must not be null")
8524 }
8525 return graphql.Null
8526 }
8527 res := resTmp.(models.IdentityWrapper)
8528 fc.Result = res
8529 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8530}
8531
8532func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8533 defer func() {
8534 if r := recover(); r != nil {
8535 ec.Error(ctx, ec.Recover(ctx, r))
8536 ret = graphql.Null
8537 }
8538 }()
8539 fc := &graphql.FieldContext{
8540 Object: "SetTitleOperation",
8541 Field: field,
8542 Args: nil,
8543 IsMethod: true,
8544 }
8545
8546 ctx = graphql.WithFieldContext(ctx, fc)
8547 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8548 ctx = rctx // use context from middleware stack in children
8549 return ec.resolvers.SetTitleOperation().Date(rctx, obj)
8550 })
8551 if err != nil {
8552 ec.Error(ctx, err)
8553 return graphql.Null
8554 }
8555 if resTmp == nil {
8556 if !graphql.HasFieldError(ctx, fc) {
8557 ec.Errorf(ctx, "must not be null")
8558 }
8559 return graphql.Null
8560 }
8561 res := resTmp.(*time.Time)
8562 fc.Result = res
8563 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8564}
8565
8566func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8567 defer func() {
8568 if r := recover(); r != nil {
8569 ec.Error(ctx, ec.Recover(ctx, r))
8570 ret = graphql.Null
8571 }
8572 }()
8573 fc := &graphql.FieldContext{
8574 Object: "SetTitleOperation",
8575 Field: field,
8576 Args: nil,
8577 IsMethod: false,
8578 }
8579
8580 ctx = graphql.WithFieldContext(ctx, fc)
8581 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8582 ctx = rctx // use context from middleware stack in children
8583 return obj.Title, nil
8584 })
8585 if err != nil {
8586 ec.Error(ctx, err)
8587 return graphql.Null
8588 }
8589 if resTmp == nil {
8590 if !graphql.HasFieldError(ctx, fc) {
8591 ec.Errorf(ctx, "must not be null")
8592 }
8593 return graphql.Null
8594 }
8595 res := resTmp.(string)
8596 fc.Result = res
8597 return ec.marshalNString2string(ctx, field.Selections, res)
8598}
8599
8600func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8601 defer func() {
8602 if r := recover(); r != nil {
8603 ec.Error(ctx, ec.Recover(ctx, r))
8604 ret = graphql.Null
8605 }
8606 }()
8607 fc := &graphql.FieldContext{
8608 Object: "SetTitleOperation",
8609 Field: field,
8610 Args: nil,
8611 IsMethod: false,
8612 }
8613
8614 ctx = graphql.WithFieldContext(ctx, fc)
8615 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8616 ctx = rctx // use context from middleware stack in children
8617 return obj.Was, nil
8618 })
8619 if err != nil {
8620 ec.Error(ctx, err)
8621 return graphql.Null
8622 }
8623 if resTmp == nil {
8624 if !graphql.HasFieldError(ctx, fc) {
8625 ec.Errorf(ctx, "must not be null")
8626 }
8627 return graphql.Null
8628 }
8629 res := resTmp.(string)
8630 fc.Result = res
8631 return ec.marshalNString2string(ctx, field.Selections, res)
8632}
8633
8634func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8635 defer func() {
8636 if r := recover(); r != nil {
8637 ec.Error(ctx, ec.Recover(ctx, r))
8638 ret = graphql.Null
8639 }
8640 }()
8641 fc := &graphql.FieldContext{
8642 Object: "SetTitlePayload",
8643 Field: field,
8644 Args: nil,
8645 IsMethod: false,
8646 }
8647
8648 ctx = graphql.WithFieldContext(ctx, fc)
8649 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8650 ctx = rctx // use context from middleware stack in children
8651 return obj.ClientMutationID, nil
8652 })
8653 if err != nil {
8654 ec.Error(ctx, err)
8655 return graphql.Null
8656 }
8657 if resTmp == nil {
8658 return graphql.Null
8659 }
8660 res := resTmp.(*string)
8661 fc.Result = res
8662 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8663}
8664
8665func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8666 defer func() {
8667 if r := recover(); r != nil {
8668 ec.Error(ctx, ec.Recover(ctx, r))
8669 ret = graphql.Null
8670 }
8671 }()
8672 fc := &graphql.FieldContext{
8673 Object: "SetTitlePayload",
8674 Field: field,
8675 Args: nil,
8676 IsMethod: false,
8677 }
8678
8679 ctx = graphql.WithFieldContext(ctx, fc)
8680 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8681 ctx = rctx // use context from middleware stack in children
8682 return obj.Bug, nil
8683 })
8684 if err != nil {
8685 ec.Error(ctx, err)
8686 return graphql.Null
8687 }
8688 if resTmp == nil {
8689 if !graphql.HasFieldError(ctx, fc) {
8690 ec.Errorf(ctx, "must not be null")
8691 }
8692 return graphql.Null
8693 }
8694 res := resTmp.(models.BugWrapper)
8695 fc.Result = res
8696 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
8697}
8698
8699func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8700 defer func() {
8701 if r := recover(); r != nil {
8702 ec.Error(ctx, ec.Recover(ctx, r))
8703 ret = graphql.Null
8704 }
8705 }()
8706 fc := &graphql.FieldContext{
8707 Object: "SetTitlePayload",
8708 Field: field,
8709 Args: nil,
8710 IsMethod: false,
8711 }
8712
8713 ctx = graphql.WithFieldContext(ctx, fc)
8714 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8715 ctx = rctx // use context from middleware stack in children
8716 return obj.Operation, nil
8717 })
8718 if err != nil {
8719 ec.Error(ctx, err)
8720 return graphql.Null
8721 }
8722 if resTmp == nil {
8723 if !graphql.HasFieldError(ctx, fc) {
8724 ec.Errorf(ctx, "must not be null")
8725 }
8726 return graphql.Null
8727 }
8728 res := resTmp.(*bug.SetTitleOperation)
8729 fc.Result = res
8730 return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
8731}
8732
8733func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8734 defer func() {
8735 if r := recover(); r != nil {
8736 ec.Error(ctx, ec.Recover(ctx, r))
8737 ret = graphql.Null
8738 }
8739 }()
8740 fc := &graphql.FieldContext{
8741 Object: "SetTitleTimelineItem",
8742 Field: field,
8743 Args: nil,
8744 IsMethod: true,
8745 }
8746
8747 ctx = graphql.WithFieldContext(ctx, fc)
8748 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8749 ctx = rctx // use context from middleware stack in children
8750 return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
8751 })
8752 if err != nil {
8753 ec.Error(ctx, err)
8754 return graphql.Null
8755 }
8756 if resTmp == nil {
8757 if !graphql.HasFieldError(ctx, fc) {
8758 ec.Errorf(ctx, "must not be null")
8759 }
8760 return graphql.Null
8761 }
8762 res := resTmp.(string)
8763 fc.Result = res
8764 return ec.marshalNString2string(ctx, field.Selections, res)
8765}
8766
8767func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8768 defer func() {
8769 if r := recover(); r != nil {
8770 ec.Error(ctx, ec.Recover(ctx, r))
8771 ret = graphql.Null
8772 }
8773 }()
8774 fc := &graphql.FieldContext{
8775 Object: "SetTitleTimelineItem",
8776 Field: field,
8777 Args: nil,
8778 IsMethod: true,
8779 }
8780
8781 ctx = graphql.WithFieldContext(ctx, fc)
8782 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8783 ctx = rctx // use context from middleware stack in children
8784 return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
8785 })
8786 if err != nil {
8787 ec.Error(ctx, err)
8788 return graphql.Null
8789 }
8790 if resTmp == nil {
8791 if !graphql.HasFieldError(ctx, fc) {
8792 ec.Errorf(ctx, "must not be null")
8793 }
8794 return graphql.Null
8795 }
8796 res := resTmp.(models.IdentityWrapper)
8797 fc.Result = res
8798 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8799}
8800
8801func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8802 defer func() {
8803 if r := recover(); r != nil {
8804 ec.Error(ctx, ec.Recover(ctx, r))
8805 ret = graphql.Null
8806 }
8807 }()
8808 fc := &graphql.FieldContext{
8809 Object: "SetTitleTimelineItem",
8810 Field: field,
8811 Args: nil,
8812 IsMethod: true,
8813 }
8814
8815 ctx = graphql.WithFieldContext(ctx, fc)
8816 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8817 ctx = rctx // use context from middleware stack in children
8818 return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
8819 })
8820 if err != nil {
8821 ec.Error(ctx, err)
8822 return graphql.Null
8823 }
8824 if resTmp == nil {
8825 if !graphql.HasFieldError(ctx, fc) {
8826 ec.Errorf(ctx, "must not be null")
8827 }
8828 return graphql.Null
8829 }
8830 res := resTmp.(*time.Time)
8831 fc.Result = res
8832 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8833}
8834
8835func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8836 defer func() {
8837 if r := recover(); r != nil {
8838 ec.Error(ctx, ec.Recover(ctx, r))
8839 ret = graphql.Null
8840 }
8841 }()
8842 fc := &graphql.FieldContext{
8843 Object: "SetTitleTimelineItem",
8844 Field: field,
8845 Args: nil,
8846 IsMethod: false,
8847 }
8848
8849 ctx = graphql.WithFieldContext(ctx, fc)
8850 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8851 ctx = rctx // use context from middleware stack in children
8852 return obj.Title, nil
8853 })
8854 if err != nil {
8855 ec.Error(ctx, err)
8856 return graphql.Null
8857 }
8858 if resTmp == nil {
8859 if !graphql.HasFieldError(ctx, fc) {
8860 ec.Errorf(ctx, "must not be null")
8861 }
8862 return graphql.Null
8863 }
8864 res := resTmp.(string)
8865 fc.Result = res
8866 return ec.marshalNString2string(ctx, field.Selections, res)
8867}
8868
8869func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8870 defer func() {
8871 if r := recover(); r != nil {
8872 ec.Error(ctx, ec.Recover(ctx, r))
8873 ret = graphql.Null
8874 }
8875 }()
8876 fc := &graphql.FieldContext{
8877 Object: "SetTitleTimelineItem",
8878 Field: field,
8879 Args: nil,
8880 IsMethod: false,
8881 }
8882
8883 ctx = graphql.WithFieldContext(ctx, fc)
8884 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8885 ctx = rctx // use context from middleware stack in children
8886 return obj.Was, nil
8887 })
8888 if err != nil {
8889 ec.Error(ctx, err)
8890 return graphql.Null
8891 }
8892 if resTmp == nil {
8893 if !graphql.HasFieldError(ctx, fc) {
8894 ec.Errorf(ctx, "must not be null")
8895 }
8896 return graphql.Null
8897 }
8898 res := resTmp.(string)
8899 fc.Result = res
8900 return ec.marshalNString2string(ctx, field.Selections, res)
8901}
8902
8903func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
8904 defer func() {
8905 if r := recover(); r != nil {
8906 ec.Error(ctx, ec.Recover(ctx, r))
8907 ret = graphql.Null
8908 }
8909 }()
8910 fc := &graphql.FieldContext{
8911 Object: "TimelineItemConnection",
8912 Field: field,
8913 Args: nil,
8914 IsMethod: false,
8915 }
8916
8917 ctx = graphql.WithFieldContext(ctx, fc)
8918 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8919 ctx = rctx // use context from middleware stack in children
8920 return obj.Edges, nil
8921 })
8922 if err != nil {
8923 ec.Error(ctx, err)
8924 return graphql.Null
8925 }
8926 if resTmp == nil {
8927 if !graphql.HasFieldError(ctx, fc) {
8928 ec.Errorf(ctx, "must not be null")
8929 }
8930 return graphql.Null
8931 }
8932 res := resTmp.([]*models.TimelineItemEdge)
8933 fc.Result = res
8934 return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
8935}
8936
8937func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
8938 defer func() {
8939 if r := recover(); r != nil {
8940 ec.Error(ctx, ec.Recover(ctx, r))
8941 ret = graphql.Null
8942 }
8943 }()
8944 fc := &graphql.FieldContext{
8945 Object: "TimelineItemConnection",
8946 Field: field,
8947 Args: nil,
8948 IsMethod: false,
8949 }
8950
8951 ctx = graphql.WithFieldContext(ctx, fc)
8952 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8953 ctx = rctx // use context from middleware stack in children
8954 return obj.Nodes, nil
8955 })
8956 if err != nil {
8957 ec.Error(ctx, err)
8958 return graphql.Null
8959 }
8960 if resTmp == nil {
8961 if !graphql.HasFieldError(ctx, fc) {
8962 ec.Errorf(ctx, "must not be null")
8963 }
8964 return graphql.Null
8965 }
8966 res := resTmp.([]bug.TimelineItem)
8967 fc.Result = res
8968 return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
8969}
8970
8971func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
8972 defer func() {
8973 if r := recover(); r != nil {
8974 ec.Error(ctx, ec.Recover(ctx, r))
8975 ret = graphql.Null
8976 }
8977 }()
8978 fc := &graphql.FieldContext{
8979 Object: "TimelineItemConnection",
8980 Field: field,
8981 Args: nil,
8982 IsMethod: false,
8983 }
8984
8985 ctx = graphql.WithFieldContext(ctx, fc)
8986 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8987 ctx = rctx // use context from middleware stack in children
8988 return obj.PageInfo, nil
8989 })
8990 if err != nil {
8991 ec.Error(ctx, err)
8992 return graphql.Null
8993 }
8994 if resTmp == nil {
8995 if !graphql.HasFieldError(ctx, fc) {
8996 ec.Errorf(ctx, "must not be null")
8997 }
8998 return graphql.Null
8999 }
9000 res := resTmp.(*models.PageInfo)
9001 fc.Result = res
9002 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
9003}
9004
9005func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9006 defer func() {
9007 if r := recover(); r != nil {
9008 ec.Error(ctx, ec.Recover(ctx, r))
9009 ret = graphql.Null
9010 }
9011 }()
9012 fc := &graphql.FieldContext{
9013 Object: "TimelineItemConnection",
9014 Field: field,
9015 Args: nil,
9016 IsMethod: false,
9017 }
9018
9019 ctx = graphql.WithFieldContext(ctx, fc)
9020 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9021 ctx = rctx // use context from middleware stack in children
9022 return obj.TotalCount, nil
9023 })
9024 if err != nil {
9025 ec.Error(ctx, err)
9026 return graphql.Null
9027 }
9028 if resTmp == nil {
9029 if !graphql.HasFieldError(ctx, fc) {
9030 ec.Errorf(ctx, "must not be null")
9031 }
9032 return graphql.Null
9033 }
9034 res := resTmp.(int)
9035 fc.Result = res
9036 return ec.marshalNInt2int(ctx, field.Selections, res)
9037}
9038
9039func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9040 defer func() {
9041 if r := recover(); r != nil {
9042 ec.Error(ctx, ec.Recover(ctx, r))
9043 ret = graphql.Null
9044 }
9045 }()
9046 fc := &graphql.FieldContext{
9047 Object: "TimelineItemEdge",
9048 Field: field,
9049 Args: nil,
9050 IsMethod: false,
9051 }
9052
9053 ctx = graphql.WithFieldContext(ctx, fc)
9054 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9055 ctx = rctx // use context from middleware stack in children
9056 return obj.Cursor, nil
9057 })
9058 if err != nil {
9059 ec.Error(ctx, err)
9060 return graphql.Null
9061 }
9062 if resTmp == nil {
9063 if !graphql.HasFieldError(ctx, fc) {
9064 ec.Errorf(ctx, "must not be null")
9065 }
9066 return graphql.Null
9067 }
9068 res := resTmp.(string)
9069 fc.Result = res
9070 return ec.marshalNString2string(ctx, field.Selections, res)
9071}
9072
9073func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9074 defer func() {
9075 if r := recover(); r != nil {
9076 ec.Error(ctx, ec.Recover(ctx, r))
9077 ret = graphql.Null
9078 }
9079 }()
9080 fc := &graphql.FieldContext{
9081 Object: "TimelineItemEdge",
9082 Field: field,
9083 Args: nil,
9084 IsMethod: false,
9085 }
9086
9087 ctx = graphql.WithFieldContext(ctx, fc)
9088 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9089 ctx = rctx // use context from middleware stack in children
9090 return obj.Node, nil
9091 })
9092 if err != nil {
9093 ec.Error(ctx, err)
9094 return graphql.Null
9095 }
9096 if resTmp == nil {
9097 if !graphql.HasFieldError(ctx, fc) {
9098 ec.Errorf(ctx, "must not be null")
9099 }
9100 return graphql.Null
9101 }
9102 res := resTmp.(bug.TimelineItem)
9103 fc.Result = res
9104 return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
9105}
9106
9107func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9108 defer func() {
9109 if r := recover(); r != nil {
9110 ec.Error(ctx, ec.Recover(ctx, r))
9111 ret = graphql.Null
9112 }
9113 }()
9114 fc := &graphql.FieldContext{
9115 Object: "__Directive",
9116 Field: field,
9117 Args: nil,
9118 IsMethod: false,
9119 }
9120
9121 ctx = graphql.WithFieldContext(ctx, fc)
9122 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9123 ctx = rctx // use context from middleware stack in children
9124 return obj.Name, nil
9125 })
9126 if err != nil {
9127 ec.Error(ctx, err)
9128 return graphql.Null
9129 }
9130 if resTmp == nil {
9131 if !graphql.HasFieldError(ctx, fc) {
9132 ec.Errorf(ctx, "must not be null")
9133 }
9134 return graphql.Null
9135 }
9136 res := resTmp.(string)
9137 fc.Result = res
9138 return ec.marshalNString2string(ctx, field.Selections, res)
9139}
9140
9141func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9142 defer func() {
9143 if r := recover(); r != nil {
9144 ec.Error(ctx, ec.Recover(ctx, r))
9145 ret = graphql.Null
9146 }
9147 }()
9148 fc := &graphql.FieldContext{
9149 Object: "__Directive",
9150 Field: field,
9151 Args: nil,
9152 IsMethod: false,
9153 }
9154
9155 ctx = graphql.WithFieldContext(ctx, fc)
9156 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9157 ctx = rctx // use context from middleware stack in children
9158 return obj.Description, nil
9159 })
9160 if err != nil {
9161 ec.Error(ctx, err)
9162 return graphql.Null
9163 }
9164 if resTmp == nil {
9165 return graphql.Null
9166 }
9167 res := resTmp.(string)
9168 fc.Result = res
9169 return ec.marshalOString2string(ctx, field.Selections, res)
9170}
9171
9172func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9173 defer func() {
9174 if r := recover(); r != nil {
9175 ec.Error(ctx, ec.Recover(ctx, r))
9176 ret = graphql.Null
9177 }
9178 }()
9179 fc := &graphql.FieldContext{
9180 Object: "__Directive",
9181 Field: field,
9182 Args: nil,
9183 IsMethod: false,
9184 }
9185
9186 ctx = graphql.WithFieldContext(ctx, fc)
9187 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9188 ctx = rctx // use context from middleware stack in children
9189 return obj.Locations, nil
9190 })
9191 if err != nil {
9192 ec.Error(ctx, err)
9193 return graphql.Null
9194 }
9195 if resTmp == nil {
9196 if !graphql.HasFieldError(ctx, fc) {
9197 ec.Errorf(ctx, "must not be null")
9198 }
9199 return graphql.Null
9200 }
9201 res := resTmp.([]string)
9202 fc.Result = res
9203 return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
9204}
9205
9206func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9207 defer func() {
9208 if r := recover(); r != nil {
9209 ec.Error(ctx, ec.Recover(ctx, r))
9210 ret = graphql.Null
9211 }
9212 }()
9213 fc := &graphql.FieldContext{
9214 Object: "__Directive",
9215 Field: field,
9216 Args: nil,
9217 IsMethod: false,
9218 }
9219
9220 ctx = graphql.WithFieldContext(ctx, fc)
9221 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9222 ctx = rctx // use context from middleware stack in children
9223 return obj.Args, nil
9224 })
9225 if err != nil {
9226 ec.Error(ctx, err)
9227 return graphql.Null
9228 }
9229 if resTmp == nil {
9230 if !graphql.HasFieldError(ctx, fc) {
9231 ec.Errorf(ctx, "must not be null")
9232 }
9233 return graphql.Null
9234 }
9235 res := resTmp.([]introspection.InputValue)
9236 fc.Result = res
9237 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
9238}
9239
9240func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9241 defer func() {
9242 if r := recover(); r != nil {
9243 ec.Error(ctx, ec.Recover(ctx, r))
9244 ret = graphql.Null
9245 }
9246 }()
9247 fc := &graphql.FieldContext{
9248 Object: "__EnumValue",
9249 Field: field,
9250 Args: nil,
9251 IsMethod: false,
9252 }
9253
9254 ctx = graphql.WithFieldContext(ctx, fc)
9255 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9256 ctx = rctx // use context from middleware stack in children
9257 return obj.Name, nil
9258 })
9259 if err != nil {
9260 ec.Error(ctx, err)
9261 return graphql.Null
9262 }
9263 if resTmp == nil {
9264 if !graphql.HasFieldError(ctx, fc) {
9265 ec.Errorf(ctx, "must not be null")
9266 }
9267 return graphql.Null
9268 }
9269 res := resTmp.(string)
9270 fc.Result = res
9271 return ec.marshalNString2string(ctx, field.Selections, res)
9272}
9273
9274func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9275 defer func() {
9276 if r := recover(); r != nil {
9277 ec.Error(ctx, ec.Recover(ctx, r))
9278 ret = graphql.Null
9279 }
9280 }()
9281 fc := &graphql.FieldContext{
9282 Object: "__EnumValue",
9283 Field: field,
9284 Args: nil,
9285 IsMethod: false,
9286 }
9287
9288 ctx = graphql.WithFieldContext(ctx, fc)
9289 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9290 ctx = rctx // use context from middleware stack in children
9291 return obj.Description, nil
9292 })
9293 if err != nil {
9294 ec.Error(ctx, err)
9295 return graphql.Null
9296 }
9297 if resTmp == nil {
9298 return graphql.Null
9299 }
9300 res := resTmp.(string)
9301 fc.Result = res
9302 return ec.marshalOString2string(ctx, field.Selections, res)
9303}
9304
9305func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9306 defer func() {
9307 if r := recover(); r != nil {
9308 ec.Error(ctx, ec.Recover(ctx, r))
9309 ret = graphql.Null
9310 }
9311 }()
9312 fc := &graphql.FieldContext{
9313 Object: "__EnumValue",
9314 Field: field,
9315 Args: nil,
9316 IsMethod: true,
9317 }
9318
9319 ctx = graphql.WithFieldContext(ctx, fc)
9320 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9321 ctx = rctx // use context from middleware stack in children
9322 return obj.IsDeprecated(), nil
9323 })
9324 if err != nil {
9325 ec.Error(ctx, err)
9326 return graphql.Null
9327 }
9328 if resTmp == nil {
9329 if !graphql.HasFieldError(ctx, fc) {
9330 ec.Errorf(ctx, "must not be null")
9331 }
9332 return graphql.Null
9333 }
9334 res := resTmp.(bool)
9335 fc.Result = res
9336 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9337}
9338
9339func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9340 defer func() {
9341 if r := recover(); r != nil {
9342 ec.Error(ctx, ec.Recover(ctx, r))
9343 ret = graphql.Null
9344 }
9345 }()
9346 fc := &graphql.FieldContext{
9347 Object: "__EnumValue",
9348 Field: field,
9349 Args: nil,
9350 IsMethod: true,
9351 }
9352
9353 ctx = graphql.WithFieldContext(ctx, fc)
9354 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9355 ctx = rctx // use context from middleware stack in children
9356 return obj.DeprecationReason(), nil
9357 })
9358 if err != nil {
9359 ec.Error(ctx, err)
9360 return graphql.Null
9361 }
9362 if resTmp == nil {
9363 return graphql.Null
9364 }
9365 res := resTmp.(*string)
9366 fc.Result = res
9367 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9368}
9369
9370func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9371 defer func() {
9372 if r := recover(); r != nil {
9373 ec.Error(ctx, ec.Recover(ctx, r))
9374 ret = graphql.Null
9375 }
9376 }()
9377 fc := &graphql.FieldContext{
9378 Object: "__Field",
9379 Field: field,
9380 Args: nil,
9381 IsMethod: false,
9382 }
9383
9384 ctx = graphql.WithFieldContext(ctx, fc)
9385 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9386 ctx = rctx // use context from middleware stack in children
9387 return obj.Name, nil
9388 })
9389 if err != nil {
9390 ec.Error(ctx, err)
9391 return graphql.Null
9392 }
9393 if resTmp == nil {
9394 if !graphql.HasFieldError(ctx, fc) {
9395 ec.Errorf(ctx, "must not be null")
9396 }
9397 return graphql.Null
9398 }
9399 res := resTmp.(string)
9400 fc.Result = res
9401 return ec.marshalNString2string(ctx, field.Selections, res)
9402}
9403
9404func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9405 defer func() {
9406 if r := recover(); r != nil {
9407 ec.Error(ctx, ec.Recover(ctx, r))
9408 ret = graphql.Null
9409 }
9410 }()
9411 fc := &graphql.FieldContext{
9412 Object: "__Field",
9413 Field: field,
9414 Args: nil,
9415 IsMethod: false,
9416 }
9417
9418 ctx = graphql.WithFieldContext(ctx, fc)
9419 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9420 ctx = rctx // use context from middleware stack in children
9421 return obj.Description, nil
9422 })
9423 if err != nil {
9424 ec.Error(ctx, err)
9425 return graphql.Null
9426 }
9427 if resTmp == nil {
9428 return graphql.Null
9429 }
9430 res := resTmp.(string)
9431 fc.Result = res
9432 return ec.marshalOString2string(ctx, field.Selections, res)
9433}
9434
9435func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9436 defer func() {
9437 if r := recover(); r != nil {
9438 ec.Error(ctx, ec.Recover(ctx, r))
9439 ret = graphql.Null
9440 }
9441 }()
9442 fc := &graphql.FieldContext{
9443 Object: "__Field",
9444 Field: field,
9445 Args: nil,
9446 IsMethod: false,
9447 }
9448
9449 ctx = graphql.WithFieldContext(ctx, fc)
9450 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9451 ctx = rctx // use context from middleware stack in children
9452 return obj.Args, nil
9453 })
9454 if err != nil {
9455 ec.Error(ctx, err)
9456 return graphql.Null
9457 }
9458 if resTmp == nil {
9459 if !graphql.HasFieldError(ctx, fc) {
9460 ec.Errorf(ctx, "must not be null")
9461 }
9462 return graphql.Null
9463 }
9464 res := resTmp.([]introspection.InputValue)
9465 fc.Result = res
9466 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
9467}
9468
9469func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9470 defer func() {
9471 if r := recover(); r != nil {
9472 ec.Error(ctx, ec.Recover(ctx, r))
9473 ret = graphql.Null
9474 }
9475 }()
9476 fc := &graphql.FieldContext{
9477 Object: "__Field",
9478 Field: field,
9479 Args: nil,
9480 IsMethod: false,
9481 }
9482
9483 ctx = graphql.WithFieldContext(ctx, fc)
9484 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9485 ctx = rctx // use context from middleware stack in children
9486 return obj.Type, nil
9487 })
9488 if err != nil {
9489 ec.Error(ctx, err)
9490 return graphql.Null
9491 }
9492 if resTmp == nil {
9493 if !graphql.HasFieldError(ctx, fc) {
9494 ec.Errorf(ctx, "must not be null")
9495 }
9496 return graphql.Null
9497 }
9498 res := resTmp.(*introspection.Type)
9499 fc.Result = res
9500 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9501}
9502
9503func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9504 defer func() {
9505 if r := recover(); r != nil {
9506 ec.Error(ctx, ec.Recover(ctx, r))
9507 ret = graphql.Null
9508 }
9509 }()
9510 fc := &graphql.FieldContext{
9511 Object: "__Field",
9512 Field: field,
9513 Args: nil,
9514 IsMethod: true,
9515 }
9516
9517 ctx = graphql.WithFieldContext(ctx, fc)
9518 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9519 ctx = rctx // use context from middleware stack in children
9520 return obj.IsDeprecated(), nil
9521 })
9522 if err != nil {
9523 ec.Error(ctx, err)
9524 return graphql.Null
9525 }
9526 if resTmp == nil {
9527 if !graphql.HasFieldError(ctx, fc) {
9528 ec.Errorf(ctx, "must not be null")
9529 }
9530 return graphql.Null
9531 }
9532 res := resTmp.(bool)
9533 fc.Result = res
9534 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9535}
9536
9537func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9538 defer func() {
9539 if r := recover(); r != nil {
9540 ec.Error(ctx, ec.Recover(ctx, r))
9541 ret = graphql.Null
9542 }
9543 }()
9544 fc := &graphql.FieldContext{
9545 Object: "__Field",
9546 Field: field,
9547 Args: nil,
9548 IsMethod: true,
9549 }
9550
9551 ctx = graphql.WithFieldContext(ctx, fc)
9552 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9553 ctx = rctx // use context from middleware stack in children
9554 return obj.DeprecationReason(), nil
9555 })
9556 if err != nil {
9557 ec.Error(ctx, err)
9558 return graphql.Null
9559 }
9560 if resTmp == nil {
9561 return graphql.Null
9562 }
9563 res := resTmp.(*string)
9564 fc.Result = res
9565 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9566}
9567
9568func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9569 defer func() {
9570 if r := recover(); r != nil {
9571 ec.Error(ctx, ec.Recover(ctx, r))
9572 ret = graphql.Null
9573 }
9574 }()
9575 fc := &graphql.FieldContext{
9576 Object: "__InputValue",
9577 Field: field,
9578 Args: nil,
9579 IsMethod: false,
9580 }
9581
9582 ctx = graphql.WithFieldContext(ctx, fc)
9583 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9584 ctx = rctx // use context from middleware stack in children
9585 return obj.Name, nil
9586 })
9587 if err != nil {
9588 ec.Error(ctx, err)
9589 return graphql.Null
9590 }
9591 if resTmp == nil {
9592 if !graphql.HasFieldError(ctx, fc) {
9593 ec.Errorf(ctx, "must not be null")
9594 }
9595 return graphql.Null
9596 }
9597 res := resTmp.(string)
9598 fc.Result = res
9599 return ec.marshalNString2string(ctx, field.Selections, res)
9600}
9601
9602func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9603 defer func() {
9604 if r := recover(); r != nil {
9605 ec.Error(ctx, ec.Recover(ctx, r))
9606 ret = graphql.Null
9607 }
9608 }()
9609 fc := &graphql.FieldContext{
9610 Object: "__InputValue",
9611 Field: field,
9612 Args: nil,
9613 IsMethod: false,
9614 }
9615
9616 ctx = graphql.WithFieldContext(ctx, fc)
9617 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9618 ctx = rctx // use context from middleware stack in children
9619 return obj.Description, nil
9620 })
9621 if err != nil {
9622 ec.Error(ctx, err)
9623 return graphql.Null
9624 }
9625 if resTmp == nil {
9626 return graphql.Null
9627 }
9628 res := resTmp.(string)
9629 fc.Result = res
9630 return ec.marshalOString2string(ctx, field.Selections, res)
9631}
9632
9633func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9634 defer func() {
9635 if r := recover(); r != nil {
9636 ec.Error(ctx, ec.Recover(ctx, r))
9637 ret = graphql.Null
9638 }
9639 }()
9640 fc := &graphql.FieldContext{
9641 Object: "__InputValue",
9642 Field: field,
9643 Args: nil,
9644 IsMethod: false,
9645 }
9646
9647 ctx = graphql.WithFieldContext(ctx, fc)
9648 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9649 ctx = rctx // use context from middleware stack in children
9650 return obj.Type, nil
9651 })
9652 if err != nil {
9653 ec.Error(ctx, err)
9654 return graphql.Null
9655 }
9656 if resTmp == nil {
9657 if !graphql.HasFieldError(ctx, fc) {
9658 ec.Errorf(ctx, "must not be null")
9659 }
9660 return graphql.Null
9661 }
9662 res := resTmp.(*introspection.Type)
9663 fc.Result = res
9664 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9665}
9666
9667func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9668 defer func() {
9669 if r := recover(); r != nil {
9670 ec.Error(ctx, ec.Recover(ctx, r))
9671 ret = graphql.Null
9672 }
9673 }()
9674 fc := &graphql.FieldContext{
9675 Object: "__InputValue",
9676 Field: field,
9677 Args: nil,
9678 IsMethod: false,
9679 }
9680
9681 ctx = graphql.WithFieldContext(ctx, fc)
9682 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9683 ctx = rctx // use context from middleware stack in children
9684 return obj.DefaultValue, nil
9685 })
9686 if err != nil {
9687 ec.Error(ctx, err)
9688 return graphql.Null
9689 }
9690 if resTmp == nil {
9691 return graphql.Null
9692 }
9693 res := resTmp.(*string)
9694 fc.Result = res
9695 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9696}
9697
9698func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
9699 defer func() {
9700 if r := recover(); r != nil {
9701 ec.Error(ctx, ec.Recover(ctx, r))
9702 ret = graphql.Null
9703 }
9704 }()
9705 fc := &graphql.FieldContext{
9706 Object: "__Schema",
9707 Field: field,
9708 Args: nil,
9709 IsMethod: true,
9710 }
9711
9712 ctx = graphql.WithFieldContext(ctx, fc)
9713 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9714 ctx = rctx // use context from middleware stack in children
9715 return obj.Types(), nil
9716 })
9717 if err != nil {
9718 ec.Error(ctx, err)
9719 return graphql.Null
9720 }
9721 if resTmp == nil {
9722 if !graphql.HasFieldError(ctx, fc) {
9723 ec.Errorf(ctx, "must not be null")
9724 }
9725 return graphql.Null
9726 }
9727 res := resTmp.([]introspection.Type)
9728 fc.Result = res
9729 return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
9730}
9731
9732func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
9733 defer func() {
9734 if r := recover(); r != nil {
9735 ec.Error(ctx, ec.Recover(ctx, r))
9736 ret = graphql.Null
9737 }
9738 }()
9739 fc := &graphql.FieldContext{
9740 Object: "__Schema",
9741 Field: field,
9742 Args: nil,
9743 IsMethod: true,
9744 }
9745
9746 ctx = graphql.WithFieldContext(ctx, fc)
9747 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9748 ctx = rctx // use context from middleware stack in children
9749 return obj.QueryType(), nil
9750 })
9751 if err != nil {
9752 ec.Error(ctx, err)
9753 return graphql.Null
9754 }
9755 if resTmp == nil {
9756 if !graphql.HasFieldError(ctx, fc) {
9757 ec.Errorf(ctx, "must not be null")
9758 }
9759 return graphql.Null
9760 }
9761 res := resTmp.(*introspection.Type)
9762 fc.Result = res
9763 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9764}
9765
9766func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
9767 defer func() {
9768 if r := recover(); r != nil {
9769 ec.Error(ctx, ec.Recover(ctx, r))
9770 ret = graphql.Null
9771 }
9772 }()
9773 fc := &graphql.FieldContext{
9774 Object: "__Schema",
9775 Field: field,
9776 Args: nil,
9777 IsMethod: true,
9778 }
9779
9780 ctx = graphql.WithFieldContext(ctx, fc)
9781 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9782 ctx = rctx // use context from middleware stack in children
9783 return obj.MutationType(), nil
9784 })
9785 if err != nil {
9786 ec.Error(ctx, err)
9787 return graphql.Null
9788 }
9789 if resTmp == nil {
9790 return graphql.Null
9791 }
9792 res := resTmp.(*introspection.Type)
9793 fc.Result = res
9794 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9795}
9796
9797func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
9798 defer func() {
9799 if r := recover(); r != nil {
9800 ec.Error(ctx, ec.Recover(ctx, r))
9801 ret = graphql.Null
9802 }
9803 }()
9804 fc := &graphql.FieldContext{
9805 Object: "__Schema",
9806 Field: field,
9807 Args: nil,
9808 IsMethod: true,
9809 }
9810
9811 ctx = graphql.WithFieldContext(ctx, fc)
9812 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9813 ctx = rctx // use context from middleware stack in children
9814 return obj.SubscriptionType(), nil
9815 })
9816 if err != nil {
9817 ec.Error(ctx, err)
9818 return graphql.Null
9819 }
9820 if resTmp == nil {
9821 return graphql.Null
9822 }
9823 res := resTmp.(*introspection.Type)
9824 fc.Result = res
9825 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9826}
9827
9828func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
9829 defer func() {
9830 if r := recover(); r != nil {
9831 ec.Error(ctx, ec.Recover(ctx, r))
9832 ret = graphql.Null
9833 }
9834 }()
9835 fc := &graphql.FieldContext{
9836 Object: "__Schema",
9837 Field: field,
9838 Args: nil,
9839 IsMethod: true,
9840 }
9841
9842 ctx = graphql.WithFieldContext(ctx, fc)
9843 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9844 ctx = rctx // use context from middleware stack in children
9845 return obj.Directives(), nil
9846 })
9847 if err != nil {
9848 ec.Error(ctx, err)
9849 return graphql.Null
9850 }
9851 if resTmp == nil {
9852 if !graphql.HasFieldError(ctx, fc) {
9853 ec.Errorf(ctx, "must not be null")
9854 }
9855 return graphql.Null
9856 }
9857 res := resTmp.([]introspection.Directive)
9858 fc.Result = res
9859 return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
9860}
9861
9862func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
9863 defer func() {
9864 if r := recover(); r != nil {
9865 ec.Error(ctx, ec.Recover(ctx, r))
9866 ret = graphql.Null
9867 }
9868 }()
9869 fc := &graphql.FieldContext{
9870 Object: "__Type",
9871 Field: field,
9872 Args: nil,
9873 IsMethod: true,
9874 }
9875
9876 ctx = graphql.WithFieldContext(ctx, fc)
9877 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9878 ctx = rctx // use context from middleware stack in children
9879 return obj.Kind(), nil
9880 })
9881 if err != nil {
9882 ec.Error(ctx, err)
9883 return graphql.Null
9884 }
9885 if resTmp == nil {
9886 if !graphql.HasFieldError(ctx, fc) {
9887 ec.Errorf(ctx, "must not be null")
9888 }
9889 return graphql.Null
9890 }
9891 res := resTmp.(string)
9892 fc.Result = res
9893 return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
9894}
9895
9896func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
9897 defer func() {
9898 if r := recover(); r != nil {
9899 ec.Error(ctx, ec.Recover(ctx, r))
9900 ret = graphql.Null
9901 }
9902 }()
9903 fc := &graphql.FieldContext{
9904 Object: "__Type",
9905 Field: field,
9906 Args: nil,
9907 IsMethod: true,
9908 }
9909
9910 ctx = graphql.WithFieldContext(ctx, fc)
9911 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9912 ctx = rctx // use context from middleware stack in children
9913 return obj.Name(), nil
9914 })
9915 if err != nil {
9916 ec.Error(ctx, err)
9917 return graphql.Null
9918 }
9919 if resTmp == nil {
9920 return graphql.Null
9921 }
9922 res := resTmp.(*string)
9923 fc.Result = res
9924 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9925}
9926
9927func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
9928 defer func() {
9929 if r := recover(); r != nil {
9930 ec.Error(ctx, ec.Recover(ctx, r))
9931 ret = graphql.Null
9932 }
9933 }()
9934 fc := &graphql.FieldContext{
9935 Object: "__Type",
9936 Field: field,
9937 Args: nil,
9938 IsMethod: true,
9939 }
9940
9941 ctx = graphql.WithFieldContext(ctx, fc)
9942 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9943 ctx = rctx // use context from middleware stack in children
9944 return obj.Description(), nil
9945 })
9946 if err != nil {
9947 ec.Error(ctx, err)
9948 return graphql.Null
9949 }
9950 if resTmp == nil {
9951 return graphql.Null
9952 }
9953 res := resTmp.(string)
9954 fc.Result = res
9955 return ec.marshalOString2string(ctx, field.Selections, res)
9956}
9957
9958func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
9959 defer func() {
9960 if r := recover(); r != nil {
9961 ec.Error(ctx, ec.Recover(ctx, r))
9962 ret = graphql.Null
9963 }
9964 }()
9965 fc := &graphql.FieldContext{
9966 Object: "__Type",
9967 Field: field,
9968 Args: nil,
9969 IsMethod: true,
9970 }
9971
9972 ctx = graphql.WithFieldContext(ctx, fc)
9973 rawArgs := field.ArgumentMap(ec.Variables)
9974 args, err := ec.field___Type_fields_args(ctx, rawArgs)
9975 if err != nil {
9976 ec.Error(ctx, err)
9977 return graphql.Null
9978 }
9979 fc.Args = args
9980 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9981 ctx = rctx // use context from middleware stack in children
9982 return obj.Fields(args["includeDeprecated"].(bool)), nil
9983 })
9984 if err != nil {
9985 ec.Error(ctx, err)
9986 return graphql.Null
9987 }
9988 if resTmp == nil {
9989 return graphql.Null
9990 }
9991 res := resTmp.([]introspection.Field)
9992 fc.Result = res
9993 return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
9994}
9995
9996func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
9997 defer func() {
9998 if r := recover(); r != nil {
9999 ec.Error(ctx, ec.Recover(ctx, r))
10000 ret = graphql.Null
10001 }
10002 }()
10003 fc := &graphql.FieldContext{
10004 Object: "__Type",
10005 Field: field,
10006 Args: nil,
10007 IsMethod: true,
10008 }
10009
10010 ctx = graphql.WithFieldContext(ctx, fc)
10011 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10012 ctx = rctx // use context from middleware stack in children
10013 return obj.Interfaces(), nil
10014 })
10015 if err != nil {
10016 ec.Error(ctx, err)
10017 return graphql.Null
10018 }
10019 if resTmp == nil {
10020 return graphql.Null
10021 }
10022 res := resTmp.([]introspection.Type)
10023 fc.Result = res
10024 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10025}
10026
10027func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10028 defer func() {
10029 if r := recover(); r != nil {
10030 ec.Error(ctx, ec.Recover(ctx, r))
10031 ret = graphql.Null
10032 }
10033 }()
10034 fc := &graphql.FieldContext{
10035 Object: "__Type",
10036 Field: field,
10037 Args: nil,
10038 IsMethod: true,
10039 }
10040
10041 ctx = graphql.WithFieldContext(ctx, fc)
10042 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10043 ctx = rctx // use context from middleware stack in children
10044 return obj.PossibleTypes(), nil
10045 })
10046 if err != nil {
10047 ec.Error(ctx, err)
10048 return graphql.Null
10049 }
10050 if resTmp == nil {
10051 return graphql.Null
10052 }
10053 res := resTmp.([]introspection.Type)
10054 fc.Result = res
10055 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10056}
10057
10058func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10059 defer func() {
10060 if r := recover(); r != nil {
10061 ec.Error(ctx, ec.Recover(ctx, r))
10062 ret = graphql.Null
10063 }
10064 }()
10065 fc := &graphql.FieldContext{
10066 Object: "__Type",
10067 Field: field,
10068 Args: nil,
10069 IsMethod: true,
10070 }
10071
10072 ctx = graphql.WithFieldContext(ctx, fc)
10073 rawArgs := field.ArgumentMap(ec.Variables)
10074 args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
10075 if err != nil {
10076 ec.Error(ctx, err)
10077 return graphql.Null
10078 }
10079 fc.Args = args
10080 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10081 ctx = rctx // use context from middleware stack in children
10082 return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10083 })
10084 if err != nil {
10085 ec.Error(ctx, err)
10086 return graphql.Null
10087 }
10088 if resTmp == nil {
10089 return graphql.Null
10090 }
10091 res := resTmp.([]introspection.EnumValue)
10092 fc.Result = res
10093 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
10094}
10095
10096func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10097 defer func() {
10098 if r := recover(); r != nil {
10099 ec.Error(ctx, ec.Recover(ctx, r))
10100 ret = graphql.Null
10101 }
10102 }()
10103 fc := &graphql.FieldContext{
10104 Object: "__Type",
10105 Field: field,
10106 Args: nil,
10107 IsMethod: true,
10108 }
10109
10110 ctx = graphql.WithFieldContext(ctx, fc)
10111 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10112 ctx = rctx // use context from middleware stack in children
10113 return obj.InputFields(), nil
10114 })
10115 if err != nil {
10116 ec.Error(ctx, err)
10117 return graphql.Null
10118 }
10119 if resTmp == nil {
10120 return graphql.Null
10121 }
10122 res := resTmp.([]introspection.InputValue)
10123 fc.Result = res
10124 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
10125}
10126
10127func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10128 defer func() {
10129 if r := recover(); r != nil {
10130 ec.Error(ctx, ec.Recover(ctx, r))
10131 ret = graphql.Null
10132 }
10133 }()
10134 fc := &graphql.FieldContext{
10135 Object: "__Type",
10136 Field: field,
10137 Args: nil,
10138 IsMethod: true,
10139 }
10140
10141 ctx = graphql.WithFieldContext(ctx, fc)
10142 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10143 ctx = rctx // use context from middleware stack in children
10144 return obj.OfType(), nil
10145 })
10146 if err != nil {
10147 ec.Error(ctx, err)
10148 return graphql.Null
10149 }
10150 if resTmp == nil {
10151 return graphql.Null
10152 }
10153 res := resTmp.(*introspection.Type)
10154 fc.Result = res
10155 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10156}
10157
10158// endregion **************************** field.gotpl *****************************
10159
10160// region **************************** input.gotpl *****************************
10161
10162func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
10163 var it models.AddCommentInput
10164 var asMap = obj.(map[string]interface{})
10165
10166 for k, v := range asMap {
10167 switch k {
10168 case "clientMutationId":
10169 var err error
10170 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10171 if err != nil {
10172 return it, err
10173 }
10174 case "repoRef":
10175 var err error
10176 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10177 if err != nil {
10178 return it, err
10179 }
10180 case "prefix":
10181 var err error
10182 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10183 if err != nil {
10184 return it, err
10185 }
10186 case "message":
10187 var err error
10188 it.Message, err = ec.unmarshalNString2string(ctx, v)
10189 if err != nil {
10190 return it, err
10191 }
10192 case "files":
10193 var err error
10194 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10195 if err != nil {
10196 return it, err
10197 }
10198 }
10199 }
10200
10201 return it, nil
10202}
10203
10204func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
10205 var it models.ChangeLabelInput
10206 var asMap = obj.(map[string]interface{})
10207
10208 for k, v := range asMap {
10209 switch k {
10210 case "clientMutationId":
10211 var err error
10212 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10213 if err != nil {
10214 return it, err
10215 }
10216 case "repoRef":
10217 var err error
10218 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10219 if err != nil {
10220 return it, err
10221 }
10222 case "prefix":
10223 var err error
10224 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10225 if err != nil {
10226 return it, err
10227 }
10228 case "added":
10229 var err error
10230 it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10231 if err != nil {
10232 return it, err
10233 }
10234 case "Removed":
10235 var err error
10236 it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10237 if err != nil {
10238 return it, err
10239 }
10240 }
10241 }
10242
10243 return it, nil
10244}
10245
10246func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
10247 var it models.CloseBugInput
10248 var asMap = obj.(map[string]interface{})
10249
10250 for k, v := range asMap {
10251 switch k {
10252 case "clientMutationId":
10253 var err error
10254 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10255 if err != nil {
10256 return it, err
10257 }
10258 case "repoRef":
10259 var err error
10260 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10261 if err != nil {
10262 return it, err
10263 }
10264 case "prefix":
10265 var err error
10266 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10267 if err != nil {
10268 return it, err
10269 }
10270 }
10271 }
10272
10273 return it, nil
10274}
10275
10276func (ec *executionContext) unmarshalInputCommitAsNeededInput(ctx context.Context, obj interface{}) (models.CommitAsNeededInput, error) {
10277 var it models.CommitAsNeededInput
10278 var asMap = obj.(map[string]interface{})
10279
10280 for k, v := range asMap {
10281 switch k {
10282 case "clientMutationId":
10283 var err error
10284 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10285 if err != nil {
10286 return it, err
10287 }
10288 case "repoRef":
10289 var err error
10290 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10291 if err != nil {
10292 return it, err
10293 }
10294 case "prefix":
10295 var err error
10296 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10297 if err != nil {
10298 return it, err
10299 }
10300 }
10301 }
10302
10303 return it, nil
10304}
10305
10306func (ec *executionContext) unmarshalInputCommitInput(ctx context.Context, obj interface{}) (models.CommitInput, error) {
10307 var it models.CommitInput
10308 var asMap = obj.(map[string]interface{})
10309
10310 for k, v := range asMap {
10311 switch k {
10312 case "clientMutationId":
10313 var err error
10314 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10315 if err != nil {
10316 return it, err
10317 }
10318 case "repoRef":
10319 var err error
10320 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10321 if err != nil {
10322 return it, err
10323 }
10324 case "prefix":
10325 var err error
10326 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10327 if err != nil {
10328 return it, err
10329 }
10330 }
10331 }
10332
10333 return it, nil
10334}
10335
10336func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
10337 var it models.NewBugInput
10338 var asMap = obj.(map[string]interface{})
10339
10340 for k, v := range asMap {
10341 switch k {
10342 case "clientMutationId":
10343 var err error
10344 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10345 if err != nil {
10346 return it, err
10347 }
10348 case "repoRef":
10349 var err error
10350 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10351 if err != nil {
10352 return it, err
10353 }
10354 case "title":
10355 var err error
10356 it.Title, err = ec.unmarshalNString2string(ctx, v)
10357 if err != nil {
10358 return it, err
10359 }
10360 case "message":
10361 var err error
10362 it.Message, err = ec.unmarshalNString2string(ctx, v)
10363 if err != nil {
10364 return it, err
10365 }
10366 case "files":
10367 var err error
10368 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10369 if err != nil {
10370 return it, err
10371 }
10372 }
10373 }
10374
10375 return it, nil
10376}
10377
10378func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10379 var it models.OpenBugInput
10380 var asMap = obj.(map[string]interface{})
10381
10382 for k, v := range asMap {
10383 switch k {
10384 case "clientMutationId":
10385 var err error
10386 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10387 if err != nil {
10388 return it, err
10389 }
10390 case "repoRef":
10391 var err error
10392 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10393 if err != nil {
10394 return it, err
10395 }
10396 case "prefix":
10397 var err error
10398 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10399 if err != nil {
10400 return it, err
10401 }
10402 }
10403 }
10404
10405 return it, nil
10406}
10407
10408func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10409 var it models.SetTitleInput
10410 var asMap = obj.(map[string]interface{})
10411
10412 for k, v := range asMap {
10413 switch k {
10414 case "clientMutationId":
10415 var err error
10416 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10417 if err != nil {
10418 return it, err
10419 }
10420 case "repoRef":
10421 var err error
10422 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10423 if err != nil {
10424 return it, err
10425 }
10426 case "prefix":
10427 var err error
10428 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10429 if err != nil {
10430 return it, err
10431 }
10432 case "title":
10433 var err error
10434 it.Title, err = ec.unmarshalNString2string(ctx, v)
10435 if err != nil {
10436 return it, err
10437 }
10438 }
10439 }
10440
10441 return it, nil
10442}
10443
10444// endregion **************************** input.gotpl *****************************
10445
10446// region ************************** interface.gotpl ***************************
10447
10448func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
10449 switch obj := (obj).(type) {
10450 case nil:
10451 return graphql.Null
10452 case bug.Comment:
10453 return ec._Comment(ctx, sel, &obj)
10454 case *bug.Comment:
10455 if obj == nil {
10456 return graphql.Null
10457 }
10458 return ec._Comment(ctx, sel, obj)
10459 case models.BugWrapper:
10460 if obj == nil {
10461 return graphql.Null
10462 }
10463 return ec._Bug(ctx, sel, obj)
10464 case *bug.CreateOperation:
10465 if obj == nil {
10466 return graphql.Null
10467 }
10468 return ec._CreateOperation(ctx, sel, obj)
10469 case *bug.SetTitleOperation:
10470 if obj == nil {
10471 return graphql.Null
10472 }
10473 return ec._SetTitleOperation(ctx, sel, obj)
10474 case *bug.AddCommentOperation:
10475 if obj == nil {
10476 return graphql.Null
10477 }
10478 return ec._AddCommentOperation(ctx, sel, obj)
10479 case *bug.EditCommentOperation:
10480 if obj == nil {
10481 return graphql.Null
10482 }
10483 return ec._EditCommentOperation(ctx, sel, obj)
10484 case *bug.SetStatusOperation:
10485 if obj == nil {
10486 return graphql.Null
10487 }
10488 return ec._SetStatusOperation(ctx, sel, obj)
10489 case *bug.LabelChangeOperation:
10490 if obj == nil {
10491 return graphql.Null
10492 }
10493 return ec._LabelChangeOperation(ctx, sel, obj)
10494 case *bug.CreateTimelineItem:
10495 if obj == nil {
10496 return graphql.Null
10497 }
10498 return ec._CreateTimelineItem(ctx, sel, obj)
10499 case *bug.AddCommentTimelineItem:
10500 if obj == nil {
10501 return graphql.Null
10502 }
10503 return ec._AddCommentTimelineItem(ctx, sel, obj)
10504 case *bug.LabelChangeTimelineItem:
10505 if obj == nil {
10506 return graphql.Null
10507 }
10508 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10509 case *bug.SetStatusTimelineItem:
10510 if obj == nil {
10511 return graphql.Null
10512 }
10513 return ec._SetStatusTimelineItem(ctx, sel, obj)
10514 case *bug.SetTitleTimelineItem:
10515 if obj == nil {
10516 return graphql.Null
10517 }
10518 return ec._SetTitleTimelineItem(ctx, sel, obj)
10519 default:
10520 panic(fmt.Errorf("unexpected type %T", obj))
10521 }
10522}
10523
10524func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
10525 switch obj := (obj).(type) {
10526 case nil:
10527 return graphql.Null
10528 case *bug.CreateOperation:
10529 if obj == nil {
10530 return graphql.Null
10531 }
10532 return ec._CreateOperation(ctx, sel, obj)
10533 case *bug.SetTitleOperation:
10534 if obj == nil {
10535 return graphql.Null
10536 }
10537 return ec._SetTitleOperation(ctx, sel, obj)
10538 case *bug.AddCommentOperation:
10539 if obj == nil {
10540 return graphql.Null
10541 }
10542 return ec._AddCommentOperation(ctx, sel, obj)
10543 case *bug.EditCommentOperation:
10544 if obj == nil {
10545 return graphql.Null
10546 }
10547 return ec._EditCommentOperation(ctx, sel, obj)
10548 case *bug.SetStatusOperation:
10549 if obj == nil {
10550 return graphql.Null
10551 }
10552 return ec._SetStatusOperation(ctx, sel, obj)
10553 case *bug.LabelChangeOperation:
10554 if obj == nil {
10555 return graphql.Null
10556 }
10557 return ec._LabelChangeOperation(ctx, sel, obj)
10558 default:
10559 panic(fmt.Errorf("unexpected type %T", obj))
10560 }
10561}
10562
10563func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
10564 switch obj := (obj).(type) {
10565 case nil:
10566 return graphql.Null
10567 case *bug.CreateTimelineItem:
10568 if obj == nil {
10569 return graphql.Null
10570 }
10571 return ec._CreateTimelineItem(ctx, sel, obj)
10572 case *bug.AddCommentTimelineItem:
10573 if obj == nil {
10574 return graphql.Null
10575 }
10576 return ec._AddCommentTimelineItem(ctx, sel, obj)
10577 case bug.LabelChangeTimelineItem:
10578 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10579 case *bug.LabelChangeTimelineItem:
10580 if obj == nil {
10581 return graphql.Null
10582 }
10583 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10584 case bug.SetStatusTimelineItem:
10585 return ec._SetStatusTimelineItem(ctx, sel, &obj)
10586 case *bug.SetStatusTimelineItem:
10587 if obj == nil {
10588 return graphql.Null
10589 }
10590 return ec._SetStatusTimelineItem(ctx, sel, obj)
10591 case bug.SetTitleTimelineItem:
10592 return ec._SetTitleTimelineItem(ctx, sel, &obj)
10593 case *bug.SetTitleTimelineItem:
10594 if obj == nil {
10595 return graphql.Null
10596 }
10597 return ec._SetTitleTimelineItem(ctx, sel, obj)
10598 default:
10599 panic(fmt.Errorf("unexpected type %T", obj))
10600 }
10601}
10602
10603// endregion ************************** interface.gotpl ***************************
10604
10605// region **************************** object.gotpl ****************************
10606
10607var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10608
10609func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10610 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
10611
10612 out := graphql.NewFieldSet(fields)
10613 var invalids uint32
10614 for i, field := range fields {
10615 switch field.Name {
10616 case "__typename":
10617 out.Values[i] = graphql.MarshalString("AddCommentOperation")
10618 case "id":
10619 field := field
10620 out.Concurrently(i, func() (res graphql.Marshaler) {
10621 defer func() {
10622 if r := recover(); r != nil {
10623 ec.Error(ctx, ec.Recover(ctx, r))
10624 }
10625 }()
10626 res = ec._AddCommentOperation_id(ctx, field, obj)
10627 if res == graphql.Null {
10628 atomic.AddUint32(&invalids, 1)
10629 }
10630 return res
10631 })
10632 case "author":
10633 field := field
10634 out.Concurrently(i, func() (res graphql.Marshaler) {
10635 defer func() {
10636 if r := recover(); r != nil {
10637 ec.Error(ctx, ec.Recover(ctx, r))
10638 }
10639 }()
10640 res = ec._AddCommentOperation_author(ctx, field, obj)
10641 if res == graphql.Null {
10642 atomic.AddUint32(&invalids, 1)
10643 }
10644 return res
10645 })
10646 case "date":
10647 field := field
10648 out.Concurrently(i, func() (res graphql.Marshaler) {
10649 defer func() {
10650 if r := recover(); r != nil {
10651 ec.Error(ctx, ec.Recover(ctx, r))
10652 }
10653 }()
10654 res = ec._AddCommentOperation_date(ctx, field, obj)
10655 if res == graphql.Null {
10656 atomic.AddUint32(&invalids, 1)
10657 }
10658 return res
10659 })
10660 case "message":
10661 out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10662 if out.Values[i] == graphql.Null {
10663 atomic.AddUint32(&invalids, 1)
10664 }
10665 case "files":
10666 out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10667 if out.Values[i] == graphql.Null {
10668 atomic.AddUint32(&invalids, 1)
10669 }
10670 default:
10671 panic("unknown field " + strconv.Quote(field.Name))
10672 }
10673 }
10674 out.Dispatch()
10675 if invalids > 0 {
10676 return graphql.Null
10677 }
10678 return out
10679}
10680
10681var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10682
10683func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10684 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
10685
10686 out := graphql.NewFieldSet(fields)
10687 var invalids uint32
10688 for i, field := range fields {
10689 switch field.Name {
10690 case "__typename":
10691 out.Values[i] = graphql.MarshalString("AddCommentPayload")
10692 case "clientMutationId":
10693 out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10694 case "bug":
10695 out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10696 if out.Values[i] == graphql.Null {
10697 invalids++
10698 }
10699 case "operation":
10700 out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10701 if out.Values[i] == graphql.Null {
10702 invalids++
10703 }
10704 default:
10705 panic("unknown field " + strconv.Quote(field.Name))
10706 }
10707 }
10708 out.Dispatch()
10709 if invalids > 0 {
10710 return graphql.Null
10711 }
10712 return out
10713}
10714
10715var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10716
10717func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10718 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
10719
10720 out := graphql.NewFieldSet(fields)
10721 var invalids uint32
10722 for i, field := range fields {
10723 switch field.Name {
10724 case "__typename":
10725 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10726 case "id":
10727 field := field
10728 out.Concurrently(i, func() (res graphql.Marshaler) {
10729 defer func() {
10730 if r := recover(); r != nil {
10731 ec.Error(ctx, ec.Recover(ctx, r))
10732 }
10733 }()
10734 res = ec._AddCommentTimelineItem_id(ctx, field, obj)
10735 if res == graphql.Null {
10736 atomic.AddUint32(&invalids, 1)
10737 }
10738 return res
10739 })
10740 case "author":
10741 field := field
10742 out.Concurrently(i, func() (res graphql.Marshaler) {
10743 defer func() {
10744 if r := recover(); r != nil {
10745 ec.Error(ctx, ec.Recover(ctx, r))
10746 }
10747 }()
10748 res = ec._AddCommentTimelineItem_author(ctx, field, obj)
10749 if res == graphql.Null {
10750 atomic.AddUint32(&invalids, 1)
10751 }
10752 return res
10753 })
10754 case "message":
10755 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
10756 if out.Values[i] == graphql.Null {
10757 atomic.AddUint32(&invalids, 1)
10758 }
10759 case "messageIsEmpty":
10760 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
10761 if out.Values[i] == graphql.Null {
10762 atomic.AddUint32(&invalids, 1)
10763 }
10764 case "files":
10765 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
10766 if out.Values[i] == graphql.Null {
10767 atomic.AddUint32(&invalids, 1)
10768 }
10769 case "createdAt":
10770 field := field
10771 out.Concurrently(i, func() (res graphql.Marshaler) {
10772 defer func() {
10773 if r := recover(); r != nil {
10774 ec.Error(ctx, ec.Recover(ctx, r))
10775 }
10776 }()
10777 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
10778 if res == graphql.Null {
10779 atomic.AddUint32(&invalids, 1)
10780 }
10781 return res
10782 })
10783 case "lastEdit":
10784 field := field
10785 out.Concurrently(i, func() (res graphql.Marshaler) {
10786 defer func() {
10787 if r := recover(); r != nil {
10788 ec.Error(ctx, ec.Recover(ctx, r))
10789 }
10790 }()
10791 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
10792 if res == graphql.Null {
10793 atomic.AddUint32(&invalids, 1)
10794 }
10795 return res
10796 })
10797 case "edited":
10798 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
10799 if out.Values[i] == graphql.Null {
10800 atomic.AddUint32(&invalids, 1)
10801 }
10802 case "history":
10803 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
10804 if out.Values[i] == graphql.Null {
10805 atomic.AddUint32(&invalids, 1)
10806 }
10807 default:
10808 panic("unknown field " + strconv.Quote(field.Name))
10809 }
10810 }
10811 out.Dispatch()
10812 if invalids > 0 {
10813 return graphql.Null
10814 }
10815 return out
10816}
10817
10818var bugImplementors = []string{"Bug", "Authored"}
10819
10820func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
10821 fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
10822
10823 out := graphql.NewFieldSet(fields)
10824 var invalids uint32
10825 for i, field := range fields {
10826 switch field.Name {
10827 case "__typename":
10828 out.Values[i] = graphql.MarshalString("Bug")
10829 case "id":
10830 field := field
10831 out.Concurrently(i, func() (res graphql.Marshaler) {
10832 defer func() {
10833 if r := recover(); r != nil {
10834 ec.Error(ctx, ec.Recover(ctx, r))
10835 }
10836 }()
10837 res = ec._Bug_id(ctx, field, obj)
10838 if res == graphql.Null {
10839 atomic.AddUint32(&invalids, 1)
10840 }
10841 return res
10842 })
10843 case "humanId":
10844 field := field
10845 out.Concurrently(i, func() (res graphql.Marshaler) {
10846 defer func() {
10847 if r := recover(); r != nil {
10848 ec.Error(ctx, ec.Recover(ctx, r))
10849 }
10850 }()
10851 res = ec._Bug_humanId(ctx, field, obj)
10852 if res == graphql.Null {
10853 atomic.AddUint32(&invalids, 1)
10854 }
10855 return res
10856 })
10857 case "status":
10858 field := field
10859 out.Concurrently(i, func() (res graphql.Marshaler) {
10860 defer func() {
10861 if r := recover(); r != nil {
10862 ec.Error(ctx, ec.Recover(ctx, r))
10863 }
10864 }()
10865 res = ec._Bug_status(ctx, field, obj)
10866 if res == graphql.Null {
10867 atomic.AddUint32(&invalids, 1)
10868 }
10869 return res
10870 })
10871 case "title":
10872 out.Values[i] = ec._Bug_title(ctx, field, obj)
10873 if out.Values[i] == graphql.Null {
10874 atomic.AddUint32(&invalids, 1)
10875 }
10876 case "labels":
10877 out.Values[i] = ec._Bug_labels(ctx, field, obj)
10878 if out.Values[i] == graphql.Null {
10879 atomic.AddUint32(&invalids, 1)
10880 }
10881 case "author":
10882 out.Values[i] = ec._Bug_author(ctx, field, obj)
10883 if out.Values[i] == graphql.Null {
10884 atomic.AddUint32(&invalids, 1)
10885 }
10886 case "createdAt":
10887 out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
10888 if out.Values[i] == graphql.Null {
10889 atomic.AddUint32(&invalids, 1)
10890 }
10891 case "lastEdit":
10892 out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
10893 if out.Values[i] == graphql.Null {
10894 atomic.AddUint32(&invalids, 1)
10895 }
10896 case "actors":
10897 field := field
10898 out.Concurrently(i, func() (res graphql.Marshaler) {
10899 defer func() {
10900 if r := recover(); r != nil {
10901 ec.Error(ctx, ec.Recover(ctx, r))
10902 }
10903 }()
10904 res = ec._Bug_actors(ctx, field, obj)
10905 if res == graphql.Null {
10906 atomic.AddUint32(&invalids, 1)
10907 }
10908 return res
10909 })
10910 case "participants":
10911 field := field
10912 out.Concurrently(i, func() (res graphql.Marshaler) {
10913 defer func() {
10914 if r := recover(); r != nil {
10915 ec.Error(ctx, ec.Recover(ctx, r))
10916 }
10917 }()
10918 res = ec._Bug_participants(ctx, field, obj)
10919 if res == graphql.Null {
10920 atomic.AddUint32(&invalids, 1)
10921 }
10922 return res
10923 })
10924 case "comments":
10925 field := field
10926 out.Concurrently(i, func() (res graphql.Marshaler) {
10927 defer func() {
10928 if r := recover(); r != nil {
10929 ec.Error(ctx, ec.Recover(ctx, r))
10930 }
10931 }()
10932 res = ec._Bug_comments(ctx, field, obj)
10933 if res == graphql.Null {
10934 atomic.AddUint32(&invalids, 1)
10935 }
10936 return res
10937 })
10938 case "timeline":
10939 field := field
10940 out.Concurrently(i, func() (res graphql.Marshaler) {
10941 defer func() {
10942 if r := recover(); r != nil {
10943 ec.Error(ctx, ec.Recover(ctx, r))
10944 }
10945 }()
10946 res = ec._Bug_timeline(ctx, field, obj)
10947 if res == graphql.Null {
10948 atomic.AddUint32(&invalids, 1)
10949 }
10950 return res
10951 })
10952 case "operations":
10953 field := field
10954 out.Concurrently(i, func() (res graphql.Marshaler) {
10955 defer func() {
10956 if r := recover(); r != nil {
10957 ec.Error(ctx, ec.Recover(ctx, r))
10958 }
10959 }()
10960 res = ec._Bug_operations(ctx, field, obj)
10961 if res == graphql.Null {
10962 atomic.AddUint32(&invalids, 1)
10963 }
10964 return res
10965 })
10966 default:
10967 panic("unknown field " + strconv.Quote(field.Name))
10968 }
10969 }
10970 out.Dispatch()
10971 if invalids > 0 {
10972 return graphql.Null
10973 }
10974 return out
10975}
10976
10977var bugConnectionImplementors = []string{"BugConnection"}
10978
10979func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
10980 fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
10981
10982 out := graphql.NewFieldSet(fields)
10983 var invalids uint32
10984 for i, field := range fields {
10985 switch field.Name {
10986 case "__typename":
10987 out.Values[i] = graphql.MarshalString("BugConnection")
10988 case "edges":
10989 out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
10990 if out.Values[i] == graphql.Null {
10991 invalids++
10992 }
10993 case "nodes":
10994 out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
10995 if out.Values[i] == graphql.Null {
10996 invalids++
10997 }
10998 case "pageInfo":
10999 out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
11000 if out.Values[i] == graphql.Null {
11001 invalids++
11002 }
11003 case "totalCount":
11004 out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
11005 if out.Values[i] == graphql.Null {
11006 invalids++
11007 }
11008 default:
11009 panic("unknown field " + strconv.Quote(field.Name))
11010 }
11011 }
11012 out.Dispatch()
11013 if invalids > 0 {
11014 return graphql.Null
11015 }
11016 return out
11017}
11018
11019var bugEdgeImplementors = []string{"BugEdge"}
11020
11021func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
11022 fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
11023
11024 out := graphql.NewFieldSet(fields)
11025 var invalids uint32
11026 for i, field := range fields {
11027 switch field.Name {
11028 case "__typename":
11029 out.Values[i] = graphql.MarshalString("BugEdge")
11030 case "cursor":
11031 out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
11032 if out.Values[i] == graphql.Null {
11033 invalids++
11034 }
11035 case "node":
11036 out.Values[i] = ec._BugEdge_node(ctx, field, obj)
11037 if out.Values[i] == graphql.Null {
11038 invalids++
11039 }
11040 default:
11041 panic("unknown field " + strconv.Quote(field.Name))
11042 }
11043 }
11044 out.Dispatch()
11045 if invalids > 0 {
11046 return graphql.Null
11047 }
11048 return out
11049}
11050
11051var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
11052
11053func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
11054 fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
11055
11056 out := graphql.NewFieldSet(fields)
11057 var invalids uint32
11058 for i, field := range fields {
11059 switch field.Name {
11060 case "__typename":
11061 out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
11062 case "clientMutationId":
11063 out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
11064 case "bug":
11065 out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
11066 if out.Values[i] == graphql.Null {
11067 invalids++
11068 }
11069 case "operation":
11070 out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
11071 if out.Values[i] == graphql.Null {
11072 invalids++
11073 }
11074 case "results":
11075 out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
11076 if out.Values[i] == graphql.Null {
11077 invalids++
11078 }
11079 default:
11080 panic("unknown field " + strconv.Quote(field.Name))
11081 }
11082 }
11083 out.Dispatch()
11084 if invalids > 0 {
11085 return graphql.Null
11086 }
11087 return out
11088}
11089
11090var closeBugPayloadImplementors = []string{"CloseBugPayload"}
11091
11092func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11093 fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
11094
11095 out := graphql.NewFieldSet(fields)
11096 var invalids uint32
11097 for i, field := range fields {
11098 switch field.Name {
11099 case "__typename":
11100 out.Values[i] = graphql.MarshalString("CloseBugPayload")
11101 case "clientMutationId":
11102 out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11103 case "bug":
11104 out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11105 if out.Values[i] == graphql.Null {
11106 invalids++
11107 }
11108 case "operation":
11109 out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11110 if out.Values[i] == graphql.Null {
11111 invalids++
11112 }
11113 default:
11114 panic("unknown field " + strconv.Quote(field.Name))
11115 }
11116 }
11117 out.Dispatch()
11118 if invalids > 0 {
11119 return graphql.Null
11120 }
11121 return out
11122}
11123
11124var colorImplementors = []string{"Color"}
11125
11126func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11127 fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
11128
11129 out := graphql.NewFieldSet(fields)
11130 var invalids uint32
11131 for i, field := range fields {
11132 switch field.Name {
11133 case "__typename":
11134 out.Values[i] = graphql.MarshalString("Color")
11135 case "R":
11136 field := field
11137 out.Concurrently(i, func() (res graphql.Marshaler) {
11138 defer func() {
11139 if r := recover(); r != nil {
11140 ec.Error(ctx, ec.Recover(ctx, r))
11141 }
11142 }()
11143 res = ec._Color_R(ctx, field, obj)
11144 if res == graphql.Null {
11145 atomic.AddUint32(&invalids, 1)
11146 }
11147 return res
11148 })
11149 case "G":
11150 field := field
11151 out.Concurrently(i, func() (res graphql.Marshaler) {
11152 defer func() {
11153 if r := recover(); r != nil {
11154 ec.Error(ctx, ec.Recover(ctx, r))
11155 }
11156 }()
11157 res = ec._Color_G(ctx, field, obj)
11158 if res == graphql.Null {
11159 atomic.AddUint32(&invalids, 1)
11160 }
11161 return res
11162 })
11163 case "B":
11164 field := field
11165 out.Concurrently(i, func() (res graphql.Marshaler) {
11166 defer func() {
11167 if r := recover(); r != nil {
11168 ec.Error(ctx, ec.Recover(ctx, r))
11169 }
11170 }()
11171 res = ec._Color_B(ctx, field, obj)
11172 if res == graphql.Null {
11173 atomic.AddUint32(&invalids, 1)
11174 }
11175 return res
11176 })
11177 default:
11178 panic("unknown field " + strconv.Quote(field.Name))
11179 }
11180 }
11181 out.Dispatch()
11182 if invalids > 0 {
11183 return graphql.Null
11184 }
11185 return out
11186}
11187
11188var commentImplementors = []string{"Comment", "Authored"}
11189
11190func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11191 fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
11192
11193 out := graphql.NewFieldSet(fields)
11194 var invalids uint32
11195 for i, field := range fields {
11196 switch field.Name {
11197 case "__typename":
11198 out.Values[i] = graphql.MarshalString("Comment")
11199 case "author":
11200 field := field
11201 out.Concurrently(i, func() (res graphql.Marshaler) {
11202 defer func() {
11203 if r := recover(); r != nil {
11204 ec.Error(ctx, ec.Recover(ctx, r))
11205 }
11206 }()
11207 res = ec._Comment_author(ctx, field, obj)
11208 if res == graphql.Null {
11209 atomic.AddUint32(&invalids, 1)
11210 }
11211 return res
11212 })
11213 case "message":
11214 out.Values[i] = ec._Comment_message(ctx, field, obj)
11215 if out.Values[i] == graphql.Null {
11216 atomic.AddUint32(&invalids, 1)
11217 }
11218 case "files":
11219 out.Values[i] = ec._Comment_files(ctx, field, obj)
11220 if out.Values[i] == graphql.Null {
11221 atomic.AddUint32(&invalids, 1)
11222 }
11223 default:
11224 panic("unknown field " + strconv.Quote(field.Name))
11225 }
11226 }
11227 out.Dispatch()
11228 if invalids > 0 {
11229 return graphql.Null
11230 }
11231 return out
11232}
11233
11234var commentConnectionImplementors = []string{"CommentConnection"}
11235
11236func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11237 fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
11238
11239 out := graphql.NewFieldSet(fields)
11240 var invalids uint32
11241 for i, field := range fields {
11242 switch field.Name {
11243 case "__typename":
11244 out.Values[i] = graphql.MarshalString("CommentConnection")
11245 case "edges":
11246 out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11247 if out.Values[i] == graphql.Null {
11248 invalids++
11249 }
11250 case "nodes":
11251 out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11252 if out.Values[i] == graphql.Null {
11253 invalids++
11254 }
11255 case "pageInfo":
11256 out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11257 if out.Values[i] == graphql.Null {
11258 invalids++
11259 }
11260 case "totalCount":
11261 out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11262 if out.Values[i] == graphql.Null {
11263 invalids++
11264 }
11265 default:
11266 panic("unknown field " + strconv.Quote(field.Name))
11267 }
11268 }
11269 out.Dispatch()
11270 if invalids > 0 {
11271 return graphql.Null
11272 }
11273 return out
11274}
11275
11276var commentEdgeImplementors = []string{"CommentEdge"}
11277
11278func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11279 fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
11280
11281 out := graphql.NewFieldSet(fields)
11282 var invalids uint32
11283 for i, field := range fields {
11284 switch field.Name {
11285 case "__typename":
11286 out.Values[i] = graphql.MarshalString("CommentEdge")
11287 case "cursor":
11288 out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11289 if out.Values[i] == graphql.Null {
11290 invalids++
11291 }
11292 case "node":
11293 out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11294 if out.Values[i] == graphql.Null {
11295 invalids++
11296 }
11297 default:
11298 panic("unknown field " + strconv.Quote(field.Name))
11299 }
11300 }
11301 out.Dispatch()
11302 if invalids > 0 {
11303 return graphql.Null
11304 }
11305 return out
11306}
11307
11308var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11309
11310func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11311 fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
11312
11313 out := graphql.NewFieldSet(fields)
11314 var invalids uint32
11315 for i, field := range fields {
11316 switch field.Name {
11317 case "__typename":
11318 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11319 case "message":
11320 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11321 if out.Values[i] == graphql.Null {
11322 atomic.AddUint32(&invalids, 1)
11323 }
11324 case "date":
11325 field := field
11326 out.Concurrently(i, func() (res graphql.Marshaler) {
11327 defer func() {
11328 if r := recover(); r != nil {
11329 ec.Error(ctx, ec.Recover(ctx, r))
11330 }
11331 }()
11332 res = ec._CommentHistoryStep_date(ctx, field, obj)
11333 if res == graphql.Null {
11334 atomic.AddUint32(&invalids, 1)
11335 }
11336 return res
11337 })
11338 default:
11339 panic("unknown field " + strconv.Quote(field.Name))
11340 }
11341 }
11342 out.Dispatch()
11343 if invalids > 0 {
11344 return graphql.Null
11345 }
11346 return out
11347}
11348
11349var commitAsNeededPayloadImplementors = []string{"CommitAsNeededPayload"}
11350
11351func (ec *executionContext) _CommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitAsNeededPayload) graphql.Marshaler {
11352 fields := graphql.CollectFields(ec.OperationContext, sel, commitAsNeededPayloadImplementors)
11353
11354 out := graphql.NewFieldSet(fields)
11355 var invalids uint32
11356 for i, field := range fields {
11357 switch field.Name {
11358 case "__typename":
11359 out.Values[i] = graphql.MarshalString("CommitAsNeededPayload")
11360 case "clientMutationId":
11361 out.Values[i] = ec._CommitAsNeededPayload_clientMutationId(ctx, field, obj)
11362 case "bug":
11363 out.Values[i] = ec._CommitAsNeededPayload_bug(ctx, field, obj)
11364 if out.Values[i] == graphql.Null {
11365 invalids++
11366 }
11367 default:
11368 panic("unknown field " + strconv.Quote(field.Name))
11369 }
11370 }
11371 out.Dispatch()
11372 if invalids > 0 {
11373 return graphql.Null
11374 }
11375 return out
11376}
11377
11378var commitPayloadImplementors = []string{"CommitPayload"}
11379
11380func (ec *executionContext) _CommitPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitPayload) graphql.Marshaler {
11381 fields := graphql.CollectFields(ec.OperationContext, sel, commitPayloadImplementors)
11382
11383 out := graphql.NewFieldSet(fields)
11384 var invalids uint32
11385 for i, field := range fields {
11386 switch field.Name {
11387 case "__typename":
11388 out.Values[i] = graphql.MarshalString("CommitPayload")
11389 case "clientMutationId":
11390 out.Values[i] = ec._CommitPayload_clientMutationId(ctx, field, obj)
11391 case "bug":
11392 out.Values[i] = ec._CommitPayload_bug(ctx, field, obj)
11393 if out.Values[i] == graphql.Null {
11394 invalids++
11395 }
11396 default:
11397 panic("unknown field " + strconv.Quote(field.Name))
11398 }
11399 }
11400 out.Dispatch()
11401 if invalids > 0 {
11402 return graphql.Null
11403 }
11404 return out
11405}
11406
11407var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11408
11409func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11410 fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
11411
11412 out := graphql.NewFieldSet(fields)
11413 var invalids uint32
11414 for i, field := range fields {
11415 switch field.Name {
11416 case "__typename":
11417 out.Values[i] = graphql.MarshalString("CreateOperation")
11418 case "id":
11419 field := field
11420 out.Concurrently(i, func() (res graphql.Marshaler) {
11421 defer func() {
11422 if r := recover(); r != nil {
11423 ec.Error(ctx, ec.Recover(ctx, r))
11424 }
11425 }()
11426 res = ec._CreateOperation_id(ctx, field, obj)
11427 if res == graphql.Null {
11428 atomic.AddUint32(&invalids, 1)
11429 }
11430 return res
11431 })
11432 case "author":
11433 field := field
11434 out.Concurrently(i, func() (res graphql.Marshaler) {
11435 defer func() {
11436 if r := recover(); r != nil {
11437 ec.Error(ctx, ec.Recover(ctx, r))
11438 }
11439 }()
11440 res = ec._CreateOperation_author(ctx, field, obj)
11441 if res == graphql.Null {
11442 atomic.AddUint32(&invalids, 1)
11443 }
11444 return res
11445 })
11446 case "date":
11447 field := field
11448 out.Concurrently(i, func() (res graphql.Marshaler) {
11449 defer func() {
11450 if r := recover(); r != nil {
11451 ec.Error(ctx, ec.Recover(ctx, r))
11452 }
11453 }()
11454 res = ec._CreateOperation_date(ctx, field, obj)
11455 if res == graphql.Null {
11456 atomic.AddUint32(&invalids, 1)
11457 }
11458 return res
11459 })
11460 case "title":
11461 out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11462 if out.Values[i] == graphql.Null {
11463 atomic.AddUint32(&invalids, 1)
11464 }
11465 case "message":
11466 out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11467 if out.Values[i] == graphql.Null {
11468 atomic.AddUint32(&invalids, 1)
11469 }
11470 case "files":
11471 out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11472 if out.Values[i] == graphql.Null {
11473 atomic.AddUint32(&invalids, 1)
11474 }
11475 default:
11476 panic("unknown field " + strconv.Quote(field.Name))
11477 }
11478 }
11479 out.Dispatch()
11480 if invalids > 0 {
11481 return graphql.Null
11482 }
11483 return out
11484}
11485
11486var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11487
11488func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11489 fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
11490
11491 out := graphql.NewFieldSet(fields)
11492 var invalids uint32
11493 for i, field := range fields {
11494 switch field.Name {
11495 case "__typename":
11496 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11497 case "id":
11498 field := field
11499 out.Concurrently(i, func() (res graphql.Marshaler) {
11500 defer func() {
11501 if r := recover(); r != nil {
11502 ec.Error(ctx, ec.Recover(ctx, r))
11503 }
11504 }()
11505 res = ec._CreateTimelineItem_id(ctx, field, obj)
11506 if res == graphql.Null {
11507 atomic.AddUint32(&invalids, 1)
11508 }
11509 return res
11510 })
11511 case "author":
11512 field := field
11513 out.Concurrently(i, func() (res graphql.Marshaler) {
11514 defer func() {
11515 if r := recover(); r != nil {
11516 ec.Error(ctx, ec.Recover(ctx, r))
11517 }
11518 }()
11519 res = ec._CreateTimelineItem_author(ctx, field, obj)
11520 if res == graphql.Null {
11521 atomic.AddUint32(&invalids, 1)
11522 }
11523 return res
11524 })
11525 case "message":
11526 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11527 if out.Values[i] == graphql.Null {
11528 atomic.AddUint32(&invalids, 1)
11529 }
11530 case "messageIsEmpty":
11531 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11532 if out.Values[i] == graphql.Null {
11533 atomic.AddUint32(&invalids, 1)
11534 }
11535 case "files":
11536 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11537 if out.Values[i] == graphql.Null {
11538 atomic.AddUint32(&invalids, 1)
11539 }
11540 case "createdAt":
11541 field := field
11542 out.Concurrently(i, func() (res graphql.Marshaler) {
11543 defer func() {
11544 if r := recover(); r != nil {
11545 ec.Error(ctx, ec.Recover(ctx, r))
11546 }
11547 }()
11548 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11549 if res == graphql.Null {
11550 atomic.AddUint32(&invalids, 1)
11551 }
11552 return res
11553 })
11554 case "lastEdit":
11555 field := field
11556 out.Concurrently(i, func() (res graphql.Marshaler) {
11557 defer func() {
11558 if r := recover(); r != nil {
11559 ec.Error(ctx, ec.Recover(ctx, r))
11560 }
11561 }()
11562 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11563 if res == graphql.Null {
11564 atomic.AddUint32(&invalids, 1)
11565 }
11566 return res
11567 })
11568 case "edited":
11569 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11570 if out.Values[i] == graphql.Null {
11571 atomic.AddUint32(&invalids, 1)
11572 }
11573 case "history":
11574 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11575 if out.Values[i] == graphql.Null {
11576 atomic.AddUint32(&invalids, 1)
11577 }
11578 default:
11579 panic("unknown field " + strconv.Quote(field.Name))
11580 }
11581 }
11582 out.Dispatch()
11583 if invalids > 0 {
11584 return graphql.Null
11585 }
11586 return out
11587}
11588
11589var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11590
11591func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11592 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
11593
11594 out := graphql.NewFieldSet(fields)
11595 var invalids uint32
11596 for i, field := range fields {
11597 switch field.Name {
11598 case "__typename":
11599 out.Values[i] = graphql.MarshalString("EditCommentOperation")
11600 case "id":
11601 field := field
11602 out.Concurrently(i, func() (res graphql.Marshaler) {
11603 defer func() {
11604 if r := recover(); r != nil {
11605 ec.Error(ctx, ec.Recover(ctx, r))
11606 }
11607 }()
11608 res = ec._EditCommentOperation_id(ctx, field, obj)
11609 if res == graphql.Null {
11610 atomic.AddUint32(&invalids, 1)
11611 }
11612 return res
11613 })
11614 case "author":
11615 field := field
11616 out.Concurrently(i, func() (res graphql.Marshaler) {
11617 defer func() {
11618 if r := recover(); r != nil {
11619 ec.Error(ctx, ec.Recover(ctx, r))
11620 }
11621 }()
11622 res = ec._EditCommentOperation_author(ctx, field, obj)
11623 if res == graphql.Null {
11624 atomic.AddUint32(&invalids, 1)
11625 }
11626 return res
11627 })
11628 case "date":
11629 field := field
11630 out.Concurrently(i, func() (res graphql.Marshaler) {
11631 defer func() {
11632 if r := recover(); r != nil {
11633 ec.Error(ctx, ec.Recover(ctx, r))
11634 }
11635 }()
11636 res = ec._EditCommentOperation_date(ctx, field, obj)
11637 if res == graphql.Null {
11638 atomic.AddUint32(&invalids, 1)
11639 }
11640 return res
11641 })
11642 case "target":
11643 field := field
11644 out.Concurrently(i, func() (res graphql.Marshaler) {
11645 defer func() {
11646 if r := recover(); r != nil {
11647 ec.Error(ctx, ec.Recover(ctx, r))
11648 }
11649 }()
11650 res = ec._EditCommentOperation_target(ctx, field, obj)
11651 if res == graphql.Null {
11652 atomic.AddUint32(&invalids, 1)
11653 }
11654 return res
11655 })
11656 case "message":
11657 out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11658 if out.Values[i] == graphql.Null {
11659 atomic.AddUint32(&invalids, 1)
11660 }
11661 case "files":
11662 out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11663 if out.Values[i] == graphql.Null {
11664 atomic.AddUint32(&invalids, 1)
11665 }
11666 default:
11667 panic("unknown field " + strconv.Quote(field.Name))
11668 }
11669 }
11670 out.Dispatch()
11671 if invalids > 0 {
11672 return graphql.Null
11673 }
11674 return out
11675}
11676
11677var identityImplementors = []string{"Identity"}
11678
11679func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
11680 fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
11681
11682 out := graphql.NewFieldSet(fields)
11683 var invalids uint32
11684 for i, field := range fields {
11685 switch field.Name {
11686 case "__typename":
11687 out.Values[i] = graphql.MarshalString("Identity")
11688 case "id":
11689 field := field
11690 out.Concurrently(i, func() (res graphql.Marshaler) {
11691 defer func() {
11692 if r := recover(); r != nil {
11693 ec.Error(ctx, ec.Recover(ctx, r))
11694 }
11695 }()
11696 res = ec._Identity_id(ctx, field, obj)
11697 if res == graphql.Null {
11698 atomic.AddUint32(&invalids, 1)
11699 }
11700 return res
11701 })
11702 case "humanId":
11703 field := field
11704 out.Concurrently(i, func() (res graphql.Marshaler) {
11705 defer func() {
11706 if r := recover(); r != nil {
11707 ec.Error(ctx, ec.Recover(ctx, r))
11708 }
11709 }()
11710 res = ec._Identity_humanId(ctx, field, obj)
11711 if res == graphql.Null {
11712 atomic.AddUint32(&invalids, 1)
11713 }
11714 return res
11715 })
11716 case "name":
11717 out.Values[i] = ec._Identity_name(ctx, field, obj)
11718 case "email":
11719 out.Values[i] = ec._Identity_email(ctx, field, obj)
11720 case "displayName":
11721 out.Values[i] = ec._Identity_displayName(ctx, field, obj)
11722 if out.Values[i] == graphql.Null {
11723 atomic.AddUint32(&invalids, 1)
11724 }
11725 case "avatarUrl":
11726 out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
11727 case "isProtected":
11728 out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
11729 if out.Values[i] == graphql.Null {
11730 atomic.AddUint32(&invalids, 1)
11731 }
11732 default:
11733 panic("unknown field " + strconv.Quote(field.Name))
11734 }
11735 }
11736 out.Dispatch()
11737 if invalids > 0 {
11738 return graphql.Null
11739 }
11740 return out
11741}
11742
11743var identityConnectionImplementors = []string{"IdentityConnection"}
11744
11745func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
11746 fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
11747
11748 out := graphql.NewFieldSet(fields)
11749 var invalids uint32
11750 for i, field := range fields {
11751 switch field.Name {
11752 case "__typename":
11753 out.Values[i] = graphql.MarshalString("IdentityConnection")
11754 case "edges":
11755 out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
11756 if out.Values[i] == graphql.Null {
11757 invalids++
11758 }
11759 case "nodes":
11760 out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
11761 if out.Values[i] == graphql.Null {
11762 invalids++
11763 }
11764 case "pageInfo":
11765 out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
11766 if out.Values[i] == graphql.Null {
11767 invalids++
11768 }
11769 case "totalCount":
11770 out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
11771 if out.Values[i] == graphql.Null {
11772 invalids++
11773 }
11774 default:
11775 panic("unknown field " + strconv.Quote(field.Name))
11776 }
11777 }
11778 out.Dispatch()
11779 if invalids > 0 {
11780 return graphql.Null
11781 }
11782 return out
11783}
11784
11785var identityEdgeImplementors = []string{"IdentityEdge"}
11786
11787func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
11788 fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
11789
11790 out := graphql.NewFieldSet(fields)
11791 var invalids uint32
11792 for i, field := range fields {
11793 switch field.Name {
11794 case "__typename":
11795 out.Values[i] = graphql.MarshalString("IdentityEdge")
11796 case "cursor":
11797 out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
11798 if out.Values[i] == graphql.Null {
11799 invalids++
11800 }
11801 case "node":
11802 out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
11803 if out.Values[i] == graphql.Null {
11804 invalids++
11805 }
11806 default:
11807 panic("unknown field " + strconv.Quote(field.Name))
11808 }
11809 }
11810 out.Dispatch()
11811 if invalids > 0 {
11812 return graphql.Null
11813 }
11814 return out
11815}
11816
11817var labelImplementors = []string{"Label"}
11818
11819func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
11820 fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
11821
11822 out := graphql.NewFieldSet(fields)
11823 var invalids uint32
11824 for i, field := range fields {
11825 switch field.Name {
11826 case "__typename":
11827 out.Values[i] = graphql.MarshalString("Label")
11828 case "name":
11829 field := field
11830 out.Concurrently(i, func() (res graphql.Marshaler) {
11831 defer func() {
11832 if r := recover(); r != nil {
11833 ec.Error(ctx, ec.Recover(ctx, r))
11834 }
11835 }()
11836 res = ec._Label_name(ctx, field, obj)
11837 if res == graphql.Null {
11838 atomic.AddUint32(&invalids, 1)
11839 }
11840 return res
11841 })
11842 case "color":
11843 field := field
11844 out.Concurrently(i, func() (res graphql.Marshaler) {
11845 defer func() {
11846 if r := recover(); r != nil {
11847 ec.Error(ctx, ec.Recover(ctx, r))
11848 }
11849 }()
11850 res = ec._Label_color(ctx, field, obj)
11851 if res == graphql.Null {
11852 atomic.AddUint32(&invalids, 1)
11853 }
11854 return res
11855 })
11856 default:
11857 panic("unknown field " + strconv.Quote(field.Name))
11858 }
11859 }
11860 out.Dispatch()
11861 if invalids > 0 {
11862 return graphql.Null
11863 }
11864 return out
11865}
11866
11867var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
11868
11869func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
11870 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
11871
11872 out := graphql.NewFieldSet(fields)
11873 var invalids uint32
11874 for i, field := range fields {
11875 switch field.Name {
11876 case "__typename":
11877 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
11878 case "id":
11879 field := field
11880 out.Concurrently(i, func() (res graphql.Marshaler) {
11881 defer func() {
11882 if r := recover(); r != nil {
11883 ec.Error(ctx, ec.Recover(ctx, r))
11884 }
11885 }()
11886 res = ec._LabelChangeOperation_id(ctx, field, obj)
11887 if res == graphql.Null {
11888 atomic.AddUint32(&invalids, 1)
11889 }
11890 return res
11891 })
11892 case "author":
11893 field := field
11894 out.Concurrently(i, func() (res graphql.Marshaler) {
11895 defer func() {
11896 if r := recover(); r != nil {
11897 ec.Error(ctx, ec.Recover(ctx, r))
11898 }
11899 }()
11900 res = ec._LabelChangeOperation_author(ctx, field, obj)
11901 if res == graphql.Null {
11902 atomic.AddUint32(&invalids, 1)
11903 }
11904 return res
11905 })
11906 case "date":
11907 field := field
11908 out.Concurrently(i, func() (res graphql.Marshaler) {
11909 defer func() {
11910 if r := recover(); r != nil {
11911 ec.Error(ctx, ec.Recover(ctx, r))
11912 }
11913 }()
11914 res = ec._LabelChangeOperation_date(ctx, field, obj)
11915 if res == graphql.Null {
11916 atomic.AddUint32(&invalids, 1)
11917 }
11918 return res
11919 })
11920 case "added":
11921 out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
11922 if out.Values[i] == graphql.Null {
11923 atomic.AddUint32(&invalids, 1)
11924 }
11925 case "removed":
11926 out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
11927 if out.Values[i] == graphql.Null {
11928 atomic.AddUint32(&invalids, 1)
11929 }
11930 default:
11931 panic("unknown field " + strconv.Quote(field.Name))
11932 }
11933 }
11934 out.Dispatch()
11935 if invalids > 0 {
11936 return graphql.Null
11937 }
11938 return out
11939}
11940
11941var labelChangeResultImplementors = []string{"LabelChangeResult"}
11942
11943func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
11944 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
11945
11946 out := graphql.NewFieldSet(fields)
11947 var invalids uint32
11948 for i, field := range fields {
11949 switch field.Name {
11950 case "__typename":
11951 out.Values[i] = graphql.MarshalString("LabelChangeResult")
11952 case "label":
11953 out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
11954 if out.Values[i] == graphql.Null {
11955 atomic.AddUint32(&invalids, 1)
11956 }
11957 case "status":
11958 field := field
11959 out.Concurrently(i, func() (res graphql.Marshaler) {
11960 defer func() {
11961 if r := recover(); r != nil {
11962 ec.Error(ctx, ec.Recover(ctx, r))
11963 }
11964 }()
11965 res = ec._LabelChangeResult_status(ctx, field, obj)
11966 if res == graphql.Null {
11967 atomic.AddUint32(&invalids, 1)
11968 }
11969 return res
11970 })
11971 default:
11972 panic("unknown field " + strconv.Quote(field.Name))
11973 }
11974 }
11975 out.Dispatch()
11976 if invalids > 0 {
11977 return graphql.Null
11978 }
11979 return out
11980}
11981
11982var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
11983
11984func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
11985 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
11986
11987 out := graphql.NewFieldSet(fields)
11988 var invalids uint32
11989 for i, field := range fields {
11990 switch field.Name {
11991 case "__typename":
11992 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
11993 case "id":
11994 field := field
11995 out.Concurrently(i, func() (res graphql.Marshaler) {
11996 defer func() {
11997 if r := recover(); r != nil {
11998 ec.Error(ctx, ec.Recover(ctx, r))
11999 }
12000 }()
12001 res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
12002 if res == graphql.Null {
12003 atomic.AddUint32(&invalids, 1)
12004 }
12005 return res
12006 })
12007 case "author":
12008 field := field
12009 out.Concurrently(i, func() (res graphql.Marshaler) {
12010 defer func() {
12011 if r := recover(); r != nil {
12012 ec.Error(ctx, ec.Recover(ctx, r))
12013 }
12014 }()
12015 res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
12016 if res == graphql.Null {
12017 atomic.AddUint32(&invalids, 1)
12018 }
12019 return res
12020 })
12021 case "date":
12022 field := field
12023 out.Concurrently(i, func() (res graphql.Marshaler) {
12024 defer func() {
12025 if r := recover(); r != nil {
12026 ec.Error(ctx, ec.Recover(ctx, r))
12027 }
12028 }()
12029 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
12030 if res == graphql.Null {
12031 atomic.AddUint32(&invalids, 1)
12032 }
12033 return res
12034 })
12035 case "added":
12036 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
12037 if out.Values[i] == graphql.Null {
12038 atomic.AddUint32(&invalids, 1)
12039 }
12040 case "removed":
12041 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
12042 if out.Values[i] == graphql.Null {
12043 atomic.AddUint32(&invalids, 1)
12044 }
12045 default:
12046 panic("unknown field " + strconv.Quote(field.Name))
12047 }
12048 }
12049 out.Dispatch()
12050 if invalids > 0 {
12051 return graphql.Null
12052 }
12053 return out
12054}
12055
12056var labelConnectionImplementors = []string{"LabelConnection"}
12057
12058func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
12059 fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
12060
12061 out := graphql.NewFieldSet(fields)
12062 var invalids uint32
12063 for i, field := range fields {
12064 switch field.Name {
12065 case "__typename":
12066 out.Values[i] = graphql.MarshalString("LabelConnection")
12067 case "edges":
12068 out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
12069 if out.Values[i] == graphql.Null {
12070 invalids++
12071 }
12072 case "nodes":
12073 out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
12074 if out.Values[i] == graphql.Null {
12075 invalids++
12076 }
12077 case "pageInfo":
12078 out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
12079 if out.Values[i] == graphql.Null {
12080 invalids++
12081 }
12082 case "totalCount":
12083 out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
12084 if out.Values[i] == graphql.Null {
12085 invalids++
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 labelEdgeImplementors = []string{"LabelEdge"}
12099
12100func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
12101 fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
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("LabelEdge")
12109 case "cursor":
12110 out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
12111 if out.Values[i] == graphql.Null {
12112 invalids++
12113 }
12114 case "node":
12115 out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
12116 if out.Values[i] == graphql.Null {
12117 invalids++
12118 }
12119 default:
12120 panic("unknown field " + strconv.Quote(field.Name))
12121 }
12122 }
12123 out.Dispatch()
12124 if invalids > 0 {
12125 return graphql.Null
12126 }
12127 return out
12128}
12129
12130var mutationImplementors = []string{"Mutation"}
12131
12132func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12133 fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
12134
12135 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12136 Object: "Mutation",
12137 })
12138
12139 out := graphql.NewFieldSet(fields)
12140 var invalids uint32
12141 for i, field := range fields {
12142 switch field.Name {
12143 case "__typename":
12144 out.Values[i] = graphql.MarshalString("Mutation")
12145 case "newBug":
12146 out.Values[i] = ec._Mutation_newBug(ctx, field)
12147 if out.Values[i] == graphql.Null {
12148 invalids++
12149 }
12150 case "addComment":
12151 out.Values[i] = ec._Mutation_addComment(ctx, field)
12152 if out.Values[i] == graphql.Null {
12153 invalids++
12154 }
12155 case "changeLabels":
12156 out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12157 if out.Values[i] == graphql.Null {
12158 invalids++
12159 }
12160 case "openBug":
12161 out.Values[i] = ec._Mutation_openBug(ctx, field)
12162 if out.Values[i] == graphql.Null {
12163 invalids++
12164 }
12165 case "closeBug":
12166 out.Values[i] = ec._Mutation_closeBug(ctx, field)
12167 if out.Values[i] == graphql.Null {
12168 invalids++
12169 }
12170 case "setTitle":
12171 out.Values[i] = ec._Mutation_setTitle(ctx, field)
12172 if out.Values[i] == graphql.Null {
12173 invalids++
12174 }
12175 case "commit":
12176 out.Values[i] = ec._Mutation_commit(ctx, field)
12177 if out.Values[i] == graphql.Null {
12178 invalids++
12179 }
12180 case "commitAsNeeded":
12181 out.Values[i] = ec._Mutation_commitAsNeeded(ctx, field)
12182 if out.Values[i] == graphql.Null {
12183 invalids++
12184 }
12185 default:
12186 panic("unknown field " + strconv.Quote(field.Name))
12187 }
12188 }
12189 out.Dispatch()
12190 if invalids > 0 {
12191 return graphql.Null
12192 }
12193 return out
12194}
12195
12196var newBugPayloadImplementors = []string{"NewBugPayload"}
12197
12198func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12199 fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
12200
12201 out := graphql.NewFieldSet(fields)
12202 var invalids uint32
12203 for i, field := range fields {
12204 switch field.Name {
12205 case "__typename":
12206 out.Values[i] = graphql.MarshalString("NewBugPayload")
12207 case "clientMutationId":
12208 out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12209 case "bug":
12210 out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12211 if out.Values[i] == graphql.Null {
12212 invalids++
12213 }
12214 case "operation":
12215 out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
12216 if out.Values[i] == graphql.Null {
12217 invalids++
12218 }
12219 default:
12220 panic("unknown field " + strconv.Quote(field.Name))
12221 }
12222 }
12223 out.Dispatch()
12224 if invalids > 0 {
12225 return graphql.Null
12226 }
12227 return out
12228}
12229
12230var openBugPayloadImplementors = []string{"OpenBugPayload"}
12231
12232func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12233 fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
12234
12235 out := graphql.NewFieldSet(fields)
12236 var invalids uint32
12237 for i, field := range fields {
12238 switch field.Name {
12239 case "__typename":
12240 out.Values[i] = graphql.MarshalString("OpenBugPayload")
12241 case "clientMutationId":
12242 out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12243 case "bug":
12244 out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12245 if out.Values[i] == graphql.Null {
12246 invalids++
12247 }
12248 case "operation":
12249 out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12250 if out.Values[i] == graphql.Null {
12251 invalids++
12252 }
12253 default:
12254 panic("unknown field " + strconv.Quote(field.Name))
12255 }
12256 }
12257 out.Dispatch()
12258 if invalids > 0 {
12259 return graphql.Null
12260 }
12261 return out
12262}
12263
12264var operationConnectionImplementors = []string{"OperationConnection"}
12265
12266func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12267 fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
12268
12269 out := graphql.NewFieldSet(fields)
12270 var invalids uint32
12271 for i, field := range fields {
12272 switch field.Name {
12273 case "__typename":
12274 out.Values[i] = graphql.MarshalString("OperationConnection")
12275 case "edges":
12276 out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12277 if out.Values[i] == graphql.Null {
12278 invalids++
12279 }
12280 case "nodes":
12281 out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12282 if out.Values[i] == graphql.Null {
12283 invalids++
12284 }
12285 case "pageInfo":
12286 out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12287 if out.Values[i] == graphql.Null {
12288 invalids++
12289 }
12290 case "totalCount":
12291 out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12292 if out.Values[i] == graphql.Null {
12293 invalids++
12294 }
12295 default:
12296 panic("unknown field " + strconv.Quote(field.Name))
12297 }
12298 }
12299 out.Dispatch()
12300 if invalids > 0 {
12301 return graphql.Null
12302 }
12303 return out
12304}
12305
12306var operationEdgeImplementors = []string{"OperationEdge"}
12307
12308func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12309 fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
12310
12311 out := graphql.NewFieldSet(fields)
12312 var invalids uint32
12313 for i, field := range fields {
12314 switch field.Name {
12315 case "__typename":
12316 out.Values[i] = graphql.MarshalString("OperationEdge")
12317 case "cursor":
12318 out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12319 if out.Values[i] == graphql.Null {
12320 invalids++
12321 }
12322 case "node":
12323 out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12324 if out.Values[i] == graphql.Null {
12325 invalids++
12326 }
12327 default:
12328 panic("unknown field " + strconv.Quote(field.Name))
12329 }
12330 }
12331 out.Dispatch()
12332 if invalids > 0 {
12333 return graphql.Null
12334 }
12335 return out
12336}
12337
12338var pageInfoImplementors = []string{"PageInfo"}
12339
12340func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12341 fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
12342
12343 out := graphql.NewFieldSet(fields)
12344 var invalids uint32
12345 for i, field := range fields {
12346 switch field.Name {
12347 case "__typename":
12348 out.Values[i] = graphql.MarshalString("PageInfo")
12349 case "hasNextPage":
12350 out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12351 if out.Values[i] == graphql.Null {
12352 invalids++
12353 }
12354 case "hasPreviousPage":
12355 out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12356 if out.Values[i] == graphql.Null {
12357 invalids++
12358 }
12359 case "startCursor":
12360 out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12361 if out.Values[i] == graphql.Null {
12362 invalids++
12363 }
12364 case "endCursor":
12365 out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12366 if out.Values[i] == graphql.Null {
12367 invalids++
12368 }
12369 default:
12370 panic("unknown field " + strconv.Quote(field.Name))
12371 }
12372 }
12373 out.Dispatch()
12374 if invalids > 0 {
12375 return graphql.Null
12376 }
12377 return out
12378}
12379
12380var queryImplementors = []string{"Query"}
12381
12382func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12383 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
12384
12385 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12386 Object: "Query",
12387 })
12388
12389 out := graphql.NewFieldSet(fields)
12390 var invalids uint32
12391 for i, field := range fields {
12392 switch field.Name {
12393 case "__typename":
12394 out.Values[i] = graphql.MarshalString("Query")
12395 case "defaultRepository":
12396 field := field
12397 out.Concurrently(i, func() (res graphql.Marshaler) {
12398 defer func() {
12399 if r := recover(); r != nil {
12400 ec.Error(ctx, ec.Recover(ctx, r))
12401 }
12402 }()
12403 res = ec._Query_defaultRepository(ctx, field)
12404 return res
12405 })
12406 case "repository":
12407 field := field
12408 out.Concurrently(i, func() (res graphql.Marshaler) {
12409 defer func() {
12410 if r := recover(); r != nil {
12411 ec.Error(ctx, ec.Recover(ctx, r))
12412 }
12413 }()
12414 res = ec._Query_repository(ctx, field)
12415 return res
12416 })
12417 case "__type":
12418 out.Values[i] = ec._Query___type(ctx, field)
12419 case "__schema":
12420 out.Values[i] = ec._Query___schema(ctx, field)
12421 default:
12422 panic("unknown field " + strconv.Quote(field.Name))
12423 }
12424 }
12425 out.Dispatch()
12426 if invalids > 0 {
12427 return graphql.Null
12428 }
12429 return out
12430}
12431
12432var repositoryImplementors = []string{"Repository"}
12433
12434func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
12435 fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
12436
12437 out := graphql.NewFieldSet(fields)
12438 var invalids uint32
12439 for i, field := range fields {
12440 switch field.Name {
12441 case "__typename":
12442 out.Values[i] = graphql.MarshalString("Repository")
12443 case "allBugs":
12444 field := field
12445 out.Concurrently(i, func() (res graphql.Marshaler) {
12446 defer func() {
12447 if r := recover(); r != nil {
12448 ec.Error(ctx, ec.Recover(ctx, r))
12449 }
12450 }()
12451 res = ec._Repository_allBugs(ctx, field, obj)
12452 if res == graphql.Null {
12453 atomic.AddUint32(&invalids, 1)
12454 }
12455 return res
12456 })
12457 case "bug":
12458 field := field
12459 out.Concurrently(i, func() (res graphql.Marshaler) {
12460 defer func() {
12461 if r := recover(); r != nil {
12462 ec.Error(ctx, ec.Recover(ctx, r))
12463 }
12464 }()
12465 res = ec._Repository_bug(ctx, field, obj)
12466 return res
12467 })
12468 case "allIdentities":
12469 field := field
12470 out.Concurrently(i, func() (res graphql.Marshaler) {
12471 defer func() {
12472 if r := recover(); r != nil {
12473 ec.Error(ctx, ec.Recover(ctx, r))
12474 }
12475 }()
12476 res = ec._Repository_allIdentities(ctx, field, obj)
12477 if res == graphql.Null {
12478 atomic.AddUint32(&invalids, 1)
12479 }
12480 return res
12481 })
12482 case "identity":
12483 field := field
12484 out.Concurrently(i, func() (res graphql.Marshaler) {
12485 defer func() {
12486 if r := recover(); r != nil {
12487 ec.Error(ctx, ec.Recover(ctx, r))
12488 }
12489 }()
12490 res = ec._Repository_identity(ctx, field, obj)
12491 return res
12492 })
12493 case "userIdentity":
12494 field := field
12495 out.Concurrently(i, func() (res graphql.Marshaler) {
12496 defer func() {
12497 if r := recover(); r != nil {
12498 ec.Error(ctx, ec.Recover(ctx, r))
12499 }
12500 }()
12501 res = ec._Repository_userIdentity(ctx, field, obj)
12502 return res
12503 })
12504 case "validLabels":
12505 field := field
12506 out.Concurrently(i, func() (res graphql.Marshaler) {
12507 defer func() {
12508 if r := recover(); r != nil {
12509 ec.Error(ctx, ec.Recover(ctx, r))
12510 }
12511 }()
12512 res = ec._Repository_validLabels(ctx, field, obj)
12513 if res == graphql.Null {
12514 atomic.AddUint32(&invalids, 1)
12515 }
12516 return res
12517 })
12518 default:
12519 panic("unknown field " + strconv.Quote(field.Name))
12520 }
12521 }
12522 out.Dispatch()
12523 if invalids > 0 {
12524 return graphql.Null
12525 }
12526 return out
12527}
12528
12529var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12530
12531func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12532 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
12533
12534 out := graphql.NewFieldSet(fields)
12535 var invalids uint32
12536 for i, field := range fields {
12537 switch field.Name {
12538 case "__typename":
12539 out.Values[i] = graphql.MarshalString("SetStatusOperation")
12540 case "id":
12541 field := field
12542 out.Concurrently(i, func() (res graphql.Marshaler) {
12543 defer func() {
12544 if r := recover(); r != nil {
12545 ec.Error(ctx, ec.Recover(ctx, r))
12546 }
12547 }()
12548 res = ec._SetStatusOperation_id(ctx, field, obj)
12549 if res == graphql.Null {
12550 atomic.AddUint32(&invalids, 1)
12551 }
12552 return res
12553 })
12554 case "author":
12555 field := field
12556 out.Concurrently(i, func() (res graphql.Marshaler) {
12557 defer func() {
12558 if r := recover(); r != nil {
12559 ec.Error(ctx, ec.Recover(ctx, r))
12560 }
12561 }()
12562 res = ec._SetStatusOperation_author(ctx, field, obj)
12563 if res == graphql.Null {
12564 atomic.AddUint32(&invalids, 1)
12565 }
12566 return res
12567 })
12568 case "date":
12569 field := field
12570 out.Concurrently(i, func() (res graphql.Marshaler) {
12571 defer func() {
12572 if r := recover(); r != nil {
12573 ec.Error(ctx, ec.Recover(ctx, r))
12574 }
12575 }()
12576 res = ec._SetStatusOperation_date(ctx, field, obj)
12577 if res == graphql.Null {
12578 atomic.AddUint32(&invalids, 1)
12579 }
12580 return res
12581 })
12582 case "status":
12583 field := field
12584 out.Concurrently(i, func() (res graphql.Marshaler) {
12585 defer func() {
12586 if r := recover(); r != nil {
12587 ec.Error(ctx, ec.Recover(ctx, r))
12588 }
12589 }()
12590 res = ec._SetStatusOperation_status(ctx, field, obj)
12591 if res == graphql.Null {
12592 atomic.AddUint32(&invalids, 1)
12593 }
12594 return res
12595 })
12596 default:
12597 panic("unknown field " + strconv.Quote(field.Name))
12598 }
12599 }
12600 out.Dispatch()
12601 if invalids > 0 {
12602 return graphql.Null
12603 }
12604 return out
12605}
12606
12607var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12608
12609func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12610 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
12611
12612 out := graphql.NewFieldSet(fields)
12613 var invalids uint32
12614 for i, field := range fields {
12615 switch field.Name {
12616 case "__typename":
12617 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12618 case "id":
12619 field := field
12620 out.Concurrently(i, func() (res graphql.Marshaler) {
12621 defer func() {
12622 if r := recover(); r != nil {
12623 ec.Error(ctx, ec.Recover(ctx, r))
12624 }
12625 }()
12626 res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12627 if res == graphql.Null {
12628 atomic.AddUint32(&invalids, 1)
12629 }
12630 return res
12631 })
12632 case "author":
12633 field := field
12634 out.Concurrently(i, func() (res graphql.Marshaler) {
12635 defer func() {
12636 if r := recover(); r != nil {
12637 ec.Error(ctx, ec.Recover(ctx, r))
12638 }
12639 }()
12640 res = ec._SetStatusTimelineItem_author(ctx, field, obj)
12641 if res == graphql.Null {
12642 atomic.AddUint32(&invalids, 1)
12643 }
12644 return res
12645 })
12646 case "date":
12647 field := field
12648 out.Concurrently(i, func() (res graphql.Marshaler) {
12649 defer func() {
12650 if r := recover(); r != nil {
12651 ec.Error(ctx, ec.Recover(ctx, r))
12652 }
12653 }()
12654 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12655 if res == graphql.Null {
12656 atomic.AddUint32(&invalids, 1)
12657 }
12658 return res
12659 })
12660 case "status":
12661 field := field
12662 out.Concurrently(i, func() (res graphql.Marshaler) {
12663 defer func() {
12664 if r := recover(); r != nil {
12665 ec.Error(ctx, ec.Recover(ctx, r))
12666 }
12667 }()
12668 res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12669 if res == graphql.Null {
12670 atomic.AddUint32(&invalids, 1)
12671 }
12672 return res
12673 })
12674 default:
12675 panic("unknown field " + strconv.Quote(field.Name))
12676 }
12677 }
12678 out.Dispatch()
12679 if invalids > 0 {
12680 return graphql.Null
12681 }
12682 return out
12683}
12684
12685var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12686
12687func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12688 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
12689
12690 out := graphql.NewFieldSet(fields)
12691 var invalids uint32
12692 for i, field := range fields {
12693 switch field.Name {
12694 case "__typename":
12695 out.Values[i] = graphql.MarshalString("SetTitleOperation")
12696 case "id":
12697 field := field
12698 out.Concurrently(i, func() (res graphql.Marshaler) {
12699 defer func() {
12700 if r := recover(); r != nil {
12701 ec.Error(ctx, ec.Recover(ctx, r))
12702 }
12703 }()
12704 res = ec._SetTitleOperation_id(ctx, field, obj)
12705 if res == graphql.Null {
12706 atomic.AddUint32(&invalids, 1)
12707 }
12708 return res
12709 })
12710 case "author":
12711 field := field
12712 out.Concurrently(i, func() (res graphql.Marshaler) {
12713 defer func() {
12714 if r := recover(); r != nil {
12715 ec.Error(ctx, ec.Recover(ctx, r))
12716 }
12717 }()
12718 res = ec._SetTitleOperation_author(ctx, field, obj)
12719 if res == graphql.Null {
12720 atomic.AddUint32(&invalids, 1)
12721 }
12722 return res
12723 })
12724 case "date":
12725 field := field
12726 out.Concurrently(i, func() (res graphql.Marshaler) {
12727 defer func() {
12728 if r := recover(); r != nil {
12729 ec.Error(ctx, ec.Recover(ctx, r))
12730 }
12731 }()
12732 res = ec._SetTitleOperation_date(ctx, field, obj)
12733 if res == graphql.Null {
12734 atomic.AddUint32(&invalids, 1)
12735 }
12736 return res
12737 })
12738 case "title":
12739 out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12740 if out.Values[i] == graphql.Null {
12741 atomic.AddUint32(&invalids, 1)
12742 }
12743 case "was":
12744 out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12745 if out.Values[i] == graphql.Null {
12746 atomic.AddUint32(&invalids, 1)
12747 }
12748 default:
12749 panic("unknown field " + strconv.Quote(field.Name))
12750 }
12751 }
12752 out.Dispatch()
12753 if invalids > 0 {
12754 return graphql.Null
12755 }
12756 return out
12757}
12758
12759var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12760
12761func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12762 fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
12763
12764 out := graphql.NewFieldSet(fields)
12765 var invalids uint32
12766 for i, field := range fields {
12767 switch field.Name {
12768 case "__typename":
12769 out.Values[i] = graphql.MarshalString("SetTitlePayload")
12770 case "clientMutationId":
12771 out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
12772 case "bug":
12773 out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
12774 if out.Values[i] == graphql.Null {
12775 invalids++
12776 }
12777 case "operation":
12778 out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
12779 if out.Values[i] == graphql.Null {
12780 invalids++
12781 }
12782 default:
12783 panic("unknown field " + strconv.Quote(field.Name))
12784 }
12785 }
12786 out.Dispatch()
12787 if invalids > 0 {
12788 return graphql.Null
12789 }
12790 return out
12791}
12792
12793var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
12794
12795func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
12796 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
12797
12798 out := graphql.NewFieldSet(fields)
12799 var invalids uint32
12800 for i, field := range fields {
12801 switch field.Name {
12802 case "__typename":
12803 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
12804 case "id":
12805 field := field
12806 out.Concurrently(i, func() (res graphql.Marshaler) {
12807 defer func() {
12808 if r := recover(); r != nil {
12809 ec.Error(ctx, ec.Recover(ctx, r))
12810 }
12811 }()
12812 res = ec._SetTitleTimelineItem_id(ctx, field, obj)
12813 if res == graphql.Null {
12814 atomic.AddUint32(&invalids, 1)
12815 }
12816 return res
12817 })
12818 case "author":
12819 field := field
12820 out.Concurrently(i, func() (res graphql.Marshaler) {
12821 defer func() {
12822 if r := recover(); r != nil {
12823 ec.Error(ctx, ec.Recover(ctx, r))
12824 }
12825 }()
12826 res = ec._SetTitleTimelineItem_author(ctx, field, obj)
12827 if res == graphql.Null {
12828 atomic.AddUint32(&invalids, 1)
12829 }
12830 return res
12831 })
12832 case "date":
12833 field := field
12834 out.Concurrently(i, func() (res graphql.Marshaler) {
12835 defer func() {
12836 if r := recover(); r != nil {
12837 ec.Error(ctx, ec.Recover(ctx, r))
12838 }
12839 }()
12840 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
12841 if res == graphql.Null {
12842 atomic.AddUint32(&invalids, 1)
12843 }
12844 return res
12845 })
12846 case "title":
12847 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
12848 if out.Values[i] == graphql.Null {
12849 atomic.AddUint32(&invalids, 1)
12850 }
12851 case "was":
12852 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
12853 if out.Values[i] == graphql.Null {
12854 atomic.AddUint32(&invalids, 1)
12855 }
12856 default:
12857 panic("unknown field " + strconv.Quote(field.Name))
12858 }
12859 }
12860 out.Dispatch()
12861 if invalids > 0 {
12862 return graphql.Null
12863 }
12864 return out
12865}
12866
12867var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
12868
12869func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
12870 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
12871
12872 out := graphql.NewFieldSet(fields)
12873 var invalids uint32
12874 for i, field := range fields {
12875 switch field.Name {
12876 case "__typename":
12877 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
12878 case "edges":
12879 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
12880 if out.Values[i] == graphql.Null {
12881 invalids++
12882 }
12883 case "nodes":
12884 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
12885 if out.Values[i] == graphql.Null {
12886 invalids++
12887 }
12888 case "pageInfo":
12889 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
12890 if out.Values[i] == graphql.Null {
12891 invalids++
12892 }
12893 case "totalCount":
12894 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
12895 if out.Values[i] == graphql.Null {
12896 invalids++
12897 }
12898 default:
12899 panic("unknown field " + strconv.Quote(field.Name))
12900 }
12901 }
12902 out.Dispatch()
12903 if invalids > 0 {
12904 return graphql.Null
12905 }
12906 return out
12907}
12908
12909var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
12910
12911func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
12912 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
12913
12914 out := graphql.NewFieldSet(fields)
12915 var invalids uint32
12916 for i, field := range fields {
12917 switch field.Name {
12918 case "__typename":
12919 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
12920 case "cursor":
12921 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
12922 if out.Values[i] == graphql.Null {
12923 invalids++
12924 }
12925 case "node":
12926 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
12927 if out.Values[i] == graphql.Null {
12928 invalids++
12929 }
12930 default:
12931 panic("unknown field " + strconv.Quote(field.Name))
12932 }
12933 }
12934 out.Dispatch()
12935 if invalids > 0 {
12936 return graphql.Null
12937 }
12938 return out
12939}
12940
12941var __DirectiveImplementors = []string{"__Directive"}
12942
12943func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
12944 fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
12945
12946 out := graphql.NewFieldSet(fields)
12947 var invalids uint32
12948 for i, field := range fields {
12949 switch field.Name {
12950 case "__typename":
12951 out.Values[i] = graphql.MarshalString("__Directive")
12952 case "name":
12953 out.Values[i] = ec.___Directive_name(ctx, field, obj)
12954 if out.Values[i] == graphql.Null {
12955 invalids++
12956 }
12957 case "description":
12958 out.Values[i] = ec.___Directive_description(ctx, field, obj)
12959 case "locations":
12960 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
12961 if out.Values[i] == graphql.Null {
12962 invalids++
12963 }
12964 case "args":
12965 out.Values[i] = ec.___Directive_args(ctx, field, obj)
12966 if out.Values[i] == graphql.Null {
12967 invalids++
12968 }
12969 default:
12970 panic("unknown field " + strconv.Quote(field.Name))
12971 }
12972 }
12973 out.Dispatch()
12974 if invalids > 0 {
12975 return graphql.Null
12976 }
12977 return out
12978}
12979
12980var __EnumValueImplementors = []string{"__EnumValue"}
12981
12982func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
12983 fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
12984
12985 out := graphql.NewFieldSet(fields)
12986 var invalids uint32
12987 for i, field := range fields {
12988 switch field.Name {
12989 case "__typename":
12990 out.Values[i] = graphql.MarshalString("__EnumValue")
12991 case "name":
12992 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
12993 if out.Values[i] == graphql.Null {
12994 invalids++
12995 }
12996 case "description":
12997 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
12998 case "isDeprecated":
12999 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
13000 if out.Values[i] == graphql.Null {
13001 invalids++
13002 }
13003 case "deprecationReason":
13004 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
13005 default:
13006 panic("unknown field " + strconv.Quote(field.Name))
13007 }
13008 }
13009 out.Dispatch()
13010 if invalids > 0 {
13011 return graphql.Null
13012 }
13013 return out
13014}
13015
13016var __FieldImplementors = []string{"__Field"}
13017
13018func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
13019 fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
13020
13021 out := graphql.NewFieldSet(fields)
13022 var invalids uint32
13023 for i, field := range fields {
13024 switch field.Name {
13025 case "__typename":
13026 out.Values[i] = graphql.MarshalString("__Field")
13027 case "name":
13028 out.Values[i] = ec.___Field_name(ctx, field, obj)
13029 if out.Values[i] == graphql.Null {
13030 invalids++
13031 }
13032 case "description":
13033 out.Values[i] = ec.___Field_description(ctx, field, obj)
13034 case "args":
13035 out.Values[i] = ec.___Field_args(ctx, field, obj)
13036 if out.Values[i] == graphql.Null {
13037 invalids++
13038 }
13039 case "type":
13040 out.Values[i] = ec.___Field_type(ctx, field, obj)
13041 if out.Values[i] == graphql.Null {
13042 invalids++
13043 }
13044 case "isDeprecated":
13045 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
13046 if out.Values[i] == graphql.Null {
13047 invalids++
13048 }
13049 case "deprecationReason":
13050 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
13051 default:
13052 panic("unknown field " + strconv.Quote(field.Name))
13053 }
13054 }
13055 out.Dispatch()
13056 if invalids > 0 {
13057 return graphql.Null
13058 }
13059 return out
13060}
13061
13062var __InputValueImplementors = []string{"__InputValue"}
13063
13064func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
13065 fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
13066
13067 out := graphql.NewFieldSet(fields)
13068 var invalids uint32
13069 for i, field := range fields {
13070 switch field.Name {
13071 case "__typename":
13072 out.Values[i] = graphql.MarshalString("__InputValue")
13073 case "name":
13074 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
13075 if out.Values[i] == graphql.Null {
13076 invalids++
13077 }
13078 case "description":
13079 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
13080 case "type":
13081 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
13082 if out.Values[i] == graphql.Null {
13083 invalids++
13084 }
13085 case "defaultValue":
13086 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
13087 default:
13088 panic("unknown field " + strconv.Quote(field.Name))
13089 }
13090 }
13091 out.Dispatch()
13092 if invalids > 0 {
13093 return graphql.Null
13094 }
13095 return out
13096}
13097
13098var __SchemaImplementors = []string{"__Schema"}
13099
13100func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
13101 fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
13102
13103 out := graphql.NewFieldSet(fields)
13104 var invalids uint32
13105 for i, field := range fields {
13106 switch field.Name {
13107 case "__typename":
13108 out.Values[i] = graphql.MarshalString("__Schema")
13109 case "types":
13110 out.Values[i] = ec.___Schema_types(ctx, field, obj)
13111 if out.Values[i] == graphql.Null {
13112 invalids++
13113 }
13114 case "queryType":
13115 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
13116 if out.Values[i] == graphql.Null {
13117 invalids++
13118 }
13119 case "mutationType":
13120 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13121 case "subscriptionType":
13122 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13123 case "directives":
13124 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13125 if out.Values[i] == graphql.Null {
13126 invalids++
13127 }
13128 default:
13129 panic("unknown field " + strconv.Quote(field.Name))
13130 }
13131 }
13132 out.Dispatch()
13133 if invalids > 0 {
13134 return graphql.Null
13135 }
13136 return out
13137}
13138
13139var __TypeImplementors = []string{"__Type"}
13140
13141func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13142 fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
13143
13144 out := graphql.NewFieldSet(fields)
13145 var invalids uint32
13146 for i, field := range fields {
13147 switch field.Name {
13148 case "__typename":
13149 out.Values[i] = graphql.MarshalString("__Type")
13150 case "kind":
13151 out.Values[i] = ec.___Type_kind(ctx, field, obj)
13152 if out.Values[i] == graphql.Null {
13153 invalids++
13154 }
13155 case "name":
13156 out.Values[i] = ec.___Type_name(ctx, field, obj)
13157 case "description":
13158 out.Values[i] = ec.___Type_description(ctx, field, obj)
13159 case "fields":
13160 out.Values[i] = ec.___Type_fields(ctx, field, obj)
13161 case "interfaces":
13162 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13163 case "possibleTypes":
13164 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13165 case "enumValues":
13166 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13167 case "inputFields":
13168 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13169 case "ofType":
13170 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13171 default:
13172 panic("unknown field " + strconv.Quote(field.Name))
13173 }
13174 }
13175 out.Dispatch()
13176 if invalids > 0 {
13177 return graphql.Null
13178 }
13179 return out
13180}
13181
13182// endregion **************************** object.gotpl ****************************
13183
13184// region ***************************** type.gotpl *****************************
13185
13186func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13187 return ec.unmarshalInputAddCommentInput(ctx, v)
13188}
13189
13190func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13191 return ec._AddCommentOperation(ctx, sel, &v)
13192}
13193
13194func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
13195 if v == nil {
13196 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13197 ec.Errorf(ctx, "must not be null")
13198 }
13199 return graphql.Null
13200 }
13201 return ec._AddCommentOperation(ctx, sel, v)
13202}
13203
13204func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13205 return ec._AddCommentPayload(ctx, sel, &v)
13206}
13207
13208func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13209 if v == nil {
13210 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13211 ec.Errorf(ctx, "must not be null")
13212 }
13213 return graphql.Null
13214 }
13215 return ec._AddCommentPayload(ctx, sel, v)
13216}
13217
13218func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13219 return graphql.UnmarshalBoolean(v)
13220}
13221
13222func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13223 res := graphql.MarshalBoolean(v)
13224 if res == graphql.Null {
13225 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13226 ec.Errorf(ctx, "must not be null")
13227 }
13228 }
13229 return res
13230}
13231
13232func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
13233 if v == nil {
13234 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13235 ec.Errorf(ctx, "must not be null")
13236 }
13237 return graphql.Null
13238 }
13239 return ec._Bug(ctx, sel, v)
13240}
13241
13242func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
13243 ret := make(graphql.Array, len(v))
13244 var wg sync.WaitGroup
13245 isLen1 := len(v) == 1
13246 if !isLen1 {
13247 wg.Add(len(v))
13248 }
13249 for i := range v {
13250 i := i
13251 fc := &graphql.FieldContext{
13252 Index: &i,
13253 Result: &v[i],
13254 }
13255 ctx := graphql.WithFieldContext(ctx, fc)
13256 f := func(i int) {
13257 defer func() {
13258 if r := recover(); r != nil {
13259 ec.Error(ctx, ec.Recover(ctx, r))
13260 ret = nil
13261 }
13262 }()
13263 if !isLen1 {
13264 defer wg.Done()
13265 }
13266 ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
13267 }
13268 if isLen1 {
13269 f(i)
13270 } else {
13271 go f(i)
13272 }
13273
13274 }
13275 wg.Wait()
13276 return ret
13277}
13278
13279func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13280 return ec._BugConnection(ctx, sel, &v)
13281}
13282
13283func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
13284 if v == nil {
13285 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13286 ec.Errorf(ctx, "must not be null")
13287 }
13288 return graphql.Null
13289 }
13290 return ec._BugConnection(ctx, sel, v)
13291}
13292
13293func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13294 return ec._BugEdge(ctx, sel, &v)
13295}
13296
13297func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13298 ret := make(graphql.Array, len(v))
13299 var wg sync.WaitGroup
13300 isLen1 := len(v) == 1
13301 if !isLen1 {
13302 wg.Add(len(v))
13303 }
13304 for i := range v {
13305 i := i
13306 fc := &graphql.FieldContext{
13307 Index: &i,
13308 Result: &v[i],
13309 }
13310 ctx := graphql.WithFieldContext(ctx, fc)
13311 f := func(i int) {
13312 defer func() {
13313 if r := recover(); r != nil {
13314 ec.Error(ctx, ec.Recover(ctx, r))
13315 ret = nil
13316 }
13317 }()
13318 if !isLen1 {
13319 defer wg.Done()
13320 }
13321 ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13322 }
13323 if isLen1 {
13324 f(i)
13325 } else {
13326 go f(i)
13327 }
13328
13329 }
13330 wg.Wait()
13331 return ret
13332}
13333
13334func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13335 if v == nil {
13336 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13337 ec.Errorf(ctx, "must not be null")
13338 }
13339 return graphql.Null
13340 }
13341 return ec._BugEdge(ctx, sel, v)
13342}
13343
13344func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13345 return ec._ChangeLabelPayload(ctx, sel, &v)
13346}
13347
13348func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13349 if v == nil {
13350 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13351 ec.Errorf(ctx, "must not be null")
13352 }
13353 return graphql.Null
13354 }
13355 return ec._ChangeLabelPayload(ctx, sel, v)
13356}
13357
13358func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13359 return ec.unmarshalInputCloseBugInput(ctx, v)
13360}
13361
13362func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13363 return ec._CloseBugPayload(ctx, sel, &v)
13364}
13365
13366func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
13367 if v == nil {
13368 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13369 ec.Errorf(ctx, "must not be null")
13370 }
13371 return graphql.Null
13372 }
13373 return ec._CloseBugPayload(ctx, sel, v)
13374}
13375
13376func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13377 return ec._Color(ctx, sel, &v)
13378}
13379
13380func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
13381 if v == nil {
13382 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13383 ec.Errorf(ctx, "must not be null")
13384 }
13385 return graphql.Null
13386 }
13387 return ec._Color(ctx, sel, v)
13388}
13389
13390func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
13391 return ec._Comment(ctx, sel, &v)
13392}
13393
13394func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
13395 ret := make(graphql.Array, len(v))
13396 var wg sync.WaitGroup
13397 isLen1 := len(v) == 1
13398 if !isLen1 {
13399 wg.Add(len(v))
13400 }
13401 for i := range v {
13402 i := i
13403 fc := &graphql.FieldContext{
13404 Index: &i,
13405 Result: &v[i],
13406 }
13407 ctx := graphql.WithFieldContext(ctx, fc)
13408 f := func(i int) {
13409 defer func() {
13410 if r := recover(); r != nil {
13411 ec.Error(ctx, ec.Recover(ctx, r))
13412 ret = nil
13413 }
13414 }()
13415 if !isLen1 {
13416 defer wg.Done()
13417 }
13418 ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
13419 }
13420 if isLen1 {
13421 f(i)
13422 } else {
13423 go f(i)
13424 }
13425
13426 }
13427 wg.Wait()
13428 return ret
13429}
13430
13431func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13432 if v == nil {
13433 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13434 ec.Errorf(ctx, "must not be null")
13435 }
13436 return graphql.Null
13437 }
13438 return ec._Comment(ctx, sel, v)
13439}
13440
13441func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13442 return ec._CommentConnection(ctx, sel, &v)
13443}
13444
13445func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13446 if v == nil {
13447 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13448 ec.Errorf(ctx, "must not be null")
13449 }
13450 return graphql.Null
13451 }
13452 return ec._CommentConnection(ctx, sel, v)
13453}
13454
13455func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13456 return ec._CommentEdge(ctx, sel, &v)
13457}
13458
13459func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13460 ret := make(graphql.Array, len(v))
13461 var wg sync.WaitGroup
13462 isLen1 := len(v) == 1
13463 if !isLen1 {
13464 wg.Add(len(v))
13465 }
13466 for i := range v {
13467 i := i
13468 fc := &graphql.FieldContext{
13469 Index: &i,
13470 Result: &v[i],
13471 }
13472 ctx := graphql.WithFieldContext(ctx, fc)
13473 f := func(i int) {
13474 defer func() {
13475 if r := recover(); r != nil {
13476 ec.Error(ctx, ec.Recover(ctx, r))
13477 ret = nil
13478 }
13479 }()
13480 if !isLen1 {
13481 defer wg.Done()
13482 }
13483 ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13484 }
13485 if isLen1 {
13486 f(i)
13487 } else {
13488 go f(i)
13489 }
13490
13491 }
13492 wg.Wait()
13493 return ret
13494}
13495
13496func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13497 if v == nil {
13498 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13499 ec.Errorf(ctx, "must not be null")
13500 }
13501 return graphql.Null
13502 }
13503 return ec._CommentEdge(ctx, sel, v)
13504}
13505
13506func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13507 return ec._CommentHistoryStep(ctx, sel, &v)
13508}
13509
13510func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13511 ret := make(graphql.Array, len(v))
13512 var wg sync.WaitGroup
13513 isLen1 := len(v) == 1
13514 if !isLen1 {
13515 wg.Add(len(v))
13516 }
13517 for i := range v {
13518 i := i
13519 fc := &graphql.FieldContext{
13520 Index: &i,
13521 Result: &v[i],
13522 }
13523 ctx := graphql.WithFieldContext(ctx, fc)
13524 f := func(i int) {
13525 defer func() {
13526 if r := recover(); r != nil {
13527 ec.Error(ctx, ec.Recover(ctx, r))
13528 ret = nil
13529 }
13530 }()
13531 if !isLen1 {
13532 defer wg.Done()
13533 }
13534 ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13535 }
13536 if isLen1 {
13537 f(i)
13538 } else {
13539 go f(i)
13540 }
13541
13542 }
13543 wg.Wait()
13544 return ret
13545}
13546
13547func (ec *executionContext) unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
13548 return ec.unmarshalInputCommitAsNeededInput(ctx, v)
13549}
13550
13551func (ec *executionContext) marshalNCommitAsNeededPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitAsNeededPayload) graphql.Marshaler {
13552 return ec._CommitAsNeededPayload(ctx, sel, &v)
13553}
13554
13555func (ec *executionContext) marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitAsNeededPayload) graphql.Marshaler {
13556 if v == nil {
13557 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13558 ec.Errorf(ctx, "must not be null")
13559 }
13560 return graphql.Null
13561 }
13562 return ec._CommitAsNeededPayload(ctx, sel, v)
13563}
13564
13565func (ec *executionContext) unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
13566 return ec.unmarshalInputCommitInput(ctx, v)
13567}
13568
13569func (ec *executionContext) marshalNCommitPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitPayload) graphql.Marshaler {
13570 return ec._CommitPayload(ctx, sel, &v)
13571}
13572
13573func (ec *executionContext) marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitPayload) graphql.Marshaler {
13574 if v == nil {
13575 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13576 ec.Errorf(ctx, "must not be null")
13577 }
13578 return graphql.Null
13579 }
13580 return ec._CommitPayload(ctx, sel, v)
13581}
13582
13583func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13584 return ec._CreateOperation(ctx, sel, &v)
13585}
13586
13587func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13588 if v == nil {
13589 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13590 ec.Errorf(ctx, "must not be null")
13591 }
13592 return graphql.Null
13593 }
13594 return ec._CreateOperation(ctx, sel, v)
13595}
13596
13597func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
13598 var res git.Hash
13599 return res, res.UnmarshalGQL(v)
13600}
13601
13602func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
13603 return v
13604}
13605
13606func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
13607 var vSlice []interface{}
13608 if v != nil {
13609 if tmp1, ok := v.([]interface{}); ok {
13610 vSlice = tmp1
13611 } else {
13612 vSlice = []interface{}{v}
13613 }
13614 }
13615 var err error
13616 res := make([]git.Hash, len(vSlice))
13617 for i := range vSlice {
13618 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
13619 if err != nil {
13620 return nil, err
13621 }
13622 }
13623 return res, nil
13624}
13625
13626func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
13627 ret := make(graphql.Array, len(v))
13628 for i := range v {
13629 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
13630 }
13631
13632 return ret
13633}
13634
13635func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
13636 if v == nil {
13637 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13638 ec.Errorf(ctx, "must not be null")
13639 }
13640 return graphql.Null
13641 }
13642 return ec._Identity(ctx, sel, v)
13643}
13644
13645func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) graphql.Marshaler {
13646 ret := make(graphql.Array, len(v))
13647 var wg sync.WaitGroup
13648 isLen1 := len(v) == 1
13649 if !isLen1 {
13650 wg.Add(len(v))
13651 }
13652 for i := range v {
13653 i := i
13654 fc := &graphql.FieldContext{
13655 Index: &i,
13656 Result: &v[i],
13657 }
13658 ctx := graphql.WithFieldContext(ctx, fc)
13659 f := func(i int) {
13660 defer func() {
13661 if r := recover(); r != nil {
13662 ec.Error(ctx, ec.Recover(ctx, r))
13663 ret = nil
13664 }
13665 }()
13666 if !isLen1 {
13667 defer wg.Done()
13668 }
13669 ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, sel, v[i])
13670 }
13671 if isLen1 {
13672 f(i)
13673 } else {
13674 go f(i)
13675 }
13676
13677 }
13678 wg.Wait()
13679 return ret
13680}
13681
13682func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13683 return ec._IdentityConnection(ctx, sel, &v)
13684}
13685
13686func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13687 if v == nil {
13688 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13689 ec.Errorf(ctx, "must not be null")
13690 }
13691 return graphql.Null
13692 }
13693 return ec._IdentityConnection(ctx, sel, v)
13694}
13695
13696func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13697 return ec._IdentityEdge(ctx, sel, &v)
13698}
13699
13700func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13701 ret := make(graphql.Array, len(v))
13702 var wg sync.WaitGroup
13703 isLen1 := len(v) == 1
13704 if !isLen1 {
13705 wg.Add(len(v))
13706 }
13707 for i := range v {
13708 i := i
13709 fc := &graphql.FieldContext{
13710 Index: &i,
13711 Result: &v[i],
13712 }
13713 ctx := graphql.WithFieldContext(ctx, fc)
13714 f := func(i int) {
13715 defer func() {
13716 if r := recover(); r != nil {
13717 ec.Error(ctx, ec.Recover(ctx, r))
13718 ret = nil
13719 }
13720 }()
13721 if !isLen1 {
13722 defer wg.Done()
13723 }
13724 ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13725 }
13726 if isLen1 {
13727 f(i)
13728 } else {
13729 go f(i)
13730 }
13731
13732 }
13733 wg.Wait()
13734 return ret
13735}
13736
13737func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
13738 if v == nil {
13739 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13740 ec.Errorf(ctx, "must not be null")
13741 }
13742 return graphql.Null
13743 }
13744 return ec._IdentityEdge(ctx, sel, v)
13745}
13746
13747func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13748 return graphql.UnmarshalInt(v)
13749}
13750
13751func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13752 res := graphql.MarshalInt(v)
13753 if res == graphql.Null {
13754 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13755 ec.Errorf(ctx, "must not be null")
13756 }
13757 }
13758 return res
13759}
13760
13761func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
13762 return ec._Label(ctx, sel, &v)
13763}
13764
13765func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
13766 ret := make(graphql.Array, len(v))
13767 var wg sync.WaitGroup
13768 isLen1 := len(v) == 1
13769 if !isLen1 {
13770 wg.Add(len(v))
13771 }
13772 for i := range v {
13773 i := i
13774 fc := &graphql.FieldContext{
13775 Index: &i,
13776 Result: &v[i],
13777 }
13778 ctx := graphql.WithFieldContext(ctx, fc)
13779 f := func(i int) {
13780 defer func() {
13781 if r := recover(); r != nil {
13782 ec.Error(ctx, ec.Recover(ctx, r))
13783 ret = nil
13784 }
13785 }()
13786 if !isLen1 {
13787 defer wg.Done()
13788 }
13789 ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
13790 }
13791 if isLen1 {
13792 f(i)
13793 } else {
13794 go f(i)
13795 }
13796
13797 }
13798 wg.Wait()
13799 return ret
13800}
13801
13802func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
13803 return ec._LabelChangeOperation(ctx, sel, &v)
13804}
13805
13806func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
13807 if v == nil {
13808 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13809 ec.Errorf(ctx, "must not be null")
13810 }
13811 return graphql.Null
13812 }
13813 return ec._LabelChangeOperation(ctx, sel, v)
13814}
13815
13816func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
13817 ret := make(graphql.Array, len(v))
13818 var wg sync.WaitGroup
13819 isLen1 := len(v) == 1
13820 if !isLen1 {
13821 wg.Add(len(v))
13822 }
13823 for i := range v {
13824 i := i
13825 fc := &graphql.FieldContext{
13826 Index: &i,
13827 Result: &v[i],
13828 }
13829 ctx := graphql.WithFieldContext(ctx, fc)
13830 f := func(i int) {
13831 defer func() {
13832 if r := recover(); r != nil {
13833 ec.Error(ctx, ec.Recover(ctx, r))
13834 ret = nil
13835 }
13836 }()
13837 if !isLen1 {
13838 defer wg.Done()
13839 }
13840 ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
13841 }
13842 if isLen1 {
13843 f(i)
13844 } else {
13845 go f(i)
13846 }
13847
13848 }
13849 wg.Wait()
13850 return ret
13851}
13852
13853func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
13854 var res models.LabelChangeStatus
13855 return res, res.UnmarshalGQL(v)
13856}
13857
13858func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
13859 return v
13860}
13861
13862func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
13863 return ec._LabelConnection(ctx, sel, &v)
13864}
13865
13866func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
13867 if v == nil {
13868 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13869 ec.Errorf(ctx, "must not be null")
13870 }
13871 return graphql.Null
13872 }
13873 return ec._LabelConnection(ctx, sel, v)
13874}
13875
13876func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
13877 return ec._LabelEdge(ctx, sel, &v)
13878}
13879
13880func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
13881 ret := make(graphql.Array, len(v))
13882 var wg sync.WaitGroup
13883 isLen1 := len(v) == 1
13884 if !isLen1 {
13885 wg.Add(len(v))
13886 }
13887 for i := range v {
13888 i := i
13889 fc := &graphql.FieldContext{
13890 Index: &i,
13891 Result: &v[i],
13892 }
13893 ctx := graphql.WithFieldContext(ctx, fc)
13894 f := func(i int) {
13895 defer func() {
13896 if r := recover(); r != nil {
13897 ec.Error(ctx, ec.Recover(ctx, r))
13898 ret = nil
13899 }
13900 }()
13901 if !isLen1 {
13902 defer wg.Done()
13903 }
13904 ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
13905 }
13906 if isLen1 {
13907 f(i)
13908 } else {
13909 go f(i)
13910 }
13911
13912 }
13913 wg.Wait()
13914 return ret
13915}
13916
13917func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
13918 if v == nil {
13919 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13920 ec.Errorf(ctx, "must not be null")
13921 }
13922 return graphql.Null
13923 }
13924 return ec._LabelEdge(ctx, sel, v)
13925}
13926
13927func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
13928 return ec.unmarshalInputNewBugInput(ctx, v)
13929}
13930
13931func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
13932 return ec._NewBugPayload(ctx, sel, &v)
13933}
13934
13935func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
13936 if v == nil {
13937 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13938 ec.Errorf(ctx, "must not be null")
13939 }
13940 return graphql.Null
13941 }
13942 return ec._NewBugPayload(ctx, sel, v)
13943}
13944
13945func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
13946 return ec.unmarshalInputOpenBugInput(ctx, v)
13947}
13948
13949func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
13950 return ec._OpenBugPayload(ctx, sel, &v)
13951}
13952
13953func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
13954 if v == nil {
13955 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13956 ec.Errorf(ctx, "must not be null")
13957 }
13958 return graphql.Null
13959 }
13960 return ec._OpenBugPayload(ctx, sel, v)
13961}
13962
13963func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
13964 if v == nil {
13965 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13966 ec.Errorf(ctx, "must not be null")
13967 }
13968 return graphql.Null
13969 }
13970 return ec._Operation(ctx, sel, v)
13971}
13972
13973func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
13974 ret := make(graphql.Array, len(v))
13975 var wg sync.WaitGroup
13976 isLen1 := len(v) == 1
13977 if !isLen1 {
13978 wg.Add(len(v))
13979 }
13980 for i := range v {
13981 i := i
13982 fc := &graphql.FieldContext{
13983 Index: &i,
13984 Result: &v[i],
13985 }
13986 ctx := graphql.WithFieldContext(ctx, fc)
13987 f := func(i int) {
13988 defer func() {
13989 if r := recover(); r != nil {
13990 ec.Error(ctx, ec.Recover(ctx, r))
13991 ret = nil
13992 }
13993 }()
13994 if !isLen1 {
13995 defer wg.Done()
13996 }
13997 ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
13998 }
13999 if isLen1 {
14000 f(i)
14001 } else {
14002 go f(i)
14003 }
14004
14005 }
14006 wg.Wait()
14007 return ret
14008}
14009
14010func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
14011 return ec._OperationConnection(ctx, sel, &v)
14012}
14013
14014func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
14015 if v == nil {
14016 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14017 ec.Errorf(ctx, "must not be null")
14018 }
14019 return graphql.Null
14020 }
14021 return ec._OperationConnection(ctx, sel, v)
14022}
14023
14024func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
14025 return ec._OperationEdge(ctx, sel, &v)
14026}
14027
14028func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
14029 ret := make(graphql.Array, len(v))
14030 var wg sync.WaitGroup
14031 isLen1 := len(v) == 1
14032 if !isLen1 {
14033 wg.Add(len(v))
14034 }
14035 for i := range v {
14036 i := i
14037 fc := &graphql.FieldContext{
14038 Index: &i,
14039 Result: &v[i],
14040 }
14041 ctx := graphql.WithFieldContext(ctx, fc)
14042 f := func(i int) {
14043 defer func() {
14044 if r := recover(); r != nil {
14045 ec.Error(ctx, ec.Recover(ctx, r))
14046 ret = nil
14047 }
14048 }()
14049 if !isLen1 {
14050 defer wg.Done()
14051 }
14052 ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
14053 }
14054 if isLen1 {
14055 f(i)
14056 } else {
14057 go f(i)
14058 }
14059
14060 }
14061 wg.Wait()
14062 return ret
14063}
14064
14065func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
14066 if v == nil {
14067 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14068 ec.Errorf(ctx, "must not be null")
14069 }
14070 return graphql.Null
14071 }
14072 return ec._OperationEdge(ctx, sel, v)
14073}
14074
14075func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
14076 return ec._PageInfo(ctx, sel, &v)
14077}
14078
14079func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
14080 if v == nil {
14081 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14082 ec.Errorf(ctx, "must not be null")
14083 }
14084 return graphql.Null
14085 }
14086 return ec._PageInfo(ctx, sel, v)
14087}
14088
14089func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
14090 return ec._SetStatusOperation(ctx, sel, &v)
14091}
14092
14093func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
14094 if v == nil {
14095 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14096 ec.Errorf(ctx, "must not be null")
14097 }
14098 return graphql.Null
14099 }
14100 return ec._SetStatusOperation(ctx, sel, v)
14101}
14102
14103func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
14104 return ec.unmarshalInputSetTitleInput(ctx, v)
14105}
14106
14107func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
14108 return ec._SetTitleOperation(ctx, sel, &v)
14109}
14110
14111func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
14112 if v == nil {
14113 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14114 ec.Errorf(ctx, "must not be null")
14115 }
14116 return graphql.Null
14117 }
14118 return ec._SetTitleOperation(ctx, sel, v)
14119}
14120
14121func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
14122 return ec._SetTitlePayload(ctx, sel, &v)
14123}
14124
14125func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14126 if v == nil {
14127 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14128 ec.Errorf(ctx, "must not be null")
14129 }
14130 return graphql.Null
14131 }
14132 return ec._SetTitlePayload(ctx, sel, v)
14133}
14134
14135func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14136 var res models.Status
14137 return res, res.UnmarshalGQL(v)
14138}
14139
14140func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14141 return v
14142}
14143
14144func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14145 return graphql.UnmarshalString(v)
14146}
14147
14148func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14149 res := graphql.MarshalString(v)
14150 if res == graphql.Null {
14151 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14152 ec.Errorf(ctx, "must not be null")
14153 }
14154 }
14155 return res
14156}
14157
14158func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14159 return graphql.UnmarshalTime(v)
14160}
14161
14162func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14163 res := graphql.MarshalTime(v)
14164 if res == graphql.Null {
14165 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14166 ec.Errorf(ctx, "must not be null")
14167 }
14168 }
14169 return res
14170}
14171
14172func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14173 if v == nil {
14174 return nil, nil
14175 }
14176 res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14177 return &res, err
14178}
14179
14180func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14181 if v == nil {
14182 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14183 ec.Errorf(ctx, "must not be null")
14184 }
14185 return graphql.Null
14186 }
14187 return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14188}
14189
14190func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14191 if v == nil {
14192 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14193 ec.Errorf(ctx, "must not be null")
14194 }
14195 return graphql.Null
14196 }
14197 return ec._TimelineItem(ctx, sel, v)
14198}
14199
14200func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14201 ret := make(graphql.Array, len(v))
14202 var wg sync.WaitGroup
14203 isLen1 := len(v) == 1
14204 if !isLen1 {
14205 wg.Add(len(v))
14206 }
14207 for i := range v {
14208 i := i
14209 fc := &graphql.FieldContext{
14210 Index: &i,
14211 Result: &v[i],
14212 }
14213 ctx := graphql.WithFieldContext(ctx, fc)
14214 f := func(i int) {
14215 defer func() {
14216 if r := recover(); r != nil {
14217 ec.Error(ctx, ec.Recover(ctx, r))
14218 ret = nil
14219 }
14220 }()
14221 if !isLen1 {
14222 defer wg.Done()
14223 }
14224 ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14225 }
14226 if isLen1 {
14227 f(i)
14228 } else {
14229 go f(i)
14230 }
14231
14232 }
14233 wg.Wait()
14234 return ret
14235}
14236
14237func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14238 return ec._TimelineItemConnection(ctx, sel, &v)
14239}
14240
14241func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14242 if v == nil {
14243 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14244 ec.Errorf(ctx, "must not be null")
14245 }
14246 return graphql.Null
14247 }
14248 return ec._TimelineItemConnection(ctx, sel, v)
14249}
14250
14251func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14252 return ec._TimelineItemEdge(ctx, sel, &v)
14253}
14254
14255func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14256 ret := make(graphql.Array, len(v))
14257 var wg sync.WaitGroup
14258 isLen1 := len(v) == 1
14259 if !isLen1 {
14260 wg.Add(len(v))
14261 }
14262 for i := range v {
14263 i := i
14264 fc := &graphql.FieldContext{
14265 Index: &i,
14266 Result: &v[i],
14267 }
14268 ctx := graphql.WithFieldContext(ctx, fc)
14269 f := func(i int) {
14270 defer func() {
14271 if r := recover(); r != nil {
14272 ec.Error(ctx, ec.Recover(ctx, r))
14273 ret = nil
14274 }
14275 }()
14276 if !isLen1 {
14277 defer wg.Done()
14278 }
14279 ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14280 }
14281 if isLen1 {
14282 f(i)
14283 } else {
14284 go f(i)
14285 }
14286
14287 }
14288 wg.Wait()
14289 return ret
14290}
14291
14292func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) 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._TimelineItemEdge(ctx, sel, v)
14300}
14301
14302func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
14303 return ec.___Directive(ctx, sel, &v)
14304}
14305
14306func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
14307 ret := make(graphql.Array, len(v))
14308 var wg sync.WaitGroup
14309 isLen1 := len(v) == 1
14310 if !isLen1 {
14311 wg.Add(len(v))
14312 }
14313 for i := range v {
14314 i := i
14315 fc := &graphql.FieldContext{
14316 Index: &i,
14317 Result: &v[i],
14318 }
14319 ctx := graphql.WithFieldContext(ctx, fc)
14320 f := func(i int) {
14321 defer func() {
14322 if r := recover(); r != nil {
14323 ec.Error(ctx, ec.Recover(ctx, r))
14324 ret = nil
14325 }
14326 }()
14327 if !isLen1 {
14328 defer wg.Done()
14329 }
14330 ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14331 }
14332 if isLen1 {
14333 f(i)
14334 } else {
14335 go f(i)
14336 }
14337
14338 }
14339 wg.Wait()
14340 return ret
14341}
14342
14343func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14344 return graphql.UnmarshalString(v)
14345}
14346
14347func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14348 res := graphql.MarshalString(v)
14349 if res == graphql.Null {
14350 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14351 ec.Errorf(ctx, "must not be null")
14352 }
14353 }
14354 return res
14355}
14356
14357func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14358 var vSlice []interface{}
14359 if v != nil {
14360 if tmp1, ok := v.([]interface{}); ok {
14361 vSlice = tmp1
14362 } else {
14363 vSlice = []interface{}{v}
14364 }
14365 }
14366 var err error
14367 res := make([]string, len(vSlice))
14368 for i := range vSlice {
14369 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14370 if err != nil {
14371 return nil, err
14372 }
14373 }
14374 return res, nil
14375}
14376
14377func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14378 ret := make(graphql.Array, len(v))
14379 var wg sync.WaitGroup
14380 isLen1 := len(v) == 1
14381 if !isLen1 {
14382 wg.Add(len(v))
14383 }
14384 for i := range v {
14385 i := i
14386 fc := &graphql.FieldContext{
14387 Index: &i,
14388 Result: &v[i],
14389 }
14390 ctx := graphql.WithFieldContext(ctx, fc)
14391 f := func(i int) {
14392 defer func() {
14393 if r := recover(); r != nil {
14394 ec.Error(ctx, ec.Recover(ctx, r))
14395 ret = nil
14396 }
14397 }()
14398 if !isLen1 {
14399 defer wg.Done()
14400 }
14401 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
14402 }
14403 if isLen1 {
14404 f(i)
14405 } else {
14406 go f(i)
14407 }
14408
14409 }
14410 wg.Wait()
14411 return ret
14412}
14413
14414func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
14415 return ec.___EnumValue(ctx, sel, &v)
14416}
14417
14418func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
14419 return ec.___Field(ctx, sel, &v)
14420}
14421
14422func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
14423 return ec.___InputValue(ctx, sel, &v)
14424}
14425
14426func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14427 ret := make(graphql.Array, len(v))
14428 var wg sync.WaitGroup
14429 isLen1 := len(v) == 1
14430 if !isLen1 {
14431 wg.Add(len(v))
14432 }
14433 for i := range v {
14434 i := i
14435 fc := &graphql.FieldContext{
14436 Index: &i,
14437 Result: &v[i],
14438 }
14439 ctx := graphql.WithFieldContext(ctx, fc)
14440 f := func(i int) {
14441 defer func() {
14442 if r := recover(); r != nil {
14443 ec.Error(ctx, ec.Recover(ctx, r))
14444 ret = nil
14445 }
14446 }()
14447 if !isLen1 {
14448 defer wg.Done()
14449 }
14450 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14451 }
14452 if isLen1 {
14453 f(i)
14454 } else {
14455 go f(i)
14456 }
14457
14458 }
14459 wg.Wait()
14460 return ret
14461}
14462
14463func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14464 return ec.___Type(ctx, sel, &v)
14465}
14466
14467func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14468 ret := make(graphql.Array, len(v))
14469 var wg sync.WaitGroup
14470 isLen1 := len(v) == 1
14471 if !isLen1 {
14472 wg.Add(len(v))
14473 }
14474 for i := range v {
14475 i := i
14476 fc := &graphql.FieldContext{
14477 Index: &i,
14478 Result: &v[i],
14479 }
14480 ctx := graphql.WithFieldContext(ctx, fc)
14481 f := func(i int) {
14482 defer func() {
14483 if r := recover(); r != nil {
14484 ec.Error(ctx, ec.Recover(ctx, r))
14485 ret = nil
14486 }
14487 }()
14488 if !isLen1 {
14489 defer wg.Done()
14490 }
14491 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14492 }
14493 if isLen1 {
14494 f(i)
14495 } else {
14496 go f(i)
14497 }
14498
14499 }
14500 wg.Wait()
14501 return ret
14502}
14503
14504func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14505 if v == nil {
14506 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14507 ec.Errorf(ctx, "must not be null")
14508 }
14509 return graphql.Null
14510 }
14511 return ec.___Type(ctx, sel, v)
14512}
14513
14514func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14515 return graphql.UnmarshalString(v)
14516}
14517
14518func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14519 res := graphql.MarshalString(v)
14520 if res == graphql.Null {
14521 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14522 ec.Errorf(ctx, "must not be null")
14523 }
14524 }
14525 return res
14526}
14527
14528func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14529 return graphql.UnmarshalBoolean(v)
14530}
14531
14532func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14533 return graphql.MarshalBoolean(v)
14534}
14535
14536func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14537 if v == nil {
14538 return nil, nil
14539 }
14540 res, err := ec.unmarshalOBoolean2bool(ctx, v)
14541 return &res, err
14542}
14543
14544func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14545 if v == nil {
14546 return graphql.Null
14547 }
14548 return ec.marshalOBoolean2bool(ctx, sel, *v)
14549}
14550
14551func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
14552 if v == nil {
14553 return graphql.Null
14554 }
14555 return ec._Bug(ctx, sel, v)
14556}
14557
14558func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14559 return ec.unmarshalInputChangeLabelInput(ctx, v)
14560}
14561
14562func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14563 if v == nil {
14564 return nil, nil
14565 }
14566 res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14567 return &res, err
14568}
14569
14570func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
14571 var vSlice []interface{}
14572 if v != nil {
14573 if tmp1, ok := v.([]interface{}); ok {
14574 vSlice = tmp1
14575 } else {
14576 vSlice = []interface{}{v}
14577 }
14578 }
14579 var err error
14580 res := make([]git.Hash, len(vSlice))
14581 for i := range vSlice {
14582 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14583 if err != nil {
14584 return nil, err
14585 }
14586 }
14587 return res, nil
14588}
14589
14590func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14591 if v == nil {
14592 return graphql.Null
14593 }
14594 ret := make(graphql.Array, len(v))
14595 for i := range v {
14596 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14597 }
14598
14599 return ret
14600}
14601
14602func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
14603 if v == nil {
14604 return graphql.Null
14605 }
14606 return ec._Identity(ctx, sel, v)
14607}
14608
14609func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14610 return graphql.UnmarshalInt(v)
14611}
14612
14613func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14614 return graphql.MarshalInt(v)
14615}
14616
14617func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14618 if v == nil {
14619 return nil, nil
14620 }
14621 res, err := ec.unmarshalOInt2int(ctx, v)
14622 return &res, err
14623}
14624
14625func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14626 if v == nil {
14627 return graphql.Null
14628 }
14629 return ec.marshalOInt2int(ctx, sel, *v)
14630}
14631
14632func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14633 return ec._LabelChangeResult(ctx, sel, &v)
14634}
14635
14636func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14637 if v == nil {
14638 return graphql.Null
14639 }
14640 return ec._LabelChangeResult(ctx, sel, v)
14641}
14642
14643func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14644 return ec._Repository(ctx, sel, &v)
14645}
14646
14647func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14648 if v == nil {
14649 return graphql.Null
14650 }
14651 return ec._Repository(ctx, sel, v)
14652}
14653
14654func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14655 return graphql.UnmarshalString(v)
14656}
14657
14658func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14659 return graphql.MarshalString(v)
14660}
14661
14662func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14663 var vSlice []interface{}
14664 if v != nil {
14665 if tmp1, ok := v.([]interface{}); ok {
14666 vSlice = tmp1
14667 } else {
14668 vSlice = []interface{}{v}
14669 }
14670 }
14671 var err error
14672 res := make([]string, len(vSlice))
14673 for i := range vSlice {
14674 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14675 if err != nil {
14676 return nil, err
14677 }
14678 }
14679 return res, nil
14680}
14681
14682func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14683 if v == nil {
14684 return graphql.Null
14685 }
14686 ret := make(graphql.Array, len(v))
14687 for i := range v {
14688 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14689 }
14690
14691 return ret
14692}
14693
14694func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14695 if v == nil {
14696 return nil, nil
14697 }
14698 res, err := ec.unmarshalOString2string(ctx, v)
14699 return &res, err
14700}
14701
14702func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14703 if v == nil {
14704 return graphql.Null
14705 }
14706 return ec.marshalOString2string(ctx, sel, *v)
14707}
14708
14709func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
14710 if v == nil {
14711 return graphql.Null
14712 }
14713 ret := make(graphql.Array, len(v))
14714 var wg sync.WaitGroup
14715 isLen1 := len(v) == 1
14716 if !isLen1 {
14717 wg.Add(len(v))
14718 }
14719 for i := range v {
14720 i := i
14721 fc := &graphql.FieldContext{
14722 Index: &i,
14723 Result: &v[i],
14724 }
14725 ctx := graphql.WithFieldContext(ctx, fc)
14726 f := func(i int) {
14727 defer func() {
14728 if r := recover(); r != nil {
14729 ec.Error(ctx, ec.Recover(ctx, r))
14730 ret = nil
14731 }
14732 }()
14733 if !isLen1 {
14734 defer wg.Done()
14735 }
14736 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14737 }
14738 if isLen1 {
14739 f(i)
14740 } else {
14741 go f(i)
14742 }
14743
14744 }
14745 wg.Wait()
14746 return ret
14747}
14748
14749func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
14750 if v == nil {
14751 return graphql.Null
14752 }
14753 ret := make(graphql.Array, len(v))
14754 var wg sync.WaitGroup
14755 isLen1 := len(v) == 1
14756 if !isLen1 {
14757 wg.Add(len(v))
14758 }
14759 for i := range v {
14760 i := i
14761 fc := &graphql.FieldContext{
14762 Index: &i,
14763 Result: &v[i],
14764 }
14765 ctx := graphql.WithFieldContext(ctx, fc)
14766 f := func(i int) {
14767 defer func() {
14768 if r := recover(); r != nil {
14769 ec.Error(ctx, ec.Recover(ctx, r))
14770 ret = nil
14771 }
14772 }()
14773 if !isLen1 {
14774 defer wg.Done()
14775 }
14776 ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
14777 }
14778 if isLen1 {
14779 f(i)
14780 } else {
14781 go f(i)
14782 }
14783
14784 }
14785 wg.Wait()
14786 return ret
14787}
14788
14789func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14790 if v == nil {
14791 return graphql.Null
14792 }
14793 ret := make(graphql.Array, len(v))
14794 var wg sync.WaitGroup
14795 isLen1 := len(v) == 1
14796 if !isLen1 {
14797 wg.Add(len(v))
14798 }
14799 for i := range v {
14800 i := i
14801 fc := &graphql.FieldContext{
14802 Index: &i,
14803 Result: &v[i],
14804 }
14805 ctx := graphql.WithFieldContext(ctx, fc)
14806 f := func(i int) {
14807 defer func() {
14808 if r := recover(); r != nil {
14809 ec.Error(ctx, ec.Recover(ctx, r))
14810 ret = nil
14811 }
14812 }()
14813 if !isLen1 {
14814 defer wg.Done()
14815 }
14816 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14817 }
14818 if isLen1 {
14819 f(i)
14820 } else {
14821 go f(i)
14822 }
14823
14824 }
14825 wg.Wait()
14826 return ret
14827}
14828
14829func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
14830 return ec.___Schema(ctx, sel, &v)
14831}
14832
14833func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
14834 if v == nil {
14835 return graphql.Null
14836 }
14837 return ec.___Schema(ctx, sel, v)
14838}
14839
14840func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14841 return ec.___Type(ctx, sel, &v)
14842}
14843
14844func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14845 if v == nil {
14846 return graphql.Null
14847 }
14848 ret := make(graphql.Array, len(v))
14849 var wg sync.WaitGroup
14850 isLen1 := len(v) == 1
14851 if !isLen1 {
14852 wg.Add(len(v))
14853 }
14854 for i := range v {
14855 i := i
14856 fc := &graphql.FieldContext{
14857 Index: &i,
14858 Result: &v[i],
14859 }
14860 ctx := graphql.WithFieldContext(ctx, fc)
14861 f := func(i int) {
14862 defer func() {
14863 if r := recover(); r != nil {
14864 ec.Error(ctx, ec.Recover(ctx, r))
14865 ret = nil
14866 }
14867 }()
14868 if !isLen1 {
14869 defer wg.Done()
14870 }
14871 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14872 }
14873 if isLen1 {
14874 f(i)
14875 } else {
14876 go f(i)
14877 }
14878
14879 }
14880 wg.Wait()
14881 return ret
14882}
14883
14884func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14885 if v == nil {
14886 return graphql.Null
14887 }
14888 return ec.___Type(ctx, sel, v)
14889}
14890
14891// endregion ***************************** type.gotpl *****************************