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 return ec._Bug(ctx, sel, obj)
10461 case *bug.CreateOperation:
10462 if obj == nil {
10463 return graphql.Null
10464 }
10465 return ec._CreateOperation(ctx, sel, obj)
10466 case *bug.SetTitleOperation:
10467 if obj == nil {
10468 return graphql.Null
10469 }
10470 return ec._SetTitleOperation(ctx, sel, obj)
10471 case *bug.AddCommentOperation:
10472 if obj == nil {
10473 return graphql.Null
10474 }
10475 return ec._AddCommentOperation(ctx, sel, obj)
10476 case *bug.EditCommentOperation:
10477 if obj == nil {
10478 return graphql.Null
10479 }
10480 return ec._EditCommentOperation(ctx, sel, obj)
10481 case *bug.SetStatusOperation:
10482 if obj == nil {
10483 return graphql.Null
10484 }
10485 return ec._SetStatusOperation(ctx, sel, obj)
10486 case *bug.LabelChangeOperation:
10487 if obj == nil {
10488 return graphql.Null
10489 }
10490 return ec._LabelChangeOperation(ctx, sel, obj)
10491 case *bug.CreateTimelineItem:
10492 if obj == nil {
10493 return graphql.Null
10494 }
10495 return ec._CreateTimelineItem(ctx, sel, obj)
10496 case *bug.AddCommentTimelineItem:
10497 if obj == nil {
10498 return graphql.Null
10499 }
10500 return ec._AddCommentTimelineItem(ctx, sel, obj)
10501 case *bug.LabelChangeTimelineItem:
10502 if obj == nil {
10503 return graphql.Null
10504 }
10505 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10506 case *bug.SetStatusTimelineItem:
10507 if obj == nil {
10508 return graphql.Null
10509 }
10510 return ec._SetStatusTimelineItem(ctx, sel, obj)
10511 case *bug.SetTitleTimelineItem:
10512 if obj == nil {
10513 return graphql.Null
10514 }
10515 return ec._SetTitleTimelineItem(ctx, sel, obj)
10516 default:
10517 panic(fmt.Errorf("unexpected type %T", obj))
10518 }
10519}
10520
10521func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
10522 switch obj := (obj).(type) {
10523 case nil:
10524 return graphql.Null
10525 case *bug.CreateOperation:
10526 if obj == nil {
10527 return graphql.Null
10528 }
10529 return ec._CreateOperation(ctx, sel, obj)
10530 case *bug.SetTitleOperation:
10531 if obj == nil {
10532 return graphql.Null
10533 }
10534 return ec._SetTitleOperation(ctx, sel, obj)
10535 case *bug.AddCommentOperation:
10536 if obj == nil {
10537 return graphql.Null
10538 }
10539 return ec._AddCommentOperation(ctx, sel, obj)
10540 case *bug.EditCommentOperation:
10541 if obj == nil {
10542 return graphql.Null
10543 }
10544 return ec._EditCommentOperation(ctx, sel, obj)
10545 case *bug.SetStatusOperation:
10546 if obj == nil {
10547 return graphql.Null
10548 }
10549 return ec._SetStatusOperation(ctx, sel, obj)
10550 case *bug.LabelChangeOperation:
10551 if obj == nil {
10552 return graphql.Null
10553 }
10554 return ec._LabelChangeOperation(ctx, sel, obj)
10555 default:
10556 panic(fmt.Errorf("unexpected type %T", obj))
10557 }
10558}
10559
10560func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
10561 switch obj := (obj).(type) {
10562 case nil:
10563 return graphql.Null
10564 case *bug.CreateTimelineItem:
10565 if obj == nil {
10566 return graphql.Null
10567 }
10568 return ec._CreateTimelineItem(ctx, sel, obj)
10569 case *bug.AddCommentTimelineItem:
10570 if obj == nil {
10571 return graphql.Null
10572 }
10573 return ec._AddCommentTimelineItem(ctx, sel, obj)
10574 case bug.LabelChangeTimelineItem:
10575 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10576 case *bug.LabelChangeTimelineItem:
10577 if obj == nil {
10578 return graphql.Null
10579 }
10580 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10581 case bug.SetStatusTimelineItem:
10582 return ec._SetStatusTimelineItem(ctx, sel, &obj)
10583 case *bug.SetStatusTimelineItem:
10584 if obj == nil {
10585 return graphql.Null
10586 }
10587 return ec._SetStatusTimelineItem(ctx, sel, obj)
10588 case bug.SetTitleTimelineItem:
10589 return ec._SetTitleTimelineItem(ctx, sel, &obj)
10590 case *bug.SetTitleTimelineItem:
10591 if obj == nil {
10592 return graphql.Null
10593 }
10594 return ec._SetTitleTimelineItem(ctx, sel, obj)
10595 default:
10596 panic(fmt.Errorf("unexpected type %T", obj))
10597 }
10598}
10599
10600// endregion ************************** interface.gotpl ***************************
10601
10602// region **************************** object.gotpl ****************************
10603
10604var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10605
10606func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10607 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
10608
10609 out := graphql.NewFieldSet(fields)
10610 var invalids uint32
10611 for i, field := range fields {
10612 switch field.Name {
10613 case "__typename":
10614 out.Values[i] = graphql.MarshalString("AddCommentOperation")
10615 case "id":
10616 field := field
10617 out.Concurrently(i, func() (res graphql.Marshaler) {
10618 defer func() {
10619 if r := recover(); r != nil {
10620 ec.Error(ctx, ec.Recover(ctx, r))
10621 }
10622 }()
10623 res = ec._AddCommentOperation_id(ctx, field, obj)
10624 if res == graphql.Null {
10625 atomic.AddUint32(&invalids, 1)
10626 }
10627 return res
10628 })
10629 case "author":
10630 field := field
10631 out.Concurrently(i, func() (res graphql.Marshaler) {
10632 defer func() {
10633 if r := recover(); r != nil {
10634 ec.Error(ctx, ec.Recover(ctx, r))
10635 }
10636 }()
10637 res = ec._AddCommentOperation_author(ctx, field, obj)
10638 if res == graphql.Null {
10639 atomic.AddUint32(&invalids, 1)
10640 }
10641 return res
10642 })
10643 case "date":
10644 field := field
10645 out.Concurrently(i, func() (res graphql.Marshaler) {
10646 defer func() {
10647 if r := recover(); r != nil {
10648 ec.Error(ctx, ec.Recover(ctx, r))
10649 }
10650 }()
10651 res = ec._AddCommentOperation_date(ctx, field, obj)
10652 if res == graphql.Null {
10653 atomic.AddUint32(&invalids, 1)
10654 }
10655 return res
10656 })
10657 case "message":
10658 out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10659 if out.Values[i] == graphql.Null {
10660 atomic.AddUint32(&invalids, 1)
10661 }
10662 case "files":
10663 out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10664 if out.Values[i] == graphql.Null {
10665 atomic.AddUint32(&invalids, 1)
10666 }
10667 default:
10668 panic("unknown field " + strconv.Quote(field.Name))
10669 }
10670 }
10671 out.Dispatch()
10672 if invalids > 0 {
10673 return graphql.Null
10674 }
10675 return out
10676}
10677
10678var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10679
10680func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10681 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
10682
10683 out := graphql.NewFieldSet(fields)
10684 var invalids uint32
10685 for i, field := range fields {
10686 switch field.Name {
10687 case "__typename":
10688 out.Values[i] = graphql.MarshalString("AddCommentPayload")
10689 case "clientMutationId":
10690 out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10691 case "bug":
10692 out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10693 if out.Values[i] == graphql.Null {
10694 invalids++
10695 }
10696 case "operation":
10697 out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10698 if out.Values[i] == graphql.Null {
10699 invalids++
10700 }
10701 default:
10702 panic("unknown field " + strconv.Quote(field.Name))
10703 }
10704 }
10705 out.Dispatch()
10706 if invalids > 0 {
10707 return graphql.Null
10708 }
10709 return out
10710}
10711
10712var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10713
10714func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10715 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
10716
10717 out := graphql.NewFieldSet(fields)
10718 var invalids uint32
10719 for i, field := range fields {
10720 switch field.Name {
10721 case "__typename":
10722 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10723 case "id":
10724 field := field
10725 out.Concurrently(i, func() (res graphql.Marshaler) {
10726 defer func() {
10727 if r := recover(); r != nil {
10728 ec.Error(ctx, ec.Recover(ctx, r))
10729 }
10730 }()
10731 res = ec._AddCommentTimelineItem_id(ctx, field, obj)
10732 if res == graphql.Null {
10733 atomic.AddUint32(&invalids, 1)
10734 }
10735 return res
10736 })
10737 case "author":
10738 field := field
10739 out.Concurrently(i, func() (res graphql.Marshaler) {
10740 defer func() {
10741 if r := recover(); r != nil {
10742 ec.Error(ctx, ec.Recover(ctx, r))
10743 }
10744 }()
10745 res = ec._AddCommentTimelineItem_author(ctx, field, obj)
10746 if res == graphql.Null {
10747 atomic.AddUint32(&invalids, 1)
10748 }
10749 return res
10750 })
10751 case "message":
10752 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
10753 if out.Values[i] == graphql.Null {
10754 atomic.AddUint32(&invalids, 1)
10755 }
10756 case "messageIsEmpty":
10757 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
10758 if out.Values[i] == graphql.Null {
10759 atomic.AddUint32(&invalids, 1)
10760 }
10761 case "files":
10762 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
10763 if out.Values[i] == graphql.Null {
10764 atomic.AddUint32(&invalids, 1)
10765 }
10766 case "createdAt":
10767 field := field
10768 out.Concurrently(i, func() (res graphql.Marshaler) {
10769 defer func() {
10770 if r := recover(); r != nil {
10771 ec.Error(ctx, ec.Recover(ctx, r))
10772 }
10773 }()
10774 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
10775 if res == graphql.Null {
10776 atomic.AddUint32(&invalids, 1)
10777 }
10778 return res
10779 })
10780 case "lastEdit":
10781 field := field
10782 out.Concurrently(i, func() (res graphql.Marshaler) {
10783 defer func() {
10784 if r := recover(); r != nil {
10785 ec.Error(ctx, ec.Recover(ctx, r))
10786 }
10787 }()
10788 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
10789 if res == graphql.Null {
10790 atomic.AddUint32(&invalids, 1)
10791 }
10792 return res
10793 })
10794 case "edited":
10795 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
10796 if out.Values[i] == graphql.Null {
10797 atomic.AddUint32(&invalids, 1)
10798 }
10799 case "history":
10800 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
10801 if out.Values[i] == graphql.Null {
10802 atomic.AddUint32(&invalids, 1)
10803 }
10804 default:
10805 panic("unknown field " + strconv.Quote(field.Name))
10806 }
10807 }
10808 out.Dispatch()
10809 if invalids > 0 {
10810 return graphql.Null
10811 }
10812 return out
10813}
10814
10815var bugImplementors = []string{"Bug", "Authored"}
10816
10817func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
10818 fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
10819
10820 out := graphql.NewFieldSet(fields)
10821 var invalids uint32
10822 for i, field := range fields {
10823 switch field.Name {
10824 case "__typename":
10825 out.Values[i] = graphql.MarshalString("Bug")
10826 case "id":
10827 field := field
10828 out.Concurrently(i, func() (res graphql.Marshaler) {
10829 defer func() {
10830 if r := recover(); r != nil {
10831 ec.Error(ctx, ec.Recover(ctx, r))
10832 }
10833 }()
10834 res = ec._Bug_id(ctx, field, obj)
10835 if res == graphql.Null {
10836 atomic.AddUint32(&invalids, 1)
10837 }
10838 return res
10839 })
10840 case "humanId":
10841 field := field
10842 out.Concurrently(i, func() (res graphql.Marshaler) {
10843 defer func() {
10844 if r := recover(); r != nil {
10845 ec.Error(ctx, ec.Recover(ctx, r))
10846 }
10847 }()
10848 res = ec._Bug_humanId(ctx, field, obj)
10849 if res == graphql.Null {
10850 atomic.AddUint32(&invalids, 1)
10851 }
10852 return res
10853 })
10854 case "status":
10855 field := field
10856 out.Concurrently(i, func() (res graphql.Marshaler) {
10857 defer func() {
10858 if r := recover(); r != nil {
10859 ec.Error(ctx, ec.Recover(ctx, r))
10860 }
10861 }()
10862 res = ec._Bug_status(ctx, field, obj)
10863 if res == graphql.Null {
10864 atomic.AddUint32(&invalids, 1)
10865 }
10866 return res
10867 })
10868 case "title":
10869 out.Values[i] = ec._Bug_title(ctx, field, obj)
10870 if out.Values[i] == graphql.Null {
10871 atomic.AddUint32(&invalids, 1)
10872 }
10873 case "labels":
10874 out.Values[i] = ec._Bug_labels(ctx, field, obj)
10875 if out.Values[i] == graphql.Null {
10876 atomic.AddUint32(&invalids, 1)
10877 }
10878 case "author":
10879 out.Values[i] = ec._Bug_author(ctx, field, obj)
10880 if out.Values[i] == graphql.Null {
10881 atomic.AddUint32(&invalids, 1)
10882 }
10883 case "createdAt":
10884 out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
10885 if out.Values[i] == graphql.Null {
10886 atomic.AddUint32(&invalids, 1)
10887 }
10888 case "lastEdit":
10889 out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
10890 if out.Values[i] == graphql.Null {
10891 atomic.AddUint32(&invalids, 1)
10892 }
10893 case "actors":
10894 field := field
10895 out.Concurrently(i, func() (res graphql.Marshaler) {
10896 defer func() {
10897 if r := recover(); r != nil {
10898 ec.Error(ctx, ec.Recover(ctx, r))
10899 }
10900 }()
10901 res = ec._Bug_actors(ctx, field, obj)
10902 if res == graphql.Null {
10903 atomic.AddUint32(&invalids, 1)
10904 }
10905 return res
10906 })
10907 case "participants":
10908 field := field
10909 out.Concurrently(i, func() (res graphql.Marshaler) {
10910 defer func() {
10911 if r := recover(); r != nil {
10912 ec.Error(ctx, ec.Recover(ctx, r))
10913 }
10914 }()
10915 res = ec._Bug_participants(ctx, field, obj)
10916 if res == graphql.Null {
10917 atomic.AddUint32(&invalids, 1)
10918 }
10919 return res
10920 })
10921 case "comments":
10922 field := field
10923 out.Concurrently(i, func() (res graphql.Marshaler) {
10924 defer func() {
10925 if r := recover(); r != nil {
10926 ec.Error(ctx, ec.Recover(ctx, r))
10927 }
10928 }()
10929 res = ec._Bug_comments(ctx, field, obj)
10930 if res == graphql.Null {
10931 atomic.AddUint32(&invalids, 1)
10932 }
10933 return res
10934 })
10935 case "timeline":
10936 field := field
10937 out.Concurrently(i, func() (res graphql.Marshaler) {
10938 defer func() {
10939 if r := recover(); r != nil {
10940 ec.Error(ctx, ec.Recover(ctx, r))
10941 }
10942 }()
10943 res = ec._Bug_timeline(ctx, field, obj)
10944 if res == graphql.Null {
10945 atomic.AddUint32(&invalids, 1)
10946 }
10947 return res
10948 })
10949 case "operations":
10950 field := field
10951 out.Concurrently(i, func() (res graphql.Marshaler) {
10952 defer func() {
10953 if r := recover(); r != nil {
10954 ec.Error(ctx, ec.Recover(ctx, r))
10955 }
10956 }()
10957 res = ec._Bug_operations(ctx, field, obj)
10958 if res == graphql.Null {
10959 atomic.AddUint32(&invalids, 1)
10960 }
10961 return res
10962 })
10963 default:
10964 panic("unknown field " + strconv.Quote(field.Name))
10965 }
10966 }
10967 out.Dispatch()
10968 if invalids > 0 {
10969 return graphql.Null
10970 }
10971 return out
10972}
10973
10974var bugConnectionImplementors = []string{"BugConnection"}
10975
10976func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
10977 fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
10978
10979 out := graphql.NewFieldSet(fields)
10980 var invalids uint32
10981 for i, field := range fields {
10982 switch field.Name {
10983 case "__typename":
10984 out.Values[i] = graphql.MarshalString("BugConnection")
10985 case "edges":
10986 out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
10987 if out.Values[i] == graphql.Null {
10988 invalids++
10989 }
10990 case "nodes":
10991 out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
10992 if out.Values[i] == graphql.Null {
10993 invalids++
10994 }
10995 case "pageInfo":
10996 out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
10997 if out.Values[i] == graphql.Null {
10998 invalids++
10999 }
11000 case "totalCount":
11001 out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
11002 if out.Values[i] == graphql.Null {
11003 invalids++
11004 }
11005 default:
11006 panic("unknown field " + strconv.Quote(field.Name))
11007 }
11008 }
11009 out.Dispatch()
11010 if invalids > 0 {
11011 return graphql.Null
11012 }
11013 return out
11014}
11015
11016var bugEdgeImplementors = []string{"BugEdge"}
11017
11018func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
11019 fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
11020
11021 out := graphql.NewFieldSet(fields)
11022 var invalids uint32
11023 for i, field := range fields {
11024 switch field.Name {
11025 case "__typename":
11026 out.Values[i] = graphql.MarshalString("BugEdge")
11027 case "cursor":
11028 out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
11029 if out.Values[i] == graphql.Null {
11030 invalids++
11031 }
11032 case "node":
11033 out.Values[i] = ec._BugEdge_node(ctx, field, obj)
11034 if out.Values[i] == graphql.Null {
11035 invalids++
11036 }
11037 default:
11038 panic("unknown field " + strconv.Quote(field.Name))
11039 }
11040 }
11041 out.Dispatch()
11042 if invalids > 0 {
11043 return graphql.Null
11044 }
11045 return out
11046}
11047
11048var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
11049
11050func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
11051 fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
11052
11053 out := graphql.NewFieldSet(fields)
11054 var invalids uint32
11055 for i, field := range fields {
11056 switch field.Name {
11057 case "__typename":
11058 out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
11059 case "clientMutationId":
11060 out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
11061 case "bug":
11062 out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
11063 if out.Values[i] == graphql.Null {
11064 invalids++
11065 }
11066 case "operation":
11067 out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
11068 if out.Values[i] == graphql.Null {
11069 invalids++
11070 }
11071 case "results":
11072 out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
11073 if out.Values[i] == graphql.Null {
11074 invalids++
11075 }
11076 default:
11077 panic("unknown field " + strconv.Quote(field.Name))
11078 }
11079 }
11080 out.Dispatch()
11081 if invalids > 0 {
11082 return graphql.Null
11083 }
11084 return out
11085}
11086
11087var closeBugPayloadImplementors = []string{"CloseBugPayload"}
11088
11089func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11090 fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
11091
11092 out := graphql.NewFieldSet(fields)
11093 var invalids uint32
11094 for i, field := range fields {
11095 switch field.Name {
11096 case "__typename":
11097 out.Values[i] = graphql.MarshalString("CloseBugPayload")
11098 case "clientMutationId":
11099 out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11100 case "bug":
11101 out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11102 if out.Values[i] == graphql.Null {
11103 invalids++
11104 }
11105 case "operation":
11106 out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11107 if out.Values[i] == graphql.Null {
11108 invalids++
11109 }
11110 default:
11111 panic("unknown field " + strconv.Quote(field.Name))
11112 }
11113 }
11114 out.Dispatch()
11115 if invalids > 0 {
11116 return graphql.Null
11117 }
11118 return out
11119}
11120
11121var colorImplementors = []string{"Color"}
11122
11123func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11124 fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
11125
11126 out := graphql.NewFieldSet(fields)
11127 var invalids uint32
11128 for i, field := range fields {
11129 switch field.Name {
11130 case "__typename":
11131 out.Values[i] = graphql.MarshalString("Color")
11132 case "R":
11133 field := field
11134 out.Concurrently(i, func() (res graphql.Marshaler) {
11135 defer func() {
11136 if r := recover(); r != nil {
11137 ec.Error(ctx, ec.Recover(ctx, r))
11138 }
11139 }()
11140 res = ec._Color_R(ctx, field, obj)
11141 if res == graphql.Null {
11142 atomic.AddUint32(&invalids, 1)
11143 }
11144 return res
11145 })
11146 case "G":
11147 field := field
11148 out.Concurrently(i, func() (res graphql.Marshaler) {
11149 defer func() {
11150 if r := recover(); r != nil {
11151 ec.Error(ctx, ec.Recover(ctx, r))
11152 }
11153 }()
11154 res = ec._Color_G(ctx, field, obj)
11155 if res == graphql.Null {
11156 atomic.AddUint32(&invalids, 1)
11157 }
11158 return res
11159 })
11160 case "B":
11161 field := field
11162 out.Concurrently(i, func() (res graphql.Marshaler) {
11163 defer func() {
11164 if r := recover(); r != nil {
11165 ec.Error(ctx, ec.Recover(ctx, r))
11166 }
11167 }()
11168 res = ec._Color_B(ctx, field, obj)
11169 if res == graphql.Null {
11170 atomic.AddUint32(&invalids, 1)
11171 }
11172 return res
11173 })
11174 default:
11175 panic("unknown field " + strconv.Quote(field.Name))
11176 }
11177 }
11178 out.Dispatch()
11179 if invalids > 0 {
11180 return graphql.Null
11181 }
11182 return out
11183}
11184
11185var commentImplementors = []string{"Comment", "Authored"}
11186
11187func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11188 fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
11189
11190 out := graphql.NewFieldSet(fields)
11191 var invalids uint32
11192 for i, field := range fields {
11193 switch field.Name {
11194 case "__typename":
11195 out.Values[i] = graphql.MarshalString("Comment")
11196 case "author":
11197 field := field
11198 out.Concurrently(i, func() (res graphql.Marshaler) {
11199 defer func() {
11200 if r := recover(); r != nil {
11201 ec.Error(ctx, ec.Recover(ctx, r))
11202 }
11203 }()
11204 res = ec._Comment_author(ctx, field, obj)
11205 if res == graphql.Null {
11206 atomic.AddUint32(&invalids, 1)
11207 }
11208 return res
11209 })
11210 case "message":
11211 out.Values[i] = ec._Comment_message(ctx, field, obj)
11212 if out.Values[i] == graphql.Null {
11213 atomic.AddUint32(&invalids, 1)
11214 }
11215 case "files":
11216 out.Values[i] = ec._Comment_files(ctx, field, obj)
11217 if out.Values[i] == graphql.Null {
11218 atomic.AddUint32(&invalids, 1)
11219 }
11220 default:
11221 panic("unknown field " + strconv.Quote(field.Name))
11222 }
11223 }
11224 out.Dispatch()
11225 if invalids > 0 {
11226 return graphql.Null
11227 }
11228 return out
11229}
11230
11231var commentConnectionImplementors = []string{"CommentConnection"}
11232
11233func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11234 fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
11235
11236 out := graphql.NewFieldSet(fields)
11237 var invalids uint32
11238 for i, field := range fields {
11239 switch field.Name {
11240 case "__typename":
11241 out.Values[i] = graphql.MarshalString("CommentConnection")
11242 case "edges":
11243 out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11244 if out.Values[i] == graphql.Null {
11245 invalids++
11246 }
11247 case "nodes":
11248 out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11249 if out.Values[i] == graphql.Null {
11250 invalids++
11251 }
11252 case "pageInfo":
11253 out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11254 if out.Values[i] == graphql.Null {
11255 invalids++
11256 }
11257 case "totalCount":
11258 out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11259 if out.Values[i] == graphql.Null {
11260 invalids++
11261 }
11262 default:
11263 panic("unknown field " + strconv.Quote(field.Name))
11264 }
11265 }
11266 out.Dispatch()
11267 if invalids > 0 {
11268 return graphql.Null
11269 }
11270 return out
11271}
11272
11273var commentEdgeImplementors = []string{"CommentEdge"}
11274
11275func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11276 fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
11277
11278 out := graphql.NewFieldSet(fields)
11279 var invalids uint32
11280 for i, field := range fields {
11281 switch field.Name {
11282 case "__typename":
11283 out.Values[i] = graphql.MarshalString("CommentEdge")
11284 case "cursor":
11285 out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11286 if out.Values[i] == graphql.Null {
11287 invalids++
11288 }
11289 case "node":
11290 out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11291 if out.Values[i] == graphql.Null {
11292 invalids++
11293 }
11294 default:
11295 panic("unknown field " + strconv.Quote(field.Name))
11296 }
11297 }
11298 out.Dispatch()
11299 if invalids > 0 {
11300 return graphql.Null
11301 }
11302 return out
11303}
11304
11305var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11306
11307func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11308 fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
11309
11310 out := graphql.NewFieldSet(fields)
11311 var invalids uint32
11312 for i, field := range fields {
11313 switch field.Name {
11314 case "__typename":
11315 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11316 case "message":
11317 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11318 if out.Values[i] == graphql.Null {
11319 atomic.AddUint32(&invalids, 1)
11320 }
11321 case "date":
11322 field := field
11323 out.Concurrently(i, func() (res graphql.Marshaler) {
11324 defer func() {
11325 if r := recover(); r != nil {
11326 ec.Error(ctx, ec.Recover(ctx, r))
11327 }
11328 }()
11329 res = ec._CommentHistoryStep_date(ctx, field, obj)
11330 if res == graphql.Null {
11331 atomic.AddUint32(&invalids, 1)
11332 }
11333 return res
11334 })
11335 default:
11336 panic("unknown field " + strconv.Quote(field.Name))
11337 }
11338 }
11339 out.Dispatch()
11340 if invalids > 0 {
11341 return graphql.Null
11342 }
11343 return out
11344}
11345
11346var commitAsNeededPayloadImplementors = []string{"CommitAsNeededPayload"}
11347
11348func (ec *executionContext) _CommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitAsNeededPayload) graphql.Marshaler {
11349 fields := graphql.CollectFields(ec.OperationContext, sel, commitAsNeededPayloadImplementors)
11350
11351 out := graphql.NewFieldSet(fields)
11352 var invalids uint32
11353 for i, field := range fields {
11354 switch field.Name {
11355 case "__typename":
11356 out.Values[i] = graphql.MarshalString("CommitAsNeededPayload")
11357 case "clientMutationId":
11358 out.Values[i] = ec._CommitAsNeededPayload_clientMutationId(ctx, field, obj)
11359 case "bug":
11360 out.Values[i] = ec._CommitAsNeededPayload_bug(ctx, field, obj)
11361 if out.Values[i] == graphql.Null {
11362 invalids++
11363 }
11364 default:
11365 panic("unknown field " + strconv.Quote(field.Name))
11366 }
11367 }
11368 out.Dispatch()
11369 if invalids > 0 {
11370 return graphql.Null
11371 }
11372 return out
11373}
11374
11375var commitPayloadImplementors = []string{"CommitPayload"}
11376
11377func (ec *executionContext) _CommitPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitPayload) graphql.Marshaler {
11378 fields := graphql.CollectFields(ec.OperationContext, sel, commitPayloadImplementors)
11379
11380 out := graphql.NewFieldSet(fields)
11381 var invalids uint32
11382 for i, field := range fields {
11383 switch field.Name {
11384 case "__typename":
11385 out.Values[i] = graphql.MarshalString("CommitPayload")
11386 case "clientMutationId":
11387 out.Values[i] = ec._CommitPayload_clientMutationId(ctx, field, obj)
11388 case "bug":
11389 out.Values[i] = ec._CommitPayload_bug(ctx, field, obj)
11390 if out.Values[i] == graphql.Null {
11391 invalids++
11392 }
11393 default:
11394 panic("unknown field " + strconv.Quote(field.Name))
11395 }
11396 }
11397 out.Dispatch()
11398 if invalids > 0 {
11399 return graphql.Null
11400 }
11401 return out
11402}
11403
11404var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11405
11406func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11407 fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
11408
11409 out := graphql.NewFieldSet(fields)
11410 var invalids uint32
11411 for i, field := range fields {
11412 switch field.Name {
11413 case "__typename":
11414 out.Values[i] = graphql.MarshalString("CreateOperation")
11415 case "id":
11416 field := field
11417 out.Concurrently(i, func() (res graphql.Marshaler) {
11418 defer func() {
11419 if r := recover(); r != nil {
11420 ec.Error(ctx, ec.Recover(ctx, r))
11421 }
11422 }()
11423 res = ec._CreateOperation_id(ctx, field, obj)
11424 if res == graphql.Null {
11425 atomic.AddUint32(&invalids, 1)
11426 }
11427 return res
11428 })
11429 case "author":
11430 field := field
11431 out.Concurrently(i, func() (res graphql.Marshaler) {
11432 defer func() {
11433 if r := recover(); r != nil {
11434 ec.Error(ctx, ec.Recover(ctx, r))
11435 }
11436 }()
11437 res = ec._CreateOperation_author(ctx, field, obj)
11438 if res == graphql.Null {
11439 atomic.AddUint32(&invalids, 1)
11440 }
11441 return res
11442 })
11443 case "date":
11444 field := field
11445 out.Concurrently(i, func() (res graphql.Marshaler) {
11446 defer func() {
11447 if r := recover(); r != nil {
11448 ec.Error(ctx, ec.Recover(ctx, r))
11449 }
11450 }()
11451 res = ec._CreateOperation_date(ctx, field, obj)
11452 if res == graphql.Null {
11453 atomic.AddUint32(&invalids, 1)
11454 }
11455 return res
11456 })
11457 case "title":
11458 out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11459 if out.Values[i] == graphql.Null {
11460 atomic.AddUint32(&invalids, 1)
11461 }
11462 case "message":
11463 out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11464 if out.Values[i] == graphql.Null {
11465 atomic.AddUint32(&invalids, 1)
11466 }
11467 case "files":
11468 out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11469 if out.Values[i] == graphql.Null {
11470 atomic.AddUint32(&invalids, 1)
11471 }
11472 default:
11473 panic("unknown field " + strconv.Quote(field.Name))
11474 }
11475 }
11476 out.Dispatch()
11477 if invalids > 0 {
11478 return graphql.Null
11479 }
11480 return out
11481}
11482
11483var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11484
11485func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11486 fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
11487
11488 out := graphql.NewFieldSet(fields)
11489 var invalids uint32
11490 for i, field := range fields {
11491 switch field.Name {
11492 case "__typename":
11493 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11494 case "id":
11495 field := field
11496 out.Concurrently(i, func() (res graphql.Marshaler) {
11497 defer func() {
11498 if r := recover(); r != nil {
11499 ec.Error(ctx, ec.Recover(ctx, r))
11500 }
11501 }()
11502 res = ec._CreateTimelineItem_id(ctx, field, obj)
11503 if res == graphql.Null {
11504 atomic.AddUint32(&invalids, 1)
11505 }
11506 return res
11507 })
11508 case "author":
11509 field := field
11510 out.Concurrently(i, func() (res graphql.Marshaler) {
11511 defer func() {
11512 if r := recover(); r != nil {
11513 ec.Error(ctx, ec.Recover(ctx, r))
11514 }
11515 }()
11516 res = ec._CreateTimelineItem_author(ctx, field, obj)
11517 if res == graphql.Null {
11518 atomic.AddUint32(&invalids, 1)
11519 }
11520 return res
11521 })
11522 case "message":
11523 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11524 if out.Values[i] == graphql.Null {
11525 atomic.AddUint32(&invalids, 1)
11526 }
11527 case "messageIsEmpty":
11528 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11529 if out.Values[i] == graphql.Null {
11530 atomic.AddUint32(&invalids, 1)
11531 }
11532 case "files":
11533 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11534 if out.Values[i] == graphql.Null {
11535 atomic.AddUint32(&invalids, 1)
11536 }
11537 case "createdAt":
11538 field := field
11539 out.Concurrently(i, func() (res graphql.Marshaler) {
11540 defer func() {
11541 if r := recover(); r != nil {
11542 ec.Error(ctx, ec.Recover(ctx, r))
11543 }
11544 }()
11545 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11546 if res == graphql.Null {
11547 atomic.AddUint32(&invalids, 1)
11548 }
11549 return res
11550 })
11551 case "lastEdit":
11552 field := field
11553 out.Concurrently(i, func() (res graphql.Marshaler) {
11554 defer func() {
11555 if r := recover(); r != nil {
11556 ec.Error(ctx, ec.Recover(ctx, r))
11557 }
11558 }()
11559 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11560 if res == graphql.Null {
11561 atomic.AddUint32(&invalids, 1)
11562 }
11563 return res
11564 })
11565 case "edited":
11566 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11567 if out.Values[i] == graphql.Null {
11568 atomic.AddUint32(&invalids, 1)
11569 }
11570 case "history":
11571 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11572 if out.Values[i] == graphql.Null {
11573 atomic.AddUint32(&invalids, 1)
11574 }
11575 default:
11576 panic("unknown field " + strconv.Quote(field.Name))
11577 }
11578 }
11579 out.Dispatch()
11580 if invalids > 0 {
11581 return graphql.Null
11582 }
11583 return out
11584}
11585
11586var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11587
11588func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11589 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
11590
11591 out := graphql.NewFieldSet(fields)
11592 var invalids uint32
11593 for i, field := range fields {
11594 switch field.Name {
11595 case "__typename":
11596 out.Values[i] = graphql.MarshalString("EditCommentOperation")
11597 case "id":
11598 field := field
11599 out.Concurrently(i, func() (res graphql.Marshaler) {
11600 defer func() {
11601 if r := recover(); r != nil {
11602 ec.Error(ctx, ec.Recover(ctx, r))
11603 }
11604 }()
11605 res = ec._EditCommentOperation_id(ctx, field, obj)
11606 if res == graphql.Null {
11607 atomic.AddUint32(&invalids, 1)
11608 }
11609 return res
11610 })
11611 case "author":
11612 field := field
11613 out.Concurrently(i, func() (res graphql.Marshaler) {
11614 defer func() {
11615 if r := recover(); r != nil {
11616 ec.Error(ctx, ec.Recover(ctx, r))
11617 }
11618 }()
11619 res = ec._EditCommentOperation_author(ctx, field, obj)
11620 if res == graphql.Null {
11621 atomic.AddUint32(&invalids, 1)
11622 }
11623 return res
11624 })
11625 case "date":
11626 field := field
11627 out.Concurrently(i, func() (res graphql.Marshaler) {
11628 defer func() {
11629 if r := recover(); r != nil {
11630 ec.Error(ctx, ec.Recover(ctx, r))
11631 }
11632 }()
11633 res = ec._EditCommentOperation_date(ctx, field, obj)
11634 if res == graphql.Null {
11635 atomic.AddUint32(&invalids, 1)
11636 }
11637 return res
11638 })
11639 case "target":
11640 field := field
11641 out.Concurrently(i, func() (res graphql.Marshaler) {
11642 defer func() {
11643 if r := recover(); r != nil {
11644 ec.Error(ctx, ec.Recover(ctx, r))
11645 }
11646 }()
11647 res = ec._EditCommentOperation_target(ctx, field, obj)
11648 if res == graphql.Null {
11649 atomic.AddUint32(&invalids, 1)
11650 }
11651 return res
11652 })
11653 case "message":
11654 out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11655 if out.Values[i] == graphql.Null {
11656 atomic.AddUint32(&invalids, 1)
11657 }
11658 case "files":
11659 out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11660 if out.Values[i] == graphql.Null {
11661 atomic.AddUint32(&invalids, 1)
11662 }
11663 default:
11664 panic("unknown field " + strconv.Quote(field.Name))
11665 }
11666 }
11667 out.Dispatch()
11668 if invalids > 0 {
11669 return graphql.Null
11670 }
11671 return out
11672}
11673
11674var identityImplementors = []string{"Identity"}
11675
11676func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
11677 fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
11678
11679 out := graphql.NewFieldSet(fields)
11680 var invalids uint32
11681 for i, field := range fields {
11682 switch field.Name {
11683 case "__typename":
11684 out.Values[i] = graphql.MarshalString("Identity")
11685 case "id":
11686 field := field
11687 out.Concurrently(i, func() (res graphql.Marshaler) {
11688 defer func() {
11689 if r := recover(); r != nil {
11690 ec.Error(ctx, ec.Recover(ctx, r))
11691 }
11692 }()
11693 res = ec._Identity_id(ctx, field, obj)
11694 if res == graphql.Null {
11695 atomic.AddUint32(&invalids, 1)
11696 }
11697 return res
11698 })
11699 case "humanId":
11700 field := field
11701 out.Concurrently(i, func() (res graphql.Marshaler) {
11702 defer func() {
11703 if r := recover(); r != nil {
11704 ec.Error(ctx, ec.Recover(ctx, r))
11705 }
11706 }()
11707 res = ec._Identity_humanId(ctx, field, obj)
11708 if res == graphql.Null {
11709 atomic.AddUint32(&invalids, 1)
11710 }
11711 return res
11712 })
11713 case "name":
11714 out.Values[i] = ec._Identity_name(ctx, field, obj)
11715 case "email":
11716 out.Values[i] = ec._Identity_email(ctx, field, obj)
11717 case "displayName":
11718 out.Values[i] = ec._Identity_displayName(ctx, field, obj)
11719 if out.Values[i] == graphql.Null {
11720 atomic.AddUint32(&invalids, 1)
11721 }
11722 case "avatarUrl":
11723 out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
11724 case "isProtected":
11725 out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
11726 if out.Values[i] == graphql.Null {
11727 atomic.AddUint32(&invalids, 1)
11728 }
11729 default:
11730 panic("unknown field " + strconv.Quote(field.Name))
11731 }
11732 }
11733 out.Dispatch()
11734 if invalids > 0 {
11735 return graphql.Null
11736 }
11737 return out
11738}
11739
11740var identityConnectionImplementors = []string{"IdentityConnection"}
11741
11742func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
11743 fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
11744
11745 out := graphql.NewFieldSet(fields)
11746 var invalids uint32
11747 for i, field := range fields {
11748 switch field.Name {
11749 case "__typename":
11750 out.Values[i] = graphql.MarshalString("IdentityConnection")
11751 case "edges":
11752 out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
11753 if out.Values[i] == graphql.Null {
11754 invalids++
11755 }
11756 case "nodes":
11757 out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
11758 if out.Values[i] == graphql.Null {
11759 invalids++
11760 }
11761 case "pageInfo":
11762 out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
11763 if out.Values[i] == graphql.Null {
11764 invalids++
11765 }
11766 case "totalCount":
11767 out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
11768 if out.Values[i] == graphql.Null {
11769 invalids++
11770 }
11771 default:
11772 panic("unknown field " + strconv.Quote(field.Name))
11773 }
11774 }
11775 out.Dispatch()
11776 if invalids > 0 {
11777 return graphql.Null
11778 }
11779 return out
11780}
11781
11782var identityEdgeImplementors = []string{"IdentityEdge"}
11783
11784func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
11785 fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
11786
11787 out := graphql.NewFieldSet(fields)
11788 var invalids uint32
11789 for i, field := range fields {
11790 switch field.Name {
11791 case "__typename":
11792 out.Values[i] = graphql.MarshalString("IdentityEdge")
11793 case "cursor":
11794 out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
11795 if out.Values[i] == graphql.Null {
11796 invalids++
11797 }
11798 case "node":
11799 out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
11800 if out.Values[i] == graphql.Null {
11801 invalids++
11802 }
11803 default:
11804 panic("unknown field " + strconv.Quote(field.Name))
11805 }
11806 }
11807 out.Dispatch()
11808 if invalids > 0 {
11809 return graphql.Null
11810 }
11811 return out
11812}
11813
11814var labelImplementors = []string{"Label"}
11815
11816func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
11817 fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
11818
11819 out := graphql.NewFieldSet(fields)
11820 var invalids uint32
11821 for i, field := range fields {
11822 switch field.Name {
11823 case "__typename":
11824 out.Values[i] = graphql.MarshalString("Label")
11825 case "name":
11826 field := field
11827 out.Concurrently(i, func() (res graphql.Marshaler) {
11828 defer func() {
11829 if r := recover(); r != nil {
11830 ec.Error(ctx, ec.Recover(ctx, r))
11831 }
11832 }()
11833 res = ec._Label_name(ctx, field, obj)
11834 if res == graphql.Null {
11835 atomic.AddUint32(&invalids, 1)
11836 }
11837 return res
11838 })
11839 case "color":
11840 field := field
11841 out.Concurrently(i, func() (res graphql.Marshaler) {
11842 defer func() {
11843 if r := recover(); r != nil {
11844 ec.Error(ctx, ec.Recover(ctx, r))
11845 }
11846 }()
11847 res = ec._Label_color(ctx, field, obj)
11848 if res == graphql.Null {
11849 atomic.AddUint32(&invalids, 1)
11850 }
11851 return res
11852 })
11853 default:
11854 panic("unknown field " + strconv.Quote(field.Name))
11855 }
11856 }
11857 out.Dispatch()
11858 if invalids > 0 {
11859 return graphql.Null
11860 }
11861 return out
11862}
11863
11864var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
11865
11866func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
11867 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
11868
11869 out := graphql.NewFieldSet(fields)
11870 var invalids uint32
11871 for i, field := range fields {
11872 switch field.Name {
11873 case "__typename":
11874 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
11875 case "id":
11876 field := field
11877 out.Concurrently(i, func() (res graphql.Marshaler) {
11878 defer func() {
11879 if r := recover(); r != nil {
11880 ec.Error(ctx, ec.Recover(ctx, r))
11881 }
11882 }()
11883 res = ec._LabelChangeOperation_id(ctx, field, obj)
11884 if res == graphql.Null {
11885 atomic.AddUint32(&invalids, 1)
11886 }
11887 return res
11888 })
11889 case "author":
11890 field := field
11891 out.Concurrently(i, func() (res graphql.Marshaler) {
11892 defer func() {
11893 if r := recover(); r != nil {
11894 ec.Error(ctx, ec.Recover(ctx, r))
11895 }
11896 }()
11897 res = ec._LabelChangeOperation_author(ctx, field, obj)
11898 if res == graphql.Null {
11899 atomic.AddUint32(&invalids, 1)
11900 }
11901 return res
11902 })
11903 case "date":
11904 field := field
11905 out.Concurrently(i, func() (res graphql.Marshaler) {
11906 defer func() {
11907 if r := recover(); r != nil {
11908 ec.Error(ctx, ec.Recover(ctx, r))
11909 }
11910 }()
11911 res = ec._LabelChangeOperation_date(ctx, field, obj)
11912 if res == graphql.Null {
11913 atomic.AddUint32(&invalids, 1)
11914 }
11915 return res
11916 })
11917 case "added":
11918 out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
11919 if out.Values[i] == graphql.Null {
11920 atomic.AddUint32(&invalids, 1)
11921 }
11922 case "removed":
11923 out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
11924 if out.Values[i] == graphql.Null {
11925 atomic.AddUint32(&invalids, 1)
11926 }
11927 default:
11928 panic("unknown field " + strconv.Quote(field.Name))
11929 }
11930 }
11931 out.Dispatch()
11932 if invalids > 0 {
11933 return graphql.Null
11934 }
11935 return out
11936}
11937
11938var labelChangeResultImplementors = []string{"LabelChangeResult"}
11939
11940func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
11941 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
11942
11943 out := graphql.NewFieldSet(fields)
11944 var invalids uint32
11945 for i, field := range fields {
11946 switch field.Name {
11947 case "__typename":
11948 out.Values[i] = graphql.MarshalString("LabelChangeResult")
11949 case "label":
11950 out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
11951 if out.Values[i] == graphql.Null {
11952 atomic.AddUint32(&invalids, 1)
11953 }
11954 case "status":
11955 field := field
11956 out.Concurrently(i, func() (res graphql.Marshaler) {
11957 defer func() {
11958 if r := recover(); r != nil {
11959 ec.Error(ctx, ec.Recover(ctx, r))
11960 }
11961 }()
11962 res = ec._LabelChangeResult_status(ctx, field, obj)
11963 if res == graphql.Null {
11964 atomic.AddUint32(&invalids, 1)
11965 }
11966 return res
11967 })
11968 default:
11969 panic("unknown field " + strconv.Quote(field.Name))
11970 }
11971 }
11972 out.Dispatch()
11973 if invalids > 0 {
11974 return graphql.Null
11975 }
11976 return out
11977}
11978
11979var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
11980
11981func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
11982 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
11983
11984 out := graphql.NewFieldSet(fields)
11985 var invalids uint32
11986 for i, field := range fields {
11987 switch field.Name {
11988 case "__typename":
11989 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
11990 case "id":
11991 field := field
11992 out.Concurrently(i, func() (res graphql.Marshaler) {
11993 defer func() {
11994 if r := recover(); r != nil {
11995 ec.Error(ctx, ec.Recover(ctx, r))
11996 }
11997 }()
11998 res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
11999 if res == graphql.Null {
12000 atomic.AddUint32(&invalids, 1)
12001 }
12002 return res
12003 })
12004 case "author":
12005 field := field
12006 out.Concurrently(i, func() (res graphql.Marshaler) {
12007 defer func() {
12008 if r := recover(); r != nil {
12009 ec.Error(ctx, ec.Recover(ctx, r))
12010 }
12011 }()
12012 res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
12013 if res == graphql.Null {
12014 atomic.AddUint32(&invalids, 1)
12015 }
12016 return res
12017 })
12018 case "date":
12019 field := field
12020 out.Concurrently(i, func() (res graphql.Marshaler) {
12021 defer func() {
12022 if r := recover(); r != nil {
12023 ec.Error(ctx, ec.Recover(ctx, r))
12024 }
12025 }()
12026 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
12027 if res == graphql.Null {
12028 atomic.AddUint32(&invalids, 1)
12029 }
12030 return res
12031 })
12032 case "added":
12033 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
12034 if out.Values[i] == graphql.Null {
12035 atomic.AddUint32(&invalids, 1)
12036 }
12037 case "removed":
12038 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
12039 if out.Values[i] == graphql.Null {
12040 atomic.AddUint32(&invalids, 1)
12041 }
12042 default:
12043 panic("unknown field " + strconv.Quote(field.Name))
12044 }
12045 }
12046 out.Dispatch()
12047 if invalids > 0 {
12048 return graphql.Null
12049 }
12050 return out
12051}
12052
12053var labelConnectionImplementors = []string{"LabelConnection"}
12054
12055func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
12056 fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
12057
12058 out := graphql.NewFieldSet(fields)
12059 var invalids uint32
12060 for i, field := range fields {
12061 switch field.Name {
12062 case "__typename":
12063 out.Values[i] = graphql.MarshalString("LabelConnection")
12064 case "edges":
12065 out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
12066 if out.Values[i] == graphql.Null {
12067 invalids++
12068 }
12069 case "nodes":
12070 out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
12071 if out.Values[i] == graphql.Null {
12072 invalids++
12073 }
12074 case "pageInfo":
12075 out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
12076 if out.Values[i] == graphql.Null {
12077 invalids++
12078 }
12079 case "totalCount":
12080 out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
12081 if out.Values[i] == graphql.Null {
12082 invalids++
12083 }
12084 default:
12085 panic("unknown field " + strconv.Quote(field.Name))
12086 }
12087 }
12088 out.Dispatch()
12089 if invalids > 0 {
12090 return graphql.Null
12091 }
12092 return out
12093}
12094
12095var labelEdgeImplementors = []string{"LabelEdge"}
12096
12097func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
12098 fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
12099
12100 out := graphql.NewFieldSet(fields)
12101 var invalids uint32
12102 for i, field := range fields {
12103 switch field.Name {
12104 case "__typename":
12105 out.Values[i] = graphql.MarshalString("LabelEdge")
12106 case "cursor":
12107 out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
12108 if out.Values[i] == graphql.Null {
12109 invalids++
12110 }
12111 case "node":
12112 out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
12113 if out.Values[i] == graphql.Null {
12114 invalids++
12115 }
12116 default:
12117 panic("unknown field " + strconv.Quote(field.Name))
12118 }
12119 }
12120 out.Dispatch()
12121 if invalids > 0 {
12122 return graphql.Null
12123 }
12124 return out
12125}
12126
12127var mutationImplementors = []string{"Mutation"}
12128
12129func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12130 fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
12131
12132 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12133 Object: "Mutation",
12134 })
12135
12136 out := graphql.NewFieldSet(fields)
12137 var invalids uint32
12138 for i, field := range fields {
12139 switch field.Name {
12140 case "__typename":
12141 out.Values[i] = graphql.MarshalString("Mutation")
12142 case "newBug":
12143 out.Values[i] = ec._Mutation_newBug(ctx, field)
12144 if out.Values[i] == graphql.Null {
12145 invalids++
12146 }
12147 case "addComment":
12148 out.Values[i] = ec._Mutation_addComment(ctx, field)
12149 if out.Values[i] == graphql.Null {
12150 invalids++
12151 }
12152 case "changeLabels":
12153 out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12154 if out.Values[i] == graphql.Null {
12155 invalids++
12156 }
12157 case "openBug":
12158 out.Values[i] = ec._Mutation_openBug(ctx, field)
12159 if out.Values[i] == graphql.Null {
12160 invalids++
12161 }
12162 case "closeBug":
12163 out.Values[i] = ec._Mutation_closeBug(ctx, field)
12164 if out.Values[i] == graphql.Null {
12165 invalids++
12166 }
12167 case "setTitle":
12168 out.Values[i] = ec._Mutation_setTitle(ctx, field)
12169 if out.Values[i] == graphql.Null {
12170 invalids++
12171 }
12172 case "commit":
12173 out.Values[i] = ec._Mutation_commit(ctx, field)
12174 if out.Values[i] == graphql.Null {
12175 invalids++
12176 }
12177 case "commitAsNeeded":
12178 out.Values[i] = ec._Mutation_commitAsNeeded(ctx, field)
12179 if out.Values[i] == graphql.Null {
12180 invalids++
12181 }
12182 default:
12183 panic("unknown field " + strconv.Quote(field.Name))
12184 }
12185 }
12186 out.Dispatch()
12187 if invalids > 0 {
12188 return graphql.Null
12189 }
12190 return out
12191}
12192
12193var newBugPayloadImplementors = []string{"NewBugPayload"}
12194
12195func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12196 fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
12197
12198 out := graphql.NewFieldSet(fields)
12199 var invalids uint32
12200 for i, field := range fields {
12201 switch field.Name {
12202 case "__typename":
12203 out.Values[i] = graphql.MarshalString("NewBugPayload")
12204 case "clientMutationId":
12205 out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12206 case "bug":
12207 out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12208 if out.Values[i] == graphql.Null {
12209 invalids++
12210 }
12211 case "operation":
12212 out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
12213 if out.Values[i] == graphql.Null {
12214 invalids++
12215 }
12216 default:
12217 panic("unknown field " + strconv.Quote(field.Name))
12218 }
12219 }
12220 out.Dispatch()
12221 if invalids > 0 {
12222 return graphql.Null
12223 }
12224 return out
12225}
12226
12227var openBugPayloadImplementors = []string{"OpenBugPayload"}
12228
12229func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12230 fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
12231
12232 out := graphql.NewFieldSet(fields)
12233 var invalids uint32
12234 for i, field := range fields {
12235 switch field.Name {
12236 case "__typename":
12237 out.Values[i] = graphql.MarshalString("OpenBugPayload")
12238 case "clientMutationId":
12239 out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12240 case "bug":
12241 out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12242 if out.Values[i] == graphql.Null {
12243 invalids++
12244 }
12245 case "operation":
12246 out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12247 if out.Values[i] == graphql.Null {
12248 invalids++
12249 }
12250 default:
12251 panic("unknown field " + strconv.Quote(field.Name))
12252 }
12253 }
12254 out.Dispatch()
12255 if invalids > 0 {
12256 return graphql.Null
12257 }
12258 return out
12259}
12260
12261var operationConnectionImplementors = []string{"OperationConnection"}
12262
12263func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12264 fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
12265
12266 out := graphql.NewFieldSet(fields)
12267 var invalids uint32
12268 for i, field := range fields {
12269 switch field.Name {
12270 case "__typename":
12271 out.Values[i] = graphql.MarshalString("OperationConnection")
12272 case "edges":
12273 out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12274 if out.Values[i] == graphql.Null {
12275 invalids++
12276 }
12277 case "nodes":
12278 out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12279 if out.Values[i] == graphql.Null {
12280 invalids++
12281 }
12282 case "pageInfo":
12283 out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12284 if out.Values[i] == graphql.Null {
12285 invalids++
12286 }
12287 case "totalCount":
12288 out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12289 if out.Values[i] == graphql.Null {
12290 invalids++
12291 }
12292 default:
12293 panic("unknown field " + strconv.Quote(field.Name))
12294 }
12295 }
12296 out.Dispatch()
12297 if invalids > 0 {
12298 return graphql.Null
12299 }
12300 return out
12301}
12302
12303var operationEdgeImplementors = []string{"OperationEdge"}
12304
12305func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12306 fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
12307
12308 out := graphql.NewFieldSet(fields)
12309 var invalids uint32
12310 for i, field := range fields {
12311 switch field.Name {
12312 case "__typename":
12313 out.Values[i] = graphql.MarshalString("OperationEdge")
12314 case "cursor":
12315 out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12316 if out.Values[i] == graphql.Null {
12317 invalids++
12318 }
12319 case "node":
12320 out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12321 if out.Values[i] == graphql.Null {
12322 invalids++
12323 }
12324 default:
12325 panic("unknown field " + strconv.Quote(field.Name))
12326 }
12327 }
12328 out.Dispatch()
12329 if invalids > 0 {
12330 return graphql.Null
12331 }
12332 return out
12333}
12334
12335var pageInfoImplementors = []string{"PageInfo"}
12336
12337func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12338 fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
12339
12340 out := graphql.NewFieldSet(fields)
12341 var invalids uint32
12342 for i, field := range fields {
12343 switch field.Name {
12344 case "__typename":
12345 out.Values[i] = graphql.MarshalString("PageInfo")
12346 case "hasNextPage":
12347 out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12348 if out.Values[i] == graphql.Null {
12349 invalids++
12350 }
12351 case "hasPreviousPage":
12352 out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12353 if out.Values[i] == graphql.Null {
12354 invalids++
12355 }
12356 case "startCursor":
12357 out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12358 if out.Values[i] == graphql.Null {
12359 invalids++
12360 }
12361 case "endCursor":
12362 out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12363 if out.Values[i] == graphql.Null {
12364 invalids++
12365 }
12366 default:
12367 panic("unknown field " + strconv.Quote(field.Name))
12368 }
12369 }
12370 out.Dispatch()
12371 if invalids > 0 {
12372 return graphql.Null
12373 }
12374 return out
12375}
12376
12377var queryImplementors = []string{"Query"}
12378
12379func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12380 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
12381
12382 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12383 Object: "Query",
12384 })
12385
12386 out := graphql.NewFieldSet(fields)
12387 var invalids uint32
12388 for i, field := range fields {
12389 switch field.Name {
12390 case "__typename":
12391 out.Values[i] = graphql.MarshalString("Query")
12392 case "defaultRepository":
12393 field := field
12394 out.Concurrently(i, func() (res graphql.Marshaler) {
12395 defer func() {
12396 if r := recover(); r != nil {
12397 ec.Error(ctx, ec.Recover(ctx, r))
12398 }
12399 }()
12400 res = ec._Query_defaultRepository(ctx, field)
12401 return res
12402 })
12403 case "repository":
12404 field := field
12405 out.Concurrently(i, func() (res graphql.Marshaler) {
12406 defer func() {
12407 if r := recover(); r != nil {
12408 ec.Error(ctx, ec.Recover(ctx, r))
12409 }
12410 }()
12411 res = ec._Query_repository(ctx, field)
12412 return res
12413 })
12414 case "__type":
12415 out.Values[i] = ec._Query___type(ctx, field)
12416 case "__schema":
12417 out.Values[i] = ec._Query___schema(ctx, field)
12418 default:
12419 panic("unknown field " + strconv.Quote(field.Name))
12420 }
12421 }
12422 out.Dispatch()
12423 if invalids > 0 {
12424 return graphql.Null
12425 }
12426 return out
12427}
12428
12429var repositoryImplementors = []string{"Repository"}
12430
12431func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
12432 fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
12433
12434 out := graphql.NewFieldSet(fields)
12435 var invalids uint32
12436 for i, field := range fields {
12437 switch field.Name {
12438 case "__typename":
12439 out.Values[i] = graphql.MarshalString("Repository")
12440 case "allBugs":
12441 field := field
12442 out.Concurrently(i, func() (res graphql.Marshaler) {
12443 defer func() {
12444 if r := recover(); r != nil {
12445 ec.Error(ctx, ec.Recover(ctx, r))
12446 }
12447 }()
12448 res = ec._Repository_allBugs(ctx, field, obj)
12449 if res == graphql.Null {
12450 atomic.AddUint32(&invalids, 1)
12451 }
12452 return res
12453 })
12454 case "bug":
12455 field := field
12456 out.Concurrently(i, func() (res graphql.Marshaler) {
12457 defer func() {
12458 if r := recover(); r != nil {
12459 ec.Error(ctx, ec.Recover(ctx, r))
12460 }
12461 }()
12462 res = ec._Repository_bug(ctx, field, obj)
12463 return res
12464 })
12465 case "allIdentities":
12466 field := field
12467 out.Concurrently(i, func() (res graphql.Marshaler) {
12468 defer func() {
12469 if r := recover(); r != nil {
12470 ec.Error(ctx, ec.Recover(ctx, r))
12471 }
12472 }()
12473 res = ec._Repository_allIdentities(ctx, field, obj)
12474 if res == graphql.Null {
12475 atomic.AddUint32(&invalids, 1)
12476 }
12477 return res
12478 })
12479 case "identity":
12480 field := field
12481 out.Concurrently(i, func() (res graphql.Marshaler) {
12482 defer func() {
12483 if r := recover(); r != nil {
12484 ec.Error(ctx, ec.Recover(ctx, r))
12485 }
12486 }()
12487 res = ec._Repository_identity(ctx, field, obj)
12488 return res
12489 })
12490 case "userIdentity":
12491 field := field
12492 out.Concurrently(i, func() (res graphql.Marshaler) {
12493 defer func() {
12494 if r := recover(); r != nil {
12495 ec.Error(ctx, ec.Recover(ctx, r))
12496 }
12497 }()
12498 res = ec._Repository_userIdentity(ctx, field, obj)
12499 return res
12500 })
12501 case "validLabels":
12502 field := field
12503 out.Concurrently(i, func() (res graphql.Marshaler) {
12504 defer func() {
12505 if r := recover(); r != nil {
12506 ec.Error(ctx, ec.Recover(ctx, r))
12507 }
12508 }()
12509 res = ec._Repository_validLabels(ctx, field, obj)
12510 if res == graphql.Null {
12511 atomic.AddUint32(&invalids, 1)
12512 }
12513 return res
12514 })
12515 default:
12516 panic("unknown field " + strconv.Quote(field.Name))
12517 }
12518 }
12519 out.Dispatch()
12520 if invalids > 0 {
12521 return graphql.Null
12522 }
12523 return out
12524}
12525
12526var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12527
12528func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12529 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
12530
12531 out := graphql.NewFieldSet(fields)
12532 var invalids uint32
12533 for i, field := range fields {
12534 switch field.Name {
12535 case "__typename":
12536 out.Values[i] = graphql.MarshalString("SetStatusOperation")
12537 case "id":
12538 field := field
12539 out.Concurrently(i, func() (res graphql.Marshaler) {
12540 defer func() {
12541 if r := recover(); r != nil {
12542 ec.Error(ctx, ec.Recover(ctx, r))
12543 }
12544 }()
12545 res = ec._SetStatusOperation_id(ctx, field, obj)
12546 if res == graphql.Null {
12547 atomic.AddUint32(&invalids, 1)
12548 }
12549 return res
12550 })
12551 case "author":
12552 field := field
12553 out.Concurrently(i, func() (res graphql.Marshaler) {
12554 defer func() {
12555 if r := recover(); r != nil {
12556 ec.Error(ctx, ec.Recover(ctx, r))
12557 }
12558 }()
12559 res = ec._SetStatusOperation_author(ctx, field, obj)
12560 if res == graphql.Null {
12561 atomic.AddUint32(&invalids, 1)
12562 }
12563 return res
12564 })
12565 case "date":
12566 field := field
12567 out.Concurrently(i, func() (res graphql.Marshaler) {
12568 defer func() {
12569 if r := recover(); r != nil {
12570 ec.Error(ctx, ec.Recover(ctx, r))
12571 }
12572 }()
12573 res = ec._SetStatusOperation_date(ctx, field, obj)
12574 if res == graphql.Null {
12575 atomic.AddUint32(&invalids, 1)
12576 }
12577 return res
12578 })
12579 case "status":
12580 field := field
12581 out.Concurrently(i, func() (res graphql.Marshaler) {
12582 defer func() {
12583 if r := recover(); r != nil {
12584 ec.Error(ctx, ec.Recover(ctx, r))
12585 }
12586 }()
12587 res = ec._SetStatusOperation_status(ctx, field, obj)
12588 if res == graphql.Null {
12589 atomic.AddUint32(&invalids, 1)
12590 }
12591 return res
12592 })
12593 default:
12594 panic("unknown field " + strconv.Quote(field.Name))
12595 }
12596 }
12597 out.Dispatch()
12598 if invalids > 0 {
12599 return graphql.Null
12600 }
12601 return out
12602}
12603
12604var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12605
12606func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12607 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
12608
12609 out := graphql.NewFieldSet(fields)
12610 var invalids uint32
12611 for i, field := range fields {
12612 switch field.Name {
12613 case "__typename":
12614 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12615 case "id":
12616 field := field
12617 out.Concurrently(i, func() (res graphql.Marshaler) {
12618 defer func() {
12619 if r := recover(); r != nil {
12620 ec.Error(ctx, ec.Recover(ctx, r))
12621 }
12622 }()
12623 res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12624 if res == graphql.Null {
12625 atomic.AddUint32(&invalids, 1)
12626 }
12627 return res
12628 })
12629 case "author":
12630 field := field
12631 out.Concurrently(i, func() (res graphql.Marshaler) {
12632 defer func() {
12633 if r := recover(); r != nil {
12634 ec.Error(ctx, ec.Recover(ctx, r))
12635 }
12636 }()
12637 res = ec._SetStatusTimelineItem_author(ctx, field, obj)
12638 if res == graphql.Null {
12639 atomic.AddUint32(&invalids, 1)
12640 }
12641 return res
12642 })
12643 case "date":
12644 field := field
12645 out.Concurrently(i, func() (res graphql.Marshaler) {
12646 defer func() {
12647 if r := recover(); r != nil {
12648 ec.Error(ctx, ec.Recover(ctx, r))
12649 }
12650 }()
12651 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12652 if res == graphql.Null {
12653 atomic.AddUint32(&invalids, 1)
12654 }
12655 return res
12656 })
12657 case "status":
12658 field := field
12659 out.Concurrently(i, func() (res graphql.Marshaler) {
12660 defer func() {
12661 if r := recover(); r != nil {
12662 ec.Error(ctx, ec.Recover(ctx, r))
12663 }
12664 }()
12665 res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12666 if res == graphql.Null {
12667 atomic.AddUint32(&invalids, 1)
12668 }
12669 return res
12670 })
12671 default:
12672 panic("unknown field " + strconv.Quote(field.Name))
12673 }
12674 }
12675 out.Dispatch()
12676 if invalids > 0 {
12677 return graphql.Null
12678 }
12679 return out
12680}
12681
12682var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12683
12684func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12685 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
12686
12687 out := graphql.NewFieldSet(fields)
12688 var invalids uint32
12689 for i, field := range fields {
12690 switch field.Name {
12691 case "__typename":
12692 out.Values[i] = graphql.MarshalString("SetTitleOperation")
12693 case "id":
12694 field := field
12695 out.Concurrently(i, func() (res graphql.Marshaler) {
12696 defer func() {
12697 if r := recover(); r != nil {
12698 ec.Error(ctx, ec.Recover(ctx, r))
12699 }
12700 }()
12701 res = ec._SetTitleOperation_id(ctx, field, obj)
12702 if res == graphql.Null {
12703 atomic.AddUint32(&invalids, 1)
12704 }
12705 return res
12706 })
12707 case "author":
12708 field := field
12709 out.Concurrently(i, func() (res graphql.Marshaler) {
12710 defer func() {
12711 if r := recover(); r != nil {
12712 ec.Error(ctx, ec.Recover(ctx, r))
12713 }
12714 }()
12715 res = ec._SetTitleOperation_author(ctx, field, obj)
12716 if res == graphql.Null {
12717 atomic.AddUint32(&invalids, 1)
12718 }
12719 return res
12720 })
12721 case "date":
12722 field := field
12723 out.Concurrently(i, func() (res graphql.Marshaler) {
12724 defer func() {
12725 if r := recover(); r != nil {
12726 ec.Error(ctx, ec.Recover(ctx, r))
12727 }
12728 }()
12729 res = ec._SetTitleOperation_date(ctx, field, obj)
12730 if res == graphql.Null {
12731 atomic.AddUint32(&invalids, 1)
12732 }
12733 return res
12734 })
12735 case "title":
12736 out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12737 if out.Values[i] == graphql.Null {
12738 atomic.AddUint32(&invalids, 1)
12739 }
12740 case "was":
12741 out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12742 if out.Values[i] == graphql.Null {
12743 atomic.AddUint32(&invalids, 1)
12744 }
12745 default:
12746 panic("unknown field " + strconv.Quote(field.Name))
12747 }
12748 }
12749 out.Dispatch()
12750 if invalids > 0 {
12751 return graphql.Null
12752 }
12753 return out
12754}
12755
12756var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12757
12758func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12759 fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
12760
12761 out := graphql.NewFieldSet(fields)
12762 var invalids uint32
12763 for i, field := range fields {
12764 switch field.Name {
12765 case "__typename":
12766 out.Values[i] = graphql.MarshalString("SetTitlePayload")
12767 case "clientMutationId":
12768 out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
12769 case "bug":
12770 out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
12771 if out.Values[i] == graphql.Null {
12772 invalids++
12773 }
12774 case "operation":
12775 out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
12776 if out.Values[i] == graphql.Null {
12777 invalids++
12778 }
12779 default:
12780 panic("unknown field " + strconv.Quote(field.Name))
12781 }
12782 }
12783 out.Dispatch()
12784 if invalids > 0 {
12785 return graphql.Null
12786 }
12787 return out
12788}
12789
12790var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
12791
12792func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
12793 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
12794
12795 out := graphql.NewFieldSet(fields)
12796 var invalids uint32
12797 for i, field := range fields {
12798 switch field.Name {
12799 case "__typename":
12800 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
12801 case "id":
12802 field := field
12803 out.Concurrently(i, func() (res graphql.Marshaler) {
12804 defer func() {
12805 if r := recover(); r != nil {
12806 ec.Error(ctx, ec.Recover(ctx, r))
12807 }
12808 }()
12809 res = ec._SetTitleTimelineItem_id(ctx, field, obj)
12810 if res == graphql.Null {
12811 atomic.AddUint32(&invalids, 1)
12812 }
12813 return res
12814 })
12815 case "author":
12816 field := field
12817 out.Concurrently(i, func() (res graphql.Marshaler) {
12818 defer func() {
12819 if r := recover(); r != nil {
12820 ec.Error(ctx, ec.Recover(ctx, r))
12821 }
12822 }()
12823 res = ec._SetTitleTimelineItem_author(ctx, field, obj)
12824 if res == graphql.Null {
12825 atomic.AddUint32(&invalids, 1)
12826 }
12827 return res
12828 })
12829 case "date":
12830 field := field
12831 out.Concurrently(i, func() (res graphql.Marshaler) {
12832 defer func() {
12833 if r := recover(); r != nil {
12834 ec.Error(ctx, ec.Recover(ctx, r))
12835 }
12836 }()
12837 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
12838 if res == graphql.Null {
12839 atomic.AddUint32(&invalids, 1)
12840 }
12841 return res
12842 })
12843 case "title":
12844 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
12845 if out.Values[i] == graphql.Null {
12846 atomic.AddUint32(&invalids, 1)
12847 }
12848 case "was":
12849 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
12850 if out.Values[i] == graphql.Null {
12851 atomic.AddUint32(&invalids, 1)
12852 }
12853 default:
12854 panic("unknown field " + strconv.Quote(field.Name))
12855 }
12856 }
12857 out.Dispatch()
12858 if invalids > 0 {
12859 return graphql.Null
12860 }
12861 return out
12862}
12863
12864var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
12865
12866func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
12867 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
12868
12869 out := graphql.NewFieldSet(fields)
12870 var invalids uint32
12871 for i, field := range fields {
12872 switch field.Name {
12873 case "__typename":
12874 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
12875 case "edges":
12876 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
12877 if out.Values[i] == graphql.Null {
12878 invalids++
12879 }
12880 case "nodes":
12881 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
12882 if out.Values[i] == graphql.Null {
12883 invalids++
12884 }
12885 case "pageInfo":
12886 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
12887 if out.Values[i] == graphql.Null {
12888 invalids++
12889 }
12890 case "totalCount":
12891 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
12892 if out.Values[i] == graphql.Null {
12893 invalids++
12894 }
12895 default:
12896 panic("unknown field " + strconv.Quote(field.Name))
12897 }
12898 }
12899 out.Dispatch()
12900 if invalids > 0 {
12901 return graphql.Null
12902 }
12903 return out
12904}
12905
12906var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
12907
12908func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
12909 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
12910
12911 out := graphql.NewFieldSet(fields)
12912 var invalids uint32
12913 for i, field := range fields {
12914 switch field.Name {
12915 case "__typename":
12916 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
12917 case "cursor":
12918 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
12919 if out.Values[i] == graphql.Null {
12920 invalids++
12921 }
12922 case "node":
12923 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
12924 if out.Values[i] == graphql.Null {
12925 invalids++
12926 }
12927 default:
12928 panic("unknown field " + strconv.Quote(field.Name))
12929 }
12930 }
12931 out.Dispatch()
12932 if invalids > 0 {
12933 return graphql.Null
12934 }
12935 return out
12936}
12937
12938var __DirectiveImplementors = []string{"__Directive"}
12939
12940func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
12941 fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
12942
12943 out := graphql.NewFieldSet(fields)
12944 var invalids uint32
12945 for i, field := range fields {
12946 switch field.Name {
12947 case "__typename":
12948 out.Values[i] = graphql.MarshalString("__Directive")
12949 case "name":
12950 out.Values[i] = ec.___Directive_name(ctx, field, obj)
12951 if out.Values[i] == graphql.Null {
12952 invalids++
12953 }
12954 case "description":
12955 out.Values[i] = ec.___Directive_description(ctx, field, obj)
12956 case "locations":
12957 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
12958 if out.Values[i] == graphql.Null {
12959 invalids++
12960 }
12961 case "args":
12962 out.Values[i] = ec.___Directive_args(ctx, field, obj)
12963 if out.Values[i] == graphql.Null {
12964 invalids++
12965 }
12966 default:
12967 panic("unknown field " + strconv.Quote(field.Name))
12968 }
12969 }
12970 out.Dispatch()
12971 if invalids > 0 {
12972 return graphql.Null
12973 }
12974 return out
12975}
12976
12977var __EnumValueImplementors = []string{"__EnumValue"}
12978
12979func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
12980 fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
12981
12982 out := graphql.NewFieldSet(fields)
12983 var invalids uint32
12984 for i, field := range fields {
12985 switch field.Name {
12986 case "__typename":
12987 out.Values[i] = graphql.MarshalString("__EnumValue")
12988 case "name":
12989 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
12990 if out.Values[i] == graphql.Null {
12991 invalids++
12992 }
12993 case "description":
12994 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
12995 case "isDeprecated":
12996 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
12997 if out.Values[i] == graphql.Null {
12998 invalids++
12999 }
13000 case "deprecationReason":
13001 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
13002 default:
13003 panic("unknown field " + strconv.Quote(field.Name))
13004 }
13005 }
13006 out.Dispatch()
13007 if invalids > 0 {
13008 return graphql.Null
13009 }
13010 return out
13011}
13012
13013var __FieldImplementors = []string{"__Field"}
13014
13015func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
13016 fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
13017
13018 out := graphql.NewFieldSet(fields)
13019 var invalids uint32
13020 for i, field := range fields {
13021 switch field.Name {
13022 case "__typename":
13023 out.Values[i] = graphql.MarshalString("__Field")
13024 case "name":
13025 out.Values[i] = ec.___Field_name(ctx, field, obj)
13026 if out.Values[i] == graphql.Null {
13027 invalids++
13028 }
13029 case "description":
13030 out.Values[i] = ec.___Field_description(ctx, field, obj)
13031 case "args":
13032 out.Values[i] = ec.___Field_args(ctx, field, obj)
13033 if out.Values[i] == graphql.Null {
13034 invalids++
13035 }
13036 case "type":
13037 out.Values[i] = ec.___Field_type(ctx, field, obj)
13038 if out.Values[i] == graphql.Null {
13039 invalids++
13040 }
13041 case "isDeprecated":
13042 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
13043 if out.Values[i] == graphql.Null {
13044 invalids++
13045 }
13046 case "deprecationReason":
13047 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
13048 default:
13049 panic("unknown field " + strconv.Quote(field.Name))
13050 }
13051 }
13052 out.Dispatch()
13053 if invalids > 0 {
13054 return graphql.Null
13055 }
13056 return out
13057}
13058
13059var __InputValueImplementors = []string{"__InputValue"}
13060
13061func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
13062 fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
13063
13064 out := graphql.NewFieldSet(fields)
13065 var invalids uint32
13066 for i, field := range fields {
13067 switch field.Name {
13068 case "__typename":
13069 out.Values[i] = graphql.MarshalString("__InputValue")
13070 case "name":
13071 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
13072 if out.Values[i] == graphql.Null {
13073 invalids++
13074 }
13075 case "description":
13076 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
13077 case "type":
13078 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
13079 if out.Values[i] == graphql.Null {
13080 invalids++
13081 }
13082 case "defaultValue":
13083 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
13084 default:
13085 panic("unknown field " + strconv.Quote(field.Name))
13086 }
13087 }
13088 out.Dispatch()
13089 if invalids > 0 {
13090 return graphql.Null
13091 }
13092 return out
13093}
13094
13095var __SchemaImplementors = []string{"__Schema"}
13096
13097func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
13098 fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
13099
13100 out := graphql.NewFieldSet(fields)
13101 var invalids uint32
13102 for i, field := range fields {
13103 switch field.Name {
13104 case "__typename":
13105 out.Values[i] = graphql.MarshalString("__Schema")
13106 case "types":
13107 out.Values[i] = ec.___Schema_types(ctx, field, obj)
13108 if out.Values[i] == graphql.Null {
13109 invalids++
13110 }
13111 case "queryType":
13112 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
13113 if out.Values[i] == graphql.Null {
13114 invalids++
13115 }
13116 case "mutationType":
13117 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13118 case "subscriptionType":
13119 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13120 case "directives":
13121 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13122 if out.Values[i] == graphql.Null {
13123 invalids++
13124 }
13125 default:
13126 panic("unknown field " + strconv.Quote(field.Name))
13127 }
13128 }
13129 out.Dispatch()
13130 if invalids > 0 {
13131 return graphql.Null
13132 }
13133 return out
13134}
13135
13136var __TypeImplementors = []string{"__Type"}
13137
13138func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13139 fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
13140
13141 out := graphql.NewFieldSet(fields)
13142 var invalids uint32
13143 for i, field := range fields {
13144 switch field.Name {
13145 case "__typename":
13146 out.Values[i] = graphql.MarshalString("__Type")
13147 case "kind":
13148 out.Values[i] = ec.___Type_kind(ctx, field, obj)
13149 if out.Values[i] == graphql.Null {
13150 invalids++
13151 }
13152 case "name":
13153 out.Values[i] = ec.___Type_name(ctx, field, obj)
13154 case "description":
13155 out.Values[i] = ec.___Type_description(ctx, field, obj)
13156 case "fields":
13157 out.Values[i] = ec.___Type_fields(ctx, field, obj)
13158 case "interfaces":
13159 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13160 case "possibleTypes":
13161 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13162 case "enumValues":
13163 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13164 case "inputFields":
13165 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13166 case "ofType":
13167 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13168 default:
13169 panic("unknown field " + strconv.Quote(field.Name))
13170 }
13171 }
13172 out.Dispatch()
13173 if invalids > 0 {
13174 return graphql.Null
13175 }
13176 return out
13177}
13178
13179// endregion **************************** object.gotpl ****************************
13180
13181// region ***************************** type.gotpl *****************************
13182
13183func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13184 return ec.unmarshalInputAddCommentInput(ctx, v)
13185}
13186
13187func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13188 return ec._AddCommentOperation(ctx, sel, &v)
13189}
13190
13191func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
13192 if v == nil {
13193 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13194 ec.Errorf(ctx, "must not be null")
13195 }
13196 return graphql.Null
13197 }
13198 return ec._AddCommentOperation(ctx, sel, v)
13199}
13200
13201func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13202 return ec._AddCommentPayload(ctx, sel, &v)
13203}
13204
13205func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13206 if v == nil {
13207 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13208 ec.Errorf(ctx, "must not be null")
13209 }
13210 return graphql.Null
13211 }
13212 return ec._AddCommentPayload(ctx, sel, v)
13213}
13214
13215func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13216 return graphql.UnmarshalBoolean(v)
13217}
13218
13219func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13220 res := graphql.MarshalBoolean(v)
13221 if res == graphql.Null {
13222 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13223 ec.Errorf(ctx, "must not be null")
13224 }
13225 }
13226 return res
13227}
13228
13229func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
13230 if v == nil {
13231 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13232 ec.Errorf(ctx, "must not be null")
13233 }
13234 return graphql.Null
13235 }
13236 return ec._Bug(ctx, sel, v)
13237}
13238
13239func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
13240 ret := make(graphql.Array, len(v))
13241 var wg sync.WaitGroup
13242 isLen1 := len(v) == 1
13243 if !isLen1 {
13244 wg.Add(len(v))
13245 }
13246 for i := range v {
13247 i := i
13248 fc := &graphql.FieldContext{
13249 Index: &i,
13250 Result: &v[i],
13251 }
13252 ctx := graphql.WithFieldContext(ctx, fc)
13253 f := func(i int) {
13254 defer func() {
13255 if r := recover(); r != nil {
13256 ec.Error(ctx, ec.Recover(ctx, r))
13257 ret = nil
13258 }
13259 }()
13260 if !isLen1 {
13261 defer wg.Done()
13262 }
13263 ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
13264 }
13265 if isLen1 {
13266 f(i)
13267 } else {
13268 go f(i)
13269 }
13270
13271 }
13272 wg.Wait()
13273 return ret
13274}
13275
13276func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13277 return ec._BugConnection(ctx, sel, &v)
13278}
13279
13280func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
13281 if v == nil {
13282 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13283 ec.Errorf(ctx, "must not be null")
13284 }
13285 return graphql.Null
13286 }
13287 return ec._BugConnection(ctx, sel, v)
13288}
13289
13290func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13291 return ec._BugEdge(ctx, sel, &v)
13292}
13293
13294func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13295 ret := make(graphql.Array, len(v))
13296 var wg sync.WaitGroup
13297 isLen1 := len(v) == 1
13298 if !isLen1 {
13299 wg.Add(len(v))
13300 }
13301 for i := range v {
13302 i := i
13303 fc := &graphql.FieldContext{
13304 Index: &i,
13305 Result: &v[i],
13306 }
13307 ctx := graphql.WithFieldContext(ctx, fc)
13308 f := func(i int) {
13309 defer func() {
13310 if r := recover(); r != nil {
13311 ec.Error(ctx, ec.Recover(ctx, r))
13312 ret = nil
13313 }
13314 }()
13315 if !isLen1 {
13316 defer wg.Done()
13317 }
13318 ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13319 }
13320 if isLen1 {
13321 f(i)
13322 } else {
13323 go f(i)
13324 }
13325
13326 }
13327 wg.Wait()
13328 return ret
13329}
13330
13331func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13332 if v == nil {
13333 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13334 ec.Errorf(ctx, "must not be null")
13335 }
13336 return graphql.Null
13337 }
13338 return ec._BugEdge(ctx, sel, v)
13339}
13340
13341func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13342 return ec._ChangeLabelPayload(ctx, sel, &v)
13343}
13344
13345func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13346 if v == nil {
13347 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13348 ec.Errorf(ctx, "must not be null")
13349 }
13350 return graphql.Null
13351 }
13352 return ec._ChangeLabelPayload(ctx, sel, v)
13353}
13354
13355func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13356 return ec.unmarshalInputCloseBugInput(ctx, v)
13357}
13358
13359func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13360 return ec._CloseBugPayload(ctx, sel, &v)
13361}
13362
13363func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
13364 if v == nil {
13365 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13366 ec.Errorf(ctx, "must not be null")
13367 }
13368 return graphql.Null
13369 }
13370 return ec._CloseBugPayload(ctx, sel, v)
13371}
13372
13373func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13374 return ec._Color(ctx, sel, &v)
13375}
13376
13377func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
13378 if v == nil {
13379 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13380 ec.Errorf(ctx, "must not be null")
13381 }
13382 return graphql.Null
13383 }
13384 return ec._Color(ctx, sel, v)
13385}
13386
13387func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
13388 return ec._Comment(ctx, sel, &v)
13389}
13390
13391func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
13392 ret := make(graphql.Array, len(v))
13393 var wg sync.WaitGroup
13394 isLen1 := len(v) == 1
13395 if !isLen1 {
13396 wg.Add(len(v))
13397 }
13398 for i := range v {
13399 i := i
13400 fc := &graphql.FieldContext{
13401 Index: &i,
13402 Result: &v[i],
13403 }
13404 ctx := graphql.WithFieldContext(ctx, fc)
13405 f := func(i int) {
13406 defer func() {
13407 if r := recover(); r != nil {
13408 ec.Error(ctx, ec.Recover(ctx, r))
13409 ret = nil
13410 }
13411 }()
13412 if !isLen1 {
13413 defer wg.Done()
13414 }
13415 ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
13416 }
13417 if isLen1 {
13418 f(i)
13419 } else {
13420 go f(i)
13421 }
13422
13423 }
13424 wg.Wait()
13425 return ret
13426}
13427
13428func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13429 if v == nil {
13430 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13431 ec.Errorf(ctx, "must not be null")
13432 }
13433 return graphql.Null
13434 }
13435 return ec._Comment(ctx, sel, v)
13436}
13437
13438func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13439 return ec._CommentConnection(ctx, sel, &v)
13440}
13441
13442func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13443 if v == nil {
13444 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13445 ec.Errorf(ctx, "must not be null")
13446 }
13447 return graphql.Null
13448 }
13449 return ec._CommentConnection(ctx, sel, v)
13450}
13451
13452func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13453 return ec._CommentEdge(ctx, sel, &v)
13454}
13455
13456func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13457 ret := make(graphql.Array, len(v))
13458 var wg sync.WaitGroup
13459 isLen1 := len(v) == 1
13460 if !isLen1 {
13461 wg.Add(len(v))
13462 }
13463 for i := range v {
13464 i := i
13465 fc := &graphql.FieldContext{
13466 Index: &i,
13467 Result: &v[i],
13468 }
13469 ctx := graphql.WithFieldContext(ctx, fc)
13470 f := func(i int) {
13471 defer func() {
13472 if r := recover(); r != nil {
13473 ec.Error(ctx, ec.Recover(ctx, r))
13474 ret = nil
13475 }
13476 }()
13477 if !isLen1 {
13478 defer wg.Done()
13479 }
13480 ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13481 }
13482 if isLen1 {
13483 f(i)
13484 } else {
13485 go f(i)
13486 }
13487
13488 }
13489 wg.Wait()
13490 return ret
13491}
13492
13493func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13494 if v == nil {
13495 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13496 ec.Errorf(ctx, "must not be null")
13497 }
13498 return graphql.Null
13499 }
13500 return ec._CommentEdge(ctx, sel, v)
13501}
13502
13503func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13504 return ec._CommentHistoryStep(ctx, sel, &v)
13505}
13506
13507func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13508 ret := make(graphql.Array, len(v))
13509 var wg sync.WaitGroup
13510 isLen1 := len(v) == 1
13511 if !isLen1 {
13512 wg.Add(len(v))
13513 }
13514 for i := range v {
13515 i := i
13516 fc := &graphql.FieldContext{
13517 Index: &i,
13518 Result: &v[i],
13519 }
13520 ctx := graphql.WithFieldContext(ctx, fc)
13521 f := func(i int) {
13522 defer func() {
13523 if r := recover(); r != nil {
13524 ec.Error(ctx, ec.Recover(ctx, r))
13525 ret = nil
13526 }
13527 }()
13528 if !isLen1 {
13529 defer wg.Done()
13530 }
13531 ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13532 }
13533 if isLen1 {
13534 f(i)
13535 } else {
13536 go f(i)
13537 }
13538
13539 }
13540 wg.Wait()
13541 return ret
13542}
13543
13544func (ec *executionContext) unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
13545 return ec.unmarshalInputCommitAsNeededInput(ctx, v)
13546}
13547
13548func (ec *executionContext) marshalNCommitAsNeededPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitAsNeededPayload) graphql.Marshaler {
13549 return ec._CommitAsNeededPayload(ctx, sel, &v)
13550}
13551
13552func (ec *executionContext) marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitAsNeededPayload) graphql.Marshaler {
13553 if v == nil {
13554 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13555 ec.Errorf(ctx, "must not be null")
13556 }
13557 return graphql.Null
13558 }
13559 return ec._CommitAsNeededPayload(ctx, sel, v)
13560}
13561
13562func (ec *executionContext) unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
13563 return ec.unmarshalInputCommitInput(ctx, v)
13564}
13565
13566func (ec *executionContext) marshalNCommitPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitPayload) graphql.Marshaler {
13567 return ec._CommitPayload(ctx, sel, &v)
13568}
13569
13570func (ec *executionContext) marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitPayload) graphql.Marshaler {
13571 if v == nil {
13572 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13573 ec.Errorf(ctx, "must not be null")
13574 }
13575 return graphql.Null
13576 }
13577 return ec._CommitPayload(ctx, sel, v)
13578}
13579
13580func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13581 return ec._CreateOperation(ctx, sel, &v)
13582}
13583
13584func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13585 if v == nil {
13586 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13587 ec.Errorf(ctx, "must not be null")
13588 }
13589 return graphql.Null
13590 }
13591 return ec._CreateOperation(ctx, sel, v)
13592}
13593
13594func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
13595 var res git.Hash
13596 return res, res.UnmarshalGQL(v)
13597}
13598
13599func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
13600 return v
13601}
13602
13603func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
13604 var vSlice []interface{}
13605 if v != nil {
13606 if tmp1, ok := v.([]interface{}); ok {
13607 vSlice = tmp1
13608 } else {
13609 vSlice = []interface{}{v}
13610 }
13611 }
13612 var err error
13613 res := make([]git.Hash, len(vSlice))
13614 for i := range vSlice {
13615 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
13616 if err != nil {
13617 return nil, err
13618 }
13619 }
13620 return res, nil
13621}
13622
13623func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
13624 ret := make(graphql.Array, len(v))
13625 for i := range v {
13626 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
13627 }
13628
13629 return ret
13630}
13631
13632func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
13633 if v == nil {
13634 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13635 ec.Errorf(ctx, "must not be null")
13636 }
13637 return graphql.Null
13638 }
13639 return ec._Identity(ctx, sel, v)
13640}
13641
13642func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) graphql.Marshaler {
13643 ret := make(graphql.Array, len(v))
13644 var wg sync.WaitGroup
13645 isLen1 := len(v) == 1
13646 if !isLen1 {
13647 wg.Add(len(v))
13648 }
13649 for i := range v {
13650 i := i
13651 fc := &graphql.FieldContext{
13652 Index: &i,
13653 Result: &v[i],
13654 }
13655 ctx := graphql.WithFieldContext(ctx, fc)
13656 f := func(i int) {
13657 defer func() {
13658 if r := recover(); r != nil {
13659 ec.Error(ctx, ec.Recover(ctx, r))
13660 ret = nil
13661 }
13662 }()
13663 if !isLen1 {
13664 defer wg.Done()
13665 }
13666 ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, sel, v[i])
13667 }
13668 if isLen1 {
13669 f(i)
13670 } else {
13671 go f(i)
13672 }
13673
13674 }
13675 wg.Wait()
13676 return ret
13677}
13678
13679func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13680 return ec._IdentityConnection(ctx, sel, &v)
13681}
13682
13683func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13684 if v == nil {
13685 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13686 ec.Errorf(ctx, "must not be null")
13687 }
13688 return graphql.Null
13689 }
13690 return ec._IdentityConnection(ctx, sel, v)
13691}
13692
13693func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13694 return ec._IdentityEdge(ctx, sel, &v)
13695}
13696
13697func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13698 ret := make(graphql.Array, len(v))
13699 var wg sync.WaitGroup
13700 isLen1 := len(v) == 1
13701 if !isLen1 {
13702 wg.Add(len(v))
13703 }
13704 for i := range v {
13705 i := i
13706 fc := &graphql.FieldContext{
13707 Index: &i,
13708 Result: &v[i],
13709 }
13710 ctx := graphql.WithFieldContext(ctx, fc)
13711 f := func(i int) {
13712 defer func() {
13713 if r := recover(); r != nil {
13714 ec.Error(ctx, ec.Recover(ctx, r))
13715 ret = nil
13716 }
13717 }()
13718 if !isLen1 {
13719 defer wg.Done()
13720 }
13721 ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13722 }
13723 if isLen1 {
13724 f(i)
13725 } else {
13726 go f(i)
13727 }
13728
13729 }
13730 wg.Wait()
13731 return ret
13732}
13733
13734func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
13735 if v == nil {
13736 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13737 ec.Errorf(ctx, "must not be null")
13738 }
13739 return graphql.Null
13740 }
13741 return ec._IdentityEdge(ctx, sel, v)
13742}
13743
13744func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13745 return graphql.UnmarshalInt(v)
13746}
13747
13748func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13749 res := graphql.MarshalInt(v)
13750 if res == graphql.Null {
13751 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13752 ec.Errorf(ctx, "must not be null")
13753 }
13754 }
13755 return res
13756}
13757
13758func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
13759 return ec._Label(ctx, sel, &v)
13760}
13761
13762func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
13763 ret := make(graphql.Array, len(v))
13764 var wg sync.WaitGroup
13765 isLen1 := len(v) == 1
13766 if !isLen1 {
13767 wg.Add(len(v))
13768 }
13769 for i := range v {
13770 i := i
13771 fc := &graphql.FieldContext{
13772 Index: &i,
13773 Result: &v[i],
13774 }
13775 ctx := graphql.WithFieldContext(ctx, fc)
13776 f := func(i int) {
13777 defer func() {
13778 if r := recover(); r != nil {
13779 ec.Error(ctx, ec.Recover(ctx, r))
13780 ret = nil
13781 }
13782 }()
13783 if !isLen1 {
13784 defer wg.Done()
13785 }
13786 ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
13787 }
13788 if isLen1 {
13789 f(i)
13790 } else {
13791 go f(i)
13792 }
13793
13794 }
13795 wg.Wait()
13796 return ret
13797}
13798
13799func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
13800 return ec._LabelChangeOperation(ctx, sel, &v)
13801}
13802
13803func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
13804 if v == nil {
13805 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13806 ec.Errorf(ctx, "must not be null")
13807 }
13808 return graphql.Null
13809 }
13810 return ec._LabelChangeOperation(ctx, sel, v)
13811}
13812
13813func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
13814 ret := make(graphql.Array, len(v))
13815 var wg sync.WaitGroup
13816 isLen1 := len(v) == 1
13817 if !isLen1 {
13818 wg.Add(len(v))
13819 }
13820 for i := range v {
13821 i := i
13822 fc := &graphql.FieldContext{
13823 Index: &i,
13824 Result: &v[i],
13825 }
13826 ctx := graphql.WithFieldContext(ctx, fc)
13827 f := func(i int) {
13828 defer func() {
13829 if r := recover(); r != nil {
13830 ec.Error(ctx, ec.Recover(ctx, r))
13831 ret = nil
13832 }
13833 }()
13834 if !isLen1 {
13835 defer wg.Done()
13836 }
13837 ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
13838 }
13839 if isLen1 {
13840 f(i)
13841 } else {
13842 go f(i)
13843 }
13844
13845 }
13846 wg.Wait()
13847 return ret
13848}
13849
13850func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
13851 var res models.LabelChangeStatus
13852 return res, res.UnmarshalGQL(v)
13853}
13854
13855func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
13856 return v
13857}
13858
13859func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
13860 return ec._LabelConnection(ctx, sel, &v)
13861}
13862
13863func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
13864 if v == nil {
13865 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13866 ec.Errorf(ctx, "must not be null")
13867 }
13868 return graphql.Null
13869 }
13870 return ec._LabelConnection(ctx, sel, v)
13871}
13872
13873func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
13874 return ec._LabelEdge(ctx, sel, &v)
13875}
13876
13877func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
13878 ret := make(graphql.Array, len(v))
13879 var wg sync.WaitGroup
13880 isLen1 := len(v) == 1
13881 if !isLen1 {
13882 wg.Add(len(v))
13883 }
13884 for i := range v {
13885 i := i
13886 fc := &graphql.FieldContext{
13887 Index: &i,
13888 Result: &v[i],
13889 }
13890 ctx := graphql.WithFieldContext(ctx, fc)
13891 f := func(i int) {
13892 defer func() {
13893 if r := recover(); r != nil {
13894 ec.Error(ctx, ec.Recover(ctx, r))
13895 ret = nil
13896 }
13897 }()
13898 if !isLen1 {
13899 defer wg.Done()
13900 }
13901 ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
13902 }
13903 if isLen1 {
13904 f(i)
13905 } else {
13906 go f(i)
13907 }
13908
13909 }
13910 wg.Wait()
13911 return ret
13912}
13913
13914func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
13915 if v == nil {
13916 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13917 ec.Errorf(ctx, "must not be null")
13918 }
13919 return graphql.Null
13920 }
13921 return ec._LabelEdge(ctx, sel, v)
13922}
13923
13924func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
13925 return ec.unmarshalInputNewBugInput(ctx, v)
13926}
13927
13928func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
13929 return ec._NewBugPayload(ctx, sel, &v)
13930}
13931
13932func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
13933 if v == nil {
13934 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13935 ec.Errorf(ctx, "must not be null")
13936 }
13937 return graphql.Null
13938 }
13939 return ec._NewBugPayload(ctx, sel, v)
13940}
13941
13942func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
13943 return ec.unmarshalInputOpenBugInput(ctx, v)
13944}
13945
13946func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
13947 return ec._OpenBugPayload(ctx, sel, &v)
13948}
13949
13950func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
13951 if v == nil {
13952 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13953 ec.Errorf(ctx, "must not be null")
13954 }
13955 return graphql.Null
13956 }
13957 return ec._OpenBugPayload(ctx, sel, v)
13958}
13959
13960func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
13961 if v == nil {
13962 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13963 ec.Errorf(ctx, "must not be null")
13964 }
13965 return graphql.Null
13966 }
13967 return ec._Operation(ctx, sel, v)
13968}
13969
13970func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
13971 ret := make(graphql.Array, len(v))
13972 var wg sync.WaitGroup
13973 isLen1 := len(v) == 1
13974 if !isLen1 {
13975 wg.Add(len(v))
13976 }
13977 for i := range v {
13978 i := i
13979 fc := &graphql.FieldContext{
13980 Index: &i,
13981 Result: &v[i],
13982 }
13983 ctx := graphql.WithFieldContext(ctx, fc)
13984 f := func(i int) {
13985 defer func() {
13986 if r := recover(); r != nil {
13987 ec.Error(ctx, ec.Recover(ctx, r))
13988 ret = nil
13989 }
13990 }()
13991 if !isLen1 {
13992 defer wg.Done()
13993 }
13994 ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
13995 }
13996 if isLen1 {
13997 f(i)
13998 } else {
13999 go f(i)
14000 }
14001
14002 }
14003 wg.Wait()
14004 return ret
14005}
14006
14007func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
14008 return ec._OperationConnection(ctx, sel, &v)
14009}
14010
14011func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
14012 if v == nil {
14013 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14014 ec.Errorf(ctx, "must not be null")
14015 }
14016 return graphql.Null
14017 }
14018 return ec._OperationConnection(ctx, sel, v)
14019}
14020
14021func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
14022 return ec._OperationEdge(ctx, sel, &v)
14023}
14024
14025func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
14026 ret := make(graphql.Array, len(v))
14027 var wg sync.WaitGroup
14028 isLen1 := len(v) == 1
14029 if !isLen1 {
14030 wg.Add(len(v))
14031 }
14032 for i := range v {
14033 i := i
14034 fc := &graphql.FieldContext{
14035 Index: &i,
14036 Result: &v[i],
14037 }
14038 ctx := graphql.WithFieldContext(ctx, fc)
14039 f := func(i int) {
14040 defer func() {
14041 if r := recover(); r != nil {
14042 ec.Error(ctx, ec.Recover(ctx, r))
14043 ret = nil
14044 }
14045 }()
14046 if !isLen1 {
14047 defer wg.Done()
14048 }
14049 ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
14050 }
14051 if isLen1 {
14052 f(i)
14053 } else {
14054 go f(i)
14055 }
14056
14057 }
14058 wg.Wait()
14059 return ret
14060}
14061
14062func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
14063 if v == nil {
14064 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14065 ec.Errorf(ctx, "must not be null")
14066 }
14067 return graphql.Null
14068 }
14069 return ec._OperationEdge(ctx, sel, v)
14070}
14071
14072func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
14073 return ec._PageInfo(ctx, sel, &v)
14074}
14075
14076func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
14077 if v == nil {
14078 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14079 ec.Errorf(ctx, "must not be null")
14080 }
14081 return graphql.Null
14082 }
14083 return ec._PageInfo(ctx, sel, v)
14084}
14085
14086func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
14087 return ec._SetStatusOperation(ctx, sel, &v)
14088}
14089
14090func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
14091 if v == nil {
14092 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14093 ec.Errorf(ctx, "must not be null")
14094 }
14095 return graphql.Null
14096 }
14097 return ec._SetStatusOperation(ctx, sel, v)
14098}
14099
14100func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
14101 return ec.unmarshalInputSetTitleInput(ctx, v)
14102}
14103
14104func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
14105 return ec._SetTitleOperation(ctx, sel, &v)
14106}
14107
14108func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
14109 if v == nil {
14110 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14111 ec.Errorf(ctx, "must not be null")
14112 }
14113 return graphql.Null
14114 }
14115 return ec._SetTitleOperation(ctx, sel, v)
14116}
14117
14118func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
14119 return ec._SetTitlePayload(ctx, sel, &v)
14120}
14121
14122func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14123 if v == nil {
14124 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14125 ec.Errorf(ctx, "must not be null")
14126 }
14127 return graphql.Null
14128 }
14129 return ec._SetTitlePayload(ctx, sel, v)
14130}
14131
14132func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14133 var res models.Status
14134 return res, res.UnmarshalGQL(v)
14135}
14136
14137func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14138 return v
14139}
14140
14141func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14142 return graphql.UnmarshalString(v)
14143}
14144
14145func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14146 res := graphql.MarshalString(v)
14147 if res == graphql.Null {
14148 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14149 ec.Errorf(ctx, "must not be null")
14150 }
14151 }
14152 return res
14153}
14154
14155func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14156 return graphql.UnmarshalTime(v)
14157}
14158
14159func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14160 res := graphql.MarshalTime(v)
14161 if res == graphql.Null {
14162 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14163 ec.Errorf(ctx, "must not be null")
14164 }
14165 }
14166 return res
14167}
14168
14169func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14170 if v == nil {
14171 return nil, nil
14172 }
14173 res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14174 return &res, err
14175}
14176
14177func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14178 if v == nil {
14179 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14180 ec.Errorf(ctx, "must not be null")
14181 }
14182 return graphql.Null
14183 }
14184 return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14185}
14186
14187func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14188 if v == nil {
14189 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14190 ec.Errorf(ctx, "must not be null")
14191 }
14192 return graphql.Null
14193 }
14194 return ec._TimelineItem(ctx, sel, v)
14195}
14196
14197func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14198 ret := make(graphql.Array, len(v))
14199 var wg sync.WaitGroup
14200 isLen1 := len(v) == 1
14201 if !isLen1 {
14202 wg.Add(len(v))
14203 }
14204 for i := range v {
14205 i := i
14206 fc := &graphql.FieldContext{
14207 Index: &i,
14208 Result: &v[i],
14209 }
14210 ctx := graphql.WithFieldContext(ctx, fc)
14211 f := func(i int) {
14212 defer func() {
14213 if r := recover(); r != nil {
14214 ec.Error(ctx, ec.Recover(ctx, r))
14215 ret = nil
14216 }
14217 }()
14218 if !isLen1 {
14219 defer wg.Done()
14220 }
14221 ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14222 }
14223 if isLen1 {
14224 f(i)
14225 } else {
14226 go f(i)
14227 }
14228
14229 }
14230 wg.Wait()
14231 return ret
14232}
14233
14234func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14235 return ec._TimelineItemConnection(ctx, sel, &v)
14236}
14237
14238func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14239 if v == nil {
14240 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14241 ec.Errorf(ctx, "must not be null")
14242 }
14243 return graphql.Null
14244 }
14245 return ec._TimelineItemConnection(ctx, sel, v)
14246}
14247
14248func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14249 return ec._TimelineItemEdge(ctx, sel, &v)
14250}
14251
14252func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14253 ret := make(graphql.Array, len(v))
14254 var wg sync.WaitGroup
14255 isLen1 := len(v) == 1
14256 if !isLen1 {
14257 wg.Add(len(v))
14258 }
14259 for i := range v {
14260 i := i
14261 fc := &graphql.FieldContext{
14262 Index: &i,
14263 Result: &v[i],
14264 }
14265 ctx := graphql.WithFieldContext(ctx, fc)
14266 f := func(i int) {
14267 defer func() {
14268 if r := recover(); r != nil {
14269 ec.Error(ctx, ec.Recover(ctx, r))
14270 ret = nil
14271 }
14272 }()
14273 if !isLen1 {
14274 defer wg.Done()
14275 }
14276 ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14277 }
14278 if isLen1 {
14279 f(i)
14280 } else {
14281 go f(i)
14282 }
14283
14284 }
14285 wg.Wait()
14286 return ret
14287}
14288
14289func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
14290 if v == nil {
14291 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14292 ec.Errorf(ctx, "must not be null")
14293 }
14294 return graphql.Null
14295 }
14296 return ec._TimelineItemEdge(ctx, sel, v)
14297}
14298
14299func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
14300 return ec.___Directive(ctx, sel, &v)
14301}
14302
14303func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
14304 ret := make(graphql.Array, len(v))
14305 var wg sync.WaitGroup
14306 isLen1 := len(v) == 1
14307 if !isLen1 {
14308 wg.Add(len(v))
14309 }
14310 for i := range v {
14311 i := i
14312 fc := &graphql.FieldContext{
14313 Index: &i,
14314 Result: &v[i],
14315 }
14316 ctx := graphql.WithFieldContext(ctx, fc)
14317 f := func(i int) {
14318 defer func() {
14319 if r := recover(); r != nil {
14320 ec.Error(ctx, ec.Recover(ctx, r))
14321 ret = nil
14322 }
14323 }()
14324 if !isLen1 {
14325 defer wg.Done()
14326 }
14327 ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14328 }
14329 if isLen1 {
14330 f(i)
14331 } else {
14332 go f(i)
14333 }
14334
14335 }
14336 wg.Wait()
14337 return ret
14338}
14339
14340func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14341 return graphql.UnmarshalString(v)
14342}
14343
14344func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14345 res := graphql.MarshalString(v)
14346 if res == graphql.Null {
14347 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14348 ec.Errorf(ctx, "must not be null")
14349 }
14350 }
14351 return res
14352}
14353
14354func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14355 var vSlice []interface{}
14356 if v != nil {
14357 if tmp1, ok := v.([]interface{}); ok {
14358 vSlice = tmp1
14359 } else {
14360 vSlice = []interface{}{v}
14361 }
14362 }
14363 var err error
14364 res := make([]string, len(vSlice))
14365 for i := range vSlice {
14366 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14367 if err != nil {
14368 return nil, err
14369 }
14370 }
14371 return res, nil
14372}
14373
14374func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14375 ret := make(graphql.Array, len(v))
14376 var wg sync.WaitGroup
14377 isLen1 := len(v) == 1
14378 if !isLen1 {
14379 wg.Add(len(v))
14380 }
14381 for i := range v {
14382 i := i
14383 fc := &graphql.FieldContext{
14384 Index: &i,
14385 Result: &v[i],
14386 }
14387 ctx := graphql.WithFieldContext(ctx, fc)
14388 f := func(i int) {
14389 defer func() {
14390 if r := recover(); r != nil {
14391 ec.Error(ctx, ec.Recover(ctx, r))
14392 ret = nil
14393 }
14394 }()
14395 if !isLen1 {
14396 defer wg.Done()
14397 }
14398 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
14399 }
14400 if isLen1 {
14401 f(i)
14402 } else {
14403 go f(i)
14404 }
14405
14406 }
14407 wg.Wait()
14408 return ret
14409}
14410
14411func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
14412 return ec.___EnumValue(ctx, sel, &v)
14413}
14414
14415func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
14416 return ec.___Field(ctx, sel, &v)
14417}
14418
14419func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
14420 return ec.___InputValue(ctx, sel, &v)
14421}
14422
14423func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14424 ret := make(graphql.Array, len(v))
14425 var wg sync.WaitGroup
14426 isLen1 := len(v) == 1
14427 if !isLen1 {
14428 wg.Add(len(v))
14429 }
14430 for i := range v {
14431 i := i
14432 fc := &graphql.FieldContext{
14433 Index: &i,
14434 Result: &v[i],
14435 }
14436 ctx := graphql.WithFieldContext(ctx, fc)
14437 f := func(i int) {
14438 defer func() {
14439 if r := recover(); r != nil {
14440 ec.Error(ctx, ec.Recover(ctx, r))
14441 ret = nil
14442 }
14443 }()
14444 if !isLen1 {
14445 defer wg.Done()
14446 }
14447 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14448 }
14449 if isLen1 {
14450 f(i)
14451 } else {
14452 go f(i)
14453 }
14454
14455 }
14456 wg.Wait()
14457 return ret
14458}
14459
14460func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14461 return ec.___Type(ctx, sel, &v)
14462}
14463
14464func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14465 ret := make(graphql.Array, len(v))
14466 var wg sync.WaitGroup
14467 isLen1 := len(v) == 1
14468 if !isLen1 {
14469 wg.Add(len(v))
14470 }
14471 for i := range v {
14472 i := i
14473 fc := &graphql.FieldContext{
14474 Index: &i,
14475 Result: &v[i],
14476 }
14477 ctx := graphql.WithFieldContext(ctx, fc)
14478 f := func(i int) {
14479 defer func() {
14480 if r := recover(); r != nil {
14481 ec.Error(ctx, ec.Recover(ctx, r))
14482 ret = nil
14483 }
14484 }()
14485 if !isLen1 {
14486 defer wg.Done()
14487 }
14488 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14489 }
14490 if isLen1 {
14491 f(i)
14492 } else {
14493 go f(i)
14494 }
14495
14496 }
14497 wg.Wait()
14498 return ret
14499}
14500
14501func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14502 if v == nil {
14503 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14504 ec.Errorf(ctx, "must not be null")
14505 }
14506 return graphql.Null
14507 }
14508 return ec.___Type(ctx, sel, v)
14509}
14510
14511func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14512 return graphql.UnmarshalString(v)
14513}
14514
14515func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14516 res := graphql.MarshalString(v)
14517 if res == graphql.Null {
14518 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14519 ec.Errorf(ctx, "must not be null")
14520 }
14521 }
14522 return res
14523}
14524
14525func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14526 return graphql.UnmarshalBoolean(v)
14527}
14528
14529func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14530 return graphql.MarshalBoolean(v)
14531}
14532
14533func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14534 if v == nil {
14535 return nil, nil
14536 }
14537 res, err := ec.unmarshalOBoolean2bool(ctx, v)
14538 return &res, err
14539}
14540
14541func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14542 if v == nil {
14543 return graphql.Null
14544 }
14545 return ec.marshalOBoolean2bool(ctx, sel, *v)
14546}
14547
14548func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
14549 if v == nil {
14550 return graphql.Null
14551 }
14552 return ec._Bug(ctx, sel, v)
14553}
14554
14555func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14556 return ec.unmarshalInputChangeLabelInput(ctx, v)
14557}
14558
14559func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14560 if v == nil {
14561 return nil, nil
14562 }
14563 res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14564 return &res, err
14565}
14566
14567func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
14568 var vSlice []interface{}
14569 if v != nil {
14570 if tmp1, ok := v.([]interface{}); ok {
14571 vSlice = tmp1
14572 } else {
14573 vSlice = []interface{}{v}
14574 }
14575 }
14576 var err error
14577 res := make([]git.Hash, len(vSlice))
14578 for i := range vSlice {
14579 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14580 if err != nil {
14581 return nil, err
14582 }
14583 }
14584 return res, nil
14585}
14586
14587func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14588 if v == nil {
14589 return graphql.Null
14590 }
14591 ret := make(graphql.Array, len(v))
14592 for i := range v {
14593 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14594 }
14595
14596 return ret
14597}
14598
14599func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
14600 if v == nil {
14601 return graphql.Null
14602 }
14603 return ec._Identity(ctx, sel, v)
14604}
14605
14606func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14607 return graphql.UnmarshalInt(v)
14608}
14609
14610func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14611 return graphql.MarshalInt(v)
14612}
14613
14614func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14615 if v == nil {
14616 return nil, nil
14617 }
14618 res, err := ec.unmarshalOInt2int(ctx, v)
14619 return &res, err
14620}
14621
14622func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14623 if v == nil {
14624 return graphql.Null
14625 }
14626 return ec.marshalOInt2int(ctx, sel, *v)
14627}
14628
14629func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14630 return ec._LabelChangeResult(ctx, sel, &v)
14631}
14632
14633func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14634 if v == nil {
14635 return graphql.Null
14636 }
14637 return ec._LabelChangeResult(ctx, sel, v)
14638}
14639
14640func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14641 return ec._Repository(ctx, sel, &v)
14642}
14643
14644func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14645 if v == nil {
14646 return graphql.Null
14647 }
14648 return ec._Repository(ctx, sel, v)
14649}
14650
14651func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14652 return graphql.UnmarshalString(v)
14653}
14654
14655func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14656 return graphql.MarshalString(v)
14657}
14658
14659func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14660 var vSlice []interface{}
14661 if v != nil {
14662 if tmp1, ok := v.([]interface{}); ok {
14663 vSlice = tmp1
14664 } else {
14665 vSlice = []interface{}{v}
14666 }
14667 }
14668 var err error
14669 res := make([]string, len(vSlice))
14670 for i := range vSlice {
14671 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14672 if err != nil {
14673 return nil, err
14674 }
14675 }
14676 return res, nil
14677}
14678
14679func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14680 if v == nil {
14681 return graphql.Null
14682 }
14683 ret := make(graphql.Array, len(v))
14684 for i := range v {
14685 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14686 }
14687
14688 return ret
14689}
14690
14691func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14692 if v == nil {
14693 return nil, nil
14694 }
14695 res, err := ec.unmarshalOString2string(ctx, v)
14696 return &res, err
14697}
14698
14699func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14700 if v == nil {
14701 return graphql.Null
14702 }
14703 return ec.marshalOString2string(ctx, sel, *v)
14704}
14705
14706func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
14707 if v == nil {
14708 return graphql.Null
14709 }
14710 ret := make(graphql.Array, len(v))
14711 var wg sync.WaitGroup
14712 isLen1 := len(v) == 1
14713 if !isLen1 {
14714 wg.Add(len(v))
14715 }
14716 for i := range v {
14717 i := i
14718 fc := &graphql.FieldContext{
14719 Index: &i,
14720 Result: &v[i],
14721 }
14722 ctx := graphql.WithFieldContext(ctx, fc)
14723 f := func(i int) {
14724 defer func() {
14725 if r := recover(); r != nil {
14726 ec.Error(ctx, ec.Recover(ctx, r))
14727 ret = nil
14728 }
14729 }()
14730 if !isLen1 {
14731 defer wg.Done()
14732 }
14733 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14734 }
14735 if isLen1 {
14736 f(i)
14737 } else {
14738 go f(i)
14739 }
14740
14741 }
14742 wg.Wait()
14743 return ret
14744}
14745
14746func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
14747 if v == nil {
14748 return graphql.Null
14749 }
14750 ret := make(graphql.Array, len(v))
14751 var wg sync.WaitGroup
14752 isLen1 := len(v) == 1
14753 if !isLen1 {
14754 wg.Add(len(v))
14755 }
14756 for i := range v {
14757 i := i
14758 fc := &graphql.FieldContext{
14759 Index: &i,
14760 Result: &v[i],
14761 }
14762 ctx := graphql.WithFieldContext(ctx, fc)
14763 f := func(i int) {
14764 defer func() {
14765 if r := recover(); r != nil {
14766 ec.Error(ctx, ec.Recover(ctx, r))
14767 ret = nil
14768 }
14769 }()
14770 if !isLen1 {
14771 defer wg.Done()
14772 }
14773 ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
14774 }
14775 if isLen1 {
14776 f(i)
14777 } else {
14778 go f(i)
14779 }
14780
14781 }
14782 wg.Wait()
14783 return ret
14784}
14785
14786func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14787 if v == nil {
14788 return graphql.Null
14789 }
14790 ret := make(graphql.Array, len(v))
14791 var wg sync.WaitGroup
14792 isLen1 := len(v) == 1
14793 if !isLen1 {
14794 wg.Add(len(v))
14795 }
14796 for i := range v {
14797 i := i
14798 fc := &graphql.FieldContext{
14799 Index: &i,
14800 Result: &v[i],
14801 }
14802 ctx := graphql.WithFieldContext(ctx, fc)
14803 f := func(i int) {
14804 defer func() {
14805 if r := recover(); r != nil {
14806 ec.Error(ctx, ec.Recover(ctx, r))
14807 ret = nil
14808 }
14809 }()
14810 if !isLen1 {
14811 defer wg.Done()
14812 }
14813 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14814 }
14815 if isLen1 {
14816 f(i)
14817 } else {
14818 go f(i)
14819 }
14820
14821 }
14822 wg.Wait()
14823 return ret
14824}
14825
14826func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
14827 return ec.___Schema(ctx, sel, &v)
14828}
14829
14830func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
14831 if v == nil {
14832 return graphql.Null
14833 }
14834 return ec.___Schema(ctx, sel, v)
14835}
14836
14837func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14838 return ec.___Type(ctx, sel, &v)
14839}
14840
14841func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14842 if v == nil {
14843 return graphql.Null
14844 }
14845 ret := make(graphql.Array, len(v))
14846 var wg sync.WaitGroup
14847 isLen1 := len(v) == 1
14848 if !isLen1 {
14849 wg.Add(len(v))
14850 }
14851 for i := range v {
14852 i := i
14853 fc := &graphql.FieldContext{
14854 Index: &i,
14855 Result: &v[i],
14856 }
14857 ctx := graphql.WithFieldContext(ctx, fc)
14858 f := func(i int) {
14859 defer func() {
14860 if r := recover(); r != nil {
14861 ec.Error(ctx, ec.Recover(ctx, r))
14862 ret = nil
14863 }
14864 }()
14865 if !isLen1 {
14866 defer wg.Done()
14867 }
14868 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14869 }
14870 if isLen1 {
14871 f(i)
14872 } else {
14873 go f(i)
14874 }
14875
14876 }
14877 wg.Wait()
14878 return ret
14879}
14880
14881func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14882 if v == nil {
14883 return graphql.Null
14884 }
14885 return ec.___Type(ctx, sel, v)
14886}
14887
14888// endregion ***************************** type.gotpl *****************************